Mercurial > emacs
annotate src/unexhp9k800.c @ 6241:49538e6c482e
entered into RCS
author | Richard M. Stallman <rms@gnu.org> |
---|---|
date | Mon, 07 Mar 1994 23:24:02 +0000 |
parents | 69e337909652 |
children | 078782db2675 |
rev | line source |
---|---|
118 | 1 /* Unexec for HP 9000 Series 800 machines. |
2 Bob Desinger <hpsemc!bd@hplabs.hp.com> | |
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%hpsemc@hplabs.HP.COM. | |
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; | |
484 | 63 long i; |
118 | 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; | |
484 | 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; | |
118 | 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); | |
1742
69e337909652
(unexec): Don't call exit, just return.
Richard M. Stallman <rms@gnu.org>
parents:
484
diff
changeset
|
110 return 0; |
118 | 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 */ |