src/unexalpha.c

   1 /* Unexec for DEC alpha.  schoepf@sc.ZIB-Berlin.DE (Rainer Schoepf).
   2
   3    Copyright (C) 1994 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 2, or (at your option)
  10 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; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 \f
  23 #include <config.h>
  24 #include <sys/types.h>
  25 #include <sys/file.h>
  26 #include <sys/stat.h>
  27 #include <sys/mman.h>
  28 #include <stdio.h>
  29 #include <varargs.h>
  30 #if !defined (__NetBSD__) && !defined (__OpenBSD__)
  31 #include <filehdr.h>
  32 #include <aouthdr.h>
  33 #include <scnhdr.h>
  34 #include <syms.h>
  35 #ifndef __linux__
  36 # include <reloc.h>
  37 # include <elf_abi.h>
  38 #endif
  39 #else /* __NetBSD__ or __OpenBSD__ */
  40 /*
  41  * NetBSD/Alpha does not have 'normal' user-land ECOFF support because
  42  * there's no desire to support ECOFF as the executable format in the
  43  * long term.
  44  */
  45 #include <sys/exec_ecoff.h>
  46
  47 /* Structures, constants, etc., that NetBSD defines strangely. */
  48 #define filehdr         ecoff_filehdr
  49 #define aouthdr         ecoff_aouthdr
  50 #define scnhdr          ecoff_scnhdr
  51 #define HDRR            struct ecoff_symhdr
  52 #define pHDRR           HDRR *
  53 #define cbHDRR          sizeof(HDRR)
  54 #ifdef __OpenBSD__
  55 #define ALPHAMAGIC      ECOFF_MAGIC_NATIVE_ALPHA
  56 #else
  57 #define ALPHAMAGIC      ECOFF_MAGIC_NETBSD_ALPHA
  58 #endif
  59 #define ZMAGIC          ECOFF_ZMAGIC
  60
  61 /* Misc. constants that NetBSD doesn't define at all. */
  62 #define ALPHAUMAGIC     0617
  63 #define _MIPS_NSCNS_MAX 35
  64 #define STYP_TEXT       0x00000020
  65 #define STYP_DATA       0x00000040
  66 #define STYP_BSS        0x00000080
  67 #define STYP_RDATA      0x00000100
  68 #define STYP_SDATA      0x00000200
  69 #define STYP_SBSS       0x00000400
  70 #define STYP_INIT       0x80000000
  71 #define _TEXT           ".text"
  72 #define _DATA           ".data"
  73 #define _BSS            ".bss"
  74 #define _INIT           ".init"
  75 #define _RDATA          ".rdata"
  76 #define _SDATA          ".sdata"
  77 #define _SBSS           ".sbss"
  78 #endif /* __NetBSD__ || __OpenBSD__ */
  79
  80 static void fatal_unexec ();
  81 static void mark_x ();
  82
  83 #define READ(_fd, _buffer, _size, _error_message, _error_arg) \
  84         errno = EEOF; \
  85         if (read (_fd, _buffer, _size) != _size) \
  86           fatal_unexec (_error_message, _error_arg);
  87
  88 #define WRITE(_fd, _buffer, _size, _error_message, _error_arg) \
  89         if (write (_fd, _buffer, _size) != _size) \
  90           fatal_unexec (_error_message, _error_arg);
  91
  92 #define SEEK(_fd, _position, _error_message, _error_arg) \
  93         errno = EEOF; \
  94         if (lseek (_fd, _position, L_SET) != _position) \
  95           fatal_unexec (_error_message, _error_arg);
  96
  97 extern int errno;
  98 extern char *strerror ();
  99
 100 void *sbrk ();
 101
 102 #define EEOF -1
 103
 104 static struct scnhdr *text_section;
 105 static struct scnhdr *rel_dyn_section;
 106 static struct scnhdr *dynstr_section;
 107 static struct scnhdr *dynsym_section;
 108 static struct scnhdr *init_section;
 109 static struct scnhdr *finit_section;
 110 static struct scnhdr *rdata_section;
 111 static struct scnhdr *rconst_section;
 112 static struct scnhdr *data_section;
 113 static struct scnhdr *pdata_section;
 114 static struct scnhdr *xdata_section;
 115 static struct scnhdr *got_section;
 116 static struct scnhdr *lit8_section;
 117 static struct scnhdr *lit4_section;
 118 static struct scnhdr *sdata_section;
 119 static struct scnhdr *sbss_section;
 120 static struct scnhdr *bss_section;
 121
 122 static struct scnhdr old_data_scnhdr;
 123
 124 static unsigned long Brk;
 125
 126 struct headers {
 127     struct filehdr fhdr;
 128     struct aouthdr aout;
 129     struct scnhdr section[_MIPS_NSCNS_MAX];
 130 };
 131
 132
 133
 134 /* Define name of label for entry point for the dumped executable.  */
 135
 136 #ifndef DEFAULT_ENTRY_ADDRESS
 137 #define DEFAULT_ENTRY_ADDRESS __start
 138 #endif
 139 \f
 140 unexec (new_name, a_name, data_start, bss_start, entry_address)
 141      char *new_name, *a_name;
 142      unsigned long data_start, bss_start, entry_address;
 143 {
 144   int new, old;
 145   char * oldptr;
 146   struct headers ohdr, nhdr;
 147   struct stat stat;
 148   long pagesize, brk;
 149   long newsyms, symrel;
 150   int nread;
 151   int i;
 152   long vaddr, scnptr;
 153 #define BUFSIZE 8192
 154   char buffer[BUFSIZE];
 155
 156   if ((old = open (a_name, O_RDONLY)) < 0)
 157     fatal_unexec ("opening %s", a_name);
 158
 159   new = creat (new_name, 0666);
 160   if (new < 0) fatal_unexec ("creating %s", new_name);
 161
 162   if ((fstat (old, &stat) == -1))
 163     fatal_unexec ("fstat %s", a_name);
 164
 165   oldptr = (char *)mmap (0, stat.st_size, PROT_READ, MAP_FILE|MAP_SHARED, old, 0);
 166
 167   if (oldptr == (char *)-1)
 168     fatal_unexec ("mmap %s", a_name);
 169
 170   close (old);
 171
 172   /* This is a copy of the a.out header of the original executable */
 173
 174   ohdr = (*(struct headers *)oldptr);
 175
 176   /* This is where we build the new header from the in-memory copy */
 177
 178   nhdr = *((struct headers *)TEXT_START);
 179
 180   /* First do some consistency checks */
 181
 182   if (nhdr.fhdr.f_magic != ALPHAMAGIC
 183       && nhdr.fhdr.f_magic != ALPHAUMAGIC)
 184     {
 185       fprintf (stderr, "unexec: input file magic number is %x, not %x or %x.\n",
 186                nhdr.fhdr.f_magic, ALPHAMAGIC, ALPHAUMAGIC);
 187       exit (1);
 188     }
 189
 190   if (nhdr.fhdr.f_opthdr != sizeof (nhdr.aout))
 191     {
 192       fprintf (stderr, "unexec: input a.out header is %d bytes, not %d.\n",
 193                nhdr.fhdr.f_opthdr, (int)sizeof (nhdr.aout));
 194       exit (1);
 195     }
 196   if (nhdr.aout.magic != ZMAGIC)
 197     {
 198       fprintf (stderr, "unexec: input file a.out magic number is %o, not %o.\n",
 199                nhdr.aout.magic, ZMAGIC);
 200       exit (1);
 201     }
 202
 203
 204   /* Now check the existence of certain header section and grab
 205      their addresses. */
 206
 207 #define CHECK_SCNHDR(ptr, name, flags)                                  \
 208   ptr = NULL;                                                           \
 209   for (i = 0; i < nhdr.fhdr.f_nscns && !ptr; i++)                       \
 210     if (strncmp (nhdr.section[i].s_name, name, 8) == 0)                 \
 211       {                                                                 \
 212         if (nhdr.section[i].s_flags != flags)                           \
 213           fprintf (stderr, "unexec: %x flags (%x expected) in %s section.\n", \
 214                    nhdr.section[i].s_flags, flags, name);               \
 215         ptr = nhdr.section + i;                                         \
 216       }                                                                 \
 217
 218   CHECK_SCNHDR (text_section,  _TEXT,  STYP_TEXT);
 219   CHECK_SCNHDR (init_section,  _INIT,  STYP_INIT);
 220 #ifdef _REL_DYN
 221   CHECK_SCNHDR (rel_dyn_section, _REL_DYN,  STYP_REL_DYN);
 222 #endif /* _REL_DYN */
 223 #ifdef _DYNSYM
 224   CHECK_SCNHDR (dynsym_section, _DYNSYM,  STYP_DYNSYM);
 225 #endif /* _REL_DYN */
 226 #ifdef _DYNSTR
 227   CHECK_SCNHDR (dynstr_section, _DYNSTR,  STYP_DYNSTR);
 228 #endif /* _REL_DYN */
 229 #ifdef _FINI
 230   CHECK_SCNHDR (finit_section, _FINI,  STYP_FINI);
 231 #endif /* _FINI */
 232   CHECK_SCNHDR (rdata_section, _RDATA, STYP_RDATA);
 233 #ifdef _RCONST
 234   CHECK_SCNHDR (rconst_section, _RCONST, STYP_RCONST);
 235 #endif
 236 #ifdef _PDATA
 237   CHECK_SCNHDR (pdata_section, _PDATA, STYP_PDATA);
 238 #endif _PDATA
 239 #ifdef _GOT
 240   CHECK_SCNHDR (got_section,   _GOT,   STYP_GOT);
 241 #endif _GOT
 242   CHECK_SCNHDR (data_section,  _DATA,  STYP_DATA);
 243 #ifdef _XDATA
 244   CHECK_SCNHDR (xdata_section, _XDATA, STYP_XDATA);
 245 #endif /* _XDATA */
 246 #ifdef _LIT8
 247   CHECK_SCNHDR (lit8_section,  _LIT8,  STYP_LIT8);
 248   CHECK_SCNHDR (lit4_section,  _LIT4,  STYP_LIT4);
 249 #endif /* _LIT8 */
 250   CHECK_SCNHDR (sdata_section, _SDATA, STYP_SDATA);
 251   CHECK_SCNHDR (sbss_section,  _SBSS,  STYP_SBSS);
 252   CHECK_SCNHDR (bss_section,   _BSS,   STYP_BSS);
 253
 254
 255   pagesize = getpagesize ();
 256   brk = (((long) (sbrk (0))) + pagesize - 1) & (-pagesize);
 257
 258   /* Remember the current break */
 259
 260   Brk = brk;
 261
 262   bcopy (data_section, &old_data_scnhdr, sizeof (old_data_scnhdr));
 263
 264   nhdr.aout.dsize = brk - DATA_START;
 265   nhdr.aout.bsize = 0;
 266   if (entry_address == 0)
 267     {
 268       extern DEFAULT_ENTRY_ADDRESS ();
 269       nhdr.aout.entry = (unsigned long)DEFAULT_ENTRY_ADDRESS;
 270     }
 271   else
 272     nhdr.aout.entry = entry_address;
 273
 274   nhdr.aout.bss_start = nhdr.aout.data_start + nhdr.aout.dsize;
 275
 276   if (rdata_section != NULL)
 277     {
 278       rdata_section->s_size = data_start - DATA_START;
 279
 280       /* Adjust start and virtual addresses of rdata_section, too.  */
 281       rdata_section->s_vaddr = DATA_START;
 282       rdata_section->s_paddr = DATA_START;
 283       rdata_section->s_scnptr = text_section->s_scnptr + nhdr.aout.tsize;
 284     }
 285
 286   data_section->s_vaddr = data_start;
 287   data_section->s_paddr = data_start;
 288   data_section->s_size = brk - data_start;
 289
 290   if (rdata_section != NULL)
 291     {
 292       data_section->s_scnptr = rdata_section->s_scnptr + rdata_section->s_size;
 293     }
 294
 295   vaddr = data_section->s_vaddr + data_section->s_size;
 296   scnptr = data_section->s_scnptr + data_section->s_size;
 297   if (lit8_section != NULL)
 298     {
 299       lit8_section->s_vaddr = vaddr;
 300       lit8_section->s_paddr = vaddr;
 301       lit8_section->s_size = 0;
 302       lit8_section->s_scnptr = scnptr;
 303     }
 304   if (lit4_section != NULL)
 305     {
 306       lit4_section->s_vaddr = vaddr;
 307       lit4_section->s_paddr = vaddr;
 308       lit4_section->s_size = 0;
 309       lit4_section->s_scnptr = scnptr;
 310     }
 311   if (sdata_section != NULL)
 312     {
 313       sdata_section->s_vaddr = vaddr;
 314       sdata_section->s_paddr = vaddr;
 315       sdata_section->s_size = 0;
 316       sdata_section->s_scnptr = scnptr;
 317     }
 318 #ifdef _XDATA
 319   if (xdata_section != NULL)
 320     {
 321       xdata_section->s_vaddr = vaddr;
 322       xdata_section->s_paddr = vaddr;
 323       xdata_section->s_size = 0;
 324       xdata_section->s_scnptr = scnptr;
 325     }
 326 #endif
 327 #ifdef _GOT
 328   if (got_section != NULL)
 329     {
 330       bcopy (got_section, buffer, sizeof (struct scnhdr));
 331
 332       got_section->s_vaddr = vaddr;
 333       got_section->s_paddr = vaddr;
 334       got_section->s_size = 0;
 335       got_section->s_scnptr = scnptr;
 336     }
 337 #endif /*_GOT */
 338   if (sbss_section != NULL)
 339     {
 340       sbss_section->s_vaddr = vaddr;
 341       sbss_section->s_paddr = vaddr;
 342       sbss_section->s_size = 0;
 343       sbss_section->s_scnptr = scnptr;
 344     }
 345   if (bss_section != NULL)
 346     {
 347       bss_section->s_vaddr = vaddr;
 348       bss_section->s_paddr = vaddr;
 349       bss_section->s_size = 0;
 350       bss_section->s_scnptr = scnptr;
 351     }
 352
 353   WRITE (new, (char *)TEXT_START, nhdr.aout.tsize,
 354          "writing text section to %s", new_name);
 355   WRITE (new, (char *)DATA_START, nhdr.aout.dsize,
 356          "writing data section to %s", new_name);
 357
 358 #ifdef _GOT
 359 #define old_got_section ((struct scnhdr *)buffer)
 360
 361   if (got_section != NULL)
 362     {
 363       SEEK (new, old_got_section->s_scnptr,
 364             "seeking to start of got_section in %s", new_name);
 365       WRITE (new, oldptr + old_got_section->s_scnptr, old_got_section->s_size,
 366              "writing new got_section of %s", new_name);
 367       SEEK (new, nhdr.aout.tsize + nhdr.aout.dsize,
 368             "seeking to end of data section of %s", new_name);
 369     }
 370
 371 #undef old_got_section
 372 #endif
 373
 374   /*
 375    * Construct new symbol table header
 376    */
 377
 378   bcopy (oldptr + nhdr.fhdr.f_symptr, buffer, cbHDRR);
 379
 380 #define symhdr ((pHDRR)buffer)
 381   newsyms = nhdr.aout.tsize + nhdr.aout.dsize;
 382   symrel = newsyms - nhdr.fhdr.f_symptr;
 383   nhdr.fhdr.f_symptr = newsyms;
 384   symhdr->cbLineOffset += symrel;
 385   symhdr->cbDnOffset += symrel;
 386   symhdr->cbPdOffset += symrel;
 387   symhdr->cbSymOffset += symrel;
 388   symhdr->cbOptOffset += symrel;
 389   symhdr->cbAuxOffset += symrel;
 390   symhdr->cbSsOffset += symrel;
 391   symhdr->cbSsExtOffset += symrel;
 392   symhdr->cbFdOffset += symrel;
 393   symhdr->cbRfdOffset += symrel;
 394   symhdr->cbExtOffset += symrel;
 395
 396   WRITE (new, buffer, cbHDRR, "writing symbol table header of %s", new_name);
 397
 398   /*
 399    * Copy the symbol table and line numbers
 400    */
 401   WRITE (new, oldptr + ohdr.fhdr.f_symptr + cbHDRR,
 402          stat.st_size - ohdr.fhdr.f_symptr - cbHDRR,
 403          "writing symbol table of %s", new_name);
 404
 405 #ifdef _REL_DYN
 406   if (rel_dyn_section)
 407     update_dynamic_symbols (oldptr, new_name, new, nhdr.aout);
 408 #endif
 409
 410 #undef symhdr
 411
 412   SEEK (new, 0, "seeking to start of header in %s", new_name);
 413   WRITE (new, &nhdr, sizeof (nhdr),
 414          "writing header of %s", new_name);
 415
 416   close (old);
 417   close (new);
 418   mark_x (new_name);
 419 }
 420
 421
 422
 423 update_dynamic_symbols (old, new_name, new, aout)
 424      char *old;                 /* Pointer to old executable */
 425      char *new_name;            /* Name of new executable */
 426      int new;                   /* File descriptor for new executable */
 427      struct aouthdr aout;       /* a.out info from the file header */
 428 {
 429 #if !defined (__linux__) && !defined (__NetBSD__) && !defined (__OpenBSD__)
 430
 431   typedef struct dynrel_info {
 432     char * addr;
 433     unsigned type:8;
 434     unsigned index:24;
 435     unsigned info:8;
 436     unsigned pad:8;
 437   } dr_info;
 438
 439   int nsyms = rel_dyn_section->s_size / sizeof (struct dynrel_info);
 440   int i;
 441   dr_info * rd_base = (dr_info *) (old + rel_dyn_section->s_scnptr);
 442   Elf32_Sym * ds_base = (Elf32_Sym *) (old + dynsym_section->s_scnptr);
 443
 444   for (i = 0; i < nsyms; i++) {
 445     register Elf32_Sym x;
 446
 447     if (rd_base[i].index == 0)
 448       continue;
 449
 450     x = ds_base[rd_base[i].index];
 451
 452 #if 0
 453       fprintf (stderr, "Object inspected: %s, addr = %lx, shndx = %x",
 454                old + dynstr_section->s_scnptr + x.st_name, rd_base[i].addr, x.st_shndx);
 455 #endif
 456
 457
 458     if ((ELF32_ST_BIND (x.st_info) == STB_GLOBAL)
 459         && (x.st_shndx == 0)
 460         /* && (x.st_value == NULL) */
 461         ) {
 462       /* OK, this is probably a reference to an object in a shared
 463          library, so copy the old value. This is done in several steps:
 464          1. reladdr is the address of the location in question relative to
 465             the start of the data section,
 466          2. oldref is the addr is the mapped in temacs executable,
 467          3. newref is the address of the location in question in the
 468             undumped executable,
 469          4. len is the size of the object reference in bytes --
 470             currently only 4 (long) and 8 (quad) are supported.
 471             */
 472       register unsigned long reladdr = (long)rd_base[i].addr - old_data_scnhdr.s_vaddr;
 473       char * oldref = old + old_data_scnhdr.s_scnptr + reladdr;
 474       unsigned long newref = aout.tsize + reladdr;
 475       int len;
 476
 477 #if 0
 478       fprintf (stderr, "...relocated\n");
 479 #endif
 480
 481       if (rd_base[i].type == R_REFLONG)
 482         len = 4;
 483       else if (rd_base[i].type == R_REFQUAD)
 484         len = 8;
 485       else
 486         fatal_unexec ("unrecognized relocation type in .dyn.rel section (symbol #%d)", i);
 487
 488       SEEK (new, newref, "seeking to dynamic symbol in %s", new_name);
 489       WRITE (new, oldref, len, "writing old dynrel info in %s", new_name);
 490     }
 491
 492 #if 0
 493     else
 494       fprintf (stderr, "...not relocated\n");
 495 #endif
 496
 497   }
 498
 499 #endif /* not __linux__ and not __NetBSD__ and not __OpenBSD__ */
 500 }
 501
 502 \f
 503 /*
 504  * mark_x
 505  *
 506  * After successfully building the new a.out, mark it executable
 507  */
 508
 509 static void
 510 mark_x (name)
 511      char *name;
 512 {
 513   struct stat sbuf;
 514   int um = umask (777);
 515   umask (um);
 516   if (stat (name, &sbuf) < 0)
 517     fatal_unexec ("getting protection on %s", name);
 518   sbuf.st_mode |= 0111 & ~um;
 519   if (chmod (name, sbuf.st_mode) < 0)
 520     fatal_unexec ("setting protection on %s", name);
 521 }
 522
 523 static void
 524 fatal_unexec (s, arg)
 525      char *s;
 526      char *arg;
 527 {
 528   if (errno == EEOF)
 529     fputs ("unexec: unexpected end of file, ", stderr);
 530   else
 531     fprintf (stderr, "unexec: %s, ", strerror (errno));
 532   fprintf (stderr, s, arg);
 533   fputs (".\n", stderr);
 534   exit (1);
 535 }