*** empty log message ***
[emacs.git] / src / unexnext.c
blobf17dd8e9ee7325154c96c3b385220f400870db0d
1 /* Dump Emacs in macho format.
2 Copyright (C) 1990, 1993 Free Software Foundation, Inc.
3 Written by Bradley Taylor (btaylor@next.com).
5 This file is part of GNU Emacs.
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.
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.
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. */
23 #undef __STRICT_BSD__
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <stdarg.h>
28 #include <mach/mach.h>
29 #include <mach-o/loader.h>
30 #include <mach-o/reloc.h>
31 #include <sys/file.h>
32 #include <sys/stat.h>
33 #include <unistd.h>
34 /* Instead of unistd.h, this used to include libc.h.
35 "Nelson H. F. Beebe" <beebe@math.utah.edu> says that doesn't work
36 in system version 3.3. */
39 int malloc_cookie;
42 * Kludge: we don't expect any program data beyond VM_HIGHDATA
43 * What is really needed is a way to find out from malloc() which
44 * pages it vm_allocated and write only those out into the data segment.
46 * This kludge may break when we stop using fixed virtual address
47 * shared libraries. Actually, emacs will probably continue working, but be
48 * much larger on disk than it needs to be (because non-malloced data will
49 * be in the file).
51 static const unsigned VM_HIGHDATA = 0x2000000;
53 typedef struct region_t {
54 vm_address_t address;
55 vm_size_t size;
56 vm_prot_t protection;
57 vm_prot_t max_protection;
58 vm_inherit_t inheritance;
59 boolean_t shared;
60 port_t object_name;
61 vm_offset_t offset;
62 } region_t;
65 static void
66 grow(
67 struct load_command ***the_commands,
68 unsigned *the_commands_len
71 if (*the_commands == NULL) {
72 *the_commands_len = 1;
73 *the_commands = malloc(sizeof(*the_commands));
74 } else {
75 (*the_commands_len)++;
76 *the_commands = realloc(*the_commands,
77 (*the_commands_len *
78 sizeof(**the_commands)));
83 static void
84 save_command(
85 struct load_command *command,
86 struct load_command ***the_commands,
87 unsigned *the_commands_len
90 struct load_command **tmp;
92 grow(the_commands, the_commands_len);
93 tmp = &(*the_commands)[*the_commands_len - 1];
94 *tmp = malloc(command->cmdsize);
95 bcopy(command, *tmp, command->cmdsize);
98 static void
99 fatal_unexec(char *format, ...)
101 va_list ap;
103 va_start(ap, format);
104 fprintf(stderr, "unexec: ");
105 vfprintf(stderr, format, ap);
106 fprintf(stderr, "\n");
107 va_end(ap);
110 static int
111 read_macho(
112 int fd,
113 struct mach_header *the_header,
114 struct load_command ***the_commands,
115 unsigned *the_commands_len
118 struct load_command command;
119 struct load_command *buf;
120 int i;
121 int size;
123 if (read(fd, the_header, sizeof(*the_header)) != sizeof(*the_header)) {
124 fatal_unexec("cannot read macho header");
125 return (0);
127 for (i = 0; i < the_header->ncmds; i++) {
128 if (read(fd, &command, sizeof(struct load_command)) !=
129 sizeof(struct load_command)) {
130 fatal_unexec("cannot read macho load command header");
131 return (0);
133 size = command.cmdsize - sizeof(struct load_command);
134 if (size < 0) {
135 fatal_unexec("bogus load command size");
136 return (0);
138 buf = malloc(command.cmdsize);
139 buf->cmd = command.cmd;
140 buf->cmdsize = command.cmdsize;
141 if (read(fd, ((char *)buf +
142 sizeof(struct load_command)),
143 size) != size) {
144 fatal_unexec("cannot read load command data");
145 return (0);
147 save_command(buf, the_commands, the_commands_len);
149 return (1);
152 static int
153 filldatagap(
154 vm_address_t start_address,
155 vm_size_t *size,
156 vm_address_t end_address
159 vm_address_t address;
160 vm_size_t gapsize;
162 address = (start_address + *size);
163 gapsize = end_address - address;
164 *size += gapsize;
165 if (vm_allocate(task_self(), &address, gapsize,
166 FALSE) != KERN_SUCCESS) {
167 fatal_unexec("cannot vm_allocate");
168 return (0);
170 return (1);
173 static int
174 get_data_region(
175 vm_address_t *address,
176 vm_size_t *size
179 region_t region;
180 kern_return_t ret;
181 struct section *sect;
183 sect = (struct section *) getsectbyname(SEG_DATA, SECT_DATA);
184 region.address = 0;
185 *address = 0;
186 for (;;) {
187 ret = vm_region(task_self(),
188 &region.address,
189 &region.size,
190 &region.protection,
191 &region.max_protection,
192 &region.inheritance,
193 &region.shared,
194 &region.object_name,
195 &region.offset);
196 if (ret != KERN_SUCCESS || region.address >= VM_HIGHDATA) {
197 break;
199 if (*address != 0) {
200 if (region.address > *address + *size) {
201 if (!filldatagap(*address, size,
202 region.address)) {
203 return (0);
206 *size += region.size;
207 } else {
208 if (region.address == sect->addr) {
209 *address = region.address;
210 *size = region.size;
213 region.address += region.size;
215 return (1);
218 static char *
219 my_malloc(
220 vm_size_t size
223 vm_address_t address;
225 if (vm_allocate(task_self(), &address, size, TRUE) != KERN_SUCCESS) {
226 return (NULL);
228 return ((char *)address);
231 static void
232 my_free(
233 char *buf,
234 vm_size_t size
237 vm_deallocate(task_self(), (vm_address_t)buf, size);
240 static int
241 unexec_doit(
242 int infd,
243 int outfd
246 int i;
247 struct load_command **the_commands = NULL;
248 unsigned the_commands_len;
249 struct mach_header the_header;
250 int fgrowth = 0;
251 int fdatastart;
252 int fdatasize;
253 int size;
254 struct stat st;
255 char *buf;
256 vm_address_t data_address;
257 vm_size_t data_size;
258 vm_size_t vmaddr_growth = 0;
259 vm_size_t dataseg_vmaddr, dataseg_vmend;
261 struct segment_command *segment;
263 #ifdef NS_TARGET
264 unsigned long extreloff = 0;
265 unsigned long nextrel = 0;
266 struct dysymtab_command *dysymtab;
267 struct relocation_info reloc_info;
268 #endif
270 if (!read_macho(infd, &the_header, &the_commands, &the_commands_len)) {
271 return (0);
275 malloc_cookie = malloc_freezedry ();
276 if (!get_data_region(&data_address, &data_size)) {
277 return (0);
282 * DO NOT USE MALLOC IN THIS SECTION
286 * Fix offsets
288 for (i = 0; i < the_commands_len; i++) {
289 switch (the_commands[i]->cmd) {
290 case LC_SEGMENT:
291 segment = ((struct segment_command *)
292 the_commands[i]);
293 if (strcmp(segment->segname, SEG_DATA) == 0) {
294 fdatastart = segment->fileoff;
295 fdatasize = segment->filesize;
296 fgrowth = (data_size -
297 segment->filesize);
298 segment->vmsize = data_size;
299 segment->filesize = data_size;
300 dataseg_vmaddr = segment->vmaddr;
301 dataseg_vmend = segment->vmaddr + segment->vmsize;
302 vmaddr_growth = segment->vmaddr + segment->vmsize;
303 } else {
304 ((struct segment_command *)the_commands[i])->fileoff += fgrowth;
307 if( strcmp( segment->segname, SEG_LINKEDIT ) == 0 ) {
308 segment->vmaddr = vmaddr_growth;
311 break;
312 case LC_SYMTAB:
313 ((struct symtab_command *)
314 the_commands[i])->symoff += fgrowth;
315 ((struct symtab_command *)
316 the_commands[i])->stroff += fgrowth;
317 break;
318 case LC_SYMSEG:
319 ((struct symseg_command *)
320 the_commands[i])->offset += fgrowth;
321 break;
322 #ifdef NS_TARGET
323 case LC_DYSYMTAB:
324 dysymtab = ((struct dysymtab_command *)the_commands[i]);
325 extreloff = dysymtab->extreloff;
326 nextrel = dysymtab->nextrel;
327 dysymtab->indirectsymoff += fgrowth;
328 dysymtab->extreloff += fgrowth;
329 break;
330 #endif
331 default:
332 break;
337 * Write header
339 if (write(outfd, &the_header,
340 sizeof(the_header)) != sizeof(the_header)) {
341 fatal_unexec("cannot write output file");
342 return (0);
346 * Write commands
348 for (i = 0; i < the_commands_len; i++) {
349 if (write(outfd, the_commands[i],
350 the_commands[i]->cmdsize) !=
351 the_commands[i]->cmdsize) {
352 fatal_unexec("cannot write output file");
353 return (0);
358 * Write original text
360 if (lseek(infd, the_header.sizeofcmds + sizeof(the_header),
361 L_SET) < 0) {
362 fatal_unexec("cannot seek input file");
363 return (0);
365 size = fdatastart - (sizeof(the_header) +
366 the_header.sizeofcmds);
367 buf = my_malloc(size);
368 if (read(infd, buf, size) != size) {
369 my_free(buf, size);
370 fatal_unexec("cannot read input file");
372 if (write(outfd, buf, size) != size) {
373 my_free(buf, size);
374 fatal_unexec("cannot write output file");
375 return (0);
377 my_free(buf, size);
381 * Write new data
383 if (write(outfd, (char *)data_address,
384 data_size) != data_size) {
385 fatal_unexec("cannot write output file");
386 return (0);
392 * OKAY TO USE MALLOC NOW
396 * Write rest of file
398 fstat(infd, &st);
399 if (lseek(infd, fdatasize, L_INCR) < 0) {
400 fatal_unexec("cannot seek input file");
401 return (0);
403 size = st.st_size - lseek(infd, 0, L_INCR);
405 buf = malloc(size);
406 if (read(infd, buf, size) != size) {
407 free(buf);
408 fatal_unexec("cannot read input file");
409 return (0);
411 if (write(outfd, buf, size) != size) {
412 free(buf);
413 fatal_unexec("cannot write output file");
414 return (0);
416 free(buf);
418 #ifdef NS_TARGET
420 * Fix up relocation entries in the data segment.
423 if (lseek(infd, extreloff, L_SET) < 0) {
424 fatal_unexec("cannot seek input file");
425 return (0);
428 for (i = 0; i < nextrel; i++)
430 long zeroval = 0;
432 if (read(infd, &reloc_info, sizeof (reloc_info)) != sizeof (reloc_info)) {
433 fatal_unexec("cannot read input file");
434 return (0);
436 if (reloc_info.r_address >= dataseg_vmaddr && reloc_info.r_address < dataseg_vmend)
438 if (lseek (outfd, fdatastart + reloc_info.r_address - dataseg_vmaddr, L_SET) < 0 ) {
439 fatal_unexec("cannot seek input file");
440 return (0);
442 switch (reloc_info.r_length) {
443 case 0:
444 if (write(outfd, &zeroval, 1) != 1) {
445 fatal_unexec("cannot write output file");
446 return (0);
448 break;
449 case 1:
450 if (write(outfd, &zeroval, 2) != 2) {
451 fatal_unexec("cannot write output file");
452 return (0);
454 break;
455 case 2:
456 if (write(outfd, &zeroval, 4) != 4) {
457 fatal_unexec("cannot write output file");
458 return (0);
460 break;
464 #endif
466 return (1);
469 void
470 unexec(
471 char *outfile,
472 char *infile
475 int infd;
476 int outfd;
477 char tmpbuf[L_tmpnam];
478 char *tmpfile;
480 infd = open(infile, O_RDONLY, 0);
481 if (infd < 0) {
482 fatal_unexec("cannot open input file `%s'", infile);
483 exit(1);
486 tmpnam(tmpbuf);
487 tmpfile = rindex(tmpbuf, '/');
488 if (tmpfile == NULL) {
489 tmpfile = tmpbuf;
490 } else {
491 tmpfile++;
493 outfd = open(tmpfile, O_WRONLY|O_TRUNC|O_CREAT, 0755);
494 if (outfd < 0) {
495 close(infd);
496 fatal_unexec("cannot open tmp file `%s'", tmpfile);
497 exit(1);
499 if (!unexec_doit(infd, outfd)) {
500 close(infd);
501 close(outfd);
502 unlink(tmpfile);
503 exit(1);
505 close(infd);
506 close(outfd);
507 if (rename(tmpfile, outfile) < 0) {
508 unlink(tmpfile);
509 fatal_unexec("cannot rename `%s' to `%s'", tmpfile, outfile);
510 exit(1);