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