![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to unexhp9k800.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / src|
Return to unexhp9k800.c CVS log | Up to [Apple XNU] / GNUtools / emacs / src |
1.1 root 1: /* Unexec for HP 9000 Series 800 machines.
2: Bob Desinger <[email protected]>
3:
4: Note that the GNU project considers support for HP operation a
5: peripheral activity which should not be allowed to divert effort
6: from development of the GNU system. Changes in this code will be
7: installed when users send them in, but aside from that we don't
8: plan to think about it, or about whether other Emacs maintenance
9: might break it.
10:
11:
12: Unexec creates a copy of the old a.out file, and replaces the old data
13: area with the current data area. When the new file is executed, the
14: process will see the same data structures and data values that the
15: original process had when unexec was called.
16:
17: Unlike other versions of unexec, this one copies symbol table and
18: debug information to the new a.out file. Thus, the new a.out file
19: may be debugged with symbolic debuggers.
20:
21: If you fix any bugs in this, I'd like to incorporate your fixes.
22: Send them to uunet!hpda!hpsemc!jmorris or jmorris%[email protected].
23:
24: CAVEATS:
25: This routine saves the current value of all static and external
26: variables. This means that any data structure that needs to be
27: initialized must be explicitly reset. Variables will not have their
28: expected default values.
29:
30: Unfortunately, the HP-UX signal handler has internal initialization
31: flags which are not explicitly reset. Thus, for signals to work in
32: conjunction with this routine, the following code must executed when
33: the new process starts up.
34:
35: void _sigreturn();
36: ...
37: sigsetreturn(_sigreturn);
38: */
39:
40: #include <stdio.h>
41: #include <fcntl.h>
42: #include <errno.h>
43:
44: #include <a.out.h>
45:
46: #define NBPG 2048
47: #define roundup(x,n) ( ( (x)+(n-1) ) & ~(n-1) ) /* n is power of 2 */
48: #define min(x,y) ( ((x)<(y))?(x):(y) )
49:
50:
51: /* Create a new a.out file, same as old but with current data space */
52:
53: unexec(new_name, old_name, new_end_of_text, dummy1, dummy2)
54: char new_name[]; /* name of the new a.out file to be created */
55: char old_name[]; /* name of the old a.out file */
56: char *new_end_of_text; /* ptr to new edata/etext; NOT USED YET */
57: int dummy1, dummy2; /* not used by emacs */
58: {
59: int old, new;
60: int old_size, new_size;
61: struct header hdr;
62: struct som_exec_auxhdr auxhdr;
63: long i;
64:
65: /* For the greatest flexibility, should create a temporary file in
66: the same directory as the new file. When everything is complete,
67: rename the temp file to the new name.
68: This way, a program could update its own a.out file even while
69: it is still executing. If problems occur, everything is still
70: intact. NOT implemented. */
71:
72: /* Open the input and output a.out files */
73: old = open(old_name, O_RDONLY);
74: if (old < 0)
75: { perror(old_name); exit(1); }
76: new = open(new_name, O_CREAT|O_RDWR|O_TRUNC, 0777);
77: if (new < 0)
78: { perror(new_name); exit(1); }
79:
80: /* Read the old headers */
81: read_header(old, &hdr, &auxhdr);
82:
83: /* Decide how large the new and old data areas are */
84: old_size = auxhdr.exec_dsize;
85: /* I suspect these two statements are separate
86: to avoid a compiler bug in hpux version 8. */
87: i = sbrk (0);
88: new_size = i - auxhdr.exec_dmem;
89:
90: /* Copy the old file to the new, up to the data space */
91: lseek(old, 0, 0);
92: copy_file(old, new, auxhdr.exec_dfile);
93:
94: /* Skip the old data segment and write a new one */
95: lseek(old, old_size, 1);
96: save_data_space(new, &hdr, &auxhdr, new_size);
97:
98: /* Copy the rest of the file */
99: copy_rest(old, new);
100:
101: /* Update file pointers since we probably changed size of data area */
102: update_file_ptrs(new, &hdr, &auxhdr, auxhdr.exec_dfile, new_size-old_size);
103:
104: /* Save the modified header */
105: write_header(new, &hdr, &auxhdr);
106:
107: /* Close the binary file */
108: close(old);
109: close(new);
110: exit(0);
111: }
112:
113: /* Save current data space in the file, update header. */
114:
115: save_data_space(file, hdr, auxhdr, size)
116: int file;
117: struct header *hdr;
118: struct som_exec_auxhdr *auxhdr;
119: int size;
120: {
121: /* Write the entire data space out to the file */
122: if (write(file, auxhdr->exec_dmem, size) != size)
123: { perror("Can't save new data space"); exit(1); }
124:
125: /* Update the header to reflect the new data size */
126: auxhdr->exec_dsize = size;
127: auxhdr->exec_bsize = 0;
128: }
129:
130: /* Update the values of file pointers when something is inserted. */
131:
132: update_file_ptrs(file, hdr, auxhdr, location, offset)
133: int file;
134: struct header *hdr;
135: struct som_exec_auxhdr *auxhdr;
136: unsigned int location;
137: int offset;
138: {
139: struct subspace_dictionary_record subspace;
140: int i;
141:
142: /* Increase the overall size of the module */
143: hdr->som_length += offset;
144:
145: /* Update the various file pointers in the header */
146: #define update(ptr) if (ptr > location) ptr = ptr + offset
147: update(hdr->aux_header_location);
148: update(hdr->space_strings_location);
149: update(hdr->init_array_location);
150: update(hdr->compiler_location);
151: update(hdr->symbol_location);
152: update(hdr->fixup_request_location);
153: update(hdr->symbol_strings_location);
154: update(hdr->unloadable_sp_location);
155: update(auxhdr->exec_tfile);
156: update(auxhdr->exec_dfile);
157:
158: /* Do for each subspace dictionary entry */
159: lseek(file, hdr->subspace_location, 0);
160: for (i = 0; i < hdr->subspace_total; i++)
161: {
162: if (read(file, &subspace, sizeof(subspace)) != sizeof(subspace))
163: { perror("Can't read subspace record"); exit(1); }
164:
165: /* If subspace has a file location, update it */
166: if (subspace.initialization_length > 0
167: && subspace.file_loc_init_value > location)
168: {
169: subspace.file_loc_init_value += offset;
170: lseek(file, -sizeof(subspace), 1);
171: if (write(file, &subspace, sizeof(subspace)) != sizeof(subspace))
172: { perror("Can't update subspace record"); exit(1); }
173: }
174: }
175:
176: /* Do for each initialization pointer record */
177: /* (I don't think it applies to executable files, only relocatables) */
178: #undef update
179: }
180:
181: /* Read in the header records from an a.out file. */
182:
183: read_header(file, hdr, auxhdr)
184: int file;
185: struct header *hdr;
186: struct som_exec_auxhdr *auxhdr;
187: {
188:
189: /* Read the header in */
190: lseek(file, 0, 0);
191: if (read(file, hdr, sizeof(*hdr)) != sizeof(*hdr))
192: { perror("Couldn't read header from a.out file"); exit(1); }
193:
194: if (hdr->a_magic != EXEC_MAGIC && hdr->a_magic != SHARE_MAGIC
195: && hdr->a_magic != DEMAND_MAGIC)
196: {
197: fprintf(stderr, "a.out file doesn't have legal magic number\n");
198: exit(1);
199: }
200:
201: lseek(file, hdr->aux_header_location, 0);
202: if (read(file, auxhdr, sizeof(*auxhdr)) != sizeof(*auxhdr))
203: {
204: perror("Couldn't read auxiliary header from a.out file");
205: exit(1);
206: }
207: }
208:
209: /* Write out the header records into an a.out file. */
210:
211: write_header(file, hdr, auxhdr)
212: int file;
213: struct header *hdr;
214: struct som_exec_auxhdr *auxhdr;
215: {
216: /* Update the checksum */
217: hdr->checksum = calculate_checksum(hdr);
218:
219: /* Write the header back into the a.out file */
220: lseek(file, 0, 0);
221: if (write(file, hdr, sizeof(*hdr)) != sizeof(*hdr))
222: { perror("Couldn't write header to a.out file"); exit(1); }
223: lseek(file, hdr->aux_header_location, 0);
224: if (write(file, auxhdr, sizeof(*auxhdr)) != sizeof(*auxhdr))
225: { perror("Couldn't write auxiliary header to a.out file"); exit(1); }
226: }
227:
228: /* Calculate the checksum of a SOM header record. */
229:
230: calculate_checksum(hdr)
231: struct header *hdr;
232: {
233: int checksum, i, *ptr;
234:
235: checksum = 0; ptr = (int *) hdr;
236:
237: for (i=0; i<sizeof(*hdr)/sizeof(int)-1; i++)
238: checksum ^= ptr[i];
239:
240: return(checksum);
241: }
242:
243: /* Copy size bytes from the old file to the new one. */
244:
245: copy_file(old, new, size)
246: int new, old;
247: int size;
248: {
249: int len;
250: int buffer[8196]; /* word aligned will be faster */
251:
252: for (; size > 0; size -= len)
253: {
254: len = min(size, sizeof(buffer));
255: if (read(old, buffer, len) != len)
256: { perror("Read failure on a.out file"); exit(1); }
257: if (write(new, buffer, len) != len)
258: { perror("Write failure in a.out file"); exit(1); }
259: }
260: }
261:
262: /* Copy the rest of the file, up to EOF. */
263:
264: copy_rest(old, new)
265: int new, old;
266: {
267: int buffer[4096];
268: int len;
269:
270: /* Copy bytes until end of file or error */
271: while ( (len = read(old, buffer, sizeof(buffer))) > 0)
272: if (write(new, buffer, len) != len) break;
273:
274: if (len != 0)
275: { perror("Unable to copy the rest of the file"); exit(1); }
276: }
277:
278: #ifdef DEBUG
279: display_header(hdr, auxhdr)
280: struct header *hdr;
281: struct som_exec_auxhdr *auxhdr;
282: {
283: /* Display the header information (debug) */
284: printf("\n\nFILE HEADER\n");
285: printf("magic number %d \n", hdr->a_magic);
286: printf("text loc %.8x size %d \n", auxhdr->exec_tmem, auxhdr->exec_tsize);
287: printf("data loc %.8x size %d \n", auxhdr->exec_dmem, auxhdr->exec_dsize);
288: printf("entry %x \n", auxhdr->exec_entry);
289: printf("Bss segment size %u\n", auxhdr->exec_bsize);
290: printf("\n");
291: printf("data file loc %d size %d\n",
292: auxhdr->exec_dfile, auxhdr->exec_dsize);
293: printf("som_length %d\n", hdr->som_length);
294: printf("unloadable sploc %d size %d\n",
295: hdr->unloadable_sp_location, hdr->unloadable_sp_size);
296: }
297: #endif /* DEBUG */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.