]> git.saurik.com Git - apple/xnu.git/blob - libsa/load.c
projects / apple / xnu.git / blob
? search:


2d64905b46db7d527a7f9bfcd0042ee1c979ef8e
[apple/xnu.git] / libsa / load.c
1 /*
2 * Copyright (c) 2004 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 /***************
24 * HEADERS
25 ***************/
26 #ifndef KERNEL
27
28 #include <CoreFoundation/CoreFoundation.h>
29
30 #include <libc.h>
31 #include <stdlib.h>
32 #include <stdarg.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <unistd.h>
36
37 #include <sys/stat.h>
38 #include <sys/file.h>
39 #include <sys/param.h>
40 #include <sys/types.h>
41 #include <sys/mman.h>
42
43 #include <mach/mach_types.h>
44 #include <mach/mach.h>
45 #include <mach/mach_init.h>
46 #include <mach/mach_error.h>
47 #include <mach/mach_host.h>
48 #include <mach/mach_port.h>
49 #include <mach-o/kld.h>
50 #include <mach-o/arch.h>
51 #include <mach-o/fat.h>
52 #include <mach-o/loader.h>
53 #include <mach-o/nlist.h>
54 #include <kern/kern_types.h>
55 #include <kern/kalloc.h>
56 #include <libkern/OSByteOrder.h>
57
58 #include "vers_rsrc.h"
59
60 #else
61
62 #include <mach-o/kld.h>
63 #include <mach-o/loader.h>
64 #include <mach-o/nlist.h>
65 #include <libsa/vers_rsrc.h>
66
67 #endif /* not KERNEL */
68
69 #include "load.h"
70 #include "dgraph.h"
71 #include "kld_patch.h"
72
73 /***************
74 * MACROS
75 ***************/
76
77 #ifndef KERNEL
78
79 #define PRIV_EXT
80
81 #else
82
83 #define PRIV_EXT __private_extern__
84
85 #ifdef DEBUG
86 #define LOG_DELAY(x) IODelay((x) * 1000000)
87 #define VTYELLOW "\033[33m"
88 #define VTRESET "\033[0m"
89 #else
90 #define LOG_DELAY()
91 #define VTYELLOW
92 #define VTRESET
93 #endif /* DEBUG */
94
95 #endif /* not KERNEL */
96
97 /***************
98 * FUNCTION PROTOS
99 ***************/
100
101 #ifdef KERNEL
102 extern kern_return_t
103 kmod_create_internal(
104 kmod_info_t *info,
105 kmod_t *id);
106
107 extern kern_return_t
108 kmod_destroy_internal(kmod_t id);
109
110 extern kern_return_t
111 kmod_start_or_stop(
112 kmod_t id,
113 int start,
114 kmod_args_t *data,
115 mach_msg_type_number_t *dataCount);
116
117 extern kern_return_t kmod_retain(kmod_t id);
118 extern kern_return_t kmod_release(kmod_t id);
119
120 extern struct mach_header _mh_execute_header;
121 #endif /* KERNEL */
122
123
124 // Used to pass info between kld library and callbacks
125 static dgraph_entry_t * G_current_load_entry = NULL;
126
127 #ifndef KERNEL
128 static mach_port_t G_kernel_port = PORT_NULL;
129 static mach_port_t G_kernel_priv_port = PORT_NULL;
130 static int G_syms_only;
131
132 static kload_error
133 register_prelink(dgraph_entry_t * entry,
134 kmod_info_t * local_kmod_info, vm_offset_t kernel_kmod_info);
135
136 struct PrelinkState
137 {
138 kmod_info_t modules[1];
139 };
140 struct PrelinkState * G_prelink;
141 CFMutableDataRef G_prelink_data;
142 CFMutableDataRef G_prelink_dependencies;
143
144 #endif /* not KERNEL */
145
146 // used by dgraph.c so can't be static
147 kload_log_level log_level = 0;
148
149 #ifndef KERNEL
150 static void __kload_null_log(const char * format, ...);
151 static void __kload_null_err_log(const char * format, ...);
152 static int __kload_null_approve(int default_answer, const char * format, ...);
153 static int __kload_null_veto(int default_answer, const char * format, ...);
154 static const char * __kload_null_input(const char * format, ...);
155
156 void (*__kload_log_func)(const char * format, ...) =
157 &__kload_null_log;
158 void (*__kload_err_log_func)(const char * format, ...) = &__kload_null_err_log;
159 int (*__kload_approve_func)(int default_answer,
160 const char * format, ...) = &__kload_null_approve;
161 int (*__kload_veto_func)(int default_answer,
162 const char * format, ...) = &__kload_null_veto;
163 const char * (*__kload_input_func)(const char * format, ...) =
164 &__kload_null_input;
165 #endif /* not KERNEL */
166
167 static unsigned long __kload_linkedit_address(
168 unsigned long size,
169 unsigned long headers_size);
170 static void __kload_clean_up_entry(dgraph_entry_t * entry);
171 static void __kload_clear_kld_globals(void);
172 static kload_error __kload_patch_dgraph(dgraph_t * dgraph
173 #ifndef KERNEL
174 ,
175 const char * kernel_file
176 #endif /* not KERNEL */
177 );
178 static kload_error __kload_load_modules(dgraph_t * dgraph
179 #ifndef KERNEL
180 ,
181 const char * kernel_file,
182 const char * patch_file, const char * patch_dir,
183 const char * symbol_file, const char * symbol_dir,
184 int do_load, int do_start_kmod, int do_prelink,
185 int interactive_level,
186 int ask_overwrite_symbols, int overwrite_symbols
187 #endif /* not KERNEL */
188 );
189
190 static kload_error __kload_check_module_loaded(
191 dgraph_t * dgraph,
192 dgraph_entry_t * entry,
193 #ifndef KERNEL
194 kmod_info_t * kmod_list,
195 #endif /* not KERNEL */
196 int log_if_already);
197
198 static kload_error __kload_load_module(dgraph_t * dgraph,
199 dgraph_entry_t * entry,
200 int is_root
201 #ifndef KERNEL
202 ,
203 const char * symbol_file,
204 const char * symbol_dir,
205 int do_load,
206 int interactive_level,
207 int ask_overwrite_symbols,
208 int overwrite_symbols
209 #endif /* not KERNEL */
210 );
211 static kload_error __kload_set_module_dependencies(dgraph_entry_t * entry);
212 static kload_error __kload_start_module(dgraph_entry_t * entry);
213
214 #ifndef KERNEL
215 static kload_error __kload_output_patches(
216 dgraph_t * dgraph,
217 const char * patch_file,
218 const char * patch_dir,
219 int ask_overwrite_symbols,
220 int overwrite_symbols);
221
222 Boolean _IOReadBytesFromFile(CFAllocatorRef alloc, const char *path, void **bytes,
223 CFIndex *length, CFIndex maxLength);
224 Boolean _IOWriteBytesToFile(const char *path, const void *bytes, CFIndex length);
225
226 #endif /* not KERNEL */
227
228 /*******************************************************************************
229 *
230 *******************************************************************************/
231 PRIV_EXT
232 kload_error kload_load_dgraph(dgraph_t * dgraph
233 #ifndef KERNEL
234 ,
235 const char * kernel_file,
236 const char * patch_file, const char * patch_dir,
237 const char * symbol_file, const char * symbol_dir,
238 int do_load, int do_start_kmod, int do_prelink,
239 int interactive_level,
240 int ask_overwrite_symbols, int overwrite_symbols
241 #endif /* not KERNEL */
242 )
243 {
244 kload_error result = kload_error_none;
245 int one_has_address = 0;
246 int one_lacks_address = 0;
247 unsigned int i;
248 #ifndef KERNEL
249 int syms_only;
250
251 syms_only = (!do_load) && (symbol_dir || symbol_file);
252
253 if (log_level >= kload_log_level_load_details) {
254 kload_log_message("loading dependency graph:" KNL);
255 dgraph_log(dgraph);
256 }
257
258 if (syms_only && log_level >= kload_log_level_load_details) {
259 kload_log_message("loading for symbol generation only" KNL);
260 }
261
262 /*****
263 * If we're not loading and have no request to emit a symbol
264 * or patch file, there's nothing to do!
265 */
266 if (!do_load && !symbol_dir && !symbol_file &&
267 !patch_dir && !patch_file) {
268
269 if (syms_only && log_level >= kload_log_level_load_details) {
270 kload_log_message("loader has no work to do" KNL);
271 }
272
273 result = kload_error_none; // fixme: should this be USAGE error?
274 goto finish;
275 }
276
277 /*****
278 * If we're doing symbols only, then all entries in the dgraph must
279 * have addresses assigned, or none must.
280 */
281 if (syms_only) {
282 if (log_level >= kload_log_level_load_details) {
283 kload_log_message("checking whether modules have addresses assigned" KNL);
284 }
285 for (i = 0; i < dgraph->length; i++) {
286 struct dgraph_entry_t * entry = dgraph->load_order[i];
287 if (entry->is_kernel_component) {
288 continue;
289 }
290 if (entry->loaded_address != 0) {
291 one_has_address = 1;
292 } else {
293 one_lacks_address = 1;
294 }
295 }
296 }
297 #endif /* not KERNEL */
298
299 if (one_has_address && one_lacks_address) {
300 kload_log_error(
301 "either all modules must have addresses set to nonzero values or "
302 "none must" KNL);
303 result = kload_error_invalid_argument;
304 goto finish;
305 }
306
307 #ifndef KERNEL
308 /* we need the priv port to check/load modules in the kernel.
309 */
310 if (PORT_NULL == G_kernel_priv_port) {
311 G_kernel_priv_port = mach_host_self(); /* if we are privileged */
312 }
313 #endif /* not KERNEL */
314
315 /*****
316 * In the kernel, ALWAYS get load addresses of existing loaded kmods.
317 */
318 #ifndef KERNEL
319 /*****
320 * If we don't have addresses, then get them from the kernel.
321 */
322 if (!one_has_address && !do_prelink && (do_load || symbol_file || symbol_dir)) {
323 #endif /* not KERNEL */
324 if (log_level >= kload_log_level_load_details) {
325 kload_log_message("getting module addresses from kernel" KNL);
326 }
327 #ifndef KERNEL
328 result = kload_set_load_addresses_from_kernel(dgraph, kernel_file,
329 do_load);
330 #else
331 result = kload_set_load_addresses_from_kernel(dgraph);
332 #endif /* not KERNEL */
333 if (result == kload_error_already_loaded) {
334
335 #ifndef KERNEL
336 if (do_load) {
337 goto finish;
338 }
339 #else
340 goto finish;
341 #endif /* not KERNEL */
342
343 } else if (result != kload_error_none) {
344 kload_log_error("can't check load addresses of modules" KNL);
345 goto finish;
346 }
347 #ifndef KERNEL
348 }
349 #endif /* not KERNEL */
350
351 #ifndef KERNEL
352 /*****
353 * At this point, if we're doing symbols only, it's an error to not
354 * have a load address for every module.
355 */
356 if (syms_only && !do_prelink) {
357 if (log_level >= kload_log_level_load_details) {
358 kload_log_message("checking that all modules have addresses assigned" KNL);
359 }
360 for (i = 0; i < dgraph->length; i++) {
361 struct dgraph_entry_t * entry = dgraph->load_order[i];
362 if (entry->is_kernel_component) {
363 continue;
364 }
365 if (!entry->loaded_address) {
366 kload_log_error(
367 "missing load address during symbol generation: %s" KNL,
368 entry->name);
369 result = kload_error_unspecified;
370 goto finish;
371 }
372 }
373 }
374
375 if (do_prelink)
376 {
377 void * bytes;
378 CFIndex length;
379 CFAllocatorRef alloc;
380
381 // We need a real allocator to pass to _IOReadBytesFromFile
382 alloc = CFRetain(CFAllocatorGetDefault());
383 if (_IOReadBytesFromFile(alloc, "prelinkstate", &bytes, &length, 0))
384 {
385 G_prelink_data = CFDataCreateMutable(alloc, 0);
386 CFDataAppendBytes(G_prelink_data, (UInt8 *) bytes, length);
387 CFAllocatorDeallocate(alloc, bytes);
388 }
389 G_prelink_dependencies = CFDataCreateMutable(alloc, 0);
390 if (_IOReadBytesFromFile(alloc, "prelinkdependencies", &bytes, &length, 0))
391 {
392 CFDataAppendBytes(G_prelink_dependencies, (UInt8 *) bytes, length);
393 CFAllocatorDeallocate(alloc, bytes);
394 }
395 CFRelease(alloc);
396
397 if (!G_prelink_data) {
398 kload_log_error(
399 "can't get load address for prelink %s" KNL, kernel_file);
400 result = kload_error_link_load;
401 goto finish;
402 }
403 else
404 G_prelink = (struct PrelinkState *) CFDataGetMutableBytePtr(G_prelink_data);
405 }
406 else
407 G_prelink = 0;
408 #endif /* not KERNEL */
409
410 #ifndef KERNEL
411
412 result = __kload_load_modules(dgraph, kernel_file,
413 patch_file, patch_dir, symbol_file, symbol_dir,
414 do_load, do_start_kmod, do_prelink, interactive_level,
415 ask_overwrite_symbols, overwrite_symbols);
416 #else
417 result = __kload_load_modules(dgraph);
418 #endif /* not KERNEL */
419
420 finish:
421
422 #ifndef KERNEL
423 /* Dispose of the host port to prevent security breaches and port
424 * leaks. We don't care about the kern_return_t value of this
425 * call for now as there's nothing we can do if it fails.
426 */
427 if (PORT_NULL != G_kernel_priv_port) {
428 mach_port_deallocate(mach_task_self(), G_kernel_priv_port);
429 G_kernel_priv_port = PORT_NULL;
430 }
431 #endif /* not KERNEL */
432
433 for (i = 0; i < dgraph->length; i++) {
434 dgraph_entry_t * current_entry = dgraph->graph[i];
435 __kload_clean_up_entry(current_entry);
436 }
437
438 #ifndef KERNEL
439 if (G_prelink)
440 {
441 SInt32 length;
442 const void * bytes;
443 Boolean success;
444
445 length = CFDataGetLength(G_prelink_data);
446 bytes = (0 == length) ? (const void *)"" : CFDataGetBytePtr(G_prelink_data);
447 success = _IOWriteBytesToFile("prelinkstate", bytes, length);
448 if (!success)
449 {
450 kload_log_error("write prelinkstate" KNL);
451 result = kload_error_link_load;
452 }
453 length = CFDataGetLength(G_prelink_dependencies);
454 bytes = (0 == length) ? (const void *)"" : CFDataGetBytePtr(G_prelink_dependencies);
455 success = _IOWriteBytesToFile("prelinkdependencies", bytes, length);
456 if (!success)
457 {
458 kload_log_error("write prelinkdependencies" KNL);
459 result = kload_error_link_load;
460 }
461 }
462 #endif /* not KERNEL */
463
464 return result;
465 }
466
467 #ifndef KERNEL
468 /*******************************************************************************
469 * This function claims the option flags d and D for object file dependencies
470 * and in-kernel dependencies, respectively.
471 *******************************************************************************/
472 kload_error kload_load_with_arglist(
473 int argc, char **argv,
474 const char * kernel_file,
475 const char * patch_file, const char * patch_dir,
476 const char * symbol_file, const char * symbol_dir,
477 int do_load, int do_start_kmod,
478 int interactive_level,
479 int ask_overwrite_symbols, int overwrite_symbols)
480 {
481 kload_error result = kload_error_none;
482 dgraph_error_t dgraph_result;
483 int syms_only = (!do_load) && (symbol_file || symbol_dir);
484
485 static dgraph_t dependency_graph;
486
487 /* Zero out fields in dependency graph for proper error handling later.
488 */
489 bzero(&dependency_graph, sizeof(dependency_graph));
490
491 dgraph_result = dgraph_init_with_arglist(&dependency_graph,
492 syms_only, "-d", "-D", argc, argv);
493 if (dgraph_result == dgraph_error) {
494 kload_log_error("error processing dependency list" KNL);
495 result = kload_error_unspecified;
496 goto finish;
497 } else if (dgraph_result == dgraph_invalid) {
498 // anything to print here, or did init call print something?
499 result = kload_error_invalid_argument;
500 goto finish;
501 }
502
503 result = kload_load_dgraph(&dependency_graph, kernel_file,
504 patch_file, patch_dir, symbol_file, symbol_dir,
505 do_load, do_start_kmod, false /* do_prelink */, interactive_level,
506 ask_overwrite_symbols, overwrite_symbols);
507
508 finish:
509 return result;
510 }
511 #endif /* not KERNEL */
512 /*******************************************************************************
513 * This function can only operate on 32 bit mach object file symbol table
514 * entries.
515 *******************************************************************************/
516 static
517 kload_error __kload_keep_symbols(dgraph_entry_t * entry)
518 {
519 struct mach_header * hdr;
520 struct segment_command * seg;
521 struct nlist * sym;
522 struct symtab_command * symcmd;
523 unsigned long idx, ncmds;
524 vm_size_t size;
525 vm_address_t mem;
526
527 if (entry->symbols)
528 return kload_error_none;
529
530 hdr = entry->linked_image;
531 ncmds = hdr->ncmds;
532 seg = (struct segment_command *)(hdr + 1);
533 for (idx = 0;
534 idx < ncmds;
535 idx++, seg = (struct segment_command *)(((vm_offset_t)seg) + seg->cmdsize))
536 {
537 if (LC_SYMTAB == seg->cmd)
538 break;
539 }
540 if (idx >= ncmds)
541 {
542 kload_log_error("no LC_SYMTAB" KNL);
543 return kload_error_unspecified;
544 }
545
546 symcmd = (struct symtab_command *) seg;
547
548 struct load_cmds {
549 struct mach_header hdr;
550 struct segment_command seg;
551 struct symtab_command symcmd;
552 };
553 struct load_cmds * cmd;
554 unsigned int symtabsize;
555
556 symtabsize = symcmd->stroff + symcmd->strsize - symcmd->symoff;
557
558 size = sizeof(struct load_cmds) + symtabsize;
559
560 mem = (vm_offset_t) malloc(size);
561
562 cmd = (struct load_cmds *) mem;
563 sym = (struct nlist *) (cmd + 1);
564
565 cmd->hdr = *hdr;
566 cmd->symcmd = *symcmd;
567 bcopy((const void *) (((vm_offset_t) hdr) + symcmd->symoff),
568 sym,
569 symtabsize);
570
571 hdr = (struct mach_header *) mem;
572 cmd->hdr.ncmds = 2;
573 cmd->hdr.sizeofcmds = sizeof(struct load_cmds) - sizeof(struct mach_header);
574 cmd->hdr.flags &= ~MH_INCRLINK;
575
576 cmd->symcmd.stroff -= (symcmd->symoff - sizeof(struct load_cmds));
577 cmd->symcmd.symoff = sizeof(struct load_cmds);
578
579 cmd->seg.cmd = LC_SEGMENT;
580 cmd->seg.cmdsize = sizeof(struct segment_command);
581 strcpy(cmd->seg.segname, SEG_LINKEDIT);
582 cmd->seg.vmaddr = 0;
583 cmd->seg.vmsize = 0;
584 cmd->seg.fileoff = cmd->symcmd.symoff;
585 cmd->seg.filesize = symtabsize;
586 cmd->seg.maxprot = 7;
587 cmd->seg.initprot = 1;
588 cmd->seg.nsects = 0;
589 cmd->seg.flags = 0;
590
591 sym = (struct nlist *) (cmd + 1);
592 for (idx = 0; idx < symcmd->nsyms; idx++, sym++)
593 {
594 if ( (sym->n_type & N_STAB) != 0)
595 {
596 sym->n_type = N_ABS;
597 sym->n_desc = 0;
598 sym->n_value = sym->n_un.n_strx;
599 sym->n_un.n_strx = 0;
600 sym->n_sect = NO_SECT;
601 }
602 else if ( (sym->n_type & N_TYPE) == N_SECT)
603 {
604 sym->n_sect = NO_SECT;
605 sym->n_type = (sym->n_type & ~N_TYPE) | N_ABS;
606 }
607 }
608 if (log_level >= kload_log_level_load_details)
609 {
610 kload_log_message("__kload_keep_symbols %s, nsyms %ld, 0x%x bytes" KNL,
611 entry->name, symcmd->nsyms, size);
612 }
613
614 entry->symbols = mem;
615 entry->symbols_malloc = mem;
616 entry->symbols_length = size;
617
618 return kload_error_none;
619 }
620
621
622 /*******************************************************************************
623 * This function can only operate on 32 bit mach object files
624 *******************************************************************************/
625 static
626 kload_error __kload_make_opaque_basefile(dgraph_t * dgraph, struct mach_header * hdr)
627 {
628 struct segment_command * seg;
629 struct segment_command * data_seg;
630 struct segment_command * text_seg;
631 struct section * sec;
632 unsigned int j;
633 vm_offset_t offset;
634 unsigned long idx, ncmds;
635 vm_size_t size;
636 vm_address_t mem, out;
637 static vm_address_t keep_base_image;
638 static vm_size_t keep_base_size;
639
640 if (dgraph->opaque_base_image)
641 return kload_error_none;
642
643 if (keep_base_image)
644 {
645 dgraph->opaque_base_image = keep_base_image;
646 dgraph->opaque_base_length = keep_base_size;
647 return kload_error_none;
648 }
649
650 data_seg = text_seg = NULL;
651 ncmds = hdr->ncmds;
652 seg = (struct segment_command *)(hdr + 1);
653 for (idx = 0;
654 idx < ncmds;
655 idx++, seg = (struct segment_command *)(((vm_offset_t)seg) + seg->cmdsize))
656 {
657 if (LC_SEGMENT != seg->cmd)
658 continue;
659 if (!strcmp(SEG_TEXT, seg->segname))
660 text_seg = seg;
661 else if (!strcmp(SEG_DATA, seg->segname))
662 data_seg = seg;
663 }
664 if (!text_seg || !data_seg)
665 {
666 kload_log_error("no SEG_TEXT or SEG_DATA" KNL);
667 return kload_error_unspecified;
668 }
669
670 size = sizeof(struct mach_header) + text_seg->cmdsize + data_seg->cmdsize;
671 mem = (vm_offset_t) malloc(size);
672
673 out = mem;
674 bcopy(hdr, (void *) out, sizeof(struct mach_header));
675 hdr = (struct mach_header *) out;
676 out += sizeof(struct mach_header);
677
678 bcopy(text_seg, (void *) out, text_seg->cmdsize);
679 text_seg = (struct segment_command *) out;
680 out += text_seg->cmdsize;
681
682 bcopy(data_seg, (void *) out, data_seg->cmdsize);
683 data_seg = (struct segment_command *) out;
684 out += data_seg->cmdsize;
685
686 hdr->ncmds = 2;
687 hdr->sizeofcmds = text_seg->cmdsize + data_seg->cmdsize;
688
689 offset = hdr->sizeofcmds;
690
691 text_seg->fileoff = offset;
692 text_seg->filesize = 0;
693
694 sec = (struct section *)(text_seg + 1);
695 for (j = 0; j < text_seg->nsects; j++, sec++)
696 {
697 // sec->addr = (unsigned long) addr;
698 sec->size = 0;
699 sec->offset = offset;
700 sec->nreloc = 0;
701 }
702
703 data_seg->fileoff = offset;
704 data_seg->filesize = 0;
705
706 sec = (struct section *)(data_seg + 1);
707 for (j = 0; j < data_seg->nsects; j++, sec++)
708 {
709 // sec->addr = (unsigned long) addr;
710 sec->size = 0;
711 sec->offset = offset;
712 sec->nreloc = 0;
713 }
714
715 dgraph->opaque_base_image = mem;
716 dgraph->opaque_base_length = size;
717 keep_base_image = mem;
718 keep_base_size = size;
719
720 return kload_error_none;
721 }
722
723 /*******************************************************************************
724 *
725 *******************************************************************************/
726 static
727 kload_error __kload_load_modules(dgraph_t * dgraph
728 #ifndef KERNEL
729 ,
730 const char * kernel_file,
731 const char * patch_file,
732 const char * patch_dir,
733 const char * symbol_file,
734 const char * symbol_dir,
735 int do_load,
736 int do_start_kmod,
737 int do_prelink,
738 int interactive_level,
739 int ask_overwrite_symbols,
740 int overwrite_symbols
741 #endif /* not KERNEL */
742 )
743 {
744 kload_error result = kload_error_none;
745 #ifndef KERNEL
746 long int kernel_size = 0;
747 kern_return_t mach_result = KERN_SUCCESS;
748 #endif /* not KERNEL */
749 char * kernel_base_addr = 0;
750 int kld_result;
751 Boolean cleanup_kld_loader = false;
752 unsigned int i;
753
754 /* We have to map all object files to get their CFBundleIdentifier
755 * names.
756 */
757 #ifndef KERNEL
758 result = kload_map_dgraph(dgraph, kernel_file);
759 #else
760 result = kload_map_dgraph(dgraph);
761 #endif /* not KERNEL */
762 if (result != kload_error_none) {
763 kload_log_error("error mapping object files" KNL);
764 goto finish;
765 }
766
767 #ifndef KERNEL
768 result = __kload_patch_dgraph(dgraph, kernel_file);
769 #else
770 result = __kload_patch_dgraph(dgraph);
771 #endif /* not KERNEL */
772 if (result != kload_error_none) {
773 // FIXME: print an error message here?
774 goto finish;
775 }
776
777 #ifndef KERNEL
778 // FIXME: check error return
779 __kload_output_patches(dgraph, patch_file, patch_dir,
780 ask_overwrite_symbols, overwrite_symbols);
781
782 /*****
783 * If we're not loading or writing symbols, we're done.
784 */
785 if (!do_load && !do_prelink && !symbol_file && !symbol_dir) {
786 goto finish;
787 }
788
789 if (do_load && PORT_NULL == G_kernel_port) {
790 mach_result = task_for_pid(mach_task_self(), 0, &G_kernel_port);
791 if (mach_result != KERN_SUCCESS) {
792 kload_log_error("unable to get kernel task port: %s" KNL,
793 mach_error_string(mach_result));
794 kload_log_error("you must be running as root to load "
795 "modules into the kernel" KNL);
796 result = kload_error_kernel_permission;
797 goto finish;
798 }
799 }
800 #endif /* not KERNEL */
801
802 kld_address_func(&__kload_linkedit_address);
803
804 #ifndef KERNEL
805 G_syms_only = (!do_load) && (symbol_file || symbol_dir || patch_dir);
806
807 kernel_base_addr = kld_file_getaddr(kernel_file, &kernel_size);
808 if (!kernel_base_addr) {
809 kload_log_error(
810 "can't get load address for kernel %s" KNL, kernel_file);
811 result = kload_error_link_load;
812 goto finish;
813 }
814 #else /* KERNEL */
815
816 const char * kernel_file = "(kernel)";
817 kernel_base_addr = (char *) &_mh_execute_header;
818
819 #endif /* not KERNEL */
820
821 kld_result = true;
822 if (dgraph->has_symbol_sets)
823 {
824 result = __kload_make_opaque_basefile(dgraph, (struct mach_header *) kernel_base_addr);
825 if (result != kload_error_none) {
826 kload_log_error("can't construct opaque base image from %s" KNL, kernel_file);
827 goto finish;
828 }
829
830 kld_result = kld_load_basefile_from_memory(kernel_file,
831 (char *) dgraph->opaque_base_image,
832 dgraph->opaque_base_length);
833 }
834 #ifndef KERNEL
835 else
836 kld_result = kld_load_basefile_from_memory(kernel_file,
837 (char *) kernel_base_addr, kernel_size);
838 #endif /* not KERNEL */
839
840 if (!kld_result) {
841 kload_log_error("can't link base image %s" KNL, kernel_file);
842 result = kload_error_link_load;
843 goto finish;
844 }
845
846 cleanup_kld_loader = true;
847 char opaque_now = false;
848
849 for (i = 0; i < dgraph->length; i++) {
850 dgraph_entry_t * current_entry = dgraph->load_order[i];
851
852 opaque_now |= current_entry->opaque_link;
853
854 if (kOpaqueLink & opaque_now)
855 {
856 unsigned int k, j;
857
858 if (log_level >= kload_log_level_load_details)
859 {
860 kload_log_message("opaque link for %s" KNL, current_entry->name);
861 }
862
863 kld_set_link_options(KLD_STRIP_ALL); // KLD_STRIP_NONE
864
865 if (dgraph->have_loaded_symbols)
866 {
867 kld_unload_all(1);
868 if (kRawKernelLink & current_entry->opaque_link) {
869 #ifndef KERNEL
870 kld_result = kld_load_basefile_from_memory(kernel_file,
871 (char *) kernel_base_addr, kernel_size);
872 #endif
873 } else {
874 kld_result = kld_load_basefile_from_memory(kernel_file,
875 (char *) dgraph->opaque_base_image,
876 dgraph->opaque_base_length);
877 dgraph->have_loaded_symbols = false;
878 }
879 if (!kld_result) {
880 kload_log_error("can't link base image %s" KNL, kernel_file);
881 result = kload_error_link_load;
882 goto finish;
883 }
884 }
885
886 for (j = 0; j < i; j++)
887 {
888
889 dgraph_entry_t * image_dep = dgraph->load_order[j];
890
891 if (current_entry->opaque_link)
892 {
893 for (k = 0;
894 (k < current_entry->num_dependencies)
895 && (current_entry->dependencies[k] != image_dep);
896 k++) {}
897
898 if (k == current_entry->num_dependencies)
899 continue;
900 }
901
902 if (!current_entry->opaque_link && image_dep->opaques)
903 {
904 // kpi not on direct dependency list
905 continue;
906 }
907 if (kRawKernelLink & image_dep->opaques)
908 {
909 // raw kernel already in base image
910 continue;
911 }
912
913 if (!image_dep->symbols)
914 {
915 kload_log_error("internal error; no dependent symbols" KNL);
916 result = kload_error_link_load;
917 goto finish;
918 }
919 else
920 {
921 struct mach_header * kld_header;
922
923 #ifndef KERNEL
924 kld_result = kld_load_from_memory(&kld_header, image_dep->name,
925 (char *) image_dep->symbols, image_dep->symbols_length, NULL);
926 #else
927 kld_result = kld_load_from_memory(&kld_header, image_dep->name,
928 (char *) image_dep->symbols, image_dep->symbols_length);
929 #endif /* not KERNEL */
930 if (!kld_result) {
931 kload_log_error("can't link dependent image %s" KNL, image_dep->name);
932 result = kload_error_link_load;
933 goto finish;
934 }
935 kld_forget_symbol("_kmod_info");
936 dgraph->have_loaded_symbols = true;
937 }
938 }
939 } /* opaque_now */
940
941 if (dgraph->has_opaque_links
942 #ifndef KERNEL
943 || symbol_file || symbol_dir
944 #endif
945 )
946 kld_set_link_options(KLD_STRIP_NONE);
947 else
948 kld_set_link_options(KLD_STRIP_ALL);
949
950 #ifndef KERNEL
951 result = __kload_load_module(dgraph, current_entry,
952 (current_entry == dgraph->root),
953 symbol_file, symbol_dir, do_load,
954 interactive_level, ask_overwrite_symbols, overwrite_symbols);
955 #else
956 result = __kload_load_module(dgraph, current_entry,
957 (current_entry == dgraph->root));
958 #endif /* not KERNEL */
959 if (result != kload_error_none) {
960 goto finish;
961 }
962
963 if (dgraph->has_opaque_links && (current_entry != dgraph->root))
964 {
965 if (!(kRawKernelLink & current_entry->opaques)) {
966 result = __kload_keep_symbols(current_entry);
967 }
968 if (result != kload_error_none) {
969 kload_log_error("__kload_keep_symbols() failed for module %s" KNL,
970 current_entry->name);
971 goto finish;
972 }
973 }
974
975 #ifndef KERNEL
976 if (do_load && current_entry->do_load) {
977 #else
978 if (current_entry->do_load) {
979 #endif /* not KERNEL */
980 result = __kload_set_module_dependencies(current_entry);
981 if ( ! (result == kload_error_none ||
982 result == kload_error_already_loaded) ) {
983 goto finish;
984 }
985
986 #ifndef KERNEL
987 if ( (interactive_level == 1 && current_entry == dgraph->root) ||
988 (interactive_level == 2) ) {
989
990 int approve = (*__kload_approve_func)(1,
991 "\nStart module %s (ansering no will abort the load)",
992 current_entry->name);
993
994 if (approve > 0) {
995 do_start_kmod = true; // override 'cause user said so
996 } else {
997 kern_return_t mach_result;
998 if (approve < 0) {
999 kload_log_message("error reading user response; "
1000 "destroying loaded module" KNL);
1001 } else {
1002 kload_log_message("user canceled module start; "
1003 "destroying loaded module" KNL);
1004 }
1005 mach_result = kmod_destroy(G_kernel_priv_port, current_entry->kmod_id);
1006 if (mach_result != KERN_SUCCESS) {
1007 kload_log_error("kmod_destroy() failed" KNL);
1008 }
1009 if (approve < 0) {
1010 result = kload_error_unspecified;
1011 goto finish;
1012 } else {
1013 result = kload_error_user_abort;
1014 goto finish;
1015 }
1016 }
1017 }
1018 #endif /* not KERNEL */
1019
1020 #ifndef KERNEL
1021 if (current_entry != dgraph->root ||
1022 (current_entry == dgraph->root && do_start_kmod)) {
1023 #endif /* not KERNEL */
1024
1025 result = __kload_start_module(current_entry);
1026 if ( ! (result == kload_error_none ||
1027 result == kload_error_already_loaded) ) {
1028 goto finish;
1029 #ifndef KERNEL
1030 } else if (interactive_level ||
1031 log_level >= kload_log_level_load_details) {
1032 #else
1033 } else if (log_level >= kload_log_level_load_details) {
1034 #endif /* not KERNEL */
1035
1036 kload_log_message("started module %s" KNL,
1037 current_entry->name);
1038 } /* log_level */
1039 #ifndef KERNEL
1040 } /* current_entry... */
1041 #endif /* not KERNEL */
1042
1043
1044 #ifndef KERNEL
1045 } /* if do_load */
1046 #else
1047 } /* if do_load */
1048 #endif /* not KERNEL */
1049 } /* for i, dgraph->length */
1050
1051 finish:
1052
1053 #ifndef KERNEL
1054 /* Dispose of the kernel port to prevent security breaches and port
1055 * leaks. We don't care about the kern_return_t value of this
1056 * call for now as there's nothing we can do if it fails.
1057 */
1058 if (PORT_NULL != G_kernel_port) {
1059 mach_port_deallocate(mach_task_self(), G_kernel_port);
1060 G_kernel_port = PORT_NULL;
1061 }
1062 #endif /* not KERNEL */
1063
1064 if (cleanup_kld_loader) {
1065 kld_unload_all(1);
1066 }
1067
1068 return result;
1069 }
1070
1071
1072 /*******************************************************************************
1073 *
1074 *******************************************************************************/
1075
1076 #ifndef KERNEL
1077 #define __KLOAD_SYMBOL_EXTENSION ".sym"
1078 #endif /* not KERNEL */
1079
1080 static
1081 kload_error __kload_load_module(dgraph_t * dgraph,
1082 dgraph_entry_t * entry,
1083 #ifdef KERNEL
1084 __unused int is_root
1085 #else /* not KERNEL */
1086 int is_root,
1087 const char * symbol_file,
1088 const char * symbol_dir,
1089 int do_load,
1090 int interactive_level,
1091 int ask_overwrite_symbols,
1092 int overwrite_symbols
1093 #endif /* not KERNEL */
1094 )
1095 {
1096 kload_error result = kload_error_none;
1097
1098 int kld_result;
1099 int mach_result;
1100 struct mach_header * kld_header;
1101 const char * kmod_symbol = "_kmod_info";
1102 unsigned long kernel_kmod_info;
1103 kmod_info_t * local_kmod_info = NULL;
1104 char * dest_address = 0;
1105 #ifndef KERNEL
1106 char * allocated_filename = NULL;
1107 char * symbol_filename = NULL;
1108 int file_check;
1109 vm_address_t vm_buffer = 0;
1110 #endif /* not KERNEL */
1111
1112 /* A kernel component is by nature already linked and loaded and has
1113 * no work to be done upon it.
1114 */
1115 if (entry->is_kernel_component && !entry->is_symbol_set) {
1116 result = kload_error_none;
1117 goto finish;
1118 }
1119
1120 G_current_load_entry = entry;
1121
1122 if (log_level >= kload_log_level_load_basic) {
1123 #ifndef KERNEL
1124 if (do_load) {
1125 #endif /* not KERNEL */
1126 kload_log_message("link/loading file %s" KNL, entry->name);
1127 #ifndef KERNEL
1128 } else {
1129 kload_log_message("linking file %s" KNL, entry->name);
1130 }
1131 #endif /* not KERNEL */
1132 }
1133
1134 #ifndef KERNEL
1135 if (entry->link_output_file != entry->name) {
1136 symbol_filename = entry->link_output_file;
1137 }
1138
1139 if (symbol_filename) {
1140 file_check = kload_file_exists(symbol_filename);
1141 if (file_check < 0) {
1142 kload_log_error("error checking existence of file %s" KNL,
1143 symbol_filename);
1144 } else if (file_check > 0 && !overwrite_symbols) {
1145
1146 if (!ask_overwrite_symbols) {
1147 kload_log_message("symbol file %s exists; not overwriting" KNL,
1148 symbol_filename);
1149 symbol_filename = NULL;
1150 } else {
1151 int approve = (*__kload_approve_func)(1,
1152 "\nSymbol file %s exists; overwrite", symbol_filename);
1153
1154 if (approve < 0) {
1155 result = kload_error_unspecified;
1156 goto finish;
1157 } else if (approve == 0) {
1158 if (allocated_filename) free(allocated_filename);
1159 allocated_filename = NULL;
1160 symbol_filename = NULL;
1161 }
1162 }
1163 }
1164 }
1165
1166 if (symbol_filename &&
1167 (interactive_level ||
1168 log_level >= kload_log_level_basic) ) {
1169
1170 kload_log_message("writing symbol file %s" KNL, symbol_filename);
1171 }
1172
1173 if (do_load) {
1174 if (interactive_level && entry->loaded_address) {
1175 kload_log_message(
1176 "module %s is already loaded as %s at address 0x%08x" KNL,
1177 entry->name, entry->expected_kmod_name,
1178 entry->loaded_address);
1179 } else if ( (interactive_level == 1 && is_root) ||
1180 (interactive_level == 2) ) {
1181
1182 int approve = (*__kload_approve_func)(1,
1183 "\nLoad module %s", entry->name);
1184
1185 if (approve < 0) {
1186 result = kload_error_unspecified;
1187 goto finish;
1188 } else if (approve == 0) {
1189 result = kload_error_user_abort;
1190 goto finish;
1191 }
1192 }
1193 }
1194 #endif /* not KERNEL */
1195
1196 entry->object = kld_file_getaddr(entry->name, &entry->object_length);
1197 if (!entry->object) {
1198 kload_log_error("kld_file_getaddr() failed for module %s" KNL,
1199 entry->name);
1200 __kload_clear_kld_globals();
1201 result = kload_error_link_load;
1202 goto finish;
1203 }
1204
1205 if (entry->is_symbol_set) {
1206 entry->symbols = (vm_address_t) entry->object;
1207 entry->symbols_length = entry->object_length;
1208
1209 #ifndef KERNEL
1210 if (symbol_filename) {
1211 if (!_IOWriteBytesToFile(symbol_filename, (void *) entry->symbols, entry->symbols_length)) {
1212 kload_log_error("write symbol file failed for module %s" KNL,
1213 entry->name);
1214 __kload_clear_kld_globals();
1215 result = kload_error_link_load;
1216 goto finish;
1217 }
1218 symbol_filename = 0;
1219 if (G_prelink && (entry->name != entry->link_output_file))
1220 {
1221 kload_log_error("prelink %s %s %s" KNL,
1222 entry->name, entry->link_output_file, entry->expected_kmod_name);
1223 register_prelink(entry, NULL, NULL);
1224 }
1225 }
1226 #endif /* not KERNEL */
1227 if (entry->opaques) {
1228 result = kload_error_none;
1229 goto finish;
1230 }
1231 }
1232
1233 #ifndef KERNEL
1234 kld_result = kld_load_from_memory(&kld_header, entry->name,
1235 entry->object, entry->object_length, symbol_filename);
1236 #else
1237 kld_result = kld_load_from_memory(&kld_header, entry->name,
1238 entry->object, entry->object_length);
1239 #endif /* not KERNEL */
1240
1241 #ifndef KERNEL
1242 fflush(stdout);
1243 fflush(stderr);
1244 #endif /* not KERNEL */
1245
1246 dgraph->have_loaded_symbols = true;
1247
1248 if (!kld_result || !entry->kernel_load_address) {
1249 kload_log_error("kld_load_from_memory() failed for module %s" KNL,
1250 entry->name);
1251 __kload_clear_kld_globals();
1252 entry->need_cleanup = 1;
1253 result = kload_error_link_load;
1254 goto finish;
1255 }
1256
1257 if (entry->is_symbol_set) {
1258 result = kload_error_none;
1259 goto finish;
1260 }
1261
1262 entry->linked_image = kld_header;
1263 entry->linked_image_length = -1; // unknown!
1264
1265 /* If we're in the kernel and not loading (as when handling an
1266 * already-loaded dependency), we don't need to waste any CPU
1267 * cycles looking up the kmod_info struct.
1268 */
1269 #ifdef KERNEL
1270 if (entry->do_load) {
1271 #endif /* KERNEL */
1272
1273 kld_result = kld_lookup(kmod_symbol, &kernel_kmod_info);
1274 if (!kld_result) {
1275 kload_log_error("kld_lookup(\"%s\") failed for module %s" KNL,
1276 kmod_symbol, entry->name);
1277 entry->need_cleanup = 1;
1278 result = kload_error_link_load;
1279 goto finish;
1280 }
1281
1282 #ifdef KERNEL
1283 }
1284 #endif /* KERNEL */
1285
1286 kld_result = kld_forget_symbol(kmod_symbol);
1287 #ifndef KERNEL
1288 fflush(stdout);
1289 fflush(stderr);
1290 #endif /* not KERNEL */
1291 if (!kld_result) {
1292 kload_log_error("kld_forget_symbol(\"%s\") failed for module %s" KNL,
1293 kmod_symbol, entry->name);
1294 entry->need_cleanup = 1;
1295 result = kload_error_link_load;
1296 goto finish;
1297 }
1298
1299 /* This section is always done in userland, but in kernel space
1300 * only if we're loading the kext, because what we have in kernel
1301 * space for an already-loaded kext is the kext itself, which
1302 * must not be touched again after it's been loaded and started.
1303 */
1304 #ifdef KERNEL
1305 if (entry->do_load)
1306 #endif /* KERNEL */
1307 {
1308
1309
1310 /* Get the linked image's kmod_info by translating from the
1311 * destined kernel-space address at kernel_kmod_info to an
1312 * offset from kld_header.
1313 */
1314 local_kmod_info = (kmod_info_t *)((unsigned long)kernel_kmod_info -
1315 (unsigned long)G_current_load_entry->kernel_load_address +
1316 (unsigned long)kld_header);
1317
1318 /* Stamp the bundle ID and version from the entry over anything
1319 * resident inside the kmod.
1320 */
1321 bzero(local_kmod_info->name, sizeof(local_kmod_info->name));
1322 strcpy(local_kmod_info->name, entry->expected_kmod_name);
1323
1324 bzero(local_kmod_info->version, sizeof(local_kmod_info->version));
1325 strcpy(local_kmod_info->version, entry->expected_kmod_vers);
1326
1327 if (log_level >= kload_log_level_details) {
1328 kload_log_message("kmod name: %s" KNL, local_kmod_info->name);
1329 kload_log_message("kmod start @ 0x%x (offset 0x%lx)" KNL,
1330 (vm_address_t)local_kmod_info->start,
1331 (unsigned long)local_kmod_info->start - (unsigned long)G_current_load_entry->kernel_load_address);
1332 kload_log_message("kmod stop @ 0x%x (offset 0x%lx)" KNL,
1333 (vm_address_t)local_kmod_info->stop,
1334 (unsigned long)local_kmod_info->stop - (unsigned long)G_current_load_entry->kernel_load_address);
1335 }
1336
1337 if (!local_kmod_info->start || !local_kmod_info->start) {
1338 kload_log_error(
1339 "error for module file %s; start or stop address is zero" KNL,
1340 entry->name);
1341 entry->need_cleanup = 1;
1342 result = kload_error_link_load;
1343 goto finish;
1344 }
1345
1346 /* Record link info into kmod_info struct, rounding the hdr_size
1347 * to fit the adjustment that was made in __kload_linkedit_address().
1348 */
1349 if (entry->kernel_alloc_address) {
1350 local_kmod_info->address = entry->kernel_alloc_address;
1351 } else {
1352 local_kmod_info->address = entry->loaded_address;
1353 }
1354 local_kmod_info->size = entry->kernel_alloc_size;
1355 local_kmod_info->hdr_size = round_page(entry->kernel_hdr_size);
1356
1357 }
1358
1359 #ifndef KERNEL
1360 if (G_prelink && (entry->name != entry->link_output_file))
1361 {
1362 register_prelink(entry, local_kmod_info, kernel_kmod_info);
1363 }
1364
1365 if (do_load && entry->do_load) {
1366 mach_result = vm_allocate(mach_task_self(), &vm_buffer,
1367 entry->kernel_alloc_size, VM_FLAGS_ANYWHERE);
1368 if (mach_result != KERN_SUCCESS) {
1369 kload_log_error("unable to vm_allocate() copy buffer" KNL);
1370 entry->need_cleanup = 1;
1371 result = kload_error_no_memory; // FIXME: kernel error?
1372 goto finish;
1373 }
1374
1375 dest_address = (char *)vm_buffer;
1376
1377 memcpy(dest_address, kld_header, entry->kernel_hdr_size);
1378 memcpy(dest_address + round_page(entry->kernel_hdr_size),
1379 (void *)((unsigned long)kld_header + entry->kernel_hdr_size),
1380 entry->kernel_load_size - entry->kernel_hdr_size);
1381
1382 mach_result = vm_write(G_kernel_port, entry->kernel_alloc_address,
1383 vm_buffer, entry->kernel_alloc_size);
1384 if (mach_result != KERN_SUCCESS) {
1385 kload_log_error("unable to write module to kernel memory" KNL);
1386 entry->need_cleanup = 1;
1387 result = kload_error_kernel_error;
1388 goto finish;
1389 }
1390
1391 mach_result = kmod_create(G_kernel_priv_port,
1392 (vm_address_t)kernel_kmod_info, &(entry->kmod_id));
1393
1394 #else
1395 if (entry->do_load) {
1396 dest_address = (char *)entry->kernel_alloc_address;
1397 memcpy(dest_address, kld_header, entry->kernel_hdr_size);
1398 memcpy(dest_address + round_page(entry->kernel_hdr_size),
1399 (void *)((unsigned long)kld_header + entry->kernel_hdr_size),
1400 entry->kernel_load_size - entry->kernel_hdr_size);
1401
1402 /* We've written data & instructions into kernel memory, so flush
1403 * the data cache and invalidate the instruction cache.
1404 */
1405 flush_dcache(entry->kernel_alloc_address, entry->kernel_alloc_size, false);
1406 invalidate_icache(entry->kernel_alloc_address, entry->kernel_alloc_size, false);
1407
1408 mach_result = kmod_create_internal(
1409 (kmod_info_t *)kernel_kmod_info, &(entry->kmod_id));
1410
1411 #endif /* not KERNEL */
1412
1413 if (mach_result != KERN_SUCCESS) {
1414 kload_log_error("unable to register module with kernel" KNL);
1415 entry->need_cleanup = 1;
1416 result = kload_error_kernel_error;
1417 goto finish;
1418 }
1419
1420 #ifndef KERNEL
1421 if (interactive_level || log_level >= kload_log_level_load_basic) {
1422 #else
1423 if (log_level >= kload_log_level_load_basic) {
1424 #endif /* not KERNEL */
1425 kload_log_message(
1426 "module %s created as # %d at address 0x%x, size %ld" KNL,
1427 entry->expected_kmod_name, entry->kmod_id,
1428 entry->kernel_alloc_address,
1429 entry->kernel_alloc_size);
1430
1431 #ifndef KERNEL
1432 }
1433 #else
1434 }
1435 #endif /* not KERNEL */
1436
1437 #ifndef KERNEL
1438 if (interactive_level) {
1439 kload_log_message(
1440 "You can now break to the debugger and set breakpoints "
1441 " for this extension." KNL);
1442 }
1443 #endif /* not KERNEL */
1444
1445 #ifndef KERNEL
1446 }
1447 #else
1448 }
1449 #endif /* not KERNEL */
1450
1451 finish:
1452
1453 #ifndef KERNEL
1454 if (allocated_filename) {
1455 free(allocated_filename);
1456 }
1457 if (vm_buffer) {
1458 vm_deallocate(mach_task_self(), vm_buffer, entry->kernel_alloc_size);
1459 }
1460 #endif /* not KERNEL */
1461 __kload_clear_kld_globals();
1462
1463 return result;
1464 }
1465
1466 /*******************************************************************************
1467 *******************************************************************************/
1468
1469 #ifndef KERNEL
1470 static kload_error
1471 register_prelink(dgraph_entry_t * entry,
1472 kmod_info_t * local_kmod_info, vm_offset_t kernel_kmod_info)
1473 {
1474 CFIndex i, j, depoffset;
1475 Boolean exists;
1476 kmod_info_t desc;
1477
1478 depoffset = CFDataGetLength(G_prelink_dependencies) / sizeof(CFIndex);
1479
1480 for (i = 0; i < entry->num_dependencies; i++)
1481 {
1482 exists = false;
1483 for (j = 1; (j < (1 + G_prelink->modules[0].id)); j++)
1484 {
1485 exists = (0 == strcmp(entry->dependencies[i]->expected_kmod_name,
1486 G_prelink->modules[j].name));
1487 if (exists)
1488 break;
1489 }
1490 if (!exists)
1491 {
1492 bzero(&desc, sizeof(desc));
1493 strcpy(desc.name, entry->dependencies[i]->expected_kmod_name);
1494
1495 if (log_level >= kload_log_level_basic) {
1496 kload_log_message("[%d] (dep)\n %s" KNL,
1497 G_prelink->modules[0].id + 1, desc.name);
1498 }
1499 G_prelink->modules[0].id++;
1500 CFDataAppendBytes(G_prelink_data, (UInt8 *) &desc, sizeof(desc));
1501 G_prelink = (struct PrelinkState *) CFDataGetMutableBytePtr(G_prelink_data);
1502 }
1503
1504 G_prelink->modules[0].reference_count++;
1505 OSWriteBigInt32(&j, 0, j);
1506 CFDataAppendBytes(G_prelink_dependencies, (UInt8 *) &j, sizeof(j));
1507 }
1508 if (log_level >= kload_log_level_basic) {
1509 kload_log_message("[%d] 0x%08x info 0x%08x\n %s,\n %s" KNL,
1510 G_prelink->modules[0].id + 1, entry->kernel_load_address,
1511 kernel_kmod_info, entry->link_output_file, entry->name);
1512 }
1513
1514 if (local_kmod_info)
1515 desc = *local_kmod_info;
1516 else
1517 {
1518 bzero(&desc, sizeof(desc));
1519 desc.size = entry->symbols_length;
1520 }
1521
1522 desc.id = kernel_kmod_info;
1523 desc.reference_count = entry->num_dependencies;
1524 desc.reference_list = (kmod_reference_t *) depoffset;
1525
1526 /* Stamp the bundle ID and version from the entry over anything
1527 * resident inside the kmod.
1528 */
1529 bzero(desc.name, sizeof(local_kmod_info->name));
1530 strcpy(desc.name, entry->expected_kmod_name);
1531 bzero(desc.version, sizeof(local_kmod_info->version));
1532 strcpy(desc.version, entry->expected_kmod_vers);
1533
1534 G_prelink->modules[0].id++;
1535 CFDataAppendBytes(G_prelink_data, (UInt8 *) &desc, sizeof(desc));
1536 G_prelink = (struct PrelinkState *) CFDataGetMutableBytePtr(G_prelink_data);
1537
1538 return kload_error_none;
1539 }
1540
1541 #endif
1542
1543 /*******************************************************************************
1544 *
1545 *******************************************************************************/
1546 PRIV_EXT
1547 #ifndef KERNEL
1548 kload_error kload_map_dgraph(
1549 dgraph_t * dgraph,
1550 const char * kernel_file)
1551 #else
1552 kload_error kload_map_dgraph(
1553 dgraph_t * dgraph)
1554 #endif /* not KERNEL */
1555 {
1556 kload_error result = kload_error_none;
1557 unsigned int i;
1558
1559 if (log_level >= kload_log_level_load_details) {
1560 #ifndef KERNEL
1561 kload_log_message("mapping the kernel file %s" KNL, kernel_file);
1562 #else
1563 kload_log_message("mapping the kernel" KNL);
1564 #endif /* not KERNEL */
1565 }
1566
1567 #ifndef KERNEL
1568 if (!kld_file_map(kernel_file)) {
1569 result = kload_error_link_load;
1570 goto finish;
1571 }
1572 #endif /* not KERNEL */
1573
1574 for (i = 0; i < dgraph->length; i++) {
1575 dgraph_entry_t * entry = dgraph->load_order[i];
1576
1577 if (entry->is_kernel_component && !entry->is_symbol_set) {
1578 continue;
1579 }
1580
1581 result = kload_map_entry(entry);
1582 if (result != kload_error_none) {
1583 goto finish;
1584 }
1585 }
1586
1587 finish:
1588 return result;
1589
1590 }
1591
1592 /*******************************************************************************
1593 *
1594 *******************************************************************************/
1595 PRIV_EXT
1596 kload_error kload_map_entry(dgraph_entry_t * entry)
1597 {
1598 kload_error result = kload_error_none;
1599
1600 if (entry->is_kernel_component && !entry->is_symbol_set) {
1601 kload_log_error("attempt to map kernel component %s" KNL, entry->name);
1602 result = kload_error_invalid_argument;
1603 goto finish;
1604 }
1605
1606 if (log_level >= kload_log_level_load_details) {
1607 kload_log_message("mapping module file %s" KNL, entry->name);
1608 }
1609
1610 if (kld_file_getaddr(entry->name, NULL)) {
1611 if (log_level >= kload_log_level_load_details) {
1612 kload_log_message("module file %s is already mapped" KNL, entry->name);
1613 }
1614 result = kload_error_none;
1615 goto finish;
1616 }
1617
1618 #ifndef KERNEL
1619 if (!kld_file_map(entry->name)) {
1620 #else
1621 if (!kld_file_map(entry->name, entry->object, entry->object_length,
1622 entry->object_is_kmem)) {
1623 #endif /* not KERNEL */
1624 kload_log_error("error mapping module file %s" KNL, entry->name);
1625
1626 result = kload_error_link_load;
1627 goto finish;
1628 #ifndef KERNEL
1629 }
1630 #else
1631 }
1632 #endif /* not KERNEL */
1633
1634 entry->is_mapped = true;
1635
1636 /* Clear these bits now, as the kld patch module now owns the info
1637 * and it is subject to change. We reset them in the entry from the
1638 * kld patch module as needed.
1639 */
1640 entry->object = 0;
1641 entry->object_length = 0;
1642 #ifdef KERNEL
1643 entry->object_is_kmem = false;
1644 #endif /* KERNEL */
1645
1646 // FIXME: Stop using this symbol; have the info passed in by
1647 // FIXME: ...the kext management library.
1648 #ifndef KERNEL
1649 if (!entry->is_kernel_component && !kld_file_lookupsymbol(entry->name, "_kmod_info")) {
1650 kload_log_error("%s does not not contain kernel extension code" KNL,
1651 entry->name);
1652 result = kload_error_executable_bad;
1653 goto finish;
1654 }
1655 #endif /* not KERNEL */
1656
1657 finish:
1658 return result;
1659 }
1660
1661 #ifndef KERNEL
1662 /*******************************************************************************
1663 *
1664 *******************************************************************************/
1665 kload_error kload_request_load_addresses(
1666 dgraph_t * dgraph,
1667 const char * kernel_file)
1668 {
1669 kload_error result = kload_error_none;
1670 int i;
1671 const char * user_response = NULL; // must free
1672 int scan_result;
1673 unsigned int address;
1674
1675 /* We have to map all object files to get their CFBundleIdentifier
1676 * names.
1677 */
1678 result = kload_map_dgraph(dgraph, kernel_file);
1679 if (result != kload_error_none) {
1680 kload_log_error("error mapping object files" KNL);
1681 goto finish;
1682 }
1683
1684 // fixme: this shouldn't be printf, should it?
1685 printf("enter the hexadecimal load addresses for these modules:\n");
1686
1687 for (i = 0; i < dgraph->length; i++) {
1688 dgraph_entry_t * entry = dgraph->load_order[i];
1689
1690 if (!entry) {
1691 result = kload_error_unspecified;
1692 goto finish;
1693 }
1694
1695 if (entry->is_kernel_component) {
1696 continue;
1697 }
1698
1699 if (!entry->is_mapped) {
1700 result = kload_error_unspecified;
1701 goto finish;
1702 }
1703
1704 user_response = __kload_input_func("%s:",
1705 entry->expected_kmod_name);
1706 if (!user_response) {
1707 result = kload_error_unspecified;
1708 goto finish;
1709 }
1710 scan_result = sscanf(user_response, "%x", &address);
1711 if (scan_result < 1 || scan_result == EOF) {
1712 result = kload_error_unspecified;
1713 goto finish;
1714 }
1715 entry->loaded_address = address;
1716 }
1717
1718 finish:
1719 return result;
1720
1721 }
1722
1723 /*******************************************************************************
1724 * addresses is a NULL-terminated list of string of the form "module_id@address"
1725 *******************************************************************************/
1726 kload_error kload_set_load_addresses_from_args(
1727 dgraph_t * dgraph,
1728 const char * kernel_file,
1729 char ** addresses)
1730 {
1731 kload_error result = kload_error_none;
1732 int i, j;
1733
1734
1735 /* We have to map all object files to get their CFBundleIdentifier
1736 * names.
1737 */
1738 result = kload_map_dgraph(dgraph, kernel_file);
1739 if (result != kload_error_none) {
1740 kload_log_error("error mapping object files" KNL);
1741 goto finish;
1742 }
1743
1744 /*****
1745 * Run through and assign all addresses to their relevant module
1746 * entries.
1747 */
1748 for (i = 0; i < dgraph->length; i++) {
1749 dgraph_entry_t * entry = dgraph->load_order[i];
1750
1751 if (!entry) {
1752 result = kload_error_unspecified;
1753 goto finish;
1754 }
1755
1756 if (entry->is_kernel_component) {
1757 continue;
1758 }
1759
1760 if (!entry->is_mapped) {
1761 result = kload_error_unspecified;
1762 goto finish;
1763 }
1764
1765 for (j = 0; addresses[j]; j++) {
1766 char * this_addr = addresses[j];
1767 char * address_string = NULL;
1768 unsigned int address;
1769 unsigned int module_namelen = strlen(entry->expected_kmod_name);
1770
1771 if (!this_addr) {
1772 result = kload_error_unspecified;
1773 goto finish;
1774 }
1775
1776 if (strncmp(this_addr, entry->expected_kmod_name, module_namelen)) {
1777 continue;
1778 }
1779 if (this_addr[module_namelen] != '@') {
1780 continue;
1781 }
1782
1783 address_string = index(this_addr, '@');
1784 if (!address_string) {
1785 result = kload_error_unspecified;
1786 goto finish;
1787 }
1788 address_string++;
1789 address = strtoul(address_string, NULL, 16);
1790 entry->loaded_address = address;
1791 }
1792 }
1793
1794 /*****
1795 * Now that we've done that see that all non-kernel modules do have
1796 * addresses set. If even one doesn't, we can't complete the link
1797 * relocation of symbols, so return a usage error.
1798 */
1799 for (i = 0; i < dgraph->length; i++) {
1800 dgraph_entry_t * entry = dgraph->load_order[i];
1801
1802 if (entry->is_kernel_component) {
1803 continue;
1804 }
1805
1806 if (!entry->loaded_address) {
1807 result = kload_error_invalid_argument;
1808 goto finish;
1809 }
1810 }
1811
1812 finish:
1813 return result;
1814
1815 }
1816
1817 /*******************************************************************************
1818 * This function requires G_kernel_priv_port to be set before it will work.
1819 *******************************************************************************/
1820 kload_error kload_set_load_addresses_from_kernel(
1821 dgraph_t * dgraph,
1822 const char * kernel_file,
1823 int do_load)
1824 {
1825 kload_error result = kload_error_none;
1826 int mach_result;
1827 kmod_info_t * loaded_modules = NULL;
1828 int loaded_bytecount = 0;
1829 unsigned int i;
1830
1831
1832 /*****
1833 * We have to map the dgraph's modules before checking whether they've
1834 * been loaded.
1835 */
1836 result = kload_map_dgraph(dgraph, kernel_file);
1837 if (result != kload_error_none) {
1838 kload_log_error("can't map module files" KNL);
1839 goto finish;
1840 }
1841
1842
1843 /* First clear all the load addresses.
1844 */
1845 for (i = 0; i < dgraph->length; i++) {
1846 struct dgraph_entry_t * entry = dgraph->load_order[i];
1847 entry->loaded_address = 0;
1848 }
1849
1850 mach_result = kmod_get_info(G_kernel_priv_port,
1851 (void *)&loaded_modules, &loaded_bytecount);
1852 if (mach_result != KERN_SUCCESS) {
1853 kload_log_error("kmod_get_info() failed" KNL);
1854 result = kload_error_kernel_error;
1855 goto finish;
1856 }
1857
1858 /*****
1859 * Find out which modules have already been loaded & verify
1860 * that loaded versions are same as requested.
1861 */
1862 for (i = 0; i < dgraph->length; i++) {
1863 kload_error cresult;
1864 dgraph_entry_t * current_entry = dgraph->load_order[i];
1865
1866 /* If necessary, check whether the current module is already loaded.
1867 * (We already did the root module above.)
1868 */
1869 cresult = __kload_check_module_loaded(dgraph, current_entry,
1870 loaded_modules, do_load);
1871 if ( ! (cresult == kload_error_none ||
1872 cresult == kload_error_already_loaded) ) {
1873 goto finish;
1874 }
1875 if (current_entry == dgraph->root &&
1876 cresult == kload_error_already_loaded) {
1877
1878 result = cresult;
1879 }
1880 }
1881
1882 finish:
1883
1884 if (loaded_modules) {
1885 vm_deallocate(mach_task_self(), (vm_address_t)loaded_modules,
1886 loaded_bytecount);
1887 loaded_modules = 0;
1888 }
1889
1890 return result;
1891 }
1892
1893 #else
1894 /*******************************************************************************
1895 *
1896 *******************************************************************************/
1897 PRIV_EXT
1898 kload_error kload_set_load_addresses_from_kernel(
1899 dgraph_t * dgraph)
1900 {
1901 kload_error result = kload_error_none;
1902 #ifndef KERNEL
1903 int mach_result;
1904 kmod_info_t * loaded_modules = NULL;
1905 int loaded_bytecount = 0;
1906 #endif /* not KERNEL */
1907 unsigned int i;
1908
1909
1910 /*****
1911 * We have to map the dgraph's modules before checking whether they've
1912 * been loaded.
1913 */
1914 result = kload_map_dgraph(dgraph);
1915 if (result != kload_error_none) {
1916 kload_log_error("can't map module files" KNL);
1917 goto finish;
1918 }
1919
1920
1921 /* First clear all the load addresses.
1922 */
1923 for (i = 0; i < dgraph->length; i++) {
1924 struct dgraph_entry_t * entry = dgraph->load_order[i];
1925 entry->loaded_address = 0;
1926 }
1927
1928 /*****
1929 * Find out which modules have already been loaded & verify
1930 * that loaded versions are same as requested.
1931 */
1932 for (i = 0; i < dgraph->length; i++) {
1933 kload_error cresult;
1934 dgraph_entry_t * current_entry = dgraph->load_order[i];
1935
1936 /* If necessary, check whether the current module is already loaded.
1937 * (We already did the root module above.)
1938 */
1939 cresult = __kload_check_module_loaded(dgraph, current_entry, false);
1940 if ( ! (cresult == kload_error_none ||
1941 cresult == kload_error_already_loaded) ) {
1942 goto finish;
1943 }
1944 if (current_entry == dgraph->root &&
1945 cresult == kload_error_already_loaded) {
1946
1947 result = cresult;
1948 }
1949 }
1950
1951 finish:
1952
1953 return result;
1954 }
1955 #endif /* not KERNEL */
1956
1957 /*******************************************************************************
1958 *
1959 *******************************************************************************/
1960 #ifdef KERNEL
1961 extern kern_return_t kmod_load_from_cache(const char * kmod_name);
1962 #endif /* KERNEL */
1963
1964 static kmod_info_t * __kload_find_kmod_info(const char * kmod_name
1965 #ifndef KERNEL
1966 ,
1967 kmod_info_t * kmod_list
1968 #endif /* not KERNEL */
1969 )
1970 {
1971 #ifndef KERNEL
1972 unsigned int i;
1973
1974 for (i = 0; ; i++) {
1975 kmod_info_t * current_kmod = &(kmod_list[i]);
1976 if (0 == strcmp(current_kmod->name, kmod_name)) {
1977 return current_kmod;
1978 }
1979 if (kmod_list[i].next == 0) {
1980 break;
1981 }
1982 }
1983 return NULL;
1984 #else
1985 kmod_info_t * info;
1986 info = kmod_lookupbyname_locked(kmod_name);
1987 if (!info && (KERN_SUCCESS == kmod_load_from_cache(kmod_name))) {
1988 info = kmod_lookupbyname_locked(kmod_name);
1989 }
1990 return info;
1991 #endif /* not KERNEL */
1992 }
1993
1994 /*******************************************************************************
1995 *
1996 *******************************************************************************/
1997 static
1998 kload_error __kload_check_module_loaded(
1999 dgraph_t * dgraph,
2000 dgraph_entry_t * entry,
2001 #ifndef KERNEL
2002 kmod_info_t * kmod_list,
2003 #endif /* not KERNEL */
2004 int log_if_already)
2005 {
2006 kload_error result = kload_error_none;
2007 const char * kmod_name;
2008 kmod_info_t * current_kmod = 0;
2009
2010 VERS_version entry_vers;
2011 VERS_version loaded_vers;
2012
2013 if (false && entry->is_kernel_component) {
2014 kmod_name = entry->name;
2015 } else {
2016 kmod_name = entry->expected_kmod_name;
2017 if (log_level >= kload_log_level_load_details) {
2018 kload_log_message("checking whether module file %s is already loaded" KNL,
2019 kmod_name);
2020 }
2021 }
2022
2023 #ifndef KERNEL
2024 current_kmod = __kload_find_kmod_info(kmod_name, kmod_list);
2025 #else
2026 current_kmod = __kload_find_kmod_info(kmod_name);
2027 #endif /* not KERNEL */
2028
2029 if (!current_kmod) {
2030 goto finish;
2031 }
2032
2033 entry->do_load = 0;
2034 entry->kmod_id = current_kmod->id;
2035 entry->loaded_address = current_kmod->address;
2036
2037 if (entry->is_kernel_component) {
2038 goto finish;
2039 }
2040
2041 if (log_level >= kload_log_level_load_details) {
2042 kload_log_message("module file %s is loaded; checking status" KNL,
2043 kmod_name);
2044 }
2045
2046 // We really want to move away from having this info in a kmod....
2047 //
2048 loaded_vers = VERS_parse_string(current_kmod->version);
2049 if (loaded_vers < 0) {
2050 kload_log_error(
2051 "can't parse version string \"%s\" of loaded module %s" KNL,
2052 current_kmod->version,
2053 current_kmod->name);
2054 result = kload_error_unspecified;
2055 goto finish;
2056 }
2057
2058 entry_vers = VERS_parse_string(entry->expected_kmod_vers);
2059 if (entry_vers < 0) {
2060 kload_log_error(
2061 "can't parse version string \"%s\" of module file %s" KNL,
2062 entry->expected_kmod_name,
2063 kmod_name);
2064 result = kload_error_unspecified;
2065 goto finish;
2066 }
2067
2068 if (loaded_vers != entry_vers) {
2069 kload_log_error(
2070 "loaded version %s of module %s differs from "
2071 "requested version %s" KNL,
2072 current_kmod->version,
2073 current_kmod->name,
2074 entry->expected_kmod_name);
2075 if (entry == dgraph->root) {
2076 result = kload_error_loaded_version_differs;
2077 } else {
2078 result = kload_error_dependency_loaded_version_differs;
2079 }
2080 goto finish;
2081 } else {
2082
2083 if (log_if_already && log_level >=
2084 kload_log_level_load_basic) {
2085
2086 kload_log_message(
2087 "module %s (identifier %s) is already loaded" KNL,
2088 entry->name, kmod_name);
2089 }
2090 result = kload_error_already_loaded;
2091 goto finish;
2092 }
2093
2094 finish:
2095 #ifdef KERNEL
2096 // Do this ONLY if in the kernel!
2097 if (current_kmod) {
2098 kfree(current_kmod, sizeof(kmod_info_t));
2099 }
2100 #endif /* KERNEL */
2101 return result;
2102 }
2103
2104 /*******************************************************************************
2105 *
2106 *******************************************************************************/
2107 PRIV_EXT
2108 kload_error __kload_patch_dgraph(dgraph_t * dgraph
2109 #ifndef KERNEL
2110 ,
2111 const char * kernel_file
2112 #endif /* not KERNEL */
2113 )
2114 {
2115 kload_error result = kload_error_none;
2116 unsigned int i;
2117
2118 #ifndef KERNEL
2119 if (!kld_file_merge_OSObjects(kernel_file)) {
2120 result = kload_error_link_load;
2121 goto finish;
2122 }
2123 #endif /* not KERNEL */
2124
2125 for (i = 0; i < dgraph->length; i++) {
2126 dgraph_entry_t * current_entry = dgraph->load_order[i];
2127
2128 /* The kernel has already been patched.
2129 */
2130 if (current_entry->is_kernel_component) {
2131 continue;
2132 }
2133
2134 if (log_level >= kload_log_level_load_details) {
2135 kload_log_message("patching C++ code in module %s" KNL,
2136 current_entry->name);
2137 }
2138
2139 #ifndef KERNEL
2140 /* In userland, we call the patch function for all kmods,
2141 * loaded or not, because we don't have all the info that
2142 * the kernel environment has.
2143 */
2144 if (!kld_file_patch_OSObjects(current_entry->name)) {
2145 result = kload_error_link_load; // FIXME: need a "patch" error?
2146 goto finish;
2147 }
2148 #else
2149 /* In the kernel, we call the merge function for already-loaded
2150 * kmods, since the kld patch environment retains info for kmods
2151 * that have already been patched. The patch function does a little
2152 * more work, and is only for kmods that haven't been processed yet.
2153 * NOTE: We are depending here on kload_check_module_loaded()
2154 * having been called, which is guaranteed by kload_load_dgraph()
2155 * is used, but not by its subroutines (such as
2156 * __kload_load_modules()).
2157 */
2158 if (current_entry->loaded_address) {
2159 if (!kld_file_merge_OSObjects(current_entry->name)) {
2160 result = kload_error_link_load; // FIXME: need a "patch" error?
2161 goto finish;
2162 }
2163 } else {
2164 if (!kld_file_patch_OSObjects(current_entry->name)) {
2165 result = kload_error_link_load; // FIXME: need a "patch" error?
2166 goto finish;
2167 }
2168 }
2169 #endif /* not KERNEL */
2170
2171 }
2172
2173 if (!kld_file_prepare_for_link()) {
2174 result = kload_error_link_load; // FIXME: need more specific error?
2175 goto finish;
2176 }
2177
2178 finish:
2179 return result;
2180 }
2181
2182 #ifndef KERNEL
2183 /*******************************************************************************
2184 *
2185 *******************************************************************************/
2186 #define __KLOAD_PATCH_EXTENSION ".patch"
2187
2188 kload_error __kload_output_patches(
2189 dgraph_t * dgraph,
2190 const char * patch_file,
2191 const char * patch_dir,
2192 int ask_overwrite_symbols,
2193 int overwrite_symbols)
2194 {
2195 kload_error result = kload_error_none;
2196 unsigned int i;
2197 char * allocated_filename = NULL;
2198 char * patch_filename = NULL;
2199 int file_check;
2200 int output_patch;
2201
2202 if (patch_dir) {
2203
2204 for (i = 0; i < dgraph->length; i++) {
2205
2206 struct dgraph_entry_t * entry = dgraph->load_order[i];
2207 unsigned long length;
2208
2209 if (entry->is_kernel_component) {
2210 continue;
2211 }
2212
2213 length = strlen(patch_dir) +
2214 strlen(entry->expected_kmod_name) +
2215 strlen(__KLOAD_PATCH_EXTENSION) +
2216 1 + 1 ; // 1 for '/' added, 1 for terminating null
2217 if (length >= MAXPATHLEN) {
2218 kload_log_error(
2219 "output filename \"%s/%s%s\" would be too long" KNL,
2220 patch_dir, entry->expected_kmod_name,
2221 __KLOAD_PATCH_EXTENSION);
2222 result = kload_error_invalid_argument;
2223 goto finish;
2224 }
2225
2226 allocated_filename = (char *)malloc(length);
2227 if (! allocated_filename) {
2228 kload_log_error("malloc failure" KNL);
2229 result = kload_error_no_memory;
2230 goto finish;
2231 }
2232
2233 patch_filename = allocated_filename;
2234 strcpy(patch_filename, patch_dir);
2235 strcat(patch_filename, "/");
2236 strcat(patch_filename, entry->expected_kmod_name);
2237 strcat(patch_filename, __KLOAD_PATCH_EXTENSION);
2238
2239 output_patch = 1;
2240 file_check = kload_file_exists(patch_filename);
2241
2242 if (file_check < 0) {
2243 kload_log_error("error checking existence of file %s" KNL,
2244 patch_filename);
2245 } else if (file_check > 0 && !overwrite_symbols) {
2246 if (!ask_overwrite_symbols) {
2247 kload_log_error(
2248 "patch file %s exists; not overwriting" KNL,
2249 patch_filename);
2250 output_patch = 0;
2251 } else {
2252 int approve = (*__kload_approve_func)(1,
2253 "\nPatch file %s exists; overwrite", patch_filename);
2254
2255 if (approve < 0) {
2256 result = kload_error_unspecified;
2257 goto finish;
2258 } else {
2259 output_patch = approve;
2260 }
2261 }
2262 }
2263
2264 if (output_patch) {
2265 if (log_level >= kload_log_level_basic) {
2266 kload_log_message("writing patch file %s" KNL, patch_filename);
2267 }
2268 kld_file_debug_dump(entry->name, patch_filename);
2269 }
2270
2271 if (allocated_filename) free(allocated_filename);
2272 allocated_filename = NULL;
2273 }
2274
2275 } else if (patch_file) {
2276 output_patch = 1;
2277 file_check = kload_file_exists(patch_file);
2278
2279 if (file_check < 0) {
2280 kload_log_error("error checking existence of file %s" KNL,
2281 patch_file);
2282 } else if (file_check > 0 && !overwrite_symbols) {
2283 if (!ask_overwrite_symbols) {
2284 kload_log_error("patch file %s exists; not overwriting" KNL,
2285 patch_filename);
2286 output_patch = 0;
2287 } else {
2288 int approve = (*__kload_approve_func)(1,
2289 "\nPatch file %s exists; overwrite", patch_filename);
2290
2291 if (approve < 0) {
2292 result = kload_error_unspecified;
2293 goto finish;
2294 } else {
2295 output_patch = approve;
2296 }
2297 }
2298 }
2299
2300 if (output_patch) {
2301 if (log_level >= kload_log_level_basic) {
2302 kload_log_message("writing patch file %s" KNL, patch_filename);
2303 }
2304 kld_file_debug_dump(dgraph->root->name, patch_file);
2305 }
2306 }
2307
2308 finish:
2309 if (allocated_filename) free(allocated_filename);
2310
2311 return result;
2312 }
2313 #endif /* not KERNEL */
2314
2315 /*******************************************************************************
2316 *
2317 *******************************************************************************/
2318 PRIV_EXT
2319 kload_error __kload_set_module_dependencies(dgraph_entry_t * entry) {
2320 kload_error result = kload_error_none;
2321 int mach_result;
2322 #ifndef KERNEL
2323 void * kmod_control_args = 0;
2324 int num_args = 0;
2325 #endif /* not KERNEL */
2326 kmod_t packed_id;
2327 unsigned int i;
2328 dgraph_entry_t * current_dep = NULL;
2329
2330 if (!entry->do_load) {
2331 result = kload_error_already_loaded;
2332 goto finish;
2333 }
2334
2335 for (i = 0; i < entry->num_dependencies; i++) {
2336 current_dep = entry->dependencies[i];
2337
2338 if (log_level >= kload_log_level_load_details) {
2339 kload_log_message("adding reference from %s (%d) to %s (%d)" KNL,
2340 entry->expected_kmod_name, entry->kmod_id,
2341 current_dep->expected_kmod_name, current_dep->kmod_id);
2342 }
2343
2344 packed_id = KMOD_PACK_IDS(entry->kmod_id, current_dep->kmod_id);
2345 #ifndef KERNEL
2346 mach_result = kmod_control(G_kernel_priv_port,
2347 packed_id, KMOD_CNTL_RETAIN, &kmod_control_args, &num_args);
2348 #else
2349 mach_result = kmod_retain(packed_id);
2350 #endif /* not KERNEL */
2351 if (mach_result != KERN_SUCCESS) {
2352 kload_log_error(
2353 "kmod retain failed for %s; destroying kmod" KNL,
2354 entry->expected_kmod_name);
2355 #ifndef KERNEL
2356 mach_result = kmod_destroy(G_kernel_priv_port, entry->kmod_id);
2357 #else
2358 mach_result = kmod_destroy_internal(entry->kmod_id);
2359 #endif /* not KERNEL */
2360 if (mach_result != KERN_SUCCESS) {
2361 kload_log_error("kmod destroy failed" KNL);
2362 }
2363 result = kload_error_link_load;
2364 goto finish;
2365 }
2366 }
2367
2368 if (log_level >= kload_log_level_load_basic) {
2369 kload_log_message("module # %d reference counts incremented" KNL,
2370 entry->kmod_id);
2371 }
2372
2373 finish:
2374 return result;
2375 }
2376
2377 /*******************************************************************************
2378 *
2379 *******************************************************************************/
2380 PRIV_EXT
2381 kload_error __kload_start_module(dgraph_entry_t * entry) {
2382 kload_error result = kload_error_none;
2383 int mach_result;
2384 #ifndef KERNEL
2385 void * kmod_control_args = 0;
2386 int num_args = 0;
2387 #endif /* not KERNEL */
2388
2389 if (!entry->do_load) {
2390 result = kload_error_already_loaded;
2391 goto finish;
2392 }
2393
2394 #ifndef KERNEL
2395 mach_result = kmod_control(G_kernel_priv_port,
2396 entry->kmod_id, KMOD_CNTL_START, &kmod_control_args, &num_args);
2397 #else
2398 mach_result = kmod_start_or_stop(entry->kmod_id, 1, 0, 0);
2399 #endif /* not KERNEL */
2400
2401 if (mach_result != KERN_SUCCESS) {
2402 kload_log_error(
2403 "kmod_control/start failed for %s; destroying kmod" KNL,
2404 entry->expected_kmod_name);
2405 #ifndef KERNEL
2406 mach_result = kmod_destroy(G_kernel_priv_port, entry->kmod_id);
2407 #else
2408 mach_result = kmod_destroy_internal(entry->kmod_id);
2409 #endif /* not KERNEL */
2410 if (mach_result != KERN_SUCCESS) {
2411 kload_log_error("kmod destroy failed" KNL);
2412 }
2413 result = kload_error_link_load;
2414 goto finish;
2415 }
2416
2417 if (log_level >= kload_log_level_load_basic) {
2418 kload_log_message("module # %d started" KNL,
2419 entry->kmod_id);
2420 }
2421
2422 finish:
2423 return result;
2424 }
2425
2426 /*******************************************************************************
2427 *******************************************************************************/
2428
2429 /*******************************************************************************
2430 * This function can only operate on 32 bit mach object file symbol table
2431 * graphs represented by G_current_load_entry.
2432 *******************************************************************************/
2433 static
2434 unsigned long __kload_linkedit_address(
2435 unsigned long size,
2436 unsigned long headers_size)
2437 {
2438 unsigned long round_segments_size;
2439 unsigned long round_headers_size;
2440 unsigned long round_size;
2441 int mach_result;
2442 const struct machOMapping {
2443 struct mach_header h;
2444 struct segment_command seg[1];
2445 } *machO;
2446
2447 if (!G_current_load_entry) {
2448 return 0;
2449 }
2450
2451 // the actual size allocated by kld_load_from_memory()
2452 G_current_load_entry->kernel_load_size = size;
2453
2454 round_headers_size = round_page(headers_size);
2455 round_segments_size = round_page(size - headers_size);
2456 round_size = round_headers_size + round_segments_size;
2457
2458 G_current_load_entry->kernel_alloc_size = round_size;
2459
2460 // will need to be rounded *after* load/link
2461 G_current_load_entry->kernel_hdr_size = headers_size;
2462 G_current_load_entry->kernel_hdr_pad = round_headers_size - headers_size;
2463
2464 if (G_current_load_entry->loaded_address) {
2465 G_current_load_entry->kernel_load_address =
2466 G_current_load_entry->loaded_address +
2467 G_current_load_entry->kernel_hdr_pad;
2468 if (log_level >= kload_log_level_load_basic) {
2469 kload_log_message(
2470 "using %s load address 0x%x (0x%x with header pad)" KNL,
2471 G_current_load_entry->kmod_id ? "existing" : "provided",
2472 G_current_load_entry->loaded_address,
2473 G_current_load_entry->kernel_load_address);
2474 }
2475 return G_current_load_entry->kernel_load_address;
2476 }
2477
2478 machO = (const struct machOMapping *) G_current_load_entry->object;
2479 if (machO->seg[0].vmaddr)
2480 {
2481 G_current_load_entry->loaded_address = trunc_page(machO->seg[0].vmaddr - machO->seg[0].fileoff);
2482
2483 G_current_load_entry->kernel_load_address = G_current_load_entry->loaded_address
2484 + G_current_load_entry->kernel_hdr_pad;
2485
2486 return G_current_load_entry->kernel_load_address;
2487 }
2488
2489 #ifndef KERNEL
2490 if (G_prelink) {
2491 G_current_load_entry->kernel_alloc_address = G_prelink->modules[0].address;
2492 G_prelink->modules[0].address += round_page(G_current_load_entry->kernel_alloc_size);
2493 mach_result = KERN_SUCCESS;
2494
2495 } else if (G_syms_only) {
2496 kload_log_error(
2497 "internal error; asked to allocate kernel memory" KNL);
2498 // FIXME: no provision for cleanup here
2499 return kload_error_unspecified;
2500
2501 } else
2502 #endif /* not KERNEL */
2503
2504 {
2505 #ifndef KERNEL
2506 mach_result = vm_allocate(G_kernel_port,
2507 &G_current_load_entry->kernel_alloc_address,
2508 G_current_load_entry->kernel_alloc_size, VM_FLAGS_ANYWHERE);
2509 #else
2510 mach_result = vm_allocate(kernel_map,
2511 &G_current_load_entry->kernel_alloc_address,
2512 G_current_load_entry->kernel_alloc_size, VM_FLAGS_ANYWHERE);
2513 #endif /* not KERNEL */
2514 }
2515
2516 if (mach_result != KERN_SUCCESS) {
2517 kload_log_error("can't allocate kernel memory" KNL);
2518 // FIXME: no provision for cleanup here
2519 return kload_error_kernel_error;
2520 }
2521
2522 if (log_level >= kload_log_level_load_basic) {
2523 kload_log_message("allocated %ld bytes in kernel space at 0x%x" KNL,
2524 G_current_load_entry->kernel_alloc_size,
2525 G_current_load_entry->kernel_alloc_address);
2526 }
2527
2528 G_current_load_entry->kernel_load_address =
2529 G_current_load_entry->kernel_alloc_address +
2530 G_current_load_entry->kernel_hdr_pad;
2531
2532 G_current_load_entry->loaded_address = G_current_load_entry->kernel_alloc_address;
2533
2534 if (log_level >= kload_log_level_load_basic) {
2535 kload_log_message(
2536 "using load address of 0x%x" KNL,
2537 G_current_load_entry->kernel_alloc_address);
2538 }
2539
2540 return G_current_load_entry->kernel_load_address;
2541 }
2542
2543 /*******************************************************************************
2544 *
2545 *******************************************************************************/
2546 static
2547 void __kload_clear_kld_globals(void) {
2548 G_current_load_entry = NULL;
2549 return;
2550 }
2551
2552 /*******************************************************************************
2553 *
2554 *******************************************************************************/
2555 static
2556 void __kload_clean_up_entry(dgraph_entry_t * entry) {
2557 int mach_result;
2558
2559 if (entry->need_cleanup && entry->kernel_alloc_address) {
2560 #ifndef KERNEL
2561 if (G_prelink) {
2562
2563 if ((entry->kernel_alloc_address + entry->kernel_alloc_size) == G_prelink->modules[0].address) {
2564 G_prelink->modules[0].address = entry->kernel_alloc_address;
2565 } else {
2566 kload_log_error(
2567 "bad free load address of 0x%x (last 0x%x)" KNL,
2568 entry->kernel_alloc_address, G_prelink->modules[0].address);
2569 }
2570 } else {
2571 mach_result = vm_deallocate(G_kernel_port, entry->kernel_alloc_address,
2572 entry->kernel_alloc_size);
2573 }
2574 #else
2575 mach_result = vm_deallocate(kernel_map, entry->kernel_alloc_address,
2576 entry->kernel_alloc_size);
2577 #endif /* not KERNEL */
2578 entry->kernel_alloc_address = 0;
2579 }
2580 return;
2581 }
2582
2583 #ifndef KERNEL
2584 /*******************************************************************************
2585 *
2586 *******************************************************************************/
2587 int kload_file_exists(const char * path)
2588 {
2589 int result = 0; // assume it doesn't exist
2590 struct stat stat_buf;
2591
2592 if (stat(path, &stat_buf) == 0) {
2593 result = 1; // the file does exist; we don't care beyond that
2594 goto finish;
2595 }
2596
2597 switch (errno) {
2598 case ENOENT:
2599 result = 0; // the file doesn't exist
2600 goto finish;
2601 break;
2602 default:
2603 result = -1; // unknown error
2604 goto finish;
2605 break;
2606 }
2607
2608 finish:
2609 return result;
2610 }
2611 #endif /* not KERNEL */
2612
2613 /*******************************************************************************
2614 *
2615 *******************************************************************************/
2616 PRIV_EXT
2617 void kload_set_log_level(kload_log_level level)
2618 {
2619 log_level = level;
2620 return;
2621 }
2622
2623 #ifndef KERNEL
2624 /*******************************************************************************
2625 *
2626 *******************************************************************************/
2627 void kload_set_log_function(
2628 void (*func)(const char * format, ...))
2629 {
2630 if (!func) {
2631 __kload_log_func = &__kload_null_log;
2632 } else {
2633 __kload_log_func = func;
2634 }
2635 return;
2636 }
2637
2638 /*******************************************************************************
2639 *
2640 *******************************************************************************/
2641 void kload_set_error_log_function(
2642 void (*func)(const char * format, ...))
2643 {
2644 if (!func) {
2645 __kload_err_log_func = &__kload_null_err_log;
2646 } else {
2647 __kload_err_log_func = func;
2648 }
2649 return;
2650 }
2651
2652 /*******************************************************************************
2653 *
2654 *******************************************************************************/
2655 void kload_set_user_approve_function(
2656 int (*func)(int default_answer, const char * format, ...))
2657 {
2658 if (!func) {
2659 __kload_approve_func = &__kload_null_approve;
2660 } else {
2661 __kload_approve_func = func;
2662 }
2663 return;
2664 }
2665
2666 /*******************************************************************************
2667 *
2668 *******************************************************************************/
2669 void kload_set_user_veto_function(
2670 int (*func)(int default_answer, const char * format, ...))
2671 {
2672 if (!func) {
2673 __kload_veto_func = &__kload_null_veto;
2674 } else {
2675 __kload_veto_func = func;
2676 }
2677 return;
2678 }
2679
2680 /*******************************************************************************
2681 *
2682 *******************************************************************************/
2683 void kload_set_user_input_function(
2684 const char * (*func)(const char * format, ...))
2685 {
2686 if (!func) {
2687 __kload_input_func = &__kload_null_input;
2688 } else {
2689 __kload_input_func = func;
2690 }
2691 return;
2692 }
2693
2694 /*******************************************************************************
2695 *
2696 *******************************************************************************/
2697 PRIV_EXT
2698 void kload_log_message(const char * format, ...)
2699 {
2700 va_list ap;
2701 char fake_buffer[2];
2702 int output_length;
2703 char * output_string;
2704
2705 if (log_level <= kload_log_level_silent) {
2706 return;
2707 }
2708
2709 va_start(ap, format);
2710 output_length = vsnprintf(fake_buffer, 1, format, ap);
2711 va_end(ap);
2712
2713 output_string = (char *)malloc(output_length + 1);
2714 if (!output_string) {
2715 return;
2716 }
2717
2718 va_start(ap, format);
2719 vsprintf(output_string, format, ap);
2720 va_end(ap);
2721
2722 __kload_log_func(output_string);
2723 free(output_string);
2724
2725 return;
2726 }
2727
2728 /*******************************************************************************
2729 *
2730 *******************************************************************************/
2731 PRIV_EXT
2732 void kload_log_error(const char * format, ...)
2733 {
2734 va_list ap;
2735 char fake_buffer[2];
2736 int output_length;
2737 char * output_string;
2738
2739 if (log_level <= kload_log_level_silent) {
2740 return;
2741 }
2742
2743 va_start(ap, format);
2744 output_length = vsnprintf(fake_buffer, 1, format, ap);
2745 va_end(ap);
2746
2747 output_string = (char *)malloc(output_length + 1);
2748 if (!output_string) {
2749 return;
2750 }
2751
2752 va_start(ap, format);
2753 vsprintf(output_string, format, ap);
2754 va_end(ap);
2755
2756 __kload_err_log_func(output_string);
2757 free(output_string);
2758
2759 return;
2760 }
2761 /*******************************************************************************
2762 *
2763 *******************************************************************************/
2764 void __kload_null_log(const char * format, ...)
2765 {
2766 return;
2767 }
2768
2769 /*******************************************************************************
2770 *
2771 *******************************************************************************/
2772 void __kload_null_err_log(const char * format, ...)
2773 {
2774 return;
2775 }
2776
2777 /*******************************************************************************
2778 *
2779 *******************************************************************************/
2780 int __kload_null_approve(int default_answer, const char * format, ...)
2781 {
2782 return 0;
2783 }
2784
2785 /*******************************************************************************
2786 *
2787 *******************************************************************************/
2788 int __kload_null_veto(int default_answer, const char * format, ...)
2789 {
2790 return 1;
2791 }
2792
2793 /*******************************************************************************
2794 *
2795 *******************************************************************************/
2796 const char * __kload_null_input(const char * format, ...)
2797 {
2798 return NULL;
2799 }
2800
2801 /*******************************************************************************
2802 * The kld_patch.c module uses this function, if defined, to print errors. In
2803 * the kernel this function is defined in libsa/misc.c.
2804 *******************************************************************************/
2805 void kld_error_vprintf(const char * format, va_list ap) {
2806 if (log_level <= kload_log_level_silent) return;
2807 vfprintf(stderr, format, ap);
2808 return;
2809 }
2810
2811 #endif /* not KERNEL */
mirror of XNU