![[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 [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src|
Return to unexhp9k800.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / 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:
64: /* For the greatest flexibility, should create a temporary file in
65: the same directory as the new file. When everything is complete,
66: rename the temp file to the new name.
67: This way, a program could update its own a.out file even while
68: it is still executing. If problems occur, everything is still
69: intact. NOT implemented. */
70:
71: /* Open the input and output a.out files */
72: old = open(old_name, O_RDONLY);
73: if (old < 0)
74: { perror(old_name); exit(1); }
75: new = open(new_name, O_CREAT|O_RDWR|O_TRUNC, 0777);
76: if (new < 0)
77: { perror(new_name); exit(1); }
78:
79: /* Read the old headers */
80: read_header(old, &hdr, &auxhdr);
81:
82: /* Decide how large the new and old data areas are */
83: old_size = auxhdr.exec_dsize;
84: new_size = sbrk(0) - auxhdr.exec_dmem;
85:
86: /* Copy the old file to the new, up to the data space */
87: lseek(old, 0, 0);
88: copy_file(old, new, auxhdr.exec_dfile);
89:
90: /* Skip the old data segment and write a new one */
91: lseek(old, old_size, 1);
92: save_data_space(new, &hdr, &auxhdr, new_size);
93:
94: /* Copy the rest of the file */
95: copy_rest(old, new);
96:
97: /* Update file pointers since we probably changed size of data area */
98: update_file_ptrs(new, &hdr, &auxhdr, auxhdr.exec_dfile, new_size-old_size);
99:
100: /* Save the modified header */
101: write_header(new, &hdr, &auxhdr);
102:
103: /* Close the binary file */
104: close(old);
105: close(new);
106: exit(0);
107: }
108:
109: /* Save current data space in the file, update header. */
110:
111: save_data_space(file, hdr, auxhdr, size)
112: int file;
113: struct header *hdr;
114: struct som_exec_auxhdr *auxhdr;
115: int size;
116: {
117: /* Write the entire data space out to the file */
118: if (write(file, auxhdr->exec_dmem, size) != size)
119: { perror("Can't save new data space"); exit(1); }
120:
121: /* Update the header to reflect the new data size */
122: auxhdr->exec_dsize = size;
123: auxhdr->exec_bsize = 0;
124: }
125:
126: /* Update the values of file pointers when something is inserted. */
127:
128: update_file_ptrs(file, hdr, auxhdr, location, offset)
129: int file;
130: struct header *hdr;
131: struct som_exec_auxhdr *auxhdr;
132: unsigned int location;
133: int offset;
134: {
135: struct subspace_dictionary_record subspace;
136: int i;
137:
138: /* Increase the overall size of the module */
139: hdr->som_length += offset;
140:
141: /* Update the various file pointers in the header */
142: #define update(ptr) if (ptr > location) ptr = ptr + offset
143: update(hdr->aux_header_location);
144: update(hdr->space_strings_location);
145: update(hdr->init_array_location);
146: update(hdr->compiler_location);
147: update(hdr->symbol_location);
148: update(hdr->fixup_request_location);
149: update(hdr->symbol_strings_location);
150: update(hdr->unloadable_sp_location);
151: update(auxhdr->exec_tfile);
152: update(auxhdr->exec_dfile);
153:
154: /* Do for each subspace dictionary entry */
155: lseek(file, hdr->subspace_location, 0);
156: for (i = 0; i < hdr->subspace_total; i++)
157: {
158: if (read(file, &subspace, sizeof(subspace)) != sizeof(subspace))
159: { perror("Can't read subspace record"); exit(1); }
160:
161: /* If subspace has a file location, update it */
162: if (subspace.initialization_length > 0
163: && subspace.file_loc_init_value > location)
164: {
165: subspace.file_loc_init_value += offset;
166: lseek(file, -sizeof(subspace), 1);
167: if (write(file, &subspace, sizeof(subspace)) != sizeof(subspace))
168: { perror("Can't update subspace record"); exit(1); }
169: }
170: }
171:
172: /* Do for each initialization pointer record */
173: /* (I don't think it applies to executable files, only relocatables) */
174: #undef update
175: }
176:
177: /* Read in the header records from an a.out file. */
178:
179: read_header(file, hdr, auxhdr)
180: int file;
181: struct header *hdr;
182: struct som_exec_auxhdr *auxhdr;
183: {
184:
185: /* Read the header in */
186: lseek(file, 0, 0);
187: if (read(file, hdr, sizeof(*hdr)) != sizeof(*hdr))
188: { perror("Couldn't read header from a.out file"); exit(1); }
189:
190: if (hdr->a_magic != EXEC_MAGIC && hdr->a_magic != SHARE_MAGIC
191: && hdr->a_magic != DEMAND_MAGIC)
192: {
193: fprintf(stderr, "a.out file doesn't have legal magic number\n");
194: exit(1);
195: }
196:
197: lseek(file, hdr->aux_header_location, 0);
198: if (read(file, auxhdr, sizeof(*auxhdr)) != sizeof(*auxhdr))
199: {
200: perror("Couldn't read auxiliary header from a.out file");
201: exit(1);
202: }
203: }
204:
205: /* Write out the header records into an a.out file. */
206:
207: write_header(file, hdr, auxhdr)
208: int file;
209: struct header *hdr;
210: struct som_exec_auxhdr *auxhdr;
211: {
212: /* Update the checksum */
213: hdr->checksum = calculate_checksum(hdr);
214:
215: /* Write the header back into the a.out file */
216: lseek(file, 0, 0);
217: if (write(file, hdr, sizeof(*hdr)) != sizeof(*hdr))
218: { perror("Couldn't write header to a.out file"); exit(1); }
219: lseek(file, hdr->aux_header_location, 0);
220: if (write(file, auxhdr, sizeof(*auxhdr)) != sizeof(*auxhdr))
221: { perror("Couldn't write auxiliary header to a.out file"); exit(1); }
222: }
223:
224: /* Calculate the checksum of a SOM header record. */
225:
226: calculate_checksum(hdr)
227: struct header *hdr;
228: {
229: int checksum, i, *ptr;
230:
231: checksum = 0; ptr = (int *) hdr;
232:
233: for (i=0; i<sizeof(*hdr)/sizeof(int)-1; i++)
234: checksum ^= ptr[i];
235:
236: return(checksum);
237: }
238:
239: /* Copy size bytes from the old file to the new one. */
240:
241: copy_file(old, new, size)
242: int new, old;
243: int size;
244: {
245: int len;
246: int buffer[8196]; /* word aligned will be faster */
247:
248: for (; size > 0; size -= len)
249: {
250: len = min(size, sizeof(buffer));
251: if (read(old, buffer, len) != len)
252: { perror("Read failure on a.out file"); exit(1); }
253: if (write(new, buffer, len) != len)
254: { perror("Write failure in a.out file"); exit(1); }
255: }
256: }
257:
258: /* Copy the rest of the file, up to EOF. */
259:
260: copy_rest(old, new)
261: int new, old;
262: {
263: int buffer[4096];
264: int len;
265:
266: /* Copy bytes until end of file or error */
267: while ( (len = read(old, buffer, sizeof(buffer))) > 0)
268: if (write(new, buffer, len) != len) break;
269:
270: if (len != 0)
271: { perror("Unable to copy the rest of the file"); exit(1); }
272: }
273:
274: #ifdef DEBUG
275: display_header(hdr, auxhdr)
276: struct header *hdr;
277: struct som_exec_auxhdr *auxhdr;
278: {
279: /* Display the header information (debug) */
280: printf("\n\nFILE HEADER\n");
281: printf("magic number %d \n", hdr->a_magic);
282: printf("text loc %.8x size %d \n", auxhdr->exec_tmem, auxhdr->exec_tsize);
283: printf("data loc %.8x size %d \n", auxhdr->exec_dmem, auxhdr->exec_dsize);
284: printf("entry %x \n", auxhdr->exec_entry);
285: printf("Bss segment size %u\n", auxhdr->exec_bsize);
286: printf("\n");
287: printf("data file loc %d size %d\n",
288: auxhdr->exec_dfile, auxhdr->exec_dsize);
289: printf("som_length %d\n", hdr->som_length);
290: printf("unloadable sploc %d size %d\n",
291: hdr->unloadable_sp_location, hdr->unloadable_sp_size);
292: }
293: #endif /* DEBUG */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.