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
  46 #define PERROR(file) report_error (file, new)
  47 #include <a.out.h>
  48 /* Define getpagesize () if the system does not.
  49    Note that this may depend on symbols defined in a.out.h
  50  */
  51 #include "getpagesize.h"
  52
  53 #include <sys/types.h>
  54 #include <stdio.h>
  55 #include <sys/stat.h>
  56 #include <errno.h>
  57 #include <unistd.h>
  58 #include <fcntl.h>
  59
  60 #include "mem-limits.h"
  61
  62 char *start_of_text (void);                     /* Start of text */
  63
  64 extern int _data;
  65 extern int _text;
  66
  67 #include <filehdr.h>
  68 #include <aouthdr.h>
  69 #include <scnhdr.h>
  70 #include <syms.h>
  71
  72 static struct filehdr f_hdr;            /* File header */
  73 static struct aouthdr f_ohdr;           /* Optional file header (a.out) */
  74 static long bias;                       /* Bias to add for growth */
  75 static long lnnoptr;                    /* Pointer to line-number info within file */
  76
  77 static long text_scnptr;
  78 static long data_scnptr;
  79 #define ALIGN(val, pwr) (((val) + ((1L<<(pwr))-1)) & ~((1L<<(pwr))-1))
  80 static long load_scnptr;
  81 static long orig_load_scnptr;
  82 static long orig_data_scnptr;
  83 static int unrelocate_symbols (int, int, const char *, const char *);
  84
  85 #ifndef MAX_SECTIONS
  86 #define MAX_SECTIONS    10
  87 #endif
  88
  89 static int adjust_lnnoptrs (int, int, const char *);
  90
  91 static int pagemask;
  92
  93 #include "lisp.h"
  94
  95 static void
  96 report_error (const char *file, int fd)
  97 {
  98   if (fd)
  99     close (fd);
 100   report_file_error ("Cannot unexec", Fcons (build_string (file), Qnil));
 101 }
 102
 103 #define ERROR0(msg) report_error_1 (new, msg, 0, 0); return -1
 104 #define ERROR1(msg,x) report_error_1 (new, msg, x, 0); return -1
 105 #define ERROR2(msg,x,y) report_error_1 (new, msg, x, y); return -1
 106
 107 #undef ADDR_CORRECT
 108 #define ADDR_CORRECT(x) ((int)(x))
 109
 110 static void
 111 report_error_1 (int fd, const char *msg, int a1, int a2)
 112 {
 113   close (fd);
 114   error (msg, a1, a2);
 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 = open (a_name, O_RDONLY)) < 0)
 134     {
 135       PERROR (a_name);
 136     }
 137   if ((new = creat (new_name, 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       close (new);
 149       return;
 150     }
 151
 152   close (new);
 153   if (a_out >= 0)
 154     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   unsigned int bss_start;
 170   unsigned int 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 = (long) start_of_data ();
 186   data_start = ADDR_CORRECT (data_start);
 187
 188   data_start = data_start & ~pagemask; /* (Down) to page boundary. */
 189
 190   bss_start = ADDR_CORRECT (sbrk (0)) + pagemask;
 191   bss_start &= ~ pagemask;
 192
 193   if (data_start > bss_start)   /* Can't have negative data size. */
 194     {
 195       ERROR2 ("unexec: data_start (%u) can't be greater than bss_start (%u)",
 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     ulong 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, (long) text_scnptr, SEEK_SET);
 382   ptr = start_of_text () + text_scnptr;
 383   end = ptr + f_ohdr.tsize;
 384   write_segment (new, ptr, end);
 385
 386   lseek (new, (long) 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 buf[80];
 400   char zeros[UnexBlockSz];
 401
 402   for (i = 0; ptr < end;)
 403     {
 404       /* distance to next block.  */
 405       nwrite = (((int) ptr + UnexBlockSz) & -UnexBlockSz) - (int) ptr;
 406       /* But not beyond specified end.  */
 407       if (nwrite > end - ptr) nwrite = end - ptr;
 408       ret = write (new, ptr, nwrite);
 409       /* If write gets a page fault, it means we reached
 410          a gap between the old text segment and the old data segment.
 411          This gap has probably been remapped into part of the text segment.
 412          So write zeros for it.  */
 413       if (ret == -1 && errno == EFAULT)
 414         {
 415           memset (zeros, 0, nwrite);
 416           write (new, zeros, nwrite);
 417         }
 418       else if (nwrite != ret)
 419         {
 420           sprintf (buf,
 421                    "unexec write failure: addr 0x%lx, fileno %d, size 0x%x, wrote 0x%x, errno %d",
 422                    (unsigned long)ptr, new, nwrite, ret, errno);
 423           PERROR (buf);
 424         }
 425       i += nwrite;
 426       ptr += nwrite;
 427     }
 428 }
 429 \f
 430 /* ****************************************************************
 431  * copy_sym
 432  *
 433  * Copy the relocation information and symbol table from the a.out to the new
 434  */
 435 static int
 436 copy_sym (int new, int a_out, const char *a_name, const char *new_name)
 437 {
 438   char page[UnexBlockSz];
 439   int n;
 440
 441   if (a_out < 0)
 442     return 0;
 443
 444   if (orig_load_scnptr == 0L)
 445     return 0;
 446
 447   if (lnnoptr && lnnoptr < orig_load_scnptr) /* if there is line number info  */
 448     lseek (a_out, lnnoptr, SEEK_SET);  /* start copying from there */
 449   else
 450     lseek (a_out, orig_load_scnptr, SEEK_SET); /* Position a.out to symtab. */
 451
 452   while ((n = read (a_out, page, sizeof page)) > 0)
 453     {
 454       if (write (new, page, n) != n)
 455         {
 456           PERROR (new_name);
 457         }
 458     }
 459   if (n < 0)
 460     {
 461       PERROR (a_name);
 462     }
 463   return 0;
 464 }
 465 \f
 466 /* ****************************************************************
 467  * mark_x
 468  *
 469  * After successfully building the new a.out, mark it executable
 470  */
 471 static void
 472 mark_x (const char *name)
 473 {
 474   struct stat sbuf;
 475   int um;
 476   int new = 0;  /* for PERROR */
 477
 478   um = umask (777);
 479   umask (um);
 480   if (stat (name, &sbuf) == -1)
 481     {
 482       PERROR (name);
 483     }
 484   sbuf.st_mode |= 0111 & ~um;
 485   if (chmod (name, sbuf.st_mode) == -1)
 486     PERROR (name);
 487 }
 488 \f
 489 static int
 490 adjust_lnnoptrs (int writedesc, int readdesc, const char *new_name)
 491 {
 492   int nsyms;
 493   int naux;
 494   int new;
 495   struct syment symentry;
 496   union auxent auxentry;
 497
 498   if (!lnnoptr || !f_hdr.f_symptr)
 499     return 0;
 500
 501   if ((new = open (new_name, O_RDWR)) < 0)
 502     {
 503       PERROR (new_name);
 504       return -1;
 505     }
 506
 507   lseek (new, f_hdr.f_symptr, SEEK_SET);
 508   for (nsyms = 0; nsyms < f_hdr.f_nsyms; nsyms++)
 509     {
 510       read (new, &symentry, SYMESZ);
 511       if (symentry.n_sclass == C_BINCL || symentry.n_sclass == C_EINCL)
 512         {
 513           symentry.n_value += bias;
 514           lseek (new, -SYMESZ, SEEK_CUR);
 515           write (new, &symentry, SYMESZ);
 516         }
 517
 518       for (naux = symentry.n_numaux; naux-- != 0; )
 519         {
 520           read (new, &auxentry, AUXESZ);
 521           nsyms++;
 522           if (naux != 0              /* skip csect auxentry (last entry) */
 523               && (symentry.n_sclass == C_EXT || symentry.n_sclass == C_HIDEXT))
 524             {
 525               auxentry.x_sym.x_fcnary.x_fcn.x_lnnoptr += bias;
 526               lseek (new, -AUXESZ, SEEK_CUR);
 527               write (new, &auxentry, AUXESZ);
 528             }
 529         }
 530     }
 531   close (new);
 532
 533   return 0;
 534 }
 535
 536 static int
 537 unrelocate_symbols (int new, int a_out,
 538                     const char *a_name, const char *new_name)
 539 {
 540   int i;
 541   LDHDR ldhdr;
 542   LDREL ldrel;
 543   ulong t_reloc = (ulong) &_text - f_ohdr.text_start;
 544 #ifndef ALIGN_DATA_RELOC
 545   ulong d_reloc = (ulong) &_data - f_ohdr.data_start;
 546 #else
 547   /* This worked (and was needed) before AIX 4.2.
 548      I have no idea why. -- Mike */
 549   ulong d_reloc = (ulong) &_data - ALIGN (f_ohdr.data_start, 2);
 550 #endif
 551   int * p;
 552
 553   if (load_scnptr == 0)
 554     return 0;
 555
 556   lseek (a_out, orig_load_scnptr, SEEK_SET);
 557   if (read (a_out, &ldhdr, sizeof (ldhdr)) != sizeof (ldhdr))
 558     {
 559       PERROR (new_name);
 560     }
 561
 562 #define SYMNDX_TEXT     0
 563 #define SYMNDX_DATA     1
 564 #define SYMNDX_BSS      2
 565
 566   for (i = 0; i < ldhdr.l_nreloc; i++)
 567     {
 568       lseek (a_out,
 569              orig_load_scnptr + LDHDRSZ + LDSYMSZ*ldhdr.l_nsyms + LDRELSZ*i,
 570              SEEK_SET);
 571
 572       if (read (a_out, &ldrel, LDRELSZ) != LDRELSZ)
 573         {
 574           PERROR (a_name);
 575         }
 576
 577       /* move the BSS loader symbols to the DATA segment */
 578       if (ldrel.l_symndx == SYMNDX_BSS)
 579         {
 580           ldrel.l_symndx = SYMNDX_DATA;
 581
 582           lseek (new,
 583                  load_scnptr + LDHDRSZ + LDSYMSZ*ldhdr.l_nsyms + LDRELSZ*i,
 584                  SEEK_SET);
 585
 586           if (write (new, &ldrel, LDRELSZ) != LDRELSZ)
 587             {
 588               PERROR (new_name);
 589             }
 590         }
 591
 592       if (ldrel.l_rsecnm == f_ohdr.o_sndata)
 593         {
 594           int orig_int;
 595
 596           lseek (a_out,
 597                  orig_data_scnptr + (ldrel.l_vaddr - f_ohdr.data_start),
 598                  SEEK_SET);
 599
 600           if (read (a_out, (void *) &orig_int, sizeof (orig_int))
 601               != sizeof (orig_int))
 602             {
 603               PERROR (a_name);
 604             }
 605
 606           p = (int *) (ldrel.l_vaddr + d_reloc);
 607
 608           switch (ldrel.l_symndx) {
 609           case SYMNDX_TEXT:
 610             orig_int = * p - t_reloc;
 611             break;
 612
 613           case SYMNDX_DATA:
 614           case SYMNDX_BSS:
 615             orig_int = * p - d_reloc;
 616             break;
 617           }
 618
 619           if (orig_int != * p)
 620             {
 621               lseek (new,
 622                      data_scnptr + (ldrel.l_vaddr - f_ohdr.data_start),
 623                      SEEK_SET);
 624               if (write (new, (void *) &orig_int, sizeof (orig_int))
 625                   != sizeof (orig_int))
 626                 {
 627                   PERROR (new_name);
 628                 }
 629             }
 630         }
 631     }
 632   return 0;
 633 }
 634
 635 /*
 636  *      Return the address of the start of the text segment prior to
 637  *      doing an unexec.  After unexec the return value is undefined.
 638  *      See crt0.c for further explanation and _start.
 639  *
 640  */
 641
 642 char *
 643 start_of_text (void)
 644 {
 645   return ((char *) 0x10000000);
 646 }