src/unexaix.c

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