![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mach_header.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to mach_header.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * File: kern/mach_header.c
24: *
25: * Functions for accessing mach-o headers.
26: *
27: * HISTORY
28: * 27-MAR-97 Umesh Vaishampayan ([email protected])
29: * Added getsegdatafromheader();
30: *
31: * 29-Jan-92 Mike DeMoney ([email protected])
32: * Made into machine independent form from machdep/m68k/mach_header.c.
33: * Ifdef'ed out most of this since I couldn't find any references.
34: */
35:
36: #if !defined(KERNEL_PRELOAD)
37: #include <kern/mach_header.h>
38:
39: extern struct mach_header _mh_execute_header;
40:
41: struct section *getsectbynamefromheader(
42: struct mach_header *header,
43: char *seg_name,
44: char *sect_name);
45: struct segment_command *getsegbynamefromheader(
46: struct mach_header *header,
47: char *seg_name);
48:
49: /*
50: * return the last address (first avail)
51: */
52: vm_offset_t getlastaddr(void)
53: {
54: struct segment_command *sgp;
55: vm_offset_t last_addr = 0;
56: struct mach_header *header = &_mh_execute_header;
57: int i;
58:
59: sgp = (struct segment_command *)
60: ((char *)header + sizeof(struct mach_header));
61: for (i = 0; i < header->ncmds; i++){
62: if ( sgp->cmd == LC_SEGMENT) {
63: if (sgp->vmaddr + sgp->vmsize > last_addr)
64: last_addr = sgp->vmaddr + sgp->vmsize;
65: }
66: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
67: }
68: return last_addr;
69: }
70:
71: #if FIXME /* [ */
72: struct mach_header **
73: getmachheaders(void)
74: {
75: extern struct mach_header _mh_execute_header;
76: struct mach_header **tl;
77: tl = (struct mach_header **)malloc(2*sizeof(struct mach_header *));
78: tl[0] = &_mh_execute_header;
79: tl[1] = (struct mach_header *)0;
80: return tl;
81: }
82: #endif /* FIXME ] */
83:
84: /*
85: * This routine returns the a pointer to the data for the named section in the
86: * named segment if it exist in the mach header passed to it. Also it returns
87: * the size of the section data indirectly through the pointer size. Otherwise
88: * it returns zero for the pointer and the size.
89: */
90: void *
91: getsectdatafromheader(
92: struct mach_header *mhp,
93: char *segname,
94: char *sectname,
95: int *size)
96: {
97: const struct section *sp;
98: void *result;
99:
100: sp = getsectbynamefromheader(mhp, segname, sectname);
101: if(sp == (struct section *)0){
102: *size = 0;
103: return((char *)0);
104: }
105: *size = sp->size;
106: result = (void *)sp->addr;
107: return result;
108: }
109:
110: /*
111: * This routine returns the a pointer to the data for the named segment
112: * if it exist in the mach header passed to it. Also it returns
113: * the size of the segment data indirectly through the pointer size.
114: * Otherwise it returns zero for the pointer and the size.
115: */
116: void *
117: getsegdatafromheader(
118: struct mach_header *mhp,
119: char *segname,
120: int *size)
121: {
122: const struct segment_command *sc;
123: void *result;
124:
125: sc = getsegbynamefromheader(mhp, segname);
126: if(sc == (struct segment_command *)0){
127: *size = 0;
128: return((char *)0);
129: }
130: *size = sc->vmsize;
131: result = (void *)sc->vmaddr;
132: return result;
133: }
134:
135: /*
136: * This routine returns the section structure for the named section in the
137: * named segment for the mach_header pointer passed to it if it exist.
138: * Otherwise it returns zero.
139: */
140: struct section *
141: getsectbynamefromheader(
142: struct mach_header *mhp,
143: char *segname,
144: char *sectname)
145: {
146: struct segment_command *sgp;
147: struct section *sp;
148: long i, j;
149:
150: sgp = (struct segment_command *)
151: ((char *)mhp + sizeof(struct mach_header));
152: for(i = 0; i < mhp->ncmds; i++){
153: if(sgp->cmd == LC_SEGMENT)
154: if(strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0 ||
155: mhp->filetype == MH_OBJECT){
156: sp = (struct section *)((char *)sgp +
157: sizeof(struct segment_command));
158: for(j = 0; j < sgp->nsects; j++){
159: if(strncmp(sp->sectname, sectname,
160: sizeof(sp->sectname)) == 0 &&
161: strncmp(sp->segname, segname,
162: sizeof(sp->segname)) == 0)
163: return(sp);
164: sp = (struct section *)((char *)sp +
165: sizeof(struct section));
166: }
167: }
168: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
169: }
170: return((struct section *)0);
171: }
172:
173: struct segment_command *getsegbynamefromheader(
174: struct mach_header *header,
175: char *seg_name)
176: {
177: struct segment_command *sgp;
178: int i;
179:
180: sgp = (struct segment_command *)
181: ((char *)header + sizeof(struct mach_header));
182: for (i = 0; i < header->ncmds; i++){
183: if ( sgp->cmd == LC_SEGMENT
184: && !strncmp(sgp->segname, seg_name, sizeof(sgp->segname)))
185: return sgp;
186: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
187: }
188: return (struct segment_command *)0;
189: }
190:
191:
192: /*
193: * For now at least, all the rest of this seems unused.
194: * NOTE: The constant in here for segment alignment is machine-dependent,
195: * so if you include this, define a machine dependent constant for it's
196: * value.
197: */
198: static struct {
199: struct segment_command seg;
200: struct section sect;
201: } fvm_data = {
202: {
203: LC_SEGMENT, // cmd
204: sizeof(fvm_data), // cmdsize
205: "__USER", // segname
206: 0, // vmaddr
207: 0, // vmsize
208: 0, // fileoff
209: 0, // filesize
210: VM_PROT_READ, // maxprot
211: VM_PROT_READ, // initprot,
212: 1, // nsects
213: 0 // flags
214: },
215: {
216: "", // sectname
217: "__USER", // segname
218: 0, // addr
219: 0, // size
220: 0, // offset
221: 4, // align
222: 0, // reloff
223: 0, // nreloc
224: 0 // flags
225: }
226: };
227:
228: struct segment_command *fvm_seg;
229:
230: static struct fvmfile_command *fvmfilefromheader(struct mach_header *header);
231: static vm_offset_t getsizeofmacho(struct mach_header *header);
232:
233: /*
234: * Return the first segment_command in the header.
235: */
236: struct segment_command *firstseg(void)
237: {
238: return firstsegfromheader(&_mh_execute_header);
239: }
240:
241: struct segment_command *firstsegfromheader(struct mach_header *header)
242: {
243: struct segment_command *sgp;
244: int i;
245:
246: sgp = (struct segment_command *)
247: ((char *)header + sizeof(struct mach_header));
248: for (i = 0; i < header->ncmds; i++){
249: if (sgp->cmd == LC_SEGMENT)
250: return sgp;
251: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
252: }
253: return (struct segment_command *)0;
254: }
255:
256: struct segment_command *nextseg(struct segment_command *sgp)
257: {
258: struct segment_command *this;
259:
260: this = nextsegfromheader(&_mh_execute_header, sgp);
261:
262: /*
263: * For the kernel's header add on the faked segment for the
264: * USER boot code identified by a FVMFILE_COMMAND in the mach header.
265: */
266: if (!this && sgp != fvm_seg)
267: this = fvm_seg;
268:
269: return this;
270: }
271:
272: struct segment_command *nextsegfromheader(
273: struct mach_header *header,
274: struct segment_command *seg)
275: {
276: struct segment_command *sgp;
277: int i;
278:
279: sgp = (struct segment_command *)
280: ((char *)header + sizeof(struct mach_header));
281: for (i = 0; i < header->ncmds; i++) {
282: if (sgp == seg)
283: break;
284: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
285: }
286:
287: if (i == header->ncmds)
288: return (struct segment_command *)0;
289:
290: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
291: for (; i < header->ncmds; i++) {
292: if (sgp->cmd == LC_SEGMENT)
293: return sgp;
294: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
295: }
296:
297: return (struct segment_command *)0;
298: }
299:
300:
301: /*
302: * Return the address of the named Mach-O segment, or NULL.
303: */
304: struct segment_command *getsegbyname(char *seg_name)
305: {
306: struct segment_command *this;
307:
308: this = getsegbynamefromheader(&_mh_execute_header, seg_name);
309:
310: /*
311: * For the kernel's header add on the faked segment for the
312: * USER boot code identified by a FVMFILE_COMMAND in the mach header.
313: */
314: if (!this && strcmp(seg_name, fvm_seg->segname) == 0)
315: this = fvm_seg;
316:
317: return this;
318: }
319:
320: /*
321: * This routine returns the a pointer the section structure of the named
322: * section in the named segment if it exist in the mach executable it is
323: * linked into. Otherwise it returns zero.
324: */
325: struct section *
326: getsectbyname(
327: char *segname,
328: char *sectname)
329: {
330: return(getsectbynamefromheader(
331: (struct mach_header *)&_mh_execute_header, segname, sectname));
332: }
333:
334: struct section *firstsect(struct segment_command *sgp)
335: {
336: struct section *sp;
337:
338: if (!sgp || sgp->nsects == 0)
339: return (struct section *)0;
340:
341: return (struct section *)(sgp+1);
342: }
343:
344: struct section *nextsect(struct segment_command *sgp, struct section *sp)
345: {
346: struct section *fsp = firstsect(sgp);
347:
348: if (sp - fsp >= sgp->nsects-1)
349: return (struct section *)0;
350:
351: return sp+1;
352: }
353:
354: static struct fvmfile_command *fvmfilefromheader(struct mach_header *header)
355: {
356: struct fvmfile_command *fvp;
357: int i;
358:
359: fvp = (struct fvmfile_command *)
360: ((char *)header + sizeof(struct mach_header));
361: for (i = 0; i < header->ncmds; i++){
362: if (fvp->cmd == LC_FVMFILE)
363: return fvp;
364: fvp = (struct fvmfile_command *)((char *)fvp + fvp->cmdsize);
365: }
366: return (struct fvmfile_command *)0;
367: }
368:
369: /*
370: * Create a fake USER seg if a fvmfile_command is present.
371: */
372: struct segment_command *getfakefvmseg(void)
373: {
374: struct segment_command *sgp = getsegbyname("__USER");
375: struct fvmfile_command *fvp = fvmfilefromheader(&_mh_execute_header);
376: struct section *sp;
377:
378: if (sgp)
379: return sgp;
380:
381: if (!fvp)
382: return (struct segment_command *)0;
383:
384: fvm_seg = &fvm_data.seg;
385: sgp = fvm_seg;
386: sp = &fvm_data.sect;
387:
388: sgp->vmaddr = fvp->header_addr;
389: sgp->vmsize = getsizeofmacho((struct mach_header *)(sgp->vmaddr));
390:
391: strcpy(sp->sectname, fvp->name.ptr);
392: sp->addr = sgp->vmaddr;
393: sp->size = sgp->vmsize;
394:
395: #if DEBUG
396: printf("fake fvm seg __USER/\"%s\" at 0x%x, size 0x%x\n",
397: sp->sectname, sp->addr, sp->size);
398: #endif DEBUG
399: }
400:
401: /*
402: * Figure out the size the size of the data associated with a
403: * loaded mach_header.
404: */
405: static vm_offset_t getsizeofmacho(struct mach_header *header)
406: {
407: struct segment_command *sgp;
408: struct section *sp;
409: vm_offset_t last_addr;
410:
411: last_addr = 0;
412: for ( sgp = firstsegfromheader(header)
413: ; sgp
414: ; sgp = nextsegfromheader(header, sgp))
415: {
416: if (sgp->fileoff + sgp->filesize > last_addr)
417: last_addr = sgp->fileoff + sgp->filesize;
418: }
419:
420: return last_addr;
421: }
422: #endif /* !defined(KERNEL_PRELOAD) */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.