src/unexaix.c

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