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