Mercurial > hg > xemacs-beta

comparison src/unexalpha.c @ 428:3ecd8885ac67 r21-2-22

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