src/unexaix.c

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