![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mach_loader.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_loader.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: * Copyright (C) 1988, 1989, NeXT, Inc.
24: *
25: * File: kern/mach_loader.c
26: * Author: Avadis Tevanian, Jr.
27: *
28: * Mach object file loader (kernel version, for now).
29: *
30: * 21-Jul-88 Avadis Tevanian, Jr. (avie) at NeXT
31: * Started.
32: */
33: #include <mach_nbc.h>
34: #include <sys/param.h>
35: #include <sys/vnode.h>
36: #include <sys/uio.h>
37: #include <sys/namei.h>
38: #include <sys/proc.h>
39: #include <sys/stat.h>
40: #include <sys/malloc.h>
41: #include <sys/mount.h>
42: #include <sys/fcntl.h>
43:
44: #include <ufs/ufs/lockf.h>
45: #include <ufs/ufs/quota.h>
46: #include <ufs/ufs/inode.h>
47:
48: #include <mach/mach_types.h>
49:
50: #include <kern/mach_loader.h>
51: #include <kern/mapfs.h>
52:
53: #include <mach-o/fat.h>
54: #include <mach-o/loader.h>
55:
56: #include <kern/cpu_number.h>
57:
58: #include <vm/vm_map.h>
59: #include <vm/vm_kern.h>
60: #include <vm/vm_pager.h>
61: #include <vm/vnode_pager.h>
62: #include <mach/shared_memory_server.h>
63:
64: /*
65: * Prototypes of static functions.
66: */
67: static
68: load_return_t
69: parse_machfile(
70: struct vnode *vp,
71: vm_map_t map,
72: struct mach_header *header,
73: unsigned long file_offset,
74: unsigned long macho_size,
75: int depth,
76: unsigned long *lib_version,
77: load_result_t *result
78: ),
79: load_segment(
80: struct segment_command *scp,
81: void * pager,
82: unsigned long pager_offset,
83: unsigned long macho_size,
84: unsigned long end_of_file,
85: vm_map_t map,
86: load_result_t *result
87: ),
88: load_unixthread(
89: struct thread_command *tcp,
90: load_result_t *result
91: ),
92: load_thread(
93: struct thread_command *tcp,
94: load_result_t *result
95: ),
96: load_threadstate(
97: thread_t thread,
98: unsigned long *ts,
99: unsigned long total_size
100: ),
101: load_threadstack(
102: thread_t thread,
103: unsigned long *ts,
104: unsigned long total_size,
105: vm_offset_t *user_stack
106: ),
107: load_threadentry(
108: thread_t thread,
109: unsigned long *ts,
110: unsigned long total_size,
111: vm_offset_t *entry_point
112: ),
113: load_fvmlib(
114: struct fvmlib_command *lcp,
115: vm_map_t map,
116: int depth
117: ),
118: load_idfvmlib(
119: struct fvmlib_command *lcp,
120: unsigned long *version
121: ),
122: load_dylinker(
123: struct dylinker_command *lcp,
124: vm_map_t map,
125: int depth,
126: load_result_t *result
127: ),
128: get_macho_vnode(
129: char *path,
130: struct mach_header *mach_header,
131: unsigned long *file_offset,
132: unsigned long *macho_size,
133: struct vnode **vpp
134: );
135:
136: load_return_t
137: load_machfile(
138: struct vnode *vp,
139: struct mach_header *header,
140: unsigned long file_offset,
141: unsigned long macho_size,
142: load_result_t *result
143: )
144: {
145: pmap_t pmap;
146: vm_map_t map;
147: vm_map_t old_map;
148: load_result_t myresult;
149: kern_return_t kret;
150: load_return_t lret;
151: extern void map_ref_fixup(vm_map_t,vm_map_t);
152:
153: old_map = current_map();
154: pmap = get_task_pmap(current_task());
155: pmap_reference(pmap);
156: map = vm_map_create(pmap,
157: get_map_min(old_map),
158: get_map_max(old_map),
159: TRUE); /**** FIXME ****/
160:
161: if (!result)
162: result = &myresult;
163:
164: *result = (load_result_t) { 0 };
165:
166: lret = parse_machfile(vp, map, header, file_offset, macho_size,
167: 0, (unsigned long *)0, result);
168:
169: if (lret != LOAD_SUCCESS) {
170: vm_map_deallocate(map); /* will lose pmap reference too */
171: return(lret);
172: }
173: /*
174: * Commit to new map, destroy old map. (Destruction
175: * of old map cleans up pmap data structures too).
176: */
177: /* current_task()->map = map; */
178: set_task_map(current_task(),map);
179: set_act_map(current_act(),map);
180: /****** FIX ME ***/
181: map_ref_fixup(old_map, map);
182: vm_map_deallocate(old_map);
183:
184: return(LOAD_SUCCESS);
185: }
186:
187: int dylink_test = 0;
188:
189: static
190: load_return_t
191: parse_machfile(
192: struct vnode *vp,
193: vm_map_t map,
194: struct mach_header *header,
195: unsigned long file_offset,
196: unsigned long macho_size,
197: int depth,
198: unsigned long *lib_version,
199: load_result_t *result
200: )
201: {
202: struct machine_slot *ms;
203: int ncmds;
204: struct load_command *lcp, *next;
205: struct dylinker_command *dlp = 0;
206: void * pager;
207: load_return_t ret;
208: vm_offset_t addr, kl_addr;
209: vm_size_t size,kl_size;
210: int offset;
211: int pass;
212: struct proc *p = current_proc(); /* XXXX */
213: int error;
214: int resid=0;
215:
216: /*
217: * Break infinite recursion
218: */
219: if (depth > 6)
220: return(LOAD_FAILURE);
221: depth++;
222:
223: /*
224: * Check to see if right machine type.
225: */
226: ms = &machine_slot[cpu_number()];
227: if ((header->cputype != ms->cpu_type) ||
228: !check_cpu_subtype(header->cpusubtype))
229: return(LOAD_BADARCH);
230:
231: switch (header->filetype) {
232:
233: case MH_OBJECT:
234: case MH_EXECUTE:
235: case MH_PRELOAD:
236: if (depth != 1)
237: return (LOAD_FAILURE);
238: break;
239:
240: case MH_FVMLIB:
241: case MH_DYLIB:
242: if (depth == 1)
243: return (LOAD_FAILURE);
244: break;
245:
246: case MH_DYLINKER:
247: if (depth != 2)
248: return (LOAD_FAILURE);
249: break;
250:
251: default:
252: return (LOAD_FAILURE);
253: }
254:
255: /*
256: * Get the pager for the file.
257: */
258: if (!vp->v_vm_info) {
259: vm_info_init(vp);
260: }
261: pager = (void *) vnode_pager_setup(vp, vp->v_vm_info->pager, FALSE, TRUE);
262:
263:
264: /*
265: * Map portion that must be accessible directly into
266: * kernel's map.
267: */
268: if ((sizeof (struct mach_header) + header->sizeofcmds) > macho_size)
269: return(LOAD_BADMACHO);
270:
271: /*
272: * Round size of Mach-O commands up to page boundry.
273: */
274: size = round_page(sizeof (struct mach_header) + header->sizeofcmds);
275: if (size <= 0)
276: return(LOAD_BADMACHO);
277:
278: /*
279: * Map the load commands into kernel memory.
280: */
281: addr = 0;
282: #if 0 /* [
283: #if FIXME
284: ret = vm_allocate_with_pager(kernel_map, &addr, size, TRUE, pager,
285: file_offset);
286: #else
287: ret = vm_map(kernel_map,&addr,size,0,TRUE, pager, file_offset, FALSE,
288: VM_PROT_DEFAULT, VM_PROT_ALL, VM_INHERIT_DEFAULT);
289: #endif /* FIXME */
290: if (ret != KERN_SUCCESS) {
291: return(LOAD_NOSPACE);
292: }
293: #else /* 0 ][ */
294: kl_size = size;
295: kl_addr = kalloc(size);
296: addr = kl_addr;
297: if (addr == NULL) {
298: printf("No space to readin load commands\n");
299: return(LOAD_NOSPACE);
300: }
301: if(error = vn_rdwr(UIO_READ, vp, addr, size, file_offset,
302: UIO_SYSSPACE, 0, p->p_ucred, &resid, p)) {
303: printf("Load command read over nfs failed\n");
304: if (kl_addr ) kfree(kl_addr,kl_size);
305: return(EIO);
306: }
307:
308: #endif /* 0 ] */
309: /*
310: * Scan through the commands, processing each one as necessary.
311: */
312: for (pass = 1; pass <= 2; pass++) {
313: offset = sizeof(struct mach_header);
314: ncmds = header->ncmds;
315: while (ncmds--) {
316: /*
317: * Get a pointer to the command.
318: */
319: lcp = (struct load_command *)(addr + offset);
320: offset += lcp->cmdsize;
321:
322: /*
323: * Check for valid lcp pointer by checking
324: * next offset.
325: */
326: if (offset > header->sizeofcmds
327: + sizeof(struct mach_header)) {
328: #if 0
329: vm_map_remove(kernel_map, addr, addr + size);
330: #endif
331: if (kl_addr ) kfree(kl_addr,kl_size);
332: return(LOAD_BADMACHO);
333: }
334:
335: /*
336: * Check for valid command.
337: */
338: switch(lcp->cmd) {
339: case LC_SEGMENT:
340: if (pass != 1)
341: break;
342: ret = load_segment(
343: (struct segment_command *) lcp,
344: pager, file_offset,
345: macho_size,
346: vp->v_vm_info->vnode_size,
347: map,
348: result);
349: break;
350: case LC_THREAD:
351: if (pass != 2)
352: break;
353: ret = load_thread((struct thread_command *)lcp,
354: result);
355: break;
356: case LC_UNIXTHREAD:
357: if (pass != 2)
358: break;
359: ret = load_unixthread(
360: (struct thread_command *) lcp,
361: result);
362: break;
363: case LC_LOADFVMLIB:
364: if (pass != 1)
365: break;
366: ret = load_fvmlib((struct fvmlib_command *)lcp,
367: map, depth);
368: break;
369: case LC_IDFVMLIB:
370: if (pass != 1)
371: break;
372: if (lib_version) {
373: ret = load_idfvmlib(
374: (struct fvmlib_command *)lcp,
375: lib_version);
376: }
377: break;
378: case LC_LOAD_DYLINKER:
379: if (pass != 2)
380: break;
381: if (depth == 1 || dlp == 0)
382: dlp = (struct dylinker_command *)lcp;
383: else
384: ret = LOAD_FAILURE;
385: break;
386: default:
387: ret = KERN_SUCCESS;/* ignore other stuff */
388: }
389: if (ret != LOAD_SUCCESS)
390: break;
391: }
392: if (ret != LOAD_SUCCESS)
393: break;
394: }
395: if (ret == LOAD_SUCCESS && dlp != 0) {
396: vm_offset_t addr;
397:
398: if (dylink_test) {
399: addr = 0x20000000;
400: vm_map(map, &addr, 0x10000000, 0, SHARED_LIB_ALIAS,
401: shared_text_region_handle, 0, FALSE,
402: VM_PROT_READ, VM_PROT_READ, VM_INHERIT_SHARE);
403: addr = 0x30000000;
404: vm_map(map, &addr, 0x10000000, 0, SHARED_LIB_ALIAS,
405: shared_data_region_handle, 0, TRUE,
406: VM_PROT_READ, VM_PROT_READ, VM_INHERIT_SHARE);
407: }
408: ret = load_dylinker(dlp, map, depth, result);
409: }
410:
411: if (kl_addr ) kfree(kl_addr,kl_size);
412: #if 0
413: vm_map_remove(kernel_map, addr, addr + size);
414: #endif
415: if ((ret == LOAD_SUCCESS) && (depth == 1) &&
416: (result->thread_count == 0))
417: ret = LOAD_FAILURE;
418: return(ret);
419: }
420:
421: static
422: load_return_t load_segment(
423: struct segment_command *scp,
424: void * pager,
425: unsigned long pager_offset,
426: unsigned long macho_size,
427: unsigned long end_of_file,
428: vm_map_t map,
429: load_result_t *result
430: )
431: {
432: kern_return_t ret;
433: vm_offset_t map_addr, map_offset;
434: vm_size_t map_size, seg_size, delta_size;
435: caddr_t tmp;
436: vm_prot_t initprot;
437: vm_prot_t maxprot;
438: #if 1
439: extern int print_map_addr;
440: #endif /* 1 */
441:
442: /*
443: * Make sure what we get from the file is really ours (as specified
444: * by macho_size).
445: */
446: if (scp->fileoff + scp->filesize > macho_size)
447: return (LOAD_BADMACHO);
448:
449: seg_size = round_page(scp->vmsize);
450: if (seg_size == 0)
451: return(KERN_SUCCESS);
452:
453: /*
454: * Round sizes to page size.
455: */
456: map_size = round_page(scp->filesize);
457: map_addr = trunc_page(scp->vmaddr);
458:
459: map_offset = pager_offset + scp->fileoff;
460:
461: if (map_size > 0) {
462: initprot = (scp->initprot) & VM_PROT_ALL;
463: maxprot = (scp->maxprot) & VM_PROT_ALL;
464: /*
465: * Map a copy of the file into the address space.
466: */
467: ret = vm_map(map,
468: &map_addr, map_size, (vm_offset_t)0, FALSE,
469: pager, map_offset, TRUE,
470: initprot, maxprot,
471: VM_INHERIT_DEFAULT);
472: if (ret != KERN_SUCCESS)
473: return(LOAD_NOSPACE);
474:
475: #if 1
476: if (print_map_addr)
477: printf("LSegment: Mapped addr= %x; size = %x\n", map_addr, map_size);
478: #endif /* 1 */
479: /*
480: * If the file didn't end on a page boundary,
481: * we need to zero the leftover.
482: */
483: delta_size = map_size - scp->filesize;
484: #if FIXME
485: if (delta_size > 0) {
486: vm_offset_t tmp;
487:
488: ret = vm_allocate(kernel_map, &tmp, delta_size, TRUE);
489: if (ret != KERN_SUCCESS)
490: return(LOAD_RESOURCE);
491:
492: if (copyout(tmp, map_addr + scp->filesize,
493: delta_size)) {
494: (void) vm_deallocate(
495: kernel_map, tmp, delta_size);
496: return(LOAD_FAILURE);
497: }
498:
499: (void) vm_deallocate(kernel_map, tmp, delta_size);
500: }
501: #endif /* FIXME */
502: }
503:
504: /*
505: * If the virtual size of the segment is greater
506: * than the size from the file, we need to allocate
507: * zero fill memory for the rest.
508: */
509: delta_size = seg_size - map_size;
510: if (delta_size > 0) {
511: vm_offset_t tmp = map_addr + map_size;
512:
513: ret = vm_allocate(map, &tmp, delta_size, FALSE);
514: if (ret != KERN_SUCCESS)
515: return(LOAD_NOSPACE);
516: }
517:
518: /*
519: * Set protection values. (Note: ignore errors!)
520: */
521:
522: if (scp->maxprot != VM_PROT_DEFAULT) {
523: (void) vm_protect(map,
524: map_addr, seg_size,
525: TRUE, scp->maxprot);
526: }
527: if (scp->initprot != VM_PROT_DEFAULT) {
528: (void) vm_protect(map,
529: map_addr, seg_size,
530: FALSE, scp->initprot);
531: }
532: if ( (scp->fileoff == 0) && (scp->filesize != 0) )
533: result->mach_header = map_addr;
534: return(LOAD_SUCCESS);
535: }
536:
537: static
538: load_return_t
539: load_unixthread(
540: struct thread_command *tcp,
541: load_result_t *result
542: )
543: {
544: thread_t thread = current_thread();
545: load_return_t ret;
546:
547: if (result->thread_count != 0)
548: return (LOAD_FAILURE);
549:
550: ret = load_threadstack(thread,
551: (unsigned long *)(((vm_offset_t)tcp) +
552: sizeof(struct thread_command)),
553: tcp->cmdsize - sizeof(struct thread_command),
554: &result->user_stack);
555: if (ret != LOAD_SUCCESS)
556: return(ret);
557:
558: ret = load_threadentry(thread,
559: (unsigned long *)(((vm_offset_t)tcp) +
560: sizeof(struct thread_command)),
561: tcp->cmdsize - sizeof(struct thread_command),
562: &result->entry_point);
563: if (ret != LOAD_SUCCESS)
564: return(ret);
565:
566: ret = load_threadstate(thread,
567: (unsigned long *)(((vm_offset_t)tcp) +
568: sizeof(struct thread_command)),
569: tcp->cmdsize - sizeof(struct thread_command));
570: if (ret != LOAD_SUCCESS)
571: return (ret);
572:
573: result->unixproc = TRUE;
574: result->thread_count++;
575:
576: return(LOAD_SUCCESS);
577: }
578:
579: static
580: load_return_t
581: load_thread(
582: struct thread_command *tcp,
583: load_result_t *result
584: )
585: {
586: thread_t thread;
587: kern_return_t kret;
588: load_return_t lret;
589:
590: if (result->thread_count == 0)
591: thread = current_thread();
592: else {
593: kret = thread_create(current_task(), &thread);
594: if (kret != KERN_SUCCESS)
595: return(LOAD_RESOURCE);
596: thread_deallocate(thread);
597: }
598:
599: lret = load_threadstate(thread,
600: (unsigned long *)(((vm_offset_t)tcp) +
601: sizeof(struct thread_command)),
602: tcp->cmdsize - sizeof(struct thread_command));
603: if (lret != LOAD_SUCCESS)
604: return (lret);
605:
606: if (result->thread_count == 0) {
607: lret = load_threadstack(current_thread(),
608: (unsigned long *)(((vm_offset_t)tcp) +
609: sizeof(struct thread_command)),
610: tcp->cmdsize - sizeof(struct thread_command),
611: &result->user_stack);
612: if (lret != LOAD_SUCCESS)
613: return(lret);
614:
615: lret = load_threadentry(current_thread(),
616: (unsigned long *)(((vm_offset_t)tcp) +
617: sizeof(struct thread_command)),
618: tcp->cmdsize - sizeof(struct thread_command),
619: &result->entry_point);
620: if (lret != LOAD_SUCCESS)
621: return(lret);
622: }
623: /*
624: * Resume thread now, note that this means that the thread
625: * commands should appear after all the load commands to
626: * be sure they don't reference anything not yet mapped.
627: */
628: else
629: thread_resume(thread);
630:
631: result->thread_count++;
632:
633: return(LOAD_SUCCESS);
634: }
635:
636: static
637: load_return_t
638: load_threadstate(
639: thread_t thread,
640: unsigned long *ts,
641: unsigned long total_size
642: )
643: {
644: kern_return_t ret;
645: unsigned long size;
646: int flavor;
647:
648: /*
649: * Set the thread state.
650: */
651:
652: while (total_size > 0) {
653: flavor = *ts++;
654: size = *ts++;
655: total_size -= (size+2)*sizeof(unsigned long);
656: if (total_size < 0)
657: return(LOAD_BADMACHO);
658: ret = thread_setstatus(getact_thread(thread), flavor, ts, size);
659: if (ret != KERN_SUCCESS)
660: return(LOAD_FAILURE);
661: ts += size; /* ts is a (unsigned long *) */
662: }
663: return(LOAD_SUCCESS);
664: }
665:
666: static
667: load_return_t
668: load_threadstack(
669: thread_t thread,
670: unsigned long *ts,
671: unsigned long total_size,
672: vm_offset_t *user_stack
673: )
674: {
675: kern_return_t ret;
676: unsigned long size;
677: int flavor;
678:
679: /*
680: * Set the thread state.
681: */
682: *user_stack = 0;
683: while (total_size > 0) {
684: flavor = *ts++;
685: size = *ts++;
686: total_size -= (size+2)*sizeof(unsigned long);
687: if (total_size < 0)
688: return(LOAD_BADMACHO);
689: ret = thread_userstack(thread, flavor, ts, size, user_stack);
690: if (ret != KERN_SUCCESS)
691: return(LOAD_FAILURE);
692: ts += size; /* ts is a (unsigned long *) */
693: }
694: return(LOAD_SUCCESS);
695: }
696:
697: static
698: load_return_t
699: load_threadentry(
700: thread_t thread,
701: unsigned long *ts,
702: unsigned long total_size,
703: vm_offset_t *entry_point
704: )
705: {
706: kern_return_t ret;
707: unsigned long size;
708: int flavor;
709:
710: /*
711: * Set the thread state.
712: */
713: *entry_point = 0;
714: while (total_size > 0) {
715: flavor = *ts++;
716: size = *ts++;
717: total_size -= (size+2)*sizeof(unsigned long);
718: if (total_size < 0)
719: return(LOAD_BADMACHO);
720: ret = thread_entrypoint(thread, flavor, ts, size, entry_point);
721: if (ret != KERN_SUCCESS)
722: return(LOAD_FAILURE);
723: ts += size; /* ts is a (unsigned long *) */
724: }
725: return(LOAD_SUCCESS);
726: }
727:
728: static
729: load_return_t
730: load_fvmlib(
731: struct fvmlib_command *lcp,
732: vm_map_t map,
733: int depth
734: )
735: {
736: char *name;
737: char *p;
738: struct vnode *vp;
739: struct mach_header header;
740: unsigned long file_offset;
741: unsigned long macho_size;
742: unsigned long lib_version;
743: load_result_t myresult;
744: kern_return_t ret;
745:
746: name = (char *)lcp + lcp->fvmlib.name.offset;
747: /*
748: * Check for a proper null terminated string.
749: */
750: p = name;
751: do {
752: if (p >= (char *)lcp + lcp->cmdsize)
753: return(LOAD_BADMACHO);
754: } while (*p++);
755:
756: ret = get_macho_vnode(name, &header, &file_offset, &macho_size, &vp);
757: if (ret)
758: return (ret);
759:
760: myresult = (load_result_t) { 0 };
761:
762: /*
763: * Load the Mach-O.
764: */
765: ret = parse_machfile(vp, map, &header,
766: file_offset, macho_size,
767: depth, &lib_version, &myresult);
768:
769: if ((ret == LOAD_SUCCESS) &&
770: (lib_version < lcp->fvmlib.minor_version))
771: ret = LOAD_SHLIB;
772:
773: vrele(vp);
774: return(ret);
775: }
776:
777: static
778: load_return_t
779: load_idfvmlib(
780: struct fvmlib_command *lcp,
781: unsigned long *version
782: )
783: {
784: *version = lcp->fvmlib.minor_version;
785: return(LOAD_SUCCESS);
786: }
787:
788:
789: static
790: load_return_t
791: load_dylinker(
792: struct dylinker_command *lcp,
793: vm_map_t map,
794: int depth,
795: load_result_t *result
796: )
797: {
798: char *name;
799: char *p;
800: struct vnode *vp;
801: struct mach_header header;
802: unsigned long file_offset;
803: unsigned long macho_size;
804: vm_map_t copy_map;
805: load_result_t myresult;
806: kern_return_t ret;
807: vm_map_copy_t tmp;
808: vm_offset_t dyl_start, map_addr;
809: vm_size_t dyl_length;
810:
811: name = (char *)lcp + lcp->name.offset;
812: /*
813: * Check for a proper null terminated string.
814: */
815: p = name;
816: do {
817: if (p >= (char *)lcp + lcp->cmdsize)
818: return(LOAD_BADMACHO);
819: } while (*p++);
820:
821: ret = get_macho_vnode(name, &header, &file_offset, &macho_size, &vp);
822: if (ret)
823: return (ret);
824:
825: myresult = (load_result_t) { 0 };
826:
827: /*
828: * Load the Mach-O.
829: */
830:
831: copy_map = vm_map_create(pmap_create(macho_size),
832: get_map_min(map), get_map_max( map), TRUE);
833:
834: ret = parse_machfile(vp, copy_map, &header,
835: file_offset, macho_size,
836: depth, 0, &myresult);
837:
838: if (ret)
839: goto out;
840:
841: if (get_map_nentries(copy_map) > 0) {
842:
843: dyl_start = get_map_start(copy_map);
844: dyl_length = get_map_end(copy_map) - dyl_start;
845:
846: map_addr = dyl_start;
847: ret = vm_allocate(map, &map_addr, dyl_length, FALSE);
848: if (ret != KERN_SUCCESS) {
849: ret = vm_allocate(map, &map_addr, dyl_length, TRUE);
850: }
851:
852: if (ret != KERN_SUCCESS) {
853: ret = LOAD_NOSPACE;
854: goto out;
855:
856: }
857: ret = vm_map_copyin(copy_map, dyl_start, dyl_length, TRUE,
858: &tmp);
859: if (ret != KERN_SUCCESS) {
860: (void) vm_map_remove(map,
861: map_addr,
862: map_addr + dyl_length,
863: VM_MAP_NO_FLAGS);
864: goto out;
865: }
866:
867: ret = vm_map_copy_overwrite(map, map_addr, tmp, FALSE);
868: if (ret != KERN_SUCCESS) {
869: vm_map_copy_discard(tmp);
870: (void) vm_map_remove(map,
871: map_addr,
872: map_addr + dyl_length,
873: VM_MAP_NO_FLAGS);
874: goto out; }
875:
876: if (map_addr != dyl_start)
877: myresult.entry_point += (map_addr - dyl_start);
878: } else
879: ret = LOAD_FAILURE;
880:
881: if (ret == LOAD_SUCCESS) {
882: result->dynlinker = TRUE;
883: result->entry_point = myresult.entry_point;
884: }
885: out:
886: vm_map_deallocate(copy_map);
887:
888: vrele(vp);
889: return (ret);
890:
891: }
892:
893: static
894: load_return_t
895: get_macho_vnode(
896: char *path,
897: struct mach_header *mach_header,
898: unsigned long *file_offset,
899: unsigned long *macho_size,
900: struct vnode **vpp
901: )
902: {
903: struct vnode *vp;
904: struct vattr attr, *atp;
905: struct nameidata nid, *ndp;
906: struct proc *p = current_proc(); /* XXXX */
907: boolean_t is_fat;
908: struct fat_arch fat_arch;
909: int error;
910: int resid;
911: union {
912: struct mach_header mach_header;
913: struct fat_header fat_header;
914: char pad[512];
915: } header;
916: error = KERN_SUCCESS;
917:
918: ndp = &nid;
919: atp = &attr;
920:
921: /* init the namei data to point the file user's program name */
922: NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF | SAVENAME, UIO_SYSSPACE, path, p);
923:
924: if (error = namei(ndp))
925: return(error);
926:
927: vp = ndp->ni_vp;
928:
929: /* check for regular file */
930: if (vp->v_type != VREG) {
931: error = EACCES;
932: goto bad1;
933: }
934:
935: /* get attributes */
936: if (error = VOP_GETATTR(vp, &attr, p->p_ucred, p))
937: goto bad1;
938:
939: /* Check mount point */
940: if (vp->v_mount->mnt_flag & MNT_NOEXEC) {
941: error = EACCES;
942: goto bad1;
943: }
944:
945: if ((vp->v_mount->mnt_flag & MNT_NOSUID) || (p->p_flag & P_TRACED))
946: atp->va_mode &= ~(VSUID | VSGID);
947:
948: /* check access. for root we have to see if any exec bit on */
949: if (error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p))
950: goto bad1;
951: if ((atp->va_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) == 0) {
952: error = EACCES;
953: goto bad1;
954: }
955:
956: /* try to open it */
957: if (error = VOP_OPEN(vp, FREAD, p->p_ucred, p))
958: goto bad1;
959: #if MACH_NBC
960: VOP_UNLOCK(vp, 0, p);
961: #endif /* MACH_NBC */
962: if(error = vn_rdwr(UIO_READ, vp, (caddr_t)&header, sizeof(header), 0,
963: UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p))
964: goto bad2;
965:
966:
967: /* XXXX WMG - we should check for a short read of the header here */
968:
969: if (header.mach_header.magic == MH_MAGIC)
970: is_fat = FALSE;
971: else if (header.fat_header.magic == FAT_MAGIC ||
972: header.fat_header.magic == FAT_CIGAM)
973: is_fat = TRUE;
974: else {
975: error = LOAD_BADMACHO;
976: goto bad2;
977: }
978:
979: if (is_fat) {
980: /*
981: * Look up our architecture in the fat file.
982: */
983: error = fatfile_getarch(vp, (vm_offset_t)(&header.fat_header), &fat_arch);
984: if (error != LOAD_SUCCESS) {
985: goto bad2;
986: }
987: /*
988: * Read the Mach-O header out of it
989: */
990: error = vn_rdwr(UIO_READ, vp, &header.mach_header,
991: sizeof(header.mach_header), fat_arch.offset,
992: UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
993: if (error) {
994: error = LOAD_FAILURE;
995: goto bad2;
996: }
997:
998: /*
999: * Is this really a Mach-O?
1000: */
1001: if (header.mach_header.magic != MH_MAGIC) {
1002: error = LOAD_BADMACHO;
1003: goto bad2;
1004: }
1005:
1006: *mach_header = header.mach_header;
1007: *file_offset = fat_arch.offset;
1008: *macho_size = fat_arch.size;
1009: *vpp = vp;
1010: // leaks otherwise - A.R
1011: FREE_ZONE(ndp->ni_cnd.cn_pnbuf, ndp->ni_cnd.cn_pnlen, M_NAMEI);
1012:
1013: // i_lock exclusive panics, otherwise during pageins
1014: #if !MACH_NBC
1015: VOP_UNLOCK(vp, 0, p);
1016: #endif /* !MACH_NBC */
1017: return (error);
1018: } else {
1019:
1020: *mach_header = header.mach_header;
1021: *file_offset = 0;
1022: if (vp->v_vm_info) {
1023: vp->v_vm_info->vnode_size = attr.va_size;
1024: }
1025: *macho_size = attr.va_size;
1026: *vpp = vp;
1027: // leaks otherwise - A.R
1028: FREE_ZONE(ndp->ni_cnd.cn_pnbuf, ndp->ni_cnd.cn_pnlen, M_NAMEI);
1029:
1030: // i_lock exclusive panics, otherwise during pageins
1031: #if !MACH_NBC
1032: VOP_UNLOCK(vp, 0, p);
1033: #endif /* !MACH_NBC */
1034: return (error);
1035: }
1036:
1037: bad2:
1038: /*
1039: * unlock and close the vnode, restore the old one, free the
1040: * pathname buf, and punt.
1041: */
1042: #if !MACH_NBC
1043: VOP_UNLOCK(vp, 0, p);
1044: #endif /* !MACH_NBC */
1045: vn_close(vp, FREAD, p->p_ucred, p);
1046: FREE_ZONE(ndp->ni_cnd.cn_pnbuf, ndp->ni_cnd.cn_pnlen, M_NAMEI);
1047: return (error);
1048: bad1:
1049: /*
1050: * free the namei pathname buffer, and put the vnode
1051: * (which we don't yet have open).
1052: */
1053: FREE_ZONE(ndp->ni_cnd.cn_pnbuf, ndp->ni_cnd.cn_pnlen, M_NAMEI);
1054: vput(vp);
1055: return(error);
1056: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.