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