src/unexaix.c

   1 /* Dump an executable image.
   2    Copyright (C) 1985-1988, 1999, 2001-2012  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software: you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation, either version 3 of the License, or
   9 (at your option) any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /*
  20 In other words, you are welcome to use, share and improve this program.
  21 You are forbidden to forbid anyone else to use, share and improve
  22 what you give them.   Help stamp out software-hoarding!  */
  23
  24
  25 /* Originally based on the COFF unexec.c by Spencer W. Thomas.
  26  *
  27  * Subsequently hacked on by
  28  * Bill Mann <Bill_Man@praxisint.com>
  29  * Andrew Vignaux <Andrew.Vignaux@comp.vuw.ac.nz>
  30  * Mike Sperber <sperber@informatik.uni-tuebingen.de>
  31  *
  32  * Synopsis:
  33  *      unexec (const char *new_name, const *old_name);
  34  *
  35  * Takes a snapshot of the program and makes an a.out format file in the
  36  * file named by the string argument new_name.
  37  * If a_name is non-NULL, the symbol table will be taken from the given file.
  38  * On some machines, an existing a_name file is required.
  39  *
  40  */
  41
  42 #include <config.h>
  43 #include "unexec.h"
  44
  45 #define PERROR(file) report_error (file, new)
  46 #include <a.out.h>
  47 /* Define getpagesize () if the system does not.
  48    Note that this may depend on symbols defined in a.out.h
  49  */
  50 #include "getpagesize.h"
  51
  52 #include <sys/types.h>
  53 #include <stdio.h>
  54 #include <sys/stat.h>
  55 #include <errno.h>
  56 #include <unistd.h>
  57 #include <fcntl.h>
  58
  59 char *start_of_text (void);                     /* Start of text */
  60 extern char *start_of_data (void);              /* Start of initialized data */
  61
  62 extern int _data;
  63 extern int _text;
  64
  65 #include <filehdr.h>
  66 #include <aouthdr.h>
  67 #include <scnhdr.h>
  68 #include <syms.h>
  69
  70 static struct filehdr f_hdr;            /* File header */
  71 static struct aouthdr f_ohdr;           /* Optional file header (a.out) */
  72 static long bias;                       /* Bias to add for growth */
  73 static long lnnoptr;                    /* Pointer to line-number info within file */
  74
  75 static long text_scnptr;
  76 static long data_scnptr;
  77 #define ALIGN(val, pwr) (((val) + ((1L<<(pwr))-1)) & ~((1L<<(pwr))-1))
  78 static long load_scnptr;
  79 static long orig_load_scnptr;
  80 static long orig_data_scnptr;
  81 static int unrelocate_symbols (int, int, const char *, const char *);
  82
  83 #ifndef MAX_SECTIONS
  84 #define MAX_SECTIONS    10
  85 #endif
  86
  87 static int adjust_lnnoptrs (int, int, const char *);
  88
  89 static int pagemask;
  90
  91 #include <setjmp.h>
  92 #include "lisp.h"
  93
  94 static void
  95 report_error (const char *file, int fd)
  96 {
  97   if (fd)
  98     close (fd);
  99   report_file_error ("Cannot unexec", Fcons (build_string (file), Qnil));
 100 }
 101
 102 #define ERROR0(msg) report_error_1 (new, msg, 0, 0); return -1
 103 #define ERROR1(msg,x) report_error_1 (new, msg, x, 0); return -1
 104 #define ERROR2(msg,x,y) report_error_1 (new, msg, x, y); return -1
 105
 106 static void
 107 report_error_1 (int fd, const char *msg, int a1, int a2)
 108 {
 109   close (fd);
 110   error (msg, a1, a2);
 111 }
 112
 113 static int make_hdr (int, int, const char *, const char *);
 114 static void mark_x (const char *);
 115 static int copy_text_and_data (int);
 116 static int copy_sym (int, int, const char *, const char *);
 117 static void write_segment (int, char *, char *);
 118 \f
 119 /* ****************************************************************
 120  * unexec
 121  *
 122  * driving logic.
 123  */
 124 void
 125 unexec (const char *new_name, const char *a_name)
 126 {
 127   int new = -1, a_out = -1;
 128
 129   if (a_name && (a_out = open (a_name, O_RDONLY)) < 0)
 130     {
 131       PERROR (a_name);
 132     }
 133   if ((new = creat (new_name, 0666)) < 0)
 134     {
 135       PERROR (new_name);
 136     }
 137   if (make_hdr (new, a_out,
 138                 a_name, new_name) < 0
 139       || copy_text_and_data (new) < 0
 140       || copy_sym (new, a_out, a_name, new_name) < 0
 141       || adjust_lnnoptrs (new, a_out, new_name) < 0
 142       || unrelocate_symbols (new, a_out, a_name, new_name) < 0)
 143     {
 144       close (new);
 145       return;
 146     }
 147
 148   close (new);
 149   if (a_out >= 0)
 150     close (a_out);
 151   mark_x (new_name);
 152 }
 153
 154 /* ****************************************************************
 155  * make_hdr
 156  *
 157  * Make the header in the new a.out from the header in core.
 158  * Modify the text and data sizes.
 159  */
 160 static int
 161 make_hdr (int new, int a_out,
 162           const char *a_name, const char *new_name)
 163 {
 164   int scns;
 165   unsigned int bss_start;
 166   unsigned int data_start;
 167
 168   struct scnhdr section[MAX_SECTIONS];
 169   struct scnhdr * f_thdr;               /* Text section header */
 170   struct scnhdr * f_dhdr;               /* Data section header */
 171   struct scnhdr * f_bhdr;               /* Bss section header */
 172   struct scnhdr * f_lhdr;               /* Loader section header */
 173   struct scnhdr * f_tchdr;              /* Typechk section header */
 174   struct scnhdr * f_dbhdr;              /* Debug section header */
 175   struct scnhdr * f_xhdr;               /* Except section header */
 176
 177   load_scnptr = orig_load_scnptr = lnnoptr = 0;
 178   pagemask = getpagesize () - 1;
 179
 180   /* Adjust text/data boundary. */
 181   data_start = (long) start_of_data ();
 182   data_start = ADDR_CORRECT (data_start);
 183
 184   data_start = data_start & ~pagemask; /* (Down) to page boundary. */
 185
 186   bss_start = ADDR_CORRECT (sbrk (0)) + pagemask;
 187   bss_start &= ~ pagemask;
 188
 189   if (data_start > bss_start)   /* Can't have negative data size. */
 190     {
 191       ERROR2 ("unexec: data_start (%u) can't be greater than bss_start (%u)",
 192               data_start, bss_start);
 193     }
 194
 195   /* Salvage as much info from the existing file as possible */
 196   f_thdr = NULL; f_dhdr = NULL; f_bhdr = NULL;
 197   f_lhdr = NULL; f_tchdr = NULL; f_dbhdr = NULL; f_xhdr = NULL;
 198   if (a_out >= 0)
 199     {
 200       if (read (a_out, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
 201         {
 202           PERROR (a_name);
 203         }
 204       if (f_hdr.f_opthdr > 0)
 205         {
 206           if (read (a_out, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
 207             {
 208               PERROR (a_name);
 209             }
 210         }
 211       if (f_hdr.f_nscns > MAX_SECTIONS)
 212         {
 213           ERROR0 ("unexec: too many section headers -- increase MAX_SECTIONS");
 214         }
 215       /* Loop through section headers */
 216       for (scns = 0; scns < f_hdr.f_nscns; scns++) {
 217         struct scnhdr *s = &section[scns];
 218         if (read (a_out, s, sizeof (*s)) != sizeof (*s))
 219           {
 220             PERROR (a_name);
 221           }
 222
 223 #define CHECK_SCNHDR(ptr, name, flags) \
 224   if (strcmp (s->s_name, name) == 0) { \
 225     if (s->s_flags != flags) { \
 226       fprintf (stderr, "unexec: %lx flags where %x expected in %s section.\n", \
 227                (unsigned long)s->s_flags, flags, name);                 \
 228     } \
 229     if (ptr) { \
 230       fprintf (stderr, "unexec: duplicate section header for section %s.\n", \
 231                name);                                                   \
 232     } \
 233     ptr = s; \
 234   }
 235         CHECK_SCNHDR (f_thdr, _TEXT, STYP_TEXT);
 236         CHECK_SCNHDR (f_dhdr, _DATA, STYP_DATA);
 237         CHECK_SCNHDR (f_bhdr, _BSS, STYP_BSS);
 238         CHECK_SCNHDR (f_lhdr, _LOADER, STYP_LOADER);
 239         CHECK_SCNHDR (f_dbhdr, _DEBUG,  STYP_DEBUG);
 240         CHECK_SCNHDR (f_tchdr, _TYPCHK,  STYP_TYPCHK);
 241         CHECK_SCNHDR (f_xhdr, _EXCEPT,  STYP_EXCEPT);
 242       }
 243
 244       if (f_thdr == 0)
 245         {
 246           ERROR1 ("unexec: couldn't find \"%s\" section", (int) _TEXT);
 247         }
 248       if (f_dhdr == 0)
 249         {
 250           ERROR1 ("unexec: couldn't find \"%s\" section", (int) _DATA);
 251         }
 252       if (f_bhdr == 0)
 253         {
 254           ERROR1 ("unexec: couldn't find \"%s\" section", (int) _BSS);
 255         }
 256     }
 257   else
 258     {
 259       ERROR0 ("can't build a COFF file from scratch yet");
 260     }
 261   orig_data_scnptr = f_dhdr->s_scnptr;
 262   orig_load_scnptr = f_lhdr ? f_lhdr->s_scnptr : 0;
 263
 264   /* Now we alter the contents of all the f_*hdr variables
 265      to correspond to what we want to dump.  */
 266
 267   /* Indicate that the reloc information is no longer valid for ld (bind);
 268      we only update it enough to fake out the exec-time loader.  */
 269   f_hdr.f_flags |= (F_RELFLG | F_EXEC);
 270
 271   f_ohdr.dsize = bss_start - f_ohdr.data_start;
 272   f_ohdr.bsize = 0;
 273
 274   f_dhdr->s_size = f_ohdr.dsize;
 275   f_bhdr->s_size = f_ohdr.bsize;
 276   f_bhdr->s_paddr = f_ohdr.data_start + f_ohdr.dsize;
 277   f_bhdr->s_vaddr = f_ohdr.data_start + f_ohdr.dsize;
 278
 279   /* fix scnptr's */
 280   {
 281     ulong ptr = section[0].s_scnptr;
 282
 283     bias = -1;
 284     for (scns = 0; scns < f_hdr.f_nscns; scns++)
 285       {
 286         struct scnhdr *s = &section[scns];
 287
 288         if (s->s_flags & STYP_PAD)        /* .pad sections omitted in AIX 4.1 */
 289           {
 290             /*
 291              * the text_start should probably be o_algntext but that doesn't
 292              * seem to change
 293              */
 294             if (f_ohdr.text_start != 0) /* && scns != 0 */
 295               {
 296                 s->s_size = 512 - (ptr % 512);
 297                 if (s->s_size == 512)
 298                   s->s_size = 0;
 299               }
 300             s->s_scnptr = ptr;
 301           }
 302         else if (s->s_flags & STYP_DATA)
 303           s->s_scnptr = ptr;
 304         else if (!(s->s_flags & (STYP_TEXT | STYP_BSS)))
 305           {
 306             if (bias == -1)                /* if first section after bss */
 307               bias = ptr - s->s_scnptr;
 308
 309             s->s_scnptr += bias;
 310             ptr = s->s_scnptr;
 311           }
 312
 313         ptr = ptr + s->s_size;
 314       }
 315   }
 316
 317   /* fix other pointers */
 318   for (scns = 0; scns < f_hdr.f_nscns; scns++)
 319     {
 320       struct scnhdr *s = &section[scns];
 321
 322       if (s->s_relptr != 0)
 323         {
 324           s->s_relptr += bias;
 325         }
 326       if (s->s_lnnoptr != 0)
 327         {
 328           if (lnnoptr == 0) lnnoptr = s->s_lnnoptr;
 329           s->s_lnnoptr += bias;
 330         }
 331     }
 332
 333   if (f_hdr.f_symptr > 0L)
 334     {
 335       f_hdr.f_symptr += bias;
 336     }
 337
 338   text_scnptr = f_thdr->s_scnptr;
 339   data_scnptr = f_dhdr->s_scnptr;
 340   load_scnptr = f_lhdr ? f_lhdr->s_scnptr : 0;
 341
 342   if (write (new, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
 343     {
 344       PERROR (new_name);
 345     }
 346
 347   if (f_hdr.f_opthdr > 0)
 348     {
 349       if (write (new, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
 350         {
 351           PERROR (new_name);
 352         }
 353     }
 354
 355   for (scns = 0; scns < f_hdr.f_nscns; scns++) {
 356     struct scnhdr *s = &section[scns];
 357     if (write (new, s, sizeof (*s)) != sizeof (*s))
 358       {
 359         PERROR (new_name);
 360       }
 361   }
 362
 363   return (0);
 364 }
 365 \f
 366 /* ****************************************************************
 367
 368  *
 369  * Copy the text and data segments from memory to the new a.out
 370  */
 371 static int
 372 copy_text_and_data (int new)
 373 {
 374   char *end;
 375   char *ptr;
 376
 377   lseek (new, (long) text_scnptr, SEEK_SET);
 378   ptr = start_of_text () + text_scnptr;
 379   end = ptr + f_ohdr.tsize;
 380   write_segment (new, ptr, end);
 381
 382   lseek (new, (long) data_scnptr, SEEK_SET);
 383   ptr = (char *) f_ohdr.data_start;
 384   end = ptr + f_ohdr.dsize;
 385   write_segment (new, ptr, end);
 386
 387   return 0;
 388 }
 389
 390 #define UnexBlockSz (1<<12)                     /* read/write block size */
 391 static void
 392 write_segment (int new, char *ptr, char *end)
 393 {
 394   int i, nwrite, ret;
 395   char buf[80];
 396   char zeros[UnexBlockSz];
 397
 398   for (i = 0; ptr < end;)
 399     {
 400       /* distance to next block.  */
 401       nwrite = (((int) ptr + UnexBlockSz) & -UnexBlockSz) - (int) ptr;
 402       /* But not beyond specified end.  */
 403       if (nwrite > end - ptr) nwrite = end - ptr;
 404       ret = write (new, ptr, nwrite);
 405       /* If write gets a page fault, it means we reached
 406          a gap between the old text segment and the old data segment.
 407          This gap has probably been remapped into part of the text segment.
 408          So write zeros for it.  */
 409       if (ret == -1 && errno == EFAULT)
 410         {
 411           memset (zeros, 0, nwrite);
 412           write (new, zeros, nwrite);
 413         }
 414       else if (nwrite != ret)
 415         {
 416           sprintf (buf,
 417                    "unexec write failure: addr 0x%lx, fileno %d, size 0x%x, wrote 0x%x, errno %d",
 418                    (unsigned long)ptr, new, nwrite, ret, errno);
 419           PERROR (buf);
 420         }
 421       i += nwrite;
 422       ptr += nwrite;
 423     }
 424 }
 425 \f
 426 /* ****************************************************************
 427  * copy_sym
 428  *
 429  * Copy the relocation information and symbol table from the a.out to the new
 430  */
 431 static int
 432 copy_sym (int new, int a_out, const char *a_name, const char *new_name)
 433 {
 434   char page[UnexBlockSz];
 435   int n;
 436
 437   if (a_out < 0)
 438     return 0;
 439
 440   if (orig_load_scnptr == 0L)
 441     return 0;
 442
 443   if (lnnoptr && lnnoptr < orig_load_scnptr) /* if there is line number info  */
 444     lseek (a_out, lnnoptr, SEEK_SET);  /* start copying from there */
 445   else
 446     lseek (a_out, orig_load_scnptr, SEEK_SET); /* Position a.out to symtab. */
 447
 448   while ((n = read (a_out, page, sizeof page)) > 0)
 449     {
 450       if (write (new, page, n) != n)
 451         {
 452           PERROR (new_name);
 453         }
 454     }
 455   if (n < 0)
 456     {
 457       PERROR (a_name);
 458     }
 459   return 0;
 460 }
 461 \f
 462 /* ****************************************************************
 463  * mark_x
 464  *
 465  * After successfully building the new a.out, mark it executable
 466  */
 467 static void
 468 mark_x (const char *name)
 469 {
 470   struct stat sbuf;
 471   int um;
 472   int new = 0;  /* for PERROR */
 473
 474   um = umask (777);
 475   umask (um);
 476   if (stat (name, &sbuf) == -1)
 477     {
 478       PERROR (name);
 479     }
 480   sbuf.st_mode |= 0111 & ~um;
 481   if (chmod (name, sbuf.st_mode) == -1)
 482     PERROR (name);
 483 }
 484 \f
 485 static int
 486 adjust_lnnoptrs (int writedesc, int readdesc, const char *new_name)
 487 {
 488   int nsyms;
 489   int naux;
 490   int new;
 491   struct syment symentry;
 492   union auxent auxentry;
 493
 494   if (!lnnoptr || !f_hdr.f_symptr)
 495     return 0;
 496
 497   if ((new = open (new_name, O_RDWR)) < 0)
 498     {
 499       PERROR (new_name);
 500       return -1;
 501     }
 502
 503   lseek (new, f_hdr.f_symptr, SEEK_SET);
 504   for (nsyms = 0; nsyms < f_hdr.f_nsyms; nsyms++)
 505     {
 506       read (new, &symentry, SYMESZ);
 507       if (symentry.n_sclass == C_BINCL || symentry.n_sclass == C_EINCL)
 508         {
 509           symentry.n_value += bias;
 510           lseek (new, -SYMESZ, SEEK_CUR);
 511           write (new, &symentry, SYMESZ);
 512         }
 513
 514       for (naux = symentry.n_numaux; naux-- != 0; )
 515         {
 516           read (new, &auxentry, AUXESZ);
 517           nsyms++;
 518           if (naux != 0              /* skip csect auxentry (last entry) */
 519               && (symentry.n_sclass == C_EXT || symentry.n_sclass == C_HIDEXT))
 520             {
 521               auxentry.x_sym.x_fcnary.x_fcn.x_lnnoptr += bias;
 522               lseek (new, -AUXESZ, SEEK_CUR);
 523               write (new, &auxentry, AUXESZ);
 524             }
 525         }
 526     }
 527   close (new);
 528
 529   return 0;
 530 }
 531
 532 static int
 533 unrelocate_symbols (int new, int a_out,
 534                     const char *a_name, const char *new_name)
 535 {
 536   int i;
 537   LDHDR ldhdr;
 538   LDREL ldrel;
 539   ulong t_reloc = (ulong) &_text - f_ohdr.text_start;
 540 #ifndef ALIGN_DATA_RELOC
 541   ulong d_reloc = (ulong) &_data - f_ohdr.data_start;
 542 #else
 543   /* This worked (and was needed) before AIX 4.2.
 544      I have no idea why. -- Mike */
 545   ulong d_reloc = (ulong) &_data - ALIGN (f_ohdr.data_start, 2);
 546 #endif
 547   int * p;
 548
 549   if (load_scnptr == 0)
 550     return 0;
 551
 552   lseek (a_out, orig_load_scnptr, SEEK_SET);
 553   if (read (a_out, &ldhdr, sizeof (ldhdr)) != sizeof (ldhdr))
 554     {
 555       PERROR (new_name);
 556     }
 557
 558 #define SYMNDX_TEXT     0
 559 #define SYMNDX_DATA     1
 560 #define SYMNDX_BSS      2
 561
 562   for (i = 0; i < ldhdr.l_nreloc; i++)
 563     {
 564       lseek (a_out,
 565              orig_load_scnptr + LDHDRSZ + LDSYMSZ*ldhdr.l_nsyms + LDRELSZ*i,
 566              SEEK_SET);
 567
 568       if (read (a_out, &ldrel, LDRELSZ) != LDRELSZ)
 569         {
 570           PERROR (a_name);
 571         }
 572
 573       /* move the BSS loader symbols to the DATA segment */
 574       if (ldrel.l_symndx == SYMNDX_BSS)
 575         {
 576           ldrel.l_symndx = SYMNDX_DATA;
 577
 578           lseek (new,
 579                  load_scnptr + LDHDRSZ + LDSYMSZ*ldhdr.l_nsyms + LDRELSZ*i,
 580                  SEEK_SET);
 581
 582           if (write (new, &ldrel, LDRELSZ) != LDRELSZ)
 583             {
 584               PERROR (new_name);
 585             }
 586         }
 587
 588       if (ldrel.l_rsecnm == f_ohdr.o_sndata)
 589         {
 590           int orig_int;
 591
 592           lseek (a_out,
 593                  orig_data_scnptr + (ldrel.l_vaddr - f_ohdr.data_start),
 594                  SEEK_SET);
 595
 596           if (read (a_out, (void *) &orig_int, sizeof (orig_int))
 597               != sizeof (orig_int))
 598             {
 599               PERROR (a_name);
 600             }
 601
 602           p = (int *) (ldrel.l_vaddr + d_reloc);
 603
 604           switch (ldrel.l_symndx) {
 605           case SYMNDX_TEXT:
 606             orig_int = * p - t_reloc;
 607             break;
 608
 609           case SYMNDX_DATA:
 610           case SYMNDX_BSS:
 611             orig_int = * p - d_reloc;
 612             break;
 613           }
 614
 615           if (orig_int != * p)
 616             {
 617               lseek (new,
 618                      data_scnptr + (ldrel.l_vaddr - f_ohdr.data_start),
 619                      SEEK_SET);
 620               if (write (new, (void *) &orig_int, sizeof (orig_int))
 621                   != sizeof (orig_int))
 622                 {
 623                   PERROR (new_name);
 624                 }
 625             }
 626         }
 627     }
 628   return 0;
 629 }
 630
 631 /*
 632  *      Return the address of the start of the text segment prior to
 633  *      doing an unexec.  After unexec the return value is undefined.
 634  *      See crt0.c for further explanation and _start.
 635  *
 636  */
 637
 638 char *
 639 start_of_text (void)
 640 {
 641   return ((char *) 0x10000000);
 642 }