git.chise.org Git - chise/xemacs-chise.git.1/blob - 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 /* Synched up with: FSF 19.31. */
  23
  24 \f
  25 #include <config.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <sys/types.h>
  30 #include <sys/file.h>
  31 #include <sys/stat.h>
  32 #include <sys/mman.h>
  33 #include <stdio.h>
  34 #include <varargs.h>
  35 #include <filehdr.h>
  36 #include <aouthdr.h>
  37 #include <scnhdr.h>
  38 #include <syms.h>
  39
  40 static void fatal_unexec (char *, char *);
  41 static void mark_x (char *);
  42
  43 #define READ(_fd, _buffer, _size, _error_message, _error_arg) \
  44         errno = EEOF; \
  45         if (read (_fd, _buffer, _size) != _size) \
  46           fatal_unexec (_error_message, _error_arg);
  47
  48 #define WRITE(_fd, _buffer, _size, _error_message, _error_arg) \
  49         if (write (_fd, _buffer, _size) != _size) \
  50           fatal_unexec (_error_message, _error_arg);
  51
  52 #define SEEK(_fd, _position, _error_message, _error_arg) \
  53         errno = EEOF; \
  54         if (lseek (_fd, _position, L_SET) != _position) \
  55           fatal_unexec (_error_message, _error_arg);
  56
  57 extern int errno;
  58 extern char *strerror ();
  59
  60 void *sbrk();
  61
  62 #define EEOF -1
  63
  64 static struct scnhdr *text_section;
  65 static struct scnhdr *init_section;
  66 static struct scnhdr *finit_section;
  67 static struct scnhdr *rdata_section;
  68 static struct scnhdr *rconst_section;
  69 static struct scnhdr *data_section;
  70 static struct scnhdr *pdata_section;
  71 static struct scnhdr *xdata_section;
  72 static struct scnhdr *got_section;
  73 static struct scnhdr *lit8_section;
  74 static struct scnhdr *lit4_section;
  75 static struct scnhdr *sdata_section;
  76 static struct scnhdr *sbss_section;
  77 static struct scnhdr *bss_section;
  78
  79 static unsigned long Brk;
  80
  81 struct headers {
  82     struct filehdr fhdr;
  83     struct aouthdr aout;
  84     struct scnhdr section[_MIPS_NSCNS_MAX];
  85 };
  86
  87
  88
  89 /* Define name of label for entry point for the dumped executable.  */
  90
  91 #ifndef DEFAULT_ENTRY_ADDRESS
  92 #define DEFAULT_ENTRY_ADDRESS __start
  93 #endif
  94 \f
  95 unexec (new_name, a_name, data_start, bss_start, entry_address)
  96      char *new_name, *a_name;
  97      unsigned long data_start, bss_start, entry_address;
  98 {
  99   int new, old;
 100   char * oldptr;
 101   struct headers ohdr, nhdr;
 102   struct stat stat;
 103   long pagesize, brk;
 104   long newsyms, symrel;
 105   int nread;
 106   int i;
 107   long vaddr, scnptr;
 108 #define BUFSIZE 8192
 109   char buffer[BUFSIZE];
 110
 111   if ((old = open (a_name, O_RDONLY)) < 0)
 112     fatal_unexec ("opening %s", a_name);
 113
 114   new = creat (new_name, 0666);
 115   if (new < 0) fatal_unexec ("creating %s", new_name);
 116
 117   if ((fstat (old, &stat) == -1))
 118     fatal_unexec ("fstat %s", a_name);
 119
 120   oldptr = (char *)mmap (0, stat.st_size, PROT_READ, MAP_FILE|MAP_SHARED, old, 0);
 121
 122   if (oldptr == (char *)-1)
 123     fatal_unexec ("mmap %s", a_name);
 124
 125   close (old);
 126
 127   /* This is a copy of the a.out header of the original executable */
 128
 129   ohdr = (*(struct headers *)oldptr);
 130
 131   /* This is where we build the new header from the in-memory copy */
 132
 133   nhdr = *((struct headers *)TEXT_START);
 134
 135   /* First do some consistency checks */
 136
 137   if (nhdr.fhdr.f_magic != ALPHAMAGIC
 138       && nhdr.fhdr.f_magic != ALPHAUMAGIC)
 139     {
 140       fprintf (stderr, "unexec: input file magic number is %x, not %x or %x.\n",
 141                nhdr.fhdr.f_magic, ALPHAMAGIC, ALPHAUMAGIC);
 142       exit (1);
 143     }
 144
 145   if (nhdr.fhdr.f_opthdr != sizeof (nhdr.aout))
 146     {
 147       fprintf (stderr, "unexec: input a.out header is %d bytes, not %ld.\n",
 148                nhdr.fhdr.f_opthdr, (long) (sizeof (nhdr.aout)));
 149       exit (1);
 150     }
 151   if (nhdr.aout.magic != ZMAGIC)
 152     {
 153       fprintf (stderr, "unexec: input file a.out magic number is %o, not %o.\n",
 154                nhdr.aout.magic, ZMAGIC);
 155       exit (1);
 156     }
 157
 158
 159   /* Now check the existence of certain header section and grab
 160      their addresses. */
 161
 162 #define CHECK_SCNHDR(ptr, name, flags)                                  \
 163   ptr = NULL;                                                           \
 164   for (i = 0; i < nhdr.fhdr.f_nscns && !ptr; i++)                       \
 165     if (strcmp (nhdr.section[i].s_name, name) == 0)                     \
 166       {                                                                 \
 167         if (nhdr.section[i].s_flags != flags)                           \
 168           fprintf (stderr, "unexec: %x flags (%x expected) in %s section.\n", \
 169                    nhdr.section[i].s_flags, flags, name);               \
 170         ptr = nhdr.section + i;                                         \
 171       }                                                                 \
 172
 173   CHECK_SCNHDR (text_section,  _TEXT,  STYP_TEXT);
 174   CHECK_SCNHDR (init_section,  _INIT,  STYP_INIT);
 175 #ifdef _FINI
 176   CHECK_SCNHDR (finit_section, _FINI,  STYP_FINI);
 177 #endif /* _FINI */
 178   CHECK_SCNHDR (rdata_section, _RDATA, STYP_RDATA);
 179 #ifdef _RCONST
 180   CHECK_SCNHDR (rconst_section, _RCONST, STYP_RCONST);
 181 #endif
 182 #ifdef _PDATA
 183   CHECK_SCNHDR (pdata_section, _PDATA, STYP_PDATA);
 184 #endif /* _PDATA */
 185 #ifdef _GOT
 186   CHECK_SCNHDR (got_section,   _GOT,   STYP_GOT);
 187 #endif /* _GOT */
 188   CHECK_SCNHDR (data_section,  _DATA,  STYP_DATA);
 189 #ifdef _XDATA
 190   CHECK_SCNHDR (xdata_section, _XDATA, STYP_XDATA);
 191 #endif /* _XDATA */
 192 #ifdef _LIT8
 193   CHECK_SCNHDR (lit8_section,  _LIT8,  STYP_LIT8);
 194   CHECK_SCNHDR (lit4_section,  _LIT4,  STYP_LIT4);
 195 #endif /* _LIT8 */
 196   CHECK_SCNHDR (sdata_section, _SDATA, STYP_SDATA);
 197   CHECK_SCNHDR (sbss_section,  _SBSS,  STYP_SBSS);
 198   CHECK_SCNHDR (bss_section,   _BSS,   STYP_BSS);
 199
 200
 201   pagesize = getpagesize ();
 202   brk = (((long) (sbrk (0))) + pagesize - 1) & (-pagesize);
 203
 204   /* Remember the current break */
 205
 206   Brk = brk;
 207
 208   nhdr.aout.dsize = brk - DATA_START;
 209   nhdr.aout.bsize = 0;
 210   if (entry_address == 0)
 211     {
 212       extern DEFAULT_ENTRY_ADDRESS ();
 213       nhdr.aout.entry = (unsigned long)DEFAULT_ENTRY_ADDRESS;
 214     }
 215   else
 216     nhdr.aout.entry = entry_address;
 217
 218   nhdr.aout.bss_start = nhdr.aout.data_start + nhdr.aout.dsize;
 219
 220   if (rdata_section != NULL)
 221     {
 222       rdata_section->s_size = data_start - DATA_START;
 223
 224       /* Adjust start and virtual addresses of rdata_section, too.  */
 225       rdata_section->s_vaddr = DATA_START;
 226       rdata_section->s_paddr = DATA_START;
 227       rdata_section->s_scnptr = text_section->s_scnptr + nhdr.aout.tsize;
 228     }
 229
 230   data_section->s_vaddr = data_start;
 231   data_section->s_paddr = data_start;
 232   data_section->s_size = brk - data_start;
 233
 234   if (rdata_section != NULL)
 235     {
 236       data_section->s_scnptr = rdata_section->s_scnptr + rdata_section->s_size;
 237     }
 238
 239   vaddr = data_section->s_vaddr + data_section->s_size;
 240   scnptr = data_section->s_scnptr + data_section->s_size;
 241   if (lit8_section != NULL)
 242     {
 243       lit8_section->s_vaddr = vaddr;
 244       lit8_section->s_paddr = vaddr;
 245       lit8_section->s_size = 0;
 246       lit8_section->s_scnptr = scnptr;
 247     }
 248   if (lit4_section != NULL)
 249     {
 250       lit4_section->s_vaddr = vaddr;
 251       lit4_section->s_paddr = vaddr;
 252       lit4_section->s_size = 0;
 253       lit4_section->s_scnptr = scnptr;
 254     }
 255   if (sdata_section != NULL)
 256     {
 257       sdata_section->s_vaddr = vaddr;
 258       sdata_section->s_paddr = vaddr;
 259       sdata_section->s_size = 0;
 260       sdata_section->s_scnptr = scnptr;
 261     }
 262 #ifdef _XDATA
 263   if (xdata_section != NULL)
 264     {
 265       xdata_section->s_vaddr = vaddr;
 266       xdata_section->s_paddr = vaddr;
 267       xdata_section->s_size = 0;
 268       xdata_section->s_scnptr = scnptr;
 269     }
 270 #endif
 271 #ifdef _GOT
 272   if (got_section != NULL)
 273     {
 274       got_section->s_vaddr = vaddr;
 275       got_section->s_paddr = vaddr;
 276       got_section->s_size = 0;
 277       got_section->s_scnptr = scnptr;
 278     }
 279 #endif /*_GOT */
 280   if (sbss_section != NULL)
 281     {
 282       sbss_section->s_vaddr = vaddr;
 283       sbss_section->s_paddr = vaddr;
 284       sbss_section->s_size = 0;
 285       sbss_section->s_scnptr = scnptr;
 286     }
 287   if (bss_section != NULL)
 288     {
 289       bss_section->s_vaddr = vaddr;
 290       bss_section->s_paddr = vaddr;
 291       bss_section->s_size = 0;
 292       bss_section->s_scnptr = scnptr;
 293     }
 294
 295   WRITE (new, (char *)TEXT_START, nhdr.aout.tsize,
 296          "writing text section to %s", new_name);
 297   WRITE (new, (char *)DATA_START, nhdr.aout.dsize,
 298          "writing data section to %s", new_name);
 299
 300
 301   /*
 302    * Construct new symbol table header
 303    */
 304
 305   memcpy (buffer, oldptr + nhdr.fhdr.f_symptr, cbHDRR);
 306
 307 #define symhdr ((pHDRR)buffer)
 308   newsyms = nhdr.aout.tsize + nhdr.aout.dsize;
 309   symrel = newsyms - nhdr.fhdr.f_symptr;
 310   nhdr.fhdr.f_symptr = newsyms;
 311   symhdr->cbLineOffset += symrel;
 312   symhdr->cbDnOffset += symrel;
 313   symhdr->cbPdOffset += symrel;
 314   symhdr->cbSymOffset += symrel;
 315   symhdr->cbOptOffset += symrel;
 316   symhdr->cbAuxOffset += symrel;
 317   symhdr->cbSsOffset += symrel;
 318   symhdr->cbSsExtOffset += symrel;
 319   symhdr->cbFdOffset += symrel;
 320   symhdr->cbRfdOffset += symrel;
 321   symhdr->cbExtOffset += symrel;
 322
 323   WRITE (new, buffer, cbHDRR, "writing symbol table header of %s", new_name);
 324
 325   /*
 326    * Copy the symbol table and line numbers
 327    */
 328   WRITE (new, oldptr + ohdr.fhdr.f_symptr + cbHDRR,
 329          stat.st_size - ohdr.fhdr.f_symptr - cbHDRR,
 330          "writing symbol table of %s", new_name);
 331
 332 #if 0
 333
 334 /* Not needed for now */
 335
 336   update_dynamic_symbols (oldptr, new_name, new, newsyms,
 337                           ((pHDRR) (oldptr + ohdr.fhdr.f_symptr))->issExtMax,
 338                           ((pHDRR) (oldptr + ohdr.fhdr.f_symptr))->cbExtOffset,
 339                           ((pHDRR) (oldptr + ohdr.fhdr.f_symptr))->cbSsExtOffset);
 340
 341 #endif
 342
 343 #undef symhdr
 344
 345   SEEK (new, 0, "seeking to start of header in %s", new_name);
 346   WRITE (new, &nhdr, sizeof (nhdr),
 347          "writing header of %s", new_name);
 348
 349   close (old);
 350   close (new);
 351   mark_x (new_name);
 352   return 0;
 353 }
 354
 355
 356 #if 0
 357
 358 /* Not needed for now */
 359
 360 /* The following function updates the values of some symbols
 361    that are used by the dynamic loader:
 362
 363    _edata
 364    _end
 365
 366 */
 367
 368
 369 update_dynamic_symbols (old, new_name, new, newsyms, nsyms, symoff, stroff)
 370      char *old;                 /* Pointer to old executable */
 371      char *new_name;            /* Name of new executable */
 372      int new;                   /* File descriptor for new executable */
 373      long newsyms;              /* Offset of Symbol table in new executable */
 374      int nsyms;                 /* Number of symbol table entries */
 375      long symoff;               /* Offset of External Symbols in old file */
 376      long stroff;               /* Offset of string table in old file */
 377 {
 378   long i;
 379   int found = 0;
 380   EXTR n_end, n_edata;
 381
 382   /* We go through the symbol table entries until we have found the two
 383      symbols. */
 384
 385   /* cbEXTR is the size of an external symbol table entry */
 386
 387   for (i = 0; i < nsyms && found < 2; i += cbEXTR)
 388     {
 389       REGISTER pEXTR x = (pEXTR) (old + symoff + i);
 390       char *s;
 391
 392       s = old + stroff + x->asym.iss; /* name of the symbol */
 393
 394       if (!strcmp(s,"_edata"))
 395         {
 396           found++;
 397           memcpy (&n_edata, x, cbEXTR);
 398           n_edata.asym.value = Brk;
 399           SEEK (new, newsyms + cbHDRR + i,
 400                 "seeking to symbol _edata in %s", new_name);
 401           WRITE (new, &n_edata, cbEXTR,
 402                  "writing symbol table entry for _edata into %s", new_name);
 403         }
 404       else if (!strcmp(s,"_end"))
 405         {
 406           found++;
 407           memcpy (&n_end, x, cbEXTR);
 408           n_end.asym.value = Brk;
 409           SEEK (new, newsyms + cbHDRR + i,
 410                 "seeking to symbol _end in %s", new_name);
 411           WRITE (new, &n_end, cbEXTR,
 412                  "writing symbol table entry for _end into %s", new_name);
 413         }
 414     }
 415
 416 }
 417
 418 #endif
 419
 420 \f
 421 /*
 422  * mark_x
 423  *
 424  * After successfully building the new a.out, mark it executable
 425  */
 426
 427 static void
 428 mark_x (char *name)
 429 {
 430   struct stat sbuf;
 431   int um = umask (777);
 432   umask (um);
 433   if (stat (name, &sbuf) < 0)
 434     fatal_unexec ("getting protection on %s", name);
 435   sbuf.st_mode |= 0111 & ~um;
 436   if (chmod (name, sbuf.st_mode) < 0)
 437     fatal_unexec ("setting protection on %s", name);
 438 }
 439
 440 static void
 441 fatal_unexec (char *s, char *arg)
 442 {
 443   if (errno == EEOF)
 444     fputs ("unexec: unexpected end of file, ", stderr);
 445   else
 446     fprintf (stderr, "unexec: %s, ", strerror (errno));
 447   fprintf (stderr, s, arg);
 448   fputs (".\n", stderr);
 449   exit (1);
 450 }