src/unexaix.c

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