src/unexaix.c

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