]> code.delx.au - gnu-emacs/blob - src/unexaix.c
Merge from emacs-24; up to 2012-12-30T19:34:25Z!jan.h.d@swipnet.se
[gnu-emacs] / 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 <inttypes.h>
55 #include <stdarg.h>
56 #include <stdio.h>
57 #include <sys/stat.h>
58 #include <errno.h>
59 #include <unistd.h>
60 #include <fcntl.h>
61
62 extern char _data[];
63 extern char _text[];
64
65 #include <filehdr.h>
66 #include <aouthdr.h>
67 #include <scnhdr.h>
68 #include <syms.h>
69
70 static struct filehdr f_hdr; /* File header */
71 static struct aouthdr f_ohdr; /* Optional file header (a.out) */
72 static off_t bias; /* Bias to add for growth */
73 static off_t lnnoptr; /* Pointer to line-number info within file */
74
75 static off_t text_scnptr;
76 static off_t data_scnptr;
77 #define ALIGN(val, pwr) (((val) + ((1L<<(pwr))-1)) & ~((1L<<(pwr))-1))
78 static off_t load_scnptr;
79 static off_t orig_load_scnptr;
80 static off_t orig_data_scnptr;
81 static int unrelocate_symbols (int, int, const char *, const char *);
82
83 #ifndef MAX_SECTIONS
84 #define MAX_SECTIONS 10
85 #endif
86
87 static int adjust_lnnoptrs (int, int, const char *);
88
89 static int pagemask;
90
91 #include "lisp.h"
92
93 static _Noreturn void
94 report_error (const char *file, int fd)
95 {
96 if (fd)
97 {
98 int failed_errno = errno;
99 close (fd);
100 errno = failed_errno;
101 }
102 report_file_error ("Cannot unexec", Fcons (build_string (file), Qnil));
103 }
104
105 #define ERROR0(msg) report_error_1 (new, msg)
106 #define ERROR1(msg,x) report_error_1 (new, msg, x)
107 #define ERROR2(msg,x,y) report_error_1 (new, msg, x, y)
108
109 static _Noreturn void ATTRIBUTE_FORMAT_PRINTF (2, 3)
110 report_error_1 (int fd, const char *msg, ...)
111 {
112 va_list ap;
113 close (fd);
114 va_start (ap, msg);
115 verror (msg, ap);
116 va_end (ap);
117 }
118
119 static int make_hdr (int, int, const char *, const char *);
120 static void mark_x (const char *);
121 static int copy_text_and_data (int);
122 static int copy_sym (int, int, const char *, const char *);
123 static void write_segment (int, char *, char *);
124 \f
125 /* ****************************************************************
126 * unexec
127 *
128 * driving logic.
129 */
130 void
131 unexec (const char *new_name, const char *a_name)
132 {
133 int new = -1, a_out = -1;
134
135 if (a_name && (a_out = open (a_name, O_RDONLY)) < 0)
136 {
137 PERROR (a_name);
138 }
139 if ((new = creat (new_name, 0666)) < 0)
140 {
141 PERROR (new_name);
142 }
143 if (make_hdr (new, a_out,
144 a_name, new_name) < 0
145 || copy_text_and_data (new) < 0
146 || copy_sym (new, a_out, a_name, new_name) < 0
147 || adjust_lnnoptrs (new, a_out, new_name) < 0
148 || unrelocate_symbols (new, a_out, a_name, new_name) < 0)
149 {
150 close (new);
151 return;
152 }
153
154 close (new);
155 if (a_out >= 0)
156 close (a_out);
157 mark_x (new_name);
158 }
159
160 /* ****************************************************************
161 * make_hdr
162 *
163 * Make the header in the new a.out from the header in core.
164 * Modify the text and data sizes.
165 */
166 static int
167 make_hdr (int new, int a_out,
168 const char *a_name, const char *new_name)
169 {
170 int scns;
171 uintptr_t bss_start;
172 uintptr_t data_start;
173
174 struct scnhdr section[MAX_SECTIONS];
175 struct scnhdr * f_thdr; /* Text section header */
176 struct scnhdr * f_dhdr; /* Data section header */
177 struct scnhdr * f_bhdr; /* Bss section header */
178 struct scnhdr * f_lhdr; /* Loader section header */
179 struct scnhdr * f_tchdr; /* Typechk section header */
180 struct scnhdr * f_dbhdr; /* Debug section header */
181 struct scnhdr * f_xhdr; /* Except section header */
182
183 load_scnptr = orig_load_scnptr = lnnoptr = 0;
184 pagemask = getpagesize () - 1;
185
186 /* Adjust text/data boundary. */
187 data_start = (uintptr_t) _data;
188
189 data_start = data_start & ~pagemask; /* (Down) to page boundary. */
190
191 bss_start = (uintptr_t) sbrk (0) + pagemask;
192 bss_start &= ~ pagemask;
193
194 if (data_start > bss_start) /* Can't have negative data size. */
195 {
196 ERROR2 (("unexec: data_start (0x%"PRIxPTR
197 ") can't be greater than bss_start (0x%"PRIxPTR")"),
198 data_start, bss_start);
199 }
200
201 /* Salvage as much info from the existing file as possible */
202 f_thdr = NULL; f_dhdr = NULL; f_bhdr = NULL;
203 f_lhdr = NULL; f_tchdr = NULL; f_dbhdr = NULL; f_xhdr = NULL;
204 if (a_out >= 0)
205 {
206 if (read (a_out, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
207 {
208 PERROR (a_name);
209 }
210 if (f_hdr.f_opthdr > 0)
211 {
212 if (read (a_out, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
213 {
214 PERROR (a_name);
215 }
216 }
217 if (f_hdr.f_nscns > MAX_SECTIONS)
218 {
219 ERROR0 ("unexec: too many section headers -- increase MAX_SECTIONS");
220 }
221 /* Loop through section headers */
222 for (scns = 0; scns < f_hdr.f_nscns; scns++) {
223 struct scnhdr *s = &section[scns];
224 if (read (a_out, s, sizeof (*s)) != sizeof (*s))
225 {
226 PERROR (a_name);
227 }
228
229 #define CHECK_SCNHDR(ptr, name, flags) \
230 if (strcmp (s->s_name, name) == 0) { \
231 if (s->s_flags != flags) { \
232 fprintf (stderr, "unexec: %lx flags where %x expected in %s section.\n", \
233 (unsigned long)s->s_flags, flags, name); \
234 } \
235 if (ptr) { \
236 fprintf (stderr, "unexec: duplicate section header for section %s.\n", \
237 name); \
238 } \
239 ptr = s; \
240 }
241 CHECK_SCNHDR (f_thdr, _TEXT, STYP_TEXT);
242 CHECK_SCNHDR (f_dhdr, _DATA, STYP_DATA);
243 CHECK_SCNHDR (f_bhdr, _BSS, STYP_BSS);
244 CHECK_SCNHDR (f_lhdr, _LOADER, STYP_LOADER);
245 CHECK_SCNHDR (f_dbhdr, _DEBUG, STYP_DEBUG);
246 CHECK_SCNHDR (f_tchdr, _TYPCHK, STYP_TYPCHK);
247 CHECK_SCNHDR (f_xhdr, _EXCEPT, STYP_EXCEPT);
248 }
249
250 if (f_thdr == 0)
251 {
252 ERROR1 ("unexec: couldn't find \"%s\" section", (int) _TEXT);
253 }
254 if (f_dhdr == 0)
255 {
256 ERROR1 ("unexec: couldn't find \"%s\" section", (int) _DATA);
257 }
258 if (f_bhdr == 0)
259 {
260 ERROR1 ("unexec: couldn't find \"%s\" section", (int) _BSS);
261 }
262 }
263 else
264 {
265 ERROR0 ("can't build a COFF file from scratch yet");
266 }
267 orig_data_scnptr = f_dhdr->s_scnptr;
268 orig_load_scnptr = f_lhdr ? f_lhdr->s_scnptr : 0;
269
270 /* Now we alter the contents of all the f_*hdr variables
271 to correspond to what we want to dump. */
272
273 /* Indicate that the reloc information is no longer valid for ld (bind);
274 we only update it enough to fake out the exec-time loader. */
275 f_hdr.f_flags |= (F_RELFLG | F_EXEC);
276
277 f_ohdr.dsize = bss_start - f_ohdr.data_start;
278 f_ohdr.bsize = 0;
279
280 f_dhdr->s_size = f_ohdr.dsize;
281 f_bhdr->s_size = f_ohdr.bsize;
282 f_bhdr->s_paddr = f_ohdr.data_start + f_ohdr.dsize;
283 f_bhdr->s_vaddr = f_ohdr.data_start + f_ohdr.dsize;
284
285 /* fix scnptr's */
286 {
287 off_t ptr = section[0].s_scnptr;
288
289 bias = -1;
290 for (scns = 0; scns < f_hdr.f_nscns; scns++)
291 {
292 struct scnhdr *s = &section[scns];
293
294 if (s->s_flags & STYP_PAD) /* .pad sections omitted in AIX 4.1 */
295 {
296 /*
297 * the text_start should probably be o_algntext but that doesn't
298 * seem to change
299 */
300 if (f_ohdr.text_start != 0) /* && scns != 0 */
301 {
302 s->s_size = 512 - (ptr % 512);
303 if (s->s_size == 512)
304 s->s_size = 0;
305 }
306 s->s_scnptr = ptr;
307 }
308 else if (s->s_flags & STYP_DATA)
309 s->s_scnptr = ptr;
310 else if (!(s->s_flags & (STYP_TEXT | STYP_BSS)))
311 {
312 if (bias == -1) /* if first section after bss */
313 bias = ptr - s->s_scnptr;
314
315 s->s_scnptr += bias;
316 ptr = s->s_scnptr;
317 }
318
319 ptr = ptr + s->s_size;
320 }
321 }
322
323 /* fix other pointers */
324 for (scns = 0; scns < f_hdr.f_nscns; scns++)
325 {
326 struct scnhdr *s = &section[scns];
327
328 if (s->s_relptr != 0)
329 {
330 s->s_relptr += bias;
331 }
332 if (s->s_lnnoptr != 0)
333 {
334 if (lnnoptr == 0) lnnoptr = s->s_lnnoptr;
335 s->s_lnnoptr += bias;
336 }
337 }
338
339 if (f_hdr.f_symptr > 0L)
340 {
341 f_hdr.f_symptr += bias;
342 }
343
344 text_scnptr = f_thdr->s_scnptr;
345 data_scnptr = f_dhdr->s_scnptr;
346 load_scnptr = f_lhdr ? f_lhdr->s_scnptr : 0;
347
348 if (write (new, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
349 {
350 PERROR (new_name);
351 }
352
353 if (f_hdr.f_opthdr > 0)
354 {
355 if (write (new, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
356 {
357 PERROR (new_name);
358 }
359 }
360
361 for (scns = 0; scns < f_hdr.f_nscns; scns++) {
362 struct scnhdr *s = &section[scns];
363 if (write (new, s, sizeof (*s)) != sizeof (*s))
364 {
365 PERROR (new_name);
366 }
367 }
368
369 return (0);
370 }
371 \f
372 /* ****************************************************************
373
374 *
375 * Copy the text and data segments from memory to the new a.out
376 */
377 static int
378 copy_text_and_data (int new)
379 {
380 char *end;
381 char *ptr;
382
383 lseek (new, text_scnptr, SEEK_SET);
384 ptr = _text + text_scnptr;
385 end = ptr + f_ohdr.tsize;
386 write_segment (new, ptr, end);
387
388 lseek (new, data_scnptr, SEEK_SET);
389 ptr = (char *) f_ohdr.data_start;
390 end = ptr + f_ohdr.dsize;
391 write_segment (new, ptr, end);
392
393 return 0;
394 }
395
396 #define UnexBlockSz (1<<12) /* read/write block size */
397 static void
398 write_segment (int new, char *ptr, char *end)
399 {
400 int i, nwrite, ret;
401 char zeros[UnexBlockSz];
402
403 for (i = 0; ptr < end;)
404 {
405 /* distance to next block. */
406 nwrite = (((int) ptr + UnexBlockSz) & -UnexBlockSz) - (int) ptr;
407 /* But not beyond specified end. */
408 if (nwrite > end - ptr) nwrite = end - ptr;
409 ret = write (new, ptr, nwrite);
410 /* If write gets a page fault, it means we reached
411 a gap between the old text segment and the old data segment.
412 This gap has probably been remapped into part of the text segment.
413 So write zeros for it. */
414 if (ret == -1 && errno == EFAULT)
415 {
416 memset (zeros, 0, nwrite);
417 write (new, zeros, nwrite);
418 }
419 else if (nwrite != ret)
420 {
421 int write_errno = errno;
422 char buf[1000];
423 void *addr = ptr;
424 sprintf (buf,
425 "unexec write failure: addr %p, fileno %d, size 0x%x, wrote 0x%x, errno %d",
426 addr, new, nwrite, ret, errno);
427 errno = write_errno;
428 PERROR (buf);
429 }
430 i += nwrite;
431 ptr += nwrite;
432 }
433 }
434 \f
435 /* ****************************************************************
436 * copy_sym
437 *
438 * Copy the relocation information and symbol table from the a.out to the new
439 */
440 static int
441 copy_sym (int new, int a_out, const char *a_name, const char *new_name)
442 {
443 char page[UnexBlockSz];
444 int n;
445
446 if (a_out < 0)
447 return 0;
448
449 if (orig_load_scnptr == 0L)
450 return 0;
451
452 if (lnnoptr && lnnoptr < orig_load_scnptr) /* if there is line number info */
453 lseek (a_out, lnnoptr, SEEK_SET); /* start copying from there */
454 else
455 lseek (a_out, orig_load_scnptr, SEEK_SET); /* Position a.out to symtab. */
456
457 while ((n = read (a_out, page, sizeof page)) > 0)
458 {
459 if (write (new, page, n) != n)
460 {
461 PERROR (new_name);
462 }
463 }
464 if (n < 0)
465 {
466 PERROR (a_name);
467 }
468 return 0;
469 }
470 \f
471 /* ****************************************************************
472 * mark_x
473 *
474 * After successfully building the new a.out, mark it executable
475 */
476 static void
477 mark_x (const char *name)
478 {
479 struct stat sbuf;
480 int um;
481 int new = 0; /* for PERROR */
482
483 um = umask (777);
484 umask (um);
485 if (stat (name, &sbuf) == -1)
486 {
487 PERROR (name);
488 }
489 sbuf.st_mode |= 0111 & ~um;
490 if (chmod (name, sbuf.st_mode) == -1)
491 PERROR (name);
492 }
493 \f
494 static int
495 adjust_lnnoptrs (int writedesc, int readdesc, const char *new_name)
496 {
497 int nsyms;
498 int naux;
499 int new;
500 struct syment symentry;
501 union auxent auxentry;
502
503 if (!lnnoptr || !f_hdr.f_symptr)
504 return 0;
505
506 if ((new = open (new_name, O_RDWR)) < 0)
507 {
508 PERROR (new_name);
509 return -1;
510 }
511
512 lseek (new, f_hdr.f_symptr, SEEK_SET);
513 for (nsyms = 0; nsyms < f_hdr.f_nsyms; nsyms++)
514 {
515 read (new, &symentry, SYMESZ);
516 if (symentry.n_sclass == C_BINCL || symentry.n_sclass == C_EINCL)
517 {
518 symentry.n_value += bias;
519 lseek (new, -SYMESZ, SEEK_CUR);
520 write (new, &symentry, SYMESZ);
521 }
522
523 for (naux = symentry.n_numaux; naux-- != 0; )
524 {
525 read (new, &auxentry, AUXESZ);
526 nsyms++;
527 if (naux != 0 /* skip csect auxentry (last entry) */
528 && (symentry.n_sclass == C_EXT || symentry.n_sclass == C_HIDEXT))
529 {
530 auxentry.x_sym.x_fcnary.x_fcn.x_lnnoptr += bias;
531 lseek (new, -AUXESZ, SEEK_CUR);
532 write (new, &auxentry, AUXESZ);
533 }
534 }
535 }
536 close (new);
537
538 return 0;
539 }
540
541 static int
542 unrelocate_symbols (int new, int a_out,
543 const char *a_name, const char *new_name)
544 {
545 int i;
546 LDHDR ldhdr;
547 LDREL ldrel;
548 off_t t_reloc = (intptr_t) _text - f_ohdr.text_start;
549 #ifndef ALIGN_DATA_RELOC
550 off_t d_reloc = (intptr_t) _data - f_ohdr.data_start;
551 #else
552 /* This worked (and was needed) before AIX 4.2.
553 I have no idea why. -- Mike */
554 off_t d_reloc = (intptr_t) _data - ALIGN (f_ohdr.data_start, 2);
555 #endif
556 int * p;
557
558 if (load_scnptr == 0)
559 return 0;
560
561 lseek (a_out, orig_load_scnptr, SEEK_SET);
562 if (read (a_out, &ldhdr, sizeof (ldhdr)) != sizeof (ldhdr))
563 {
564 PERROR (new_name);
565 }
566
567 #define SYMNDX_TEXT 0
568 #define SYMNDX_DATA 1
569 #define SYMNDX_BSS 2
570
571 for (i = 0; i < ldhdr.l_nreloc; i++)
572 {
573 lseek (a_out,
574 orig_load_scnptr + LDHDRSZ + LDSYMSZ*ldhdr.l_nsyms + LDRELSZ*i,
575 SEEK_SET);
576
577 if (read (a_out, &ldrel, LDRELSZ) != LDRELSZ)
578 {
579 PERROR (a_name);
580 }
581
582 /* move the BSS loader symbols to the DATA segment */
583 if (ldrel.l_symndx == SYMNDX_BSS)
584 {
585 ldrel.l_symndx = SYMNDX_DATA;
586
587 lseek (new,
588 load_scnptr + LDHDRSZ + LDSYMSZ*ldhdr.l_nsyms + LDRELSZ*i,
589 SEEK_SET);
590
591 if (write (new, &ldrel, LDRELSZ) != LDRELSZ)
592 {
593 PERROR (new_name);
594 }
595 }
596
597 if (ldrel.l_rsecnm == f_ohdr.o_sndata)
598 {
599 int orig_int;
600
601 lseek (a_out,
602 orig_data_scnptr + (ldrel.l_vaddr - f_ohdr.data_start),
603 SEEK_SET);
604
605 if (read (a_out, (void *) &orig_int, sizeof (orig_int))
606 != sizeof (orig_int))
607 {
608 PERROR (a_name);
609 }
610
611 p = (int *) (ldrel.l_vaddr + d_reloc);
612
613 switch (ldrel.l_symndx) {
614 case SYMNDX_TEXT:
615 orig_int = * p - t_reloc;
616 break;
617
618 case SYMNDX_DATA:
619 case SYMNDX_BSS:
620 orig_int = * p - d_reloc;
621 break;
622 }
623
624 if (orig_int != * p)
625 {
626 lseek (new,
627 data_scnptr + (ldrel.l_vaddr - f_ohdr.data_start),
628 SEEK_SET);
629 if (write (new, (void *) &orig_int, sizeof (orig_int))
630 != sizeof (orig_int))
631 {
632 PERROR (new_name);
633 }
634 }
635 }
636 }
637 return 0;
638 }