src/unexaix.c

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