]> git.saurik.com Git - apple/xnu.git/blob - libkern/kxld/kxld_object.c
projects / apple / xnu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xnu-3789.1.32.tar.gz
[apple/xnu.git] / libkern / kxld / kxld_object.c
1 /*
2 * Copyright (c) 2009-2014 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 #include <string.h>
29 #include <sys/types.h>
30
31 #if KERNEL
32 #include <libkern/kernel_mach_header.h>
33 #include <mach/machine.h>
34 #include <mach/vm_param.h>
35 #include <mach-o/fat.h>
36 #else /* !KERNEL */
37 /* Get machine.h from the kernel source so we can support all platforms
38 * that the kernel supports. Otherwise we're at the mercy of the host.
39 */
40 #include "../../osfmk/mach/machine.h"
41
42 #include <architecture/byte_order.h>
43 #include <mach/mach_init.h>
44 #include <mach-o/arch.h>
45 #include <mach-o/swap.h>
46 #endif /* KERNEL */
47
48 #include <mach-o/loader.h>
49 #include <mach-o/nlist.h>
50 #include <mach-o/reloc.h>
51
52 #define DEBUG_ASSERT_COMPONENT_NAME_STRING "kxld"
53 #include <AssertMacros.h>
54
55 #include "kxld_demangle.h"
56 #include "kxld_dict.h"
57 #include "kxld_reloc.h"
58 #include "kxld_sect.h"
59 #include "kxld_seg.h"
60 #include "kxld_srcversion.h"
61 #include "kxld_symtab.h"
62 #include "kxld_util.h"
63 #include "kxld_uuid.h"
64 #include "kxld_versionmin.h"
65 #include "kxld_vtable.h"
66 #include "kxld_splitinfolc.h"
67
68 #include "kxld_object.h"
69
70 extern boolean_t isSplitKext;
71 extern boolean_t isOldInterface;
72
73 /*******************************************************************************
74 * Data structures
75 *******************************************************************************/
76
77 struct kxld_object {
78 u_char *file; // used by old interface
79 u_long size; // used by old interface
80 const char *name;
81 uint32_t filetype;
82 cpu_type_t cputype;
83 cpu_subtype_t cpusubtype;
84 KXLDArray segs;
85 KXLDArray sects;
86 KXLDArray extrelocs;
87 KXLDArray locrelocs;
88 KXLDRelocator relocator;
89 KXLDuuid uuid;
90 KXLDversionmin versionmin;
91 KXLDsrcversion srcversion;
92 KXLDSymtab *symtab;
93 struct dysymtab_command *dysymtab_hdr;
94 KXLDsplitinfolc splitinfolc;
95 splitKextLinkInfo split_info;
96 kxld_addr_t link_addr;
97 u_long output_buffer_size;
98 boolean_t is_kernel;
99 boolean_t is_final_image;
100 boolean_t is_linked;
101 boolean_t got_is_created;
102 #if KXLD_USER_OR_OBJECT
103 KXLDArray *section_order;
104 #endif
105 #if KXLD_PIC_KEXTS
106 boolean_t include_kaslr_relocs;
107 #endif
108 #if !KERNEL
109 enum NXByteOrder host_order;
110 enum NXByteOrder target_order;
111 #endif
112 };
113
114 /*******************************************************************************
115 * Prototypes
116 *******************************************************************************/
117
118 static kern_return_t get_target_machine_info(KXLDObject *object,
119 cpu_type_t cputype, cpu_subtype_t cpusubtype);
120 static kern_return_t get_macho_slice_for_arch(KXLDObject *object,
121 u_char *file, u_long size);
122
123 static u_long get_macho_header_size(const KXLDObject *object);
124 static u_long get_macho_data_size(const KXLDObject *object) __unused;
125
126 static kern_return_t init_from_execute(KXLDObject *object);
127 static kern_return_t init_from_final_linked_image(KXLDObject *object,
128 u_int *filetype_out, struct symtab_command **symtab_hdr_out);
129
130 static boolean_t target_supports_protected_segments(const KXLDObject *object)
131 __attribute__((pure));
132 static void set_is_object_linked(KXLDObject *object);
133
134 #if KXLD_USER_OR_BUNDLE
135 static boolean_t target_supports_bundle(const KXLDObject *object)
136 __attribute((pure));
137 static kern_return_t init_from_bundle(KXLDObject *object);
138 static kern_return_t process_relocs_from_tables(KXLDObject *object);
139 static KXLDSeg *get_seg_by_base_addr(KXLDObject *object,
140 kxld_addr_t base_addr);
141 static kern_return_t process_symbol_pointers(KXLDObject *object);
142 static void add_to_ptr(u_char *symptr, kxld_addr_t val, boolean_t is_32_bit);
143 #endif /* KXLD_USER_OR_BUNDLE */
144
145 #if KXLD_USER_OR_OBJECT
146 static boolean_t target_supports_object(const KXLDObject *object)
147 __attribute((pure));
148 static kern_return_t init_from_object(KXLDObject *object);
149 static kern_return_t process_relocs_from_sections(KXLDObject *object);
150 #endif /* KXLD_USER_OR_OBJECT */
151
152 #if KXLD_PIC_KEXTS
153 static boolean_t target_supports_slideable_kexts(const KXLDObject *object);
154 #endif /* KXLD_PIC_KEXTS */
155
156
157 static kern_return_t export_macho_header(const KXLDObject *object, u_char *buf,
158 u_int ncmds, u_long *header_offset, u_long header_size);
159 #if KXLD_USER_OR_ILP32
160 static u_long get_macho_cmd_data_32(u_char *file, u_long offset,
161 u_int *filetype, u_int *ncmds);
162 static kern_return_t export_macho_header_32(const KXLDObject *object,
163 u_char *buf, u_int ncmds, u_long *header_offset, u_long header_size);
164 #endif /* KXLD_USER_OR_ILP32 */
165 #if KXLD_USER_OR_LP64
166 static u_long get_macho_cmd_data_64(u_char *file, u_long offset,
167 u_int *filetype, u_int *ncmds);
168 static kern_return_t export_macho_header_64(const KXLDObject *object,
169 u_char *buf, u_int ncmds, u_long *header_offset, u_long header_size);
170 #endif /* KXLD_USER_OR_LP64 */
171
172 #if KXLD_USER_OR_GOT || KXLD_USER_OR_COMMON
173 static kern_return_t add_section(KXLDObject *object, KXLDSect **sect);
174 #endif /* KXLD_USER_OR_GOT || KXLD_USER_OR_COMMON */
175
176 #if KXLD_USER_OR_COMMON
177 static kern_return_t resolve_common_symbols(KXLDObject *object);
178 #endif /* KXLD_USER_OR_COMMON */
179
180 #if KXLD_USER_OR_GOT
181 static boolean_t target_has_got(const KXLDObject *object) __attribute__((pure));
182 static kern_return_t create_got(KXLDObject *object);
183 static kern_return_t populate_got(KXLDObject *object);
184 #endif /* KXLD_USER_OR_GOT */
185
186 static KXLDSym *get_mutable_sym(const KXLDObject *object, const KXLDSym *sym);
187
188 static kern_return_t populate_kmod_info(KXLDObject *object);
189
190 /*******************************************************************************
191 * Prototypes that may need to be exported
192 *******************************************************************************/
193 static boolean_t kxld_object_target_needs_swap(const KXLDObject *object __unused);
194 static KXLDSeg * kxld_object_get_seg_by_name(const KXLDObject *object, const char *segname);
195 static KXLDSect * kxld_object_get_sect_by_name(const KXLDObject *object, const char *segname,
196 const char *sectname);
197
198 /*******************************************************************************
199 *******************************************************************************/
200 size_t
201 kxld_object_sizeof(void)
202 {
203 return sizeof(KXLDObject);
204 }
205
206 /*******************************************************************************
207 *******************************************************************************/
208 kern_return_t
209 kxld_object_init_from_macho(KXLDObject *object, u_char *file, u_long size,
210 const char *name, KXLDArray *section_order __unused,
211 cpu_type_t cputype, cpu_subtype_t cpusubtype, KXLDFlags flags __unused)
212 {
213 kern_return_t rval = KERN_FAILURE;
214 KXLDSeg * seg = NULL;
215 u_int i = 0;
216 u_char * my_file;
217
218 check(object);
219 check(file);
220 check(name);
221
222 object->name = name;
223
224 #if KXLD_USER_OR_OBJECT
225 object->section_order = section_order;
226 #endif
227 #if KXLD_PIC_KEXTS
228 object->include_kaslr_relocs = ((flags & kKXLDFlagIncludeRelocs) == kKXLDFlagIncludeRelocs);
229 #endif
230
231 /* Find the local architecture */
232
233 rval = get_target_machine_info(object, cputype, cpusubtype);
234 require_noerr(rval, finish);
235
236 /* Find the Mach-O slice for the target architecture */
237
238 rval = get_macho_slice_for_arch(object, file, size);
239 require_noerr(rval, finish);
240
241 if (isOldInterface) {
242 my_file = object->file;
243 }
244 else {
245 my_file = object->split_info.kextExecutable;
246 }
247
248 /* Allocate the symbol table */
249
250 if (!object->symtab) {
251 object->symtab = kxld_alloc(kxld_symtab_sizeof());
252 require_action(object->symtab, finish, rval=KERN_RESOURCE_SHORTAGE);
253 bzero(object->symtab, kxld_symtab_sizeof());
254 }
255
256 /* Build the relocator */
257
258 rval = kxld_relocator_init(&object->relocator,
259 my_file,
260 object->symtab, &object->sects,
261 object->cputype,
262 object->cpusubtype,
263 kxld_object_target_needs_swap(object));
264 require_noerr(rval, finish);
265
266 /* There are four types of Mach-O files that we can support:
267 * 1) 32-bit MH_OBJECT - Snow Leopard and earlier
268 * 2) 32-bit MH_KEXT_BUNDLE - Lion and Later
269 * 3) 64-bit MH_OBJECT - Unsupported
270 * 4) 64-bit MH_KEXT_BUNDLE - Snow Leopard and Later
271 */
272
273 if (kxld_object_is_32_bit(object)) {
274 struct mach_header *mach_hdr = (struct mach_header *) ((void *) my_file);
275 object->filetype = mach_hdr->filetype;
276 } else {
277 struct mach_header_64 *mach_hdr = (struct mach_header_64 *) ((void *) my_file);
278 object->filetype = mach_hdr->filetype;
279 }
280
281 switch (object->filetype) {
282 #if KXLD_USER_OR_BUNDLE
283 case MH_KEXT_BUNDLE:
284 rval = init_from_bundle(object);
285 require_noerr(rval, finish);
286 break;
287 #endif /* KXLD_USER_OR_BUNDLE */
288 #if KXLD_USER_OR_OBJECT
289 case MH_OBJECT:
290 rval = init_from_object(object);
291 require_noerr(rval, finish);
292 break;
293 #endif /* KXLD_USER_OR_OBJECT */
294 case MH_EXECUTE:
295 object->is_kernel = TRUE;
296 rval = init_from_execute(object);
297 require_noerr(rval, finish);
298 break;
299 default:
300 rval = KERN_FAILURE;
301 kxld_log(kKxldLogLinking, kKxldLogErr,
302 kKxldLogFiletypeNotSupported, object->filetype);
303 goto finish;
304 }
305
306 if (!kxld_object_is_kernel(object)) {
307 for (i = 0; i < object->segs.nitems; ++i) {
308 seg = kxld_array_get_item(&object->segs, i);
309 kxld_seg_set_vm_protections(seg,
310 target_supports_protected_segments(object));
311 }
312
313 seg = kxld_object_get_seg_by_name(object, SEG_LINKEDIT);
314 if (seg) {
315 (void) kxld_seg_populate_linkedit(seg, object->symtab,
316 kxld_object_is_32_bit(object)
317 #if KXLD_PIC_KEXTS
318 , &object->locrelocs, &object->extrelocs,
319 target_supports_slideable_kexts(object)
320 #endif
321 , isOldInterface ? 0 : object->splitinfolc.datasize
322 );
323 }
324 }
325
326 (void) set_is_object_linked(object);
327
328 rval = KERN_SUCCESS;
329 finish:
330 return rval;
331 }
332
333 /*******************************************************************************
334 *******************************************************************************/
335 splitKextLinkInfo *
336 kxld_object_get_link_info(KXLDObject *object)
337 {
338 check(object);
339
340 return &object->split_info;
341 }
342
343
344 /*******************************************************************************
345 *******************************************************************************/
346 void
347 kxld_object_set_link_info(KXLDObject *object, splitKextLinkInfo *link_info)
348 {
349 check(object);
350 check(link_info);
351
352 object->split_info.vmaddr_TEXT = link_info->vmaddr_TEXT;
353 object->split_info.vmaddr_TEXT_EXEC = link_info->vmaddr_TEXT_EXEC;
354 object->split_info.vmaddr_DATA = link_info->vmaddr_DATA;
355 object->split_info.vmaddr_DATA_CONST = link_info->vmaddr_DATA_CONST;
356 object->split_info.vmaddr_LINKEDIT = link_info->vmaddr_LINKEDIT;
357
358 return;
359 }
360
361 /*******************************************************************************
362 *******************************************************************************/
363 kern_return_t
364 get_target_machine_info(KXLDObject *object, cpu_type_t cputype __unused,
365 cpu_subtype_t cpusubtype __unused)
366 {
367 #if KERNEL
368
369 /* Because the kernel can only link for its own architecture, we know what
370 * the host and target architectures are at compile time, so we can use
371 * a vastly simplified version of this function.
372 */
373
374 check(object);
375
376 #if defined(__x86_64__)
377 object->cputype = CPU_TYPE_X86_64;
378 /* FIXME: we need clang to provide a __x86_64h__ macro for the sub-type. Using
379 * __AVX2__ is a temporary solution until this is available. */
380 #if defined(__AVX2__)
381 object->cpusubtype = CPU_SUBTYPE_X86_64_H;
382 #else
383 object->cpusubtype = CPU_SUBTYPE_X86_64_ALL;
384 #endif
385 return KERN_SUCCESS;
386 #else
387 kxld_log(kKxldLogLinking, kKxldLogErr,
388 kKxldLogArchNotSupported, _mh_execute_header->cputype);
389 return KERN_NOT_SUPPORTED;
390 #endif /* Supported architecture defines */
391
392
393 #else /* !KERNEL */
394
395 /* User-space must look up the architecture it's running on and the target
396 * architecture at run-time.
397 */
398
399 kern_return_t rval = KERN_FAILURE;
400 const NXArchInfo *host_arch = NULL;
401
402 check(object);
403
404 host_arch = NXGetLocalArchInfo();
405 require_action(host_arch, finish, rval=KERN_FAILURE);
406
407 object->host_order = host_arch->byteorder;
408
409 /* If the user did not specify a cputype, use the local architecture.
410 */
411
412 if (cputype) {
413 object->cputype = cputype;
414 object->cpusubtype = cpusubtype;
415 } else {
416 object->cputype = host_arch->cputype;
417 object->target_order = object->host_order;
418
419 switch (object->cputype) {
420 case CPU_TYPE_I386:
421 object->cpusubtype = CPU_SUBTYPE_I386_ALL;
422 break;
423 case CPU_TYPE_X86_64:
424 object->cpusubtype = CPU_SUBTYPE_X86_64_ALL;
425 break;
426 case CPU_TYPE_ARM:
427 object->cpusubtype = CPU_SUBTYPE_ARM_ALL;
428 break;
429 case CPU_TYPE_ARM64:
430 object->cpusubtype = CPU_SUBTYPE_ARM64_ALL;
431 break;
432 default:
433 object->cpusubtype = 0;
434 break;
435 }
436 }
437
438 /* Validate that we support the target architecture and record its
439 * endianness.
440 */
441
442 switch(object->cputype) {
443 case CPU_TYPE_ARM:
444 case CPU_TYPE_ARM64:
445 case CPU_TYPE_I386:
446 case CPU_TYPE_X86_64:
447 object->target_order = NX_LittleEndian;
448 break;
449 default:
450 rval = KERN_NOT_SUPPORTED;
451 kxld_log(kKxldLogLinking, kKxldLogErr,
452 kKxldLogArchNotSupported, object->cputype);
453 goto finish;
454 }
455
456 rval = KERN_SUCCESS;
457
458 finish:
459 return rval;
460 #endif /* KERNEL */
461 }
462
463 /*******************************************************************************
464 *******************************************************************************/
465 static kern_return_t
466 get_macho_slice_for_arch(KXLDObject *object, u_char *file, u_long size)
467 {
468 kern_return_t rval = KERN_FAILURE;
469 struct mach_header *mach_hdr = NULL;
470 #if !KERNEL
471 struct fat_header *fat = (struct fat_header *) ((void *) file);
472 struct fat_arch *archs = (struct fat_arch *) &fat[1];
473 boolean_t swap = FALSE;
474 #endif /* KERNEL */
475 u_char *my_file = file;
476 u_long my_file_size = size;
477
478 check(object);
479 check(file);
480 check(size);
481
482 /* We are assuming that we will never receive a fat file in the kernel */
483
484 #if !KERNEL
485 require_action(size >= sizeof(*fat), finish,
486 rval=KERN_FAILURE;
487 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogTruncatedMachO));
488
489 /* The fat header is always big endian, so swap if necessary */
490 if (fat->magic == FAT_CIGAM) {
491 (void) swap_fat_header(fat, object->host_order);
492 swap = TRUE;
493 }
494
495 if (fat->magic == FAT_MAGIC) {
496 struct fat_arch *arch = NULL;
497
498 require_action(size >= (sizeof(*fat) + (fat->nfat_arch * sizeof(*archs))),
499 finish,
500 rval=KERN_FAILURE;
501 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogTruncatedMachO));
502
503 /* Swap the fat_arch structures if necessary */
504 if (swap) {
505 (void) swap_fat_arch(archs, fat->nfat_arch, object->host_order);
506 }
507
508 /* Locate the Mach-O for the requested architecture */
509
510 arch = NXFindBestFatArch(object->cputype, object->cpusubtype, archs, fat->nfat_arch);
511 require_action(arch, finish, rval=KERN_FAILURE;
512 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogArchNotFound));
513 require_action(size >= arch->offset + arch->size, finish,
514 rval=KERN_FAILURE;
515 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogTruncatedMachO));
516
517 my_file = my_file + arch->offset;
518 my_file_size = arch->size;
519 }
520 #endif /* !KERNEL */
521
522 /* Swap the Mach-O's headers to this architecture if necessary */
523 if (kxld_object_is_32_bit(object)) {
524 rval = validate_and_swap_macho_32(my_file, my_file_size
525 #if !KERNEL
526 , object->host_order
527 #endif /* !KERNEL */
528 );
529 } else {
530 rval = validate_and_swap_macho_64(my_file, my_file_size
531 #if !KERNEL
532 , object->host_order
533 #endif /* !KERNEL */
534 );
535 }
536 require_noerr(rval, finish);
537
538 mach_hdr = (struct mach_header *) ((void *) my_file);
539 require_action(object->cputype == mach_hdr->cputype, finish,
540 rval=KERN_FAILURE;
541 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogTruncatedMachO));
542 object->cpusubtype = mach_hdr->cpusubtype; /* <rdar://problem/16008438> */
543
544 if (isOldInterface) {
545 object->file = my_file;
546 object->size = my_file_size;
547 }
548 else {
549 object->split_info.kextExecutable = my_file;
550 object->split_info.kextSize = my_file_size;
551 }
552
553 rval = KERN_SUCCESS;
554 finish:
555 return rval;
556 }
557
558 /*******************************************************************************
559 *******************************************************************************/
560 static kern_return_t
561 init_from_final_linked_image(KXLDObject *object, u_int *filetype_out,
562 struct symtab_command **symtab_hdr_out)
563 {
564 kern_return_t rval = KERN_FAILURE;
565 KXLDSeg *seg = NULL;
566 KXLDSect *sect = NULL;
567 struct load_command *cmd_hdr = NULL;
568 struct symtab_command *symtab_hdr = NULL;
569 struct uuid_command *uuid_hdr = NULL;
570 struct version_min_command *versionmin_hdr = NULL;
571 struct source_version_command *source_version_hdr = NULL;
572 u_long base_offset = 0;
573 u_long offset = 0;
574 u_long sect_offset = 0;
575 u_int filetype = 0;
576 u_int i = 0;
577 u_int j = 0;
578 u_int segi = 0;
579 u_int secti = 0;
580 u_int nsegs = 0;
581 u_int nsects = 0;
582 u_int ncmds = 0;
583 u_char *my_file;
584
585 if (isOldInterface) {
586 my_file = object->file;
587 }
588 else {
589 my_file = object->split_info.kextExecutable;
590 }
591
592 KXLD_3264_FUNC(kxld_object_is_32_bit(object), base_offset,
593 get_macho_cmd_data_32, get_macho_cmd_data_64,
594 my_file, offset, &filetype, &ncmds);
595
596 /* First pass to count segments and sections */
597
598 offset = base_offset;
599 for (i = 0; i < ncmds; ++i, offset += cmd_hdr->cmdsize) {
600 cmd_hdr = (struct load_command *) ((void *) (my_file + offset));
601
602 switch(cmd_hdr->cmd) {
603 #if KXLD_USER_OR_ILP32
604 case LC_SEGMENT:
605 {
606 struct segment_command *seg_hdr =
607 (struct segment_command *) cmd_hdr;
608
609 /* Ignore segments with no vm size */
610 if (!seg_hdr->vmsize) continue;
611
612 ++nsegs;
613 nsects += seg_hdr->nsects;
614 }
615 break;
616 #endif /* KXLD_USER_OR_ILP32 */
617 #if KXLD_USER_OR_LP64
618 case LC_SEGMENT_64:
619 {
620 struct segment_command_64 *seg_hdr =
621 (struct segment_command_64 *) ((void *) cmd_hdr);
622
623 /* Ignore segments with no vm size */
624 if (!seg_hdr->vmsize) continue;
625
626 ++nsegs;
627 nsects += seg_hdr->nsects;
628 }
629 break;
630 #endif /* KXLD_USER_OR_LP64 */
631 default:
632 continue;
633 }
634 }
635
636 /* Allocate the segments and sections */
637
638 if (nsegs) {
639 rval = kxld_array_init(&object->segs, sizeof(KXLDSeg), nsegs);
640 require_noerr(rval, finish);
641
642 rval = kxld_array_init(&object->sects, sizeof(KXLDSect), nsects);
643 require_noerr(rval, finish);
644 }
645
646 /* Initialize the segments and sections */
647
648 offset = base_offset;
649 for (i = 0; i < ncmds; ++i, offset += cmd_hdr->cmdsize) {
650 cmd_hdr = (struct load_command *) ((void *) (my_file + offset));
651 seg = NULL;
652
653 switch(cmd_hdr->cmd) {
654 #if KXLD_USER_OR_ILP32
655 case LC_SEGMENT:
656 {
657 struct segment_command *seg_hdr =
658 (struct segment_command *) cmd_hdr;
659
660 /* Ignore segments with no vm size */
661 if (!seg_hdr->vmsize) continue;
662
663 seg = kxld_array_get_item(&object->segs, segi++);
664
665 rval = kxld_seg_init_from_macho_32(seg, seg_hdr);
666 require_noerr(rval, finish);
667
668 sect_offset = offset + sizeof(*seg_hdr);
669 }
670 break;
671 #endif /* KXLD_USER_OR_ILP32 */
672 #if KXLD_USER_OR_LP64
673 case LC_SEGMENT_64:
674 {
675 struct segment_command_64 *seg_hdr =
676 (struct segment_command_64 *) ((void *) cmd_hdr);
677
678 /* Ignore segments with no vm size */
679 if (!seg_hdr->vmsize) continue;
680
681 seg = kxld_array_get_item(&object->segs, segi++);
682
683 rval = kxld_seg_init_from_macho_64(seg, seg_hdr);
684 require_noerr(rval, finish);
685
686 sect_offset = offset + sizeof(*seg_hdr);
687 }
688 break;
689 #endif /* KXLD_USER_OR_LP64 */
690 case LC_SYMTAB:
691 symtab_hdr = (struct symtab_command *) cmd_hdr;
692 break;
693 case LC_UUID:
694 uuid_hdr = (struct uuid_command *) cmd_hdr;
695 kxld_uuid_init_from_macho(&object->uuid, uuid_hdr);
696 break;
697 case LC_VERSION_MIN_MACOSX:
698 case LC_VERSION_MIN_IPHONEOS:
699 case LC_VERSION_MIN_TVOS:
700 case LC_VERSION_MIN_WATCHOS:
701 versionmin_hdr = (struct version_min_command *) cmd_hdr;
702 kxld_versionmin_init_from_macho(&object->versionmin, versionmin_hdr);
703 break;
704 case LC_SOURCE_VERSION:
705 source_version_hdr = (struct source_version_command *) (void *) cmd_hdr;
706 kxld_srcversion_init_from_macho(&object->srcversion, source_version_hdr);
707 break;
708 case LC_DYSYMTAB:
709 object->dysymtab_hdr = (struct dysymtab_command *) cmd_hdr;
710 rval = kxld_reloc_create_macho(&object->extrelocs, &object->relocator,
711 (struct relocation_info *) ((void *) (my_file + object->dysymtab_hdr->extreloff)),
712 object->dysymtab_hdr->nextrel);
713 require_noerr(rval, finish);
714
715 rval = kxld_reloc_create_macho(&object->locrelocs, &object->relocator,
716 (struct relocation_info *) ((void *) (my_file + object->dysymtab_hdr->locreloff)),
717 object->dysymtab_hdr->nlocrel);
718 require_noerr(rval, finish);
719
720 break;
721 case LC_UNIXTHREAD:
722 case LC_MAIN:
723 /* Don't need to do anything with UNIXTHREAD or MAIN for the kernel */
724 require_action(kxld_object_is_kernel(object),
725 finish, rval=KERN_FAILURE;
726 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
727 "LC_UNIXTHREAD/LC_MAIN segment is not valid in a kext."));
728 break;
729 case LC_SEGMENT_SPLIT_INFO:
730 if (isSplitKext) {
731 struct linkedit_data_command *split_info_hdr = NULL;
732 split_info_hdr = (struct linkedit_data_command *) (void *) cmd_hdr;
733 kxld_splitinfolc_init_from_macho(&object->splitinfolc, split_info_hdr);
734 }
735 break;
736 case LC_CODE_SIGNATURE:
737 case LC_DYLD_INFO:
738 case LC_DYLD_INFO_ONLY:
739 case LC_FUNCTION_STARTS:
740 case LC_DATA_IN_CODE:
741 case LC_DYLIB_CODE_SIGN_DRS:
742 /* Various metadata that might be stored in the linkedit segment */
743 break;
744 default:
745 rval=KERN_FAILURE;
746 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
747 "Invalid load command type in MH_KEXT_BUNDLE kext: %u.", cmd_hdr->cmd);
748 goto finish;
749 }
750
751 if (seg) {
752
753 /* Initialize the sections */
754 for (j = 0; j < seg->sects.nitems; ++j, ++secti) {
755 sect = kxld_array_get_item(&object->sects, secti);
756
757 KXLD_3264_FUNC(kxld_object_is_32_bit(object), rval,
758 kxld_sect_init_from_macho_32, kxld_sect_init_from_macho_64,
759 sect, my_file, &sect_offset, secti, &object->relocator);
760 require_noerr(rval, finish);
761
762 /* Add the section to the segment. This will also make sure
763 * that the sections and segments have the same segname.
764 */
765 rval = kxld_seg_add_section(seg, sect);
766 require_noerr(rval, finish);
767 }
768 rval = kxld_seg_finish_init(seg);
769 require_noerr(rval, finish);
770 }
771 }
772
773 if (filetype_out) *filetype_out = filetype;
774 if (symtab_hdr_out) *symtab_hdr_out = symtab_hdr;
775 object->is_final_image = TRUE;
776 rval = KERN_SUCCESS;
777 finish:
778 return rval;
779 }
780
781 /*******************************************************************************
782 *******************************************************************************/
783 static kern_return_t
784 init_from_execute(KXLDObject *object)
785 {
786 kern_return_t rval = KERN_FAILURE;
787 struct symtab_command *symtab_hdr = NULL;
788 u_int filetype = 0;
789 KXLDSeg * kernel_linkedit_seg = NULL; // used if running kernel
790 #if KXLD_USER_OR_OBJECT
791 KXLDSeg *seg = NULL;
792 KXLDSect *sect = NULL;
793 KXLDSectionName *sname = NULL;
794 u_int i = 0, j = 0, k = 0;
795 #endif /* KXLD_USER_OR_OBJECT */
796 u_char *my_file;
797
798 check(object);
799
800 if (isOldInterface) {
801 my_file = object->file;
802 }
803 else {
804 my_file = object->split_info.kextExecutable;
805 }
806
807 require_action(kxld_object_is_kernel(object), finish, rval=KERN_FAILURE);
808
809 rval = init_from_final_linked_image(object, &filetype, &symtab_hdr);
810 require_noerr(rval, finish);
811
812 require_action(filetype == MH_EXECUTE, finish, rval=KERN_FAILURE;
813 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
814 "The kernel file is not of type MH_EXECUTE."));
815
816 /* Initialize the symbol table. If this is the running kernel
817 * we will work from the in-memory linkedit segment;
818 * otherwise we work from the whole mach-o image.
819 */
820 #if KERNEL
821 kernel_linkedit_seg = kxld_object_get_seg_by_name(object, SEG_LINKEDIT);
822 require_action(kernel_linkedit_seg, finish, rval=KERN_FAILURE;
823 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO));
824 #endif
825
826 KXLD_3264_FUNC(kxld_object_is_32_bit(object), rval,
827 kxld_symtab_init_from_macho_32, kxld_symtab_init_from_macho_64,
828 object->symtab, symtab_hdr, my_file, kernel_linkedit_seg);
829 require_noerr(rval, finish);
830
831 #if KXLD_USER_OR_OBJECT
832 /* Save off the order of section names so that we can lay out kext
833 * sections for MH_OBJECT-based systems.
834 */
835 if (target_supports_object(object)) {
836
837 rval = kxld_array_init(object->section_order, sizeof(KXLDSectionName),
838 object->sects.nitems);
839 require_noerr(rval, finish);
840
841 /* Copy the section names into the section_order array for future kext
842 * section ordering.
843 */
844 for (i = 0, k = 0; i < object->segs.nitems; ++i) {
845 seg = kxld_array_get_item(&object->segs, i);
846
847 for (j = 0; j < seg->sects.nitems; ++j, ++k) {
848 sect = *(KXLDSect **) kxld_array_get_item(&seg->sects, j);
849 sname = kxld_array_get_item(object->section_order, k);
850
851 strlcpy(sname->segname, sect->segname, sizeof(sname->segname));
852 strlcpy(sname->sectname, sect->sectname, sizeof(sname->sectname));
853 }
854 }
855 }
856 #endif /* KXLD_USER_OR_OBJECT */
857
858 rval = KERN_SUCCESS;
859 finish:
860 return rval;
861 }
862
863 #if KXLD_USER_OR_BUNDLE
864 /*******************************************************************************
865 *******************************************************************************/
866 static boolean_t
867 target_supports_bundle(const KXLDObject *object __unused)
868 {
869 return TRUE;
870 }
871
872 /*******************************************************************************
873 *******************************************************************************/
874 static kern_return_t
875 init_from_bundle(KXLDObject *object)
876 {
877 kern_return_t rval = KERN_FAILURE;
878 struct symtab_command *symtab_hdr = NULL;
879 u_int filetype = 0;
880 u_char *my_file;
881
882 check(object);
883
884 if (isOldInterface) {
885 my_file = object->file;
886 }
887 else {
888 my_file = object->split_info.kextExecutable;
889 }
890
891 require_action(target_supports_bundle(object), finish,
892 rval=KERN_FAILURE;
893 kxld_log(kKxldLogLinking, kKxldLogErr,
894 kKxldLogFiletypeNotSupported, MH_KEXT_BUNDLE));
895
896 rval = init_from_final_linked_image(object, &filetype, &symtab_hdr);
897 require_noerr(rval, finish);
898
899 require_action(filetype == MH_KEXT_BUNDLE, finish,
900 rval=KERN_FAILURE);
901
902 KXLD_3264_FUNC(kxld_object_is_32_bit(object), rval,
903 kxld_symtab_init_from_macho_32, kxld_symtab_init_from_macho_64,
904 object->symtab, symtab_hdr, my_file,
905 /* kernel_linkedit_seg */ NULL);
906 require_noerr(rval, finish);
907
908 rval = KERN_SUCCESS;
909 finish:
910 return rval;
911 }
912 #endif /* KXLD_USER_OR_BUNDLE */
913
914 #if KXLD_USER_OR_OBJECT
915 /*******************************************************************************
916 *******************************************************************************/
917 static boolean_t target_supports_object(const KXLDObject *object)
918 {
919 return (object->cputype == CPU_TYPE_I386);
920 }
921
922 /*******************************************************************************
923 *******************************************************************************/
924 static kern_return_t
925 init_from_object(KXLDObject *object)
926 {
927 kern_return_t rval = KERN_FAILURE;
928 struct load_command *cmd_hdr = NULL;
929 struct symtab_command *symtab_hdr = NULL;
930 struct uuid_command *uuid_hdr = NULL;
931 KXLDSect *sect = NULL;
932 u_long offset = 0;
933 u_long sect_offset = 0;
934 u_int filetype = 0;
935 u_int ncmds = 0;
936 u_int nsects = 0;
937 u_int i = 0;
938 boolean_t has_segment = FALSE;
939 u_char *my_file;
940
941 check(object);
942
943 if (isOldInterface) {
944 my_file = object->file;
945 }
946 else {
947 my_file = object->split_info.kextExecutable;
948 }
949
950 require_action(target_supports_object(object),
951 finish, rval=KERN_FAILURE;
952 kxld_log(kKxldLogLinking, kKxldLogErr,
953 kKxldLogFiletypeNotSupported, MH_OBJECT));
954
955 KXLD_3264_FUNC(kxld_object_is_32_bit(object), offset,
956 get_macho_cmd_data_32, get_macho_cmd_data_64,
957 my_file, offset, &filetype, &ncmds);
958
959 require_action(filetype == MH_OBJECT, finish, rval=KERN_FAILURE);
960
961 /* MH_OBJECTs use one unnamed segment to contain all of the sections. We
962 * loop over all of the load commands to initialize the structures we
963 * expect. Then, we'll use the unnamed segment to get to all of the
964 * sections, and then use those sections to create the actual segments.
965 */
966
967 for (; i < ncmds; ++i, offset += cmd_hdr->cmdsize) {
968 cmd_hdr = (struct load_command *) ((void *) (my_file + offset));
969
970 switch(cmd_hdr->cmd) {
971 #if KXLD_USER_OR_ILP32
972 case LC_SEGMENT:
973 {
974 struct segment_command *seg_hdr =
975 (struct segment_command *) cmd_hdr;
976
977 /* Ignore segments with no vm size */
978 if (!seg_hdr->vmsize) continue;
979
980 /* Ignore LINKEDIT segments */
981 if (streq_safe(seg_hdr->segname, SEG_LINKEDIT,
982 const_strlen(SEG_LINKEDIT)))
983 {
984 continue;
985 }
986
987 require_action(kxld_object_is_32_bit(object), finish, rval=KERN_FAILURE;
988 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
989 "LC_SEGMENT in 64-bit kext."));
990 require_action(!has_segment, finish, rval=KERN_FAILURE;
991 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
992 "Multiple segments in an MH_OBJECT kext."));
993
994 nsects = seg_hdr->nsects;
995 sect_offset = offset + sizeof(*seg_hdr);
996 has_segment = TRUE;
997 }
998 break;
999 #endif /* KXLD_USER_OR_ILP32 */
1000 #if KXLD_USER_OR_LP64
1001 case LC_SEGMENT_64:
1002 {
1003 struct segment_command_64 *seg_hdr =
1004 (struct segment_command_64 *) ((void *) cmd_hdr);
1005
1006 /* Ignore segments with no vm size */
1007 if (!seg_hdr->vmsize) continue;
1008
1009 /* Ignore LINKEDIT segments */
1010 if (streq_safe(seg_hdr->segname, SEG_LINKEDIT,
1011 const_strlen(SEG_LINKEDIT)))
1012 {
1013 continue;
1014 }
1015
1016 require_action(!kxld_object_is_32_bit(object), finish, rval=KERN_FAILURE;
1017 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
1018 "LC_SEGMENT_64 in a 32-bit kext."));
1019 require_action(!has_segment, finish, rval=KERN_FAILURE;
1020 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
1021 "Multiple segments in an MH_OBJECT kext."));
1022
1023 nsects = seg_hdr->nsects;
1024 sect_offset = offset + sizeof(*seg_hdr);
1025 has_segment = TRUE;
1026 }
1027 break;
1028 #endif /* KXLD_USER_OR_LP64 */
1029 case LC_SYMTAB:
1030 symtab_hdr = (struct symtab_command *) cmd_hdr;
1031
1032 KXLD_3264_FUNC(kxld_object_is_32_bit(object), rval,
1033 kxld_symtab_init_from_macho_32, kxld_symtab_init_from_macho_64,
1034 object->symtab, symtab_hdr, my_file,
1035 /* kernel_linkedit_seg */ NULL);
1036 require_noerr(rval, finish);
1037 break;
1038 case LC_UUID:
1039 uuid_hdr = (struct uuid_command *) cmd_hdr;
1040 kxld_uuid_init_from_macho(&object->uuid, uuid_hdr);
1041 break;
1042 case LC_UNIXTHREAD:
1043 case LC_MAIN:
1044 /* Don't need to do anything with UNIXTHREAD or MAIN */
1045 break;
1046 case LC_CODE_SIGNATURE:
1047 case LC_DYLD_INFO:
1048 case LC_DYLD_INFO_ONLY:
1049 case LC_FUNCTION_STARTS:
1050 case LC_DATA_IN_CODE:
1051 case LC_DYLIB_CODE_SIGN_DRS:
1052 /* Various metadata that might be stored in the linkedit segment */
1053 break;
1054 case LC_VERSION_MIN_MACOSX:
1055 case LC_VERSION_MIN_IPHONEOS:
1056 case LC_VERSION_MIN_TVOS:
1057 case LC_VERSION_MIN_WATCHOS:
1058 case LC_SOURCE_VERSION:
1059 /* Not supported for object files, fall through */
1060 default:
1061 rval = KERN_FAILURE;
1062 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
1063 "Invalid load command type in MH_OBJECT kext: %u.", cmd_hdr->cmd);
1064 goto finish;
1065 }
1066 }
1067
1068 if (has_segment) {
1069
1070 /* Get the number of sections from the segment and build the section index */
1071
1072 rval = kxld_array_init(&object->sects, sizeof(KXLDSect), nsects);
1073 require_noerr(rval, finish);
1074
1075 /* Loop over all of the sections to initialize the section index */
1076
1077 for (i = 0; i < nsects; ++i) {
1078 sect = kxld_array_get_item(&object->sects, i);
1079
1080 KXLD_3264_FUNC(kxld_object_is_32_bit(object), rval,
1081 kxld_sect_init_from_macho_32, kxld_sect_init_from_macho_64,
1082 sect, my_file, &sect_offset, i, &object->relocator);
1083 require_noerr(rval, finish);
1084 }
1085
1086 /* Create special sections */
1087
1088 #if KXLD_USER_OR_GOT
1089 rval = create_got(object);
1090 require_noerr(rval, finish);
1091 #endif /* KXLD_USER_OR_GOT */
1092
1093 #if KXLD_USER_OR_COMMON
1094 rval = resolve_common_symbols(object);
1095 require_noerr(rval, finish);
1096 #endif /* KXLD_USER_OR_COMMON */
1097
1098 /* Create the segments from the section index */
1099
1100 rval = kxld_seg_create_seg_from_sections(&object->segs, &object->sects);
1101 require_noerr(rval, finish);
1102
1103 rval = kxld_seg_finalize_object_segment(&object->segs,
1104 object->section_order, get_macho_header_size(object));
1105 require_noerr(rval, finish);
1106
1107 rval = kxld_seg_init_linkedit(&object->segs);
1108 require_noerr(rval, finish);
1109 }
1110
1111 rval = KERN_SUCCESS;
1112 finish:
1113 return rval;
1114 }
1115 #endif /* KXLD_USER_OR_OBJECT */
1116
1117 #if KXLD_USER_OR_ILP32
1118 /*******************************************************************************
1119 *******************************************************************************/
1120 static u_long
1121 get_macho_cmd_data_32(u_char *file, u_long offset, u_int *filetype, u_int *ncmds)
1122 {
1123 struct mach_header *mach_hdr = (struct mach_header *) ((void *) (file + offset));
1124
1125 if (filetype) *filetype = mach_hdr->filetype;
1126 if (ncmds) *ncmds = mach_hdr->ncmds;
1127
1128 return sizeof(*mach_hdr);
1129 }
1130
1131 #endif /* KXLD_USER_OR_ILP32 */
1132
1133 #if KXLD_USER_OR_LP64
1134 /*******************************************************************************
1135 *******************************************************************************/
1136 static u_long
1137 get_macho_cmd_data_64(u_char *file, u_long offset, u_int *filetype, u_int *ncmds)
1138 {
1139 struct mach_header_64 *mach_hdr = (struct mach_header_64 *) ((void *) (file + offset));
1140
1141 if (filetype) *filetype = mach_hdr->filetype;
1142 if (ncmds) *ncmds = mach_hdr->ncmds;
1143
1144 return sizeof(*mach_hdr);
1145 }
1146 #endif /* KXLD_USER_OR_LP64 */
1147
1148 /*******************************************************************************
1149 *******************************************************************************/
1150 static u_long
1151 get_macho_header_size(const KXLDObject *object)
1152 {
1153 KXLDSeg *seg = NULL;
1154 u_long header_size = 0;
1155 u_int i = 0;
1156 boolean_t object_is_32_bit = kxld_object_is_32_bit(object);
1157
1158 check(object);
1159
1160 /* Mach, segment, symtab, and UUID headers */
1161
1162 header_size += object_is_32_bit ? sizeof(struct mach_header) : sizeof(struct mach_header_64);
1163
1164 for (i = 0; i < object->segs.nitems; ++i) {
1165 seg = kxld_array_get_item(&object->segs, i);
1166 header_size += kxld_seg_get_macho_header_size(seg, object_is_32_bit);
1167 }
1168
1169 header_size += kxld_symtab_get_macho_header_size();
1170
1171 #if KXLD_PIC_KEXTS
1172 if (target_supports_slideable_kexts(object)) {
1173 header_size += kxld_reloc_get_macho_header_size();
1174 }
1175 #endif /* KXLD_PIC_KEXTS */
1176
1177 if (object->uuid.has_uuid) {
1178 header_size += kxld_uuid_get_macho_header_size();
1179 }
1180
1181 if (object->versionmin.has_versionmin) {
1182 header_size += kxld_versionmin_get_macho_header_size();
1183 }
1184
1185 if (object->srcversion.has_srcversion) {
1186 header_size += kxld_srcversion_get_macho_header_size();
1187 }
1188
1189 if (isSplitKext && object->splitinfolc.has_splitinfolc) {
1190 header_size += kxld_splitinfolc_get_macho_header_size();
1191 }
1192
1193 return header_size;
1194 }
1195
1196 /*******************************************************************************
1197 *******************************************************************************/
1198 static u_long
1199 get_macho_data_size(const KXLDObject *object)
1200 {
1201 KXLDSeg *seg = NULL;
1202 u_long data_size = 0;
1203 u_int i = 0;
1204
1205 check(object);
1206
1207 /* total all segment vmsize values */
1208 for (i = 0; i < object->segs.nitems; ++i) {
1209 seg = kxld_array_get_item(&object->segs, i);
1210 data_size += (u_long) kxld_seg_get_vmsize(seg);
1211 }
1212
1213 #if KXLD_PIC_KEXTS
1214 {
1215 /* ensure that when we eventually emit the final linked object,
1216 * appending the __DYSYMTAB data after the __LINKEDIT data will
1217 * not overflow the space allocated for the __LINKEDIT segment
1218 */
1219
1220 u_long seg_vmsize = 0;
1221 u_long symtab_size = 0;
1222 u_long reloc_size = 0;
1223
1224 /* get current __LINKEDIT sizes */
1225 seg = kxld_object_get_seg_by_name(object, SEG_LINKEDIT);
1226
1227 seg_vmsize = (u_long) kxld_seg_get_vmsize(seg);
1228
1229 /* get size of symbol table data that will eventually be dumped
1230 * into the __LINKEDIT segment
1231 */
1232 symtab_size = kxld_symtab_get_macho_data_size(object->symtab, kxld_object_is_32_bit(object));
1233
1234 if (target_supports_slideable_kexts(object)) {
1235 /* get size of __DYSYMTAB relocation entries */
1236 reloc_size = kxld_reloc_get_macho_data_size(&object->locrelocs, &object->extrelocs);
1237 }
1238
1239 /* combine, and ensure they'll both fit within the page(s)
1240 * allocated for the __LINKEDIT segment. If they'd overflow,
1241 * increase the vmsize appropriately so no overflow will occur
1242 */
1243 if ((symtab_size + reloc_size) > seg_vmsize) {
1244 u_long overflow = (symtab_size + reloc_size) - seg_vmsize;
1245 data_size += kxld_round_page_cross_safe(overflow);
1246 }
1247 }
1248 #endif // KXLD_PIC_KEXTS
1249
1250 return data_size;
1251 }
1252
1253 /*******************************************************************************
1254 *******************************************************************************/
1255 boolean_t
1256 kxld_object_target_needs_swap(const KXLDObject *object __unused)
1257 {
1258 #if KERNEL
1259 return FALSE;
1260 #else
1261 return (object->target_order != object->host_order);
1262 #endif /* KERNEL */
1263 }
1264
1265 /*******************************************************************************
1266 *******************************************************************************/
1267 KXLDSeg *
1268 kxld_object_get_seg_by_name(const KXLDObject *object, const char *segname)
1269 {
1270 KXLDSeg *seg = NULL;
1271 u_int i = 0;
1272
1273 for (i = 0; i < object->segs.nitems; ++i) {
1274 seg = kxld_array_get_item(&object->segs, i);
1275
1276 if (streq_safe(segname, seg->segname, sizeof(seg->segname))) break;
1277
1278 seg = NULL;
1279 }
1280
1281 return seg;
1282 }
1283
1284 /*******************************************************************************
1285 *******************************************************************************/
1286 const KXLDRelocator *
1287 kxld_object_get_relocator(const KXLDObject * object)
1288 {
1289 check(object);
1290
1291 return &object->relocator;
1292 }
1293
1294 /*******************************************************************************
1295 *******************************************************************************/
1296 KXLDSect *
1297 kxld_object_get_sect_by_name(const KXLDObject *object, const char *segname,
1298 const char *sectname)
1299 {
1300 KXLDSect *sect = NULL;
1301 u_int i = 0;
1302
1303 for (i = 0; i < object->sects.nitems; ++i) {
1304 sect = kxld_array_get_item(&object->sects, i);
1305
1306 if (streq_safe(segname, sect->segname, sizeof(sect->segname)) &&
1307 streq_safe(sectname, sect->sectname, sizeof(sect->sectname)))
1308 {
1309 break;
1310 }
1311
1312 sect = NULL;
1313 }
1314
1315 return sect;
1316 }
1317
1318 /*******************************************************************************
1319 *******************************************************************************/
1320 const KXLDReloc *
1321 kxld_object_get_reloc_at_symbol(const KXLDObject *object, const KXLDSym *sym)
1322 {
1323 const KXLDReloc *reloc = NULL;
1324 const KXLDSect *sect = NULL;
1325 uint32_t offset = 0;
1326
1327 check(object);
1328 check(sym);
1329
1330 sect = kxld_object_get_section_by_index(object, sym->sectnum);
1331 require(sect, finish);
1332
1333 if (kxld_object_is_final_image(object)) {
1334 reloc = kxld_reloc_get_reloc_by_offset(&object->extrelocs,
1335 sym->base_addr);
1336 if (!reloc) {
1337 reloc = kxld_reloc_get_reloc_by_offset(&object->locrelocs,
1338 sym->base_addr);
1339 }
1340 } else {
1341 offset = kxld_sym_get_section_offset(sym, sect);
1342 reloc = kxld_reloc_get_reloc_by_offset(&sect->relocs, offset);
1343 }
1344
1345 finish:
1346 return reloc;
1347 }
1348
1349 /*******************************************************************************
1350 *******************************************************************************/
1351 const KXLDSym *
1352 kxld_object_get_symbol_of_reloc(const KXLDObject *object,
1353 const KXLDReloc *reloc, const KXLDSect *sect)
1354 {
1355 const KXLDSym *sym = NULL;
1356 u_char *my_file;
1357
1358 if (isOldInterface) {
1359 my_file = object->file;
1360 }
1361 else {
1362 my_file = object->split_info.kextExecutable;
1363 }
1364
1365 if (kxld_object_is_final_image(object)) {
1366 sym = kxld_reloc_get_symbol(&object->relocator, reloc, my_file);
1367 } else {
1368 sym = kxld_reloc_get_symbol(&object->relocator, reloc, sect->data);
1369 }
1370 return sym;
1371 }
1372
1373 /*******************************************************************************
1374 *******************************************************************************/
1375 const KXLDSect *
1376 kxld_object_get_section_by_index(const KXLDObject *object, u_int sectnum)
1377 {
1378 KXLDSect *sect = NULL;
1379
1380 check(object);
1381
1382 if (sectnum < object->sects.nitems) {
1383 sect = kxld_array_get_item(&object->sects, sectnum);
1384 }
1385
1386 return sect;
1387 }
1388
1389 /*******************************************************************************
1390 *******************************************************************************/
1391 const KXLDArray *
1392 kxld_object_get_extrelocs(const KXLDObject *object)
1393 {
1394 const KXLDArray *rval = NULL;
1395
1396 check(object);
1397
1398 if (kxld_object_is_final_image(object)) {
1399 rval = &object->extrelocs;
1400 }
1401
1402 return rval;
1403 }
1404
1405 /*******************************************************************************
1406 *******************************************************************************/
1407 const KXLDSymtab *
1408 kxld_object_get_symtab(const KXLDObject *object)
1409 {
1410 check(object);
1411
1412 return object->symtab;
1413 }
1414
1415 #if KXLD_USER_OR_GOT || KXLD_USER_OR_COMMON
1416 /*******************************************************************************
1417 *******************************************************************************/
1418 static kern_return_t
1419 add_section(KXLDObject *object, KXLDSect **sect)
1420 {
1421 kern_return_t rval = KERN_FAILURE;
1422 u_int nsects = object->sects.nitems;
1423
1424 rval = kxld_array_resize(&object->sects, nsects + 1);
1425 require_noerr(rval, finish);
1426
1427 *sect = kxld_array_get_item(&object->sects, nsects);
1428
1429 rval = KERN_SUCCESS;
1430
1431 finish:
1432 return rval;
1433 }
1434 #endif /* KXLD_USER_OR_GOT || KXLD_USER_OR_COMMON */
1435
1436 #if KXLD_USER_OR_COMMON
1437 /*******************************************************************************
1438 * If there are common symbols, calculate how much space they'll need
1439 * and create/grow the __DATA __common section to accommodate them.
1440 * Then, resolve them against that section.
1441 *******************************************************************************/
1442 static kern_return_t
1443 resolve_common_symbols(KXLDObject *object)
1444 {
1445 kern_return_t rval = KERN_FAILURE;
1446 KXLDSymtabIterator iter;
1447 KXLDSym *sym = NULL;
1448 KXLDSect *sect = NULL;
1449 kxld_addr_t base_addr = 0;
1450 kxld_size_t size = 0;
1451 kxld_size_t total_size = 0;
1452 u_int align = 0;
1453 u_int max_align = 0;
1454 u_int sectnum = 0;
1455
1456 if (!kxld_object_target_supports_common_symbols(object)) {
1457 rval = KERN_SUCCESS;
1458 goto finish;
1459 }
1460
1461 /* Iterate over the common symbols to calculate their total aligned size */
1462 kxld_symtab_iterator_init(&iter, object->symtab, kxld_sym_is_common, FALSE);
1463 while ((sym = kxld_symtab_iterator_get_next(&iter))) {
1464 align = kxld_sym_get_common_align(sym);
1465 size = kxld_sym_get_common_size(sym);
1466
1467 if (align > max_align) max_align = align;
1468
1469 total_size = kxld_align_address(total_size, align) + size;
1470 }
1471
1472 /* If there are common symbols, grow or create the __DATA __common section
1473 * to hold them.
1474 */
1475 if (total_size) {
1476 sect = kxld_object_get_sect_by_name(object, SEG_DATA, SECT_COMMON);
1477 if (sect) {
1478 base_addr = sect->base_addr + sect->size;
1479
1480 kxld_sect_grow(sect, total_size, max_align);
1481 } else {
1482 base_addr = 0;
1483
1484 rval = add_section(object, &sect);
1485 require_noerr(rval, finish);
1486
1487 kxld_sect_init_zerofill(sect, SEG_DATA, SECT_COMMON,
1488 total_size, max_align);
1489 }
1490
1491 /* Resolve the common symbols against the new section */
1492 rval = kxld_array_get_index(&object->sects, sect, &sectnum);
1493 require_noerr(rval, finish);
1494
1495 kxld_symtab_iterator_reset(&iter);
1496 while ((sym = kxld_symtab_iterator_get_next(&iter))) {
1497 align = kxld_sym_get_common_align(sym);
1498 size = kxld_sym_get_common_size(sym);
1499
1500 base_addr = kxld_align_address(base_addr, align);
1501 kxld_sym_resolve_common(sym, sectnum, base_addr);
1502
1503 base_addr += size;
1504 }
1505 }
1506
1507 rval = KERN_SUCCESS;
1508
1509 finish:
1510 return rval;
1511 }
1512 #endif /* KXLD_USER_OR_COMMON */
1513
1514 #if KXLD_USER_OR_GOT
1515 /*******************************************************************************
1516 *******************************************************************************/
1517 static boolean_t
1518 target_has_got(const KXLDObject *object)
1519 {
1520 return FALSE:
1521 }
1522
1523 /*******************************************************************************
1524 * Create and initialize the Global Offset Table
1525 *******************************************************************************/
1526 static kern_return_t
1527 create_got(KXLDObject *object)
1528 {
1529 kern_return_t rval = KERN_FAILURE;
1530 KXLDSect *sect = NULL;
1531 u_int ngots = 0;
1532 u_int i = 0;
1533
1534 if (!target_has_got(object)) {
1535 rval = KERN_SUCCESS;
1536 goto finish;
1537 }
1538
1539 for (i = 0; i < object->sects.nitems; ++i) {
1540 sect = kxld_array_get_item(&object->sects, i);
1541 ngots += kxld_sect_get_ngots(sect, &object->relocator,
1542 object->symtab);
1543 }
1544
1545 rval = add_section(object, &sect);
1546 require_noerr(rval, finish);
1547
1548 rval = kxld_sect_init_got(sect, ngots);
1549 require_noerr(rval, finish);
1550
1551 object->got_is_created = TRUE;
1552 rval = KERN_SUCCESS;
1553
1554 finish:
1555 return rval;
1556 }
1557
1558 /*******************************************************************************
1559 *******************************************************************************/
1560 static kern_return_t
1561 populate_got(KXLDObject *object)
1562 {
1563 kern_return_t rval = KERN_FAILURE;
1564 KXLDSect *sect = NULL;
1565 u_int i = 0;
1566
1567 if (!target_has_got(object) || !object->got_is_created) {
1568 rval = KERN_SUCCESS;
1569 goto finish;
1570 }
1571
1572 for (i = 0; i < object->sects.nitems; ++i) {
1573 sect = kxld_array_get_item(&object->sects, i);
1574 if (streq_safe(sect->segname, KXLD_SEG_GOT, sizeof(KXLD_SEG_GOT)) &&
1575 streq_safe(sect->sectname, KXLD_SECT_GOT, sizeof(KXLD_SECT_GOT)))
1576 {
1577 kxld_sect_populate_got(sect, object->symtab,
1578 kxld_object_target_needs_swap(object));
1579 break;
1580 }
1581 }
1582
1583 require_action(i < object->sects.nitems, finish, rval=KXLD_MISSING_GOT);
1584
1585 rval = KERN_SUCCESS;
1586
1587 finish:
1588 return rval;
1589 }
1590 #endif /* KXLD_USER_OR_GOT */
1591
1592 /*******************************************************************************
1593 *******************************************************************************/
1594 static boolean_t
1595 target_supports_protected_segments(const KXLDObject *object)
1596 {
1597 return (object->is_final_image &&
1598 (object->cputype == CPU_TYPE_X86_64 ||
1599 object->cputype == CPU_TYPE_ARM ||
1600 object->cputype == CPU_TYPE_ARM64));
1601 }
1602
1603 /*******************************************************************************
1604 *******************************************************************************/
1605 static void
1606 set_is_object_linked(KXLDObject *object)
1607 {
1608 u_int i = 0;
1609
1610 if (kxld_object_is_kernel(object)) {
1611 object->is_linked = TRUE;
1612 return;
1613 }
1614
1615 if (object->is_final_image) {
1616 object->is_linked = !object->extrelocs.nitems;
1617 return;
1618 }
1619
1620 object->is_linked = TRUE;
1621 for (i = 0; i < object->sects.nitems; ++i) {
1622 KXLDSect *sect = kxld_array_get_item(&object->sects, i);
1623 if (sect->relocs.nitems) {
1624 object->is_linked = FALSE;
1625 break;
1626 }
1627 }
1628 }
1629
1630
1631 /*******************************************************************************
1632 *******************************************************************************/
1633 void kxld_object_clear(KXLDObject *object)
1634 {
1635 KXLDSeg *seg = NULL;
1636 KXLDSect *sect = NULL;
1637 u_int i;
1638 u_char *my_file;
1639
1640 check(object);
1641
1642 if (isOldInterface) {
1643 my_file = object->file;
1644 }
1645 else {
1646 my_file = object->split_info.kextExecutable;
1647 }
1648
1649 #if !KERNEL
1650 if (kxld_object_is_kernel(object)) {
1651 unswap_macho(my_file, object->host_order, object->target_order);
1652 }
1653 #endif /* !KERNEL */
1654
1655 for (i = 0; i < object->segs.nitems; ++i) {
1656 seg = kxld_array_get_item(&object->segs, i);
1657 kxld_seg_clear(seg);
1658 }
1659 kxld_array_reset(&object->segs);
1660
1661 for (i = 0; i < object->sects.nitems; ++i) {
1662 sect = kxld_array_get_item(&object->sects, i);
1663 kxld_sect_clear(sect);
1664 }
1665 kxld_array_reset(&object->sects);
1666
1667 kxld_array_reset(&object->extrelocs);
1668 kxld_array_reset(&object->locrelocs);
1669 kxld_relocator_clear(&object->relocator);
1670 kxld_uuid_clear(&object->uuid);
1671 kxld_versionmin_clear(&object->versionmin);
1672 kxld_srcversion_clear(&object->srcversion);
1673
1674 if (object->symtab) kxld_symtab_clear(object->symtab);
1675
1676 if (isOldInterface) {
1677 object->file = NULL;
1678 object->size = 0;
1679 }
1680 else {
1681 kxld_splitinfolc_clear(&object->splitinfolc);
1682 object->split_info.kextExecutable = NULL;
1683 object->split_info.kextSize = 0;
1684 }
1685 object->filetype = 0;
1686 object->cputype = 0;
1687 object->cpusubtype = 0;
1688 object->is_kernel = FALSE;
1689 object->is_final_image = FALSE;
1690 object->is_linked = FALSE;
1691 object->got_is_created = FALSE;
1692
1693 #if KXLD_USER_OR_OBJECT
1694 object->section_order = NULL;
1695 #endif
1696 #if !KERNEL
1697 object->host_order = 0;
1698 object->target_order = 0;
1699 #endif
1700 }
1701
1702 /*******************************************************************************
1703 *******************************************************************************/
1704 void kxld_object_deinit(KXLDObject *object __unused)
1705 {
1706 KXLDSeg *seg = NULL;
1707 KXLDSect *sect = NULL;
1708 u_int i;
1709 u_char *my_file;
1710
1711 check(object);
1712
1713 if (isOldInterface) {
1714 my_file = object->file;
1715 }
1716 else {
1717 my_file = object->split_info.kextExecutable;
1718 }
1719
1720 #if !KERNEL
1721 if (my_file && kxld_object_is_kernel(object)) {
1722 unswap_macho(my_file, object->host_order, object->target_order);
1723 }
1724 #endif /* !KERNEL */
1725
1726 for (i = 0; i < object->segs.maxitems; ++i) {
1727 seg = kxld_array_get_slot(&object->segs, i);
1728 kxld_seg_deinit(seg);
1729 }
1730 kxld_array_deinit(&object->segs);
1731
1732 for (i = 0; i < object->sects.maxitems; ++i) {
1733 sect = kxld_array_get_slot(&object->sects, i);
1734 kxld_sect_deinit(sect);
1735 }
1736 kxld_array_deinit(&object->sects);
1737
1738 kxld_array_deinit(&object->extrelocs);
1739 kxld_array_deinit(&object->locrelocs);
1740
1741 if (object->symtab) {
1742 kxld_symtab_deinit(object->symtab);
1743 kxld_free(object->symtab, kxld_symtab_sizeof());
1744 }
1745
1746 bzero(object, sizeof(*object));
1747 }
1748
1749 /*******************************************************************************
1750 *******************************************************************************/
1751 const u_char *
1752 kxld_object_get_file(const KXLDObject *object)
1753 {
1754 const u_char *my_file;
1755
1756 check(object);
1757
1758 if (isOldInterface) {
1759 my_file = object->file;
1760 }
1761 else {
1762 my_file = object->split_info.kextExecutable;
1763 }
1764
1765 return my_file;
1766 }
1767
1768 /*******************************************************************************
1769 *******************************************************************************/
1770 const char *
1771 kxld_object_get_name(const KXLDObject *object)
1772 {
1773 check(object);
1774
1775 return object->name;
1776 }
1777
1778 /*******************************************************************************
1779 *******************************************************************************/
1780 boolean_t
1781 kxld_object_is_32_bit(const KXLDObject *object)
1782 {
1783 check(object);
1784
1785 return kxld_is_32_bit(object->cputype);
1786 }
1787
1788 /*******************************************************************************
1789 *******************************************************************************/
1790 boolean_t
1791 kxld_object_is_final_image(const KXLDObject *object)
1792 {
1793 check(object);
1794
1795 return object->is_final_image;
1796 }
1797
1798 /*******************************************************************************
1799 *******************************************************************************/
1800 boolean_t
1801 kxld_object_is_kernel(const KXLDObject *object)
1802 {
1803 check(object);
1804
1805 return object->is_kernel;
1806 }
1807
1808 /*******************************************************************************
1809 *******************************************************************************/
1810 boolean_t
1811 kxld_object_is_linked(const KXLDObject *object)
1812 {
1813 check(object);
1814
1815 return object->is_linked;
1816 }
1817
1818 /*******************************************************************************
1819 *******************************************************************************/
1820 boolean_t
1821 kxld_object_target_supports_strict_patching(const KXLDObject *object)
1822 {
1823 check(object);
1824
1825 return (object->cputype != CPU_TYPE_I386);
1826 }
1827
1828 /*******************************************************************************
1829 *******************************************************************************/
1830 boolean_t
1831 kxld_object_target_supports_common_symbols(const KXLDObject *object)
1832 {
1833 check(object);
1834
1835 return (object->cputype == CPU_TYPE_I386);
1836 }
1837
1838
1839 /*******************************************************************************
1840 *******************************************************************************/
1841 void
1842 kxld_object_get_vmsize_for_seg_by_name(const KXLDObject *object,
1843 const char *segname,
1844 u_long *vmsize)
1845 {
1846 check(object);
1847 check(segname);
1848 check(vmsize);
1849
1850 KXLDSeg *seg = NULL;
1851 u_long my_size = 0;
1852
1853 /* segment vmsize */
1854 seg = kxld_object_get_seg_by_name(object, segname);
1855
1856 my_size = (u_long) kxld_seg_get_vmsize(seg);
1857
1858 #if KXLD_PIC_KEXTS
1859 if (kxld_seg_is_linkedit_seg(seg))
1860 {
1861 u_long reloc_size = 0;
1862
1863 if (target_supports_slideable_kexts(object)) {
1864 /* get size of __DYSYMTAB relocation entries */
1865 reloc_size = kxld_reloc_get_macho_data_size(&object->locrelocs, &object->extrelocs);
1866 my_size += reloc_size;
1867 }
1868 }
1869 #endif
1870
1871 *vmsize = my_size;
1872 }
1873
1874 /*******************************************************************************
1875 *******************************************************************************/
1876 void
1877 kxld_object_get_vmsize(const KXLDObject *object, u_long *header_size,
1878 u_long *vmsize)
1879 {
1880 check(object);
1881 check(header_size);
1882 check(vmsize);
1883 *header_size = 0;
1884 *vmsize = 0;
1885
1886 /* vmsize is the padded header page(s) + segment vmsizes */
1887
1888 *header_size = (object->is_final_image) ?
1889 0 : (u_long)kxld_round_page_cross_safe(get_macho_header_size(object));
1890
1891 *vmsize = *header_size + get_macho_data_size(object);
1892
1893 }
1894
1895 /*******************************************************************************
1896 *******************************************************************************/
1897 void
1898 kxld_object_set_linked_object_size(KXLDObject *object, u_long vmsize)
1899 {
1900 check(object);
1901
1902 if (isOldInterface) {
1903 object->output_buffer_size = vmsize; /* cache this for use later */
1904 }
1905 else {
1906 object->split_info.linkedKextSize = vmsize;
1907 }
1908 return;
1909 }
1910
1911 /*******************************************************************************
1912 *******************************************************************************/
1913 kern_return_t
1914 kxld_object_export_linked_object(const KXLDObject *object,
1915 void *linked_object
1916 )
1917 {
1918 kern_return_t rval = KERN_FAILURE;
1919 KXLDSeg *seg = NULL;
1920 u_long size = 0;
1921 u_long header_size = 0;
1922 u_long header_offset = 0;
1923 u_long data_offset = 0;
1924 u_int ncmds = 0;
1925 u_int i = 0;
1926 boolean_t is_32bit_object = kxld_object_is_32_bit(object);
1927 kxld_addr_t link_addr;
1928 u_char *my_linked_object;
1929
1930 check(object);
1931 check(linked_object);
1932
1933 if (isOldInterface) {
1934 size = object->output_buffer_size;
1935 link_addr = object->link_addr;
1936 my_linked_object = (u_char *) linked_object;
1937 }
1938 else {
1939 size = ((splitKextLinkInfo *)linked_object)->linkedKextSize;
1940 link_addr = ((splitKextLinkInfo *)linked_object)->vmaddr_TEXT;
1941 my_linked_object = ((splitKextLinkInfo *)linked_object)->linkedKext;
1942 }
1943
1944 /* Calculate the size of the headers and data */
1945
1946 header_size = get_macho_header_size(object);
1947
1948 /* Copy data to the file */
1949
1950 ncmds = object->segs.nitems + 1 /* LC_SYMTAB */;
1951
1952 #if KXLD_PIC_KEXTS
1953 /* don't write out a DYSYMTAB segment for targets that can't digest it
1954 */
1955 if (target_supports_slideable_kexts(object)) {
1956 ncmds++; /* dysymtab */
1957 }
1958 #endif /* KXLD_PIC_KEXTS */
1959
1960 if (object->uuid.has_uuid == TRUE) {
1961 ncmds++;
1962 }
1963
1964 if (object->versionmin.has_versionmin == TRUE) {
1965 ncmds++;
1966 }
1967
1968 if (object->srcversion.has_srcversion == TRUE) {
1969 ncmds++;
1970 }
1971
1972 if (isSplitKext && object->splitinfolc.has_splitinfolc) {
1973 ncmds++;
1974 }
1975
1976 rval = export_macho_header(object, my_linked_object, ncmds, &header_offset, header_size);
1977 require_noerr(rval, finish);
1978
1979 for (i = 0; i < object->segs.nitems; ++i) {
1980 seg = kxld_array_get_item(&object->segs, i);
1981
1982 rval = kxld_seg_export_macho_to_vm(seg, my_linked_object, &header_offset,
1983 header_size, size, link_addr, is_32bit_object);
1984 require_noerr(rval, finish);
1985 }
1986
1987 seg = kxld_object_get_seg_by_name(object, SEG_LINKEDIT);
1988 data_offset = (u_long) (seg->link_addr - link_addr);
1989
1990 // data_offset is used to set the fileoff in the macho header load commands
1991 rval = kxld_symtab_export_macho(object->symtab,
1992 my_linked_object,
1993 &header_offset,
1994 header_size,
1995 &data_offset, size, is_32bit_object);
1996 require_noerr(rval, finish);
1997
1998 // data_offset now points past the symbol tab and strings data in the linkedit
1999 // segment - (it was used to set new values for symoff and stroff)
2000
2001 #if KXLD_PIC_KEXTS
2002 if (target_supports_slideable_kexts(object)) {
2003 rval = kxld_reloc_export_macho(&object->relocator,
2004 &object->locrelocs,
2005 &object->extrelocs,
2006 my_linked_object,
2007 &header_offset,
2008 header_size,
2009 &data_offset, size);
2010 require_noerr(rval, finish);
2011 }
2012 #endif /* KXLD_PIC_KEXTS */
2013
2014 if (object->uuid.has_uuid) {
2015 rval = kxld_uuid_export_macho(&object->uuid, my_linked_object, &header_offset, header_size);
2016 require_noerr(rval, finish);
2017 }
2018
2019 if (object->versionmin.has_versionmin) {
2020 rval = kxld_versionmin_export_macho(&object->versionmin, my_linked_object, &header_offset, header_size);
2021 require_noerr(rval, finish);
2022 }
2023
2024 if (object->srcversion.has_srcversion) {
2025 rval = kxld_srcversion_export_macho(&object->srcversion, my_linked_object, &header_offset, header_size);
2026 require_noerr(rval, finish);
2027 }
2028
2029 if (isSplitKext && object->splitinfolc.has_splitinfolc) {
2030 rval = kxld_splitinfolc_export_macho(&object->splitinfolc,
2031 linked_object,
2032 &header_offset,
2033 header_size,
2034 &data_offset,
2035 size);
2036 require_noerr(rval, finish);
2037 }
2038
2039 #if !KERNEL
2040 unswap_macho(my_linked_object, object->host_order, object->target_order);
2041 #endif /* KERNEL */
2042
2043 rval = KERN_SUCCESS;
2044
2045 finish:
2046 return rval;
2047 }
2048
2049 /*******************************************************************************
2050 *******************************************************************************/
2051 static kern_return_t
2052 export_macho_header(const KXLDObject *object, u_char *buf, u_int ncmds,
2053 u_long *header_offset, u_long header_size)
2054 {
2055 kern_return_t rval = KERN_FAILURE;
2056
2057 check(object);
2058 check(buf);
2059 check(header_offset);
2060
2061 KXLD_3264_FUNC(kxld_object_is_32_bit(object), rval,
2062 export_macho_header_32, export_macho_header_64,
2063 object, buf, ncmds, header_offset, header_size);
2064 require_noerr(rval, finish);
2065
2066 rval = KERN_SUCCESS;
2067
2068 finish:
2069 return rval;
2070 }
2071
2072 #if KXLD_USER_OR_ILP32
2073 /*******************************************************************************
2074 *******************************************************************************/
2075 static kern_return_t
2076 export_macho_header_32(const KXLDObject *object, u_char *buf, u_int ncmds,
2077 u_long *header_offset, u_long header_size)
2078 {
2079 kern_return_t rval = KERN_FAILURE;
2080 struct mach_header *mach = NULL;
2081
2082 check(object);
2083 check(buf);
2084 check(header_offset);
2085
2086 require_action(sizeof(*mach) <= header_size - *header_offset, finish,
2087 rval=KERN_FAILURE);
2088 mach = (struct mach_header *) ((void *) (buf + *header_offset));
2089
2090 mach->magic = MH_MAGIC;
2091 mach->cputype = object->cputype;
2092 mach->cpusubtype = object->cpusubtype;
2093 mach->filetype = object->filetype;
2094 mach->ncmds = ncmds;
2095 mach->sizeofcmds = (uint32_t) (header_size - sizeof(*mach));
2096 mach->flags = MH_NOUNDEFS;
2097
2098 *header_offset += sizeof(*mach);
2099
2100 rval = KERN_SUCCESS;
2101
2102 finish:
2103 return rval;
2104 }
2105 #endif /* KXLD_USER_OR_ILP32 */
2106
2107 #if KXLD_USER_OR_LP64
2108 /*******************************************************************************
2109 *******************************************************************************/
2110 static kern_return_t
2111 export_macho_header_64(const KXLDObject *object, u_char *buf, u_int ncmds,
2112 u_long *header_offset, u_long header_size)
2113 {
2114 kern_return_t rval = KERN_FAILURE;
2115 struct mach_header_64 *mach = NULL;
2116
2117 check(object);
2118 check(buf);
2119 check(header_offset);
2120
2121 require_action(sizeof(*mach) <= header_size - *header_offset, finish,
2122 rval=KERN_FAILURE);
2123 mach = (struct mach_header_64 *) ((void *) (buf + *header_offset));
2124
2125 mach->magic = MH_MAGIC_64;
2126 mach->cputype = object->cputype;
2127 mach->cpusubtype = object->cpusubtype;
2128 mach->filetype = object->filetype;
2129 mach->ncmds = ncmds;
2130 mach->sizeofcmds = (uint32_t) (header_size - sizeof(*mach));
2131 mach->flags = MH_NOUNDEFS;
2132
2133 *header_offset += sizeof(*mach);
2134
2135 #if SPLIT_KEXTS_DEBUG
2136 {
2137 kxld_log(kKxldLogLinking, kKxldLogErr,
2138 " %p >>> Start of macho header (size %lu) <%s>",
2139 (void *) mach,
2140 sizeof(*mach),
2141 __func__);
2142 kxld_log(kKxldLogLinking, kKxldLogErr,
2143 " %p <<< End of macho header <%s>",
2144 (void *) ((u_char *)mach + sizeof(*mach)),
2145 __func__);
2146 }
2147 #endif
2148
2149 rval = KERN_SUCCESS;
2150
2151 finish:
2152 return rval;
2153 }
2154 #endif /* KXLD_USER_OR_LP64 */
2155
2156 /*******************************************************************************
2157 *******************************************************************************/
2158 kern_return_t
2159 kxld_object_index_symbols_by_name(KXLDObject *object)
2160 {
2161 return kxld_symtab_index_symbols_by_name(object->symtab);
2162 }
2163
2164 /*******************************************************************************
2165 *******************************************************************************/
2166 kern_return_t
2167 kxld_object_index_cxx_symbols_by_value(KXLDObject *object)
2168 {
2169 return kxld_symtab_index_cxx_symbols_by_value(object->symtab);
2170 }
2171
2172 /*******************************************************************************
2173 *******************************************************************************/
2174 kern_return_t
2175 kxld_object_relocate(KXLDObject *object, kxld_addr_t link_address)
2176 {
2177 kern_return_t rval = KERN_FAILURE;
2178 KXLDSeg *seg = NULL;
2179 u_int i = 0;
2180
2181 check(object);
2182
2183 object->link_addr = link_address;
2184
2185 /* Relocate segments (which relocates the sections) */
2186 for (i = 0; i < object->segs.nitems; ++i) {
2187 seg = kxld_array_get_item(&object->segs, i);
2188 kxld_seg_relocate(seg, link_address);
2189 } // for...
2190
2191 /* Relocate symbols */
2192 rval = kxld_symtab_relocate(object->symtab, &object->sects);
2193 require_noerr(rval, finish);
2194
2195 rval = KERN_SUCCESS;
2196 finish:
2197 return rval;
2198 }
2199
2200 /*******************************************************************************
2201 *******************************************************************************/
2202 static KXLDSym *
2203 get_mutable_sym(const KXLDObject *object, const KXLDSym *sym)
2204 {
2205 KXLDSym *rval = NULL;
2206 kern_return_t result = KERN_FAILURE;
2207 u_int i = 0;
2208
2209 result = kxld_symtab_get_sym_index(object->symtab, sym, &i);
2210 require_noerr(result, finish);
2211
2212 rval = kxld_symtab_get_symbol_by_index(object->symtab, i);
2213 require_action(rval == sym, finish, rval=NULL);
2214
2215 finish:
2216 return rval;
2217 }
2218
2219 /*******************************************************************************
2220 *******************************************************************************/
2221 kern_return_t
2222 kxld_object_resolve_symbol(KXLDObject *object,
2223 const KXLDSym *sym, kxld_addr_t addr)
2224 {
2225 kern_return_t rval = KERN_FAILURE;
2226 KXLDSym *resolved_sym = NULL;
2227
2228 resolved_sym = get_mutable_sym(object, sym);
2229 require_action(resolved_sym, finish, rval=KERN_FAILURE);
2230
2231 rval = kxld_sym_resolve(resolved_sym, addr);
2232 require_noerr(rval, finish);
2233
2234 rval = KERN_SUCCESS;
2235 finish:
2236 return rval;
2237 }
2238
2239 /*******************************************************************************
2240 *******************************************************************************/
2241 kern_return_t
2242 kxld_object_patch_symbol(KXLDObject *object, const struct kxld_sym *sym)
2243 {
2244 kern_return_t rval = KERN_FAILURE;
2245 KXLDSym *patched_sym = NULL;
2246
2247 patched_sym = get_mutable_sym(object, sym);
2248 require_action(patched_sym, finish, rval=KERN_FAILURE);
2249
2250 (void) kxld_sym_patch(patched_sym);
2251 rval = KERN_SUCCESS;
2252 finish:
2253 return rval;
2254 }
2255
2256 /*******************************************************************************
2257 *******************************************************************************/
2258 kern_return_t
2259 kxld_object_add_symbol(KXLDObject *object, char *name, kxld_addr_t link_addr,
2260 const KXLDSym **sym_out)
2261 {
2262 kern_return_t rval = KERN_FAILURE;
2263 KXLDSym *sym = NULL;
2264
2265 rval = kxld_symtab_add_symbol(object->symtab, name, link_addr, &sym);
2266 require_noerr(rval, finish);
2267
2268 *sym_out = sym;
2269 rval = KERN_SUCCESS;
2270 finish:
2271 return rval;
2272 }
2273
2274 /*******************************************************************************
2275 *******************************************************************************/
2276 kern_return_t
2277 kxld_object_process_relocations(KXLDObject *object,
2278 const KXLDDict *patched_vtables)
2279 {
2280 kern_return_t rval = KERN_FAILURE;
2281
2282 (void) kxld_relocator_set_vtables(&object->relocator, patched_vtables);
2283
2284 /* Process relocation entries and populate the global offset table.
2285 *
2286 * For final linked images: the relocation entries are contained in a couple
2287 * of tables hanging off the end of the symbol table. The GOT has its own
2288 * section created by the linker; we simply need to fill it.
2289 *
2290 * For object files: the relocation entries are bound to each section.
2291 * The GOT, if it exists for the target architecture, is created by kxld,
2292 * and we must populate it according to our internal structures.
2293 */
2294 if (object->is_final_image) {
2295 #if KXLD_USER_OR_BUNDLE
2296 rval = process_symbol_pointers(object);
2297 require_noerr(rval, finish);
2298
2299 rval = process_relocs_from_tables(object);
2300 require_noerr(rval, finish);
2301 #else
2302 require_action(FALSE, finish, rval=KERN_FAILURE);
2303 #endif /* KXLD_USER_OR_BUNDLE */
2304 } else {
2305 #if KXLD_USER_OR_GOT
2306 /* Populate GOT */
2307 rval = populate_got(object);
2308 require_noerr(rval, finish);
2309 #endif /* KXLD_USER_OR_GOT */
2310 #if KXLD_USER_OR_OBJECT
2311 rval = process_relocs_from_sections(object);
2312 require_noerr(rval, finish);
2313 #else
2314 require_action(FALSE, finish, rval=KERN_FAILURE);
2315 #endif /* KXLD_USER_OR_OBJECT */
2316 }
2317
2318 /* Populate kmod info structure */
2319 rval = populate_kmod_info(object);
2320 require_noerr(rval, finish);
2321
2322 rval = KERN_SUCCESS;
2323 finish:
2324 return rval;
2325 }
2326
2327 #if KXLD_USER_OR_BUNDLE
2328
2329 #if SPLIT_KEXTS_DEBUG
2330 static boolean_t kxld_show_ptr_value;
2331 #endif
2332
2333 #define SECT_SYM_PTRS "__nl_symbol_ptr"
2334
2335 /*******************************************************************************
2336 * Final linked images create an __nl_symbol_ptr section for the global offset
2337 * table and for symbol pointer lookups in general. Rather than use relocation
2338 * entries, the linker creates an "indirect symbol table" which stores indexes
2339 * into the symbol table corresponding to the entries of this section. This
2340 * function populates the section with the relocated addresses of those symbols.
2341 *******************************************************************************/
2342 static kern_return_t
2343 process_symbol_pointers(KXLDObject *object)
2344 {
2345 kern_return_t rval = KERN_FAILURE;
2346 KXLDSect *sect = NULL;
2347 KXLDSym *sym = NULL;
2348 int32_t *symidx = NULL;
2349 u_char *symptr = NULL;
2350 u_long symptrsize = 0;
2351 u_int nsyms = 0;
2352 u_int firstsym = 0;
2353 u_int i = 0;
2354
2355 check(object);
2356
2357 require_action(object->is_final_image && object->dysymtab_hdr,
2358 finish, rval=KERN_FAILURE);
2359
2360 /* Get the __DATA,__nl_symbol_ptr section. If it doesn't exist, we have
2361 * nothing to do.
2362 */
2363
2364 sect = kxld_object_get_sect_by_name(object, SEG_DATA, SECT_SYM_PTRS);
2365 if (!sect || !(sect->flags & S_NON_LAZY_SYMBOL_POINTERS)) {
2366 rval = KERN_SUCCESS;
2367 goto finish;
2368 }
2369
2370 /* Calculate the table offset and number of entries in the section */
2371
2372 if (kxld_object_is_32_bit(object)) {
2373 symptrsize = sizeof(uint32_t);
2374 } else {
2375 symptrsize = sizeof(uint64_t);
2376 }
2377
2378 nsyms = (u_int) (sect->size / symptrsize);
2379 firstsym = sect->reserved1;
2380
2381 require_action(firstsym + nsyms <= object->dysymtab_hdr->nindirectsyms,
2382 finish, rval=KERN_FAILURE;
2383 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
2384 "firstsym + nsyms > object->dysymtab_hdr->nindirectsyms"));
2385
2386 /* Iterate through the indirect symbol table and fill in the section of
2387 * symbol pointers. There are three cases:
2388 * 1) A normal symbol - put its value directly in the table
2389 * 2) An INDIRECT_SYMBOL_LOCAL - symbols that are local and already have
2390 * their offset from the start of the file in the section. Simply
2391 * add the file's link address to fill this entry.
2392 * 3) An INDIRECT_SYMBOL_ABS - prepopulated absolute symbols. No
2393 * action is required.
2394 */
2395
2396 if (isOldInterface) {
2397 symidx = (int32_t *) ((void *) (object->file + object->dysymtab_hdr->indirectsymoff));
2398 }
2399 else {
2400 symidx = (int32_t *) ((void *) (object->split_info.kextExecutable + object->dysymtab_hdr->indirectsymoff));
2401 }
2402
2403 symidx += firstsym;
2404 symptr = sect->data;
2405 for (i = 0; i < nsyms; ++i, ++symidx, symptr+=symptrsize) {
2406 if (*symidx & INDIRECT_SYMBOL_LOCAL) {
2407 if (*symidx & INDIRECT_SYMBOL_ABS) continue;
2408
2409 if (isOldInterface) {
2410 add_to_ptr(symptr, object->link_addr, kxld_object_is_32_bit(object));
2411 }
2412 else {
2413 add_to_ptr(symptr, object->split_info.vmaddr_TEXT, kxld_object_is_32_bit(object));
2414 }
2415 } else {
2416 sym = kxld_symtab_get_symbol_by_index(object->symtab, *symidx);
2417 require_action(sym, finish, rval=KERN_FAILURE);
2418
2419 if (isOldInterface) {
2420 add_to_ptr(symptr, sym->link_addr, kxld_object_is_32_bit(object));
2421 }
2422 else {
2423 add_to_ptr(symptr, object->split_info.vmaddr_TEXT, kxld_object_is_32_bit(object));
2424 }
2425 }
2426 }
2427
2428 rval = KERN_SUCCESS;
2429 finish:
2430 return rval;
2431 }
2432
2433 /*******************************************************************************
2434 *******************************************************************************/
2435 static KXLDSeg *
2436 get_seg_by_base_addr(KXLDObject *object, kxld_addr_t base_addr)
2437 {
2438 KXLDSeg *seg = NULL;
2439 kxld_addr_t start = 0;
2440 kxld_addr_t end = 0;
2441 u_int i = 0;
2442
2443 for (i = 0; i < object->segs.nitems; ++i) {
2444 seg = kxld_array_get_item(&object->segs, i);
2445 start = seg->base_addr;
2446 end = seg->base_addr + seg->vmsize;
2447
2448 if (start <= base_addr && base_addr < end) return seg;
2449 }
2450
2451 return NULL;
2452 }
2453
2454 /*******************************************************************************
2455 *******************************************************************************/
2456 static kern_return_t
2457 process_relocs_from_tables(KXLDObject *object)
2458 {
2459 kern_return_t rval = KERN_FAILURE;
2460 KXLDReloc *reloc = NULL;
2461 KXLDSeg *seg = NULL;
2462 u_int i = 0;
2463
2464 /* Process external relocations */
2465 for (i = 0; i < object->extrelocs.nitems; ++i) {
2466 reloc = kxld_array_get_item(&object->extrelocs, i);
2467
2468 seg = get_seg_by_base_addr(object, reloc->address);
2469 require_action(seg, finish, rval=KERN_FAILURE);
2470
2471 if (isOldInterface) {
2472 rval = kxld_relocator_process_table_reloc(&object->relocator, reloc,
2473 seg, object->link_addr);
2474 }
2475 else {
2476 kxld_addr_t my_link_addr = object->split_info.vmaddr_TEXT;
2477 if (isSplitKext) {
2478 if (kxld_seg_is_text_exec_seg(seg)) {
2479 my_link_addr = object->split_info.vmaddr_TEXT_EXEC;
2480 }
2481 else if (kxld_seg_is_data_seg(seg)) {
2482 my_link_addr = object->split_info.vmaddr_DATA;
2483 }
2484 else if (kxld_seg_is_data_const_seg(seg)) {
2485 my_link_addr = object->split_info.vmaddr_DATA_CONST;
2486 }
2487 else if (kxld_seg_is_linkedit_seg(seg)) {
2488 my_link_addr = object->split_info.vmaddr_LINKEDIT;
2489 }
2490 }
2491 rval = kxld_relocator_process_table_reloc(&object->relocator,
2492 reloc,
2493 seg,
2494 my_link_addr);
2495 }
2496 require_noerr(rval, finish);
2497 }
2498
2499 /* Process local relocations */
2500 for (i = 0; i < object->locrelocs.nitems; ++i) {
2501 reloc = kxld_array_get_item(&object->locrelocs, i);
2502
2503 seg = get_seg_by_base_addr(object, reloc->address);
2504 require_action(seg, finish, rval=KERN_FAILURE);
2505
2506 if (isOldInterface) {
2507 rval = kxld_relocator_process_table_reloc(&object->relocator, reloc,
2508 seg, object->link_addr);
2509 }
2510 else {
2511 kxld_addr_t my_link_addr = object->split_info.vmaddr_TEXT;
2512 if (isSplitKext) {
2513 if (kxld_seg_is_text_exec_seg(seg)) {
2514 my_link_addr = object->split_info.vmaddr_TEXT_EXEC;
2515 }
2516 else if (kxld_seg_is_data_seg(seg)) {
2517 my_link_addr = object->split_info.vmaddr_DATA;
2518 }
2519 else if (kxld_seg_is_data_const_seg(seg)) {
2520 my_link_addr = object->split_info.vmaddr_DATA_CONST;
2521 }
2522 else if (kxld_seg_is_linkedit_seg(seg)) {
2523 my_link_addr = object->split_info.vmaddr_LINKEDIT;
2524 }
2525 }
2526 rval = kxld_relocator_process_table_reloc(&object->relocator,
2527 reloc,
2528 seg,
2529 my_link_addr);
2530 }
2531 require_noerr(rval, finish);
2532 }
2533
2534 rval = KERN_SUCCESS;
2535 finish:
2536 return rval;
2537 }
2538
2539 /*******************************************************************************
2540 *******************************************************************************/
2541 static void
2542 add_to_ptr(u_char *symptr, kxld_addr_t val, boolean_t is_32_bit)
2543 {
2544 if (is_32_bit) {
2545 uint32_t *ptr = (uint32_t *) ((void *) symptr);
2546
2547 *ptr += (uint32_t) val;
2548 } else {
2549 uint64_t *ptr = (uint64_t *) ((void *) symptr);
2550
2551 *ptr += (uint64_t) val;
2552 }
2553
2554 #if SPLIT_KEXTS_DEBUG
2555 kxld_show_ptr_value = FALSE;
2556 #endif
2557
2558 }
2559 #endif /* KXLD_USER_OR_BUNDLE */
2560
2561 #if KXLD_USER_OR_OBJECT
2562 /*******************************************************************************
2563 *******************************************************************************/
2564 static kern_return_t
2565 process_relocs_from_sections(KXLDObject *object)
2566 {
2567 kern_return_t rval = KERN_FAILURE;
2568 KXLDSect *sect = NULL;
2569 u_int i = 0;
2570
2571 for (i = 0; i < object->sects.nitems; ++i) {
2572 sect = kxld_array_get_item(&object->sects, i);
2573 rval = kxld_sect_process_relocs(sect, &object->relocator);
2574 require_noerr(rval, finish);
2575 }
2576
2577 rval = KERN_SUCCESS;
2578 finish:
2579 return rval;
2580 }
2581 #endif /* KXLD_USER_OR_OBJECT */
2582
2583 /*******************************************************************************
2584 *******************************************************************************/
2585 static kern_return_t
2586 populate_kmod_info(KXLDObject *object)
2587 {
2588 kern_return_t rval = KERN_FAILURE;
2589 KXLDSect *kmodsect = NULL;
2590 KXLDSym *kmodsym = NULL;
2591 kmod_info_t *kmod_info = NULL;
2592 u_long kmod_offset = 0;
2593 u_long header_size;
2594 u_long size;
2595
2596 if (kxld_object_is_kernel(object)) {
2597 rval = KERN_SUCCESS;
2598 goto finish;
2599 }
2600
2601 kxld_object_get_vmsize(object, &header_size, &size);
2602
2603 kmodsym = kxld_symtab_get_locally_defined_symbol_by_name(object->symtab,
2604 KXLD_KMOD_INFO_SYMBOL);
2605 require_action(kmodsym, finish, rval=KERN_FAILURE;
2606 kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogNoKmodInfo));
2607
2608 kmodsect = kxld_array_get_item(&object->sects, kmodsym->sectnum);
2609
2610 kmod_offset = (u_long) (kmodsym->base_addr - kmodsect->base_addr);
2611 kmod_info = (kmod_info_t *) ((void *) (kmodsect->data + kmod_offset));
2612
2613 if (kxld_object_is_32_bit(object)) {
2614 kmod_info_32_v1_t *kmod = (kmod_info_32_v1_t *) (kmod_info);
2615
2616 if (isOldInterface) {
2617 kmod->address = (uint32_t) object->link_addr;
2618 }
2619 else {
2620 kmod->address = (uint32_t) object->split_info.vmaddr_TEXT;
2621 }
2622
2623 kmod->size = (uint32_t) size;
2624 kmod->hdr_size = (uint32_t) header_size;
2625
2626 #if !KERNEL
2627 if (kxld_object_target_needs_swap(object)) {
2628 kmod->address = OSSwapInt32(kmod->address);
2629 kmod->size = OSSwapInt32(kmod->size);
2630 kmod->hdr_size = OSSwapInt32(kmod->hdr_size);
2631 }
2632 #endif /* !KERNEL */
2633 } else {
2634 kmod_info_64_v1_t *kmod = (kmod_info_64_v1_t *) (kmod_info);
2635
2636 if (isOldInterface) {
2637 kmod->address = object->link_addr;
2638 }
2639 else {
2640 kmod->address = object->split_info.vmaddr_TEXT;
2641 }
2642
2643 kmod->size = size;
2644 kmod->hdr_size = header_size;
2645
2646 #if !KERNEL
2647 if (kxld_object_target_needs_swap(object)) {
2648 kmod->address = OSSwapInt64(kmod->address);
2649 kmod->size = OSSwapInt64(kmod->size);
2650 kmod->hdr_size = OSSwapInt64(kmod->hdr_size);
2651 }
2652 #endif /* !KERNEL */
2653
2654 #if SPLIT_KEXTS_DEBUG
2655 {
2656 kxld_log(kKxldLogLinking, kKxldLogErr,
2657 " kmodsect %p kmod_info %p = kmodsect->data %p + kmod_offset %lu <%s>",
2658 (void *) kmodsect,
2659 (void *) kmod_info,
2660 (void *) kmodsect->data,
2661 kmod_offset,
2662 __func__);
2663
2664 kxld_log(kKxldLogLinking, kKxldLogErr,
2665 " kmod_info data: address %p size %llu hdr_size %llu start_addr %p stop_addr %p <%s>",
2666 (void *) kmod->address,
2667 kmod->size,
2668 kmod->hdr_size,
2669 (void *) kmod->start_addr,
2670 (void *) kmod->stop_addr,
2671 __func__);
2672 }
2673 #endif
2674
2675 }
2676
2677 rval = KERN_SUCCESS;
2678
2679 finish:
2680 return rval;
2681 }
2682
2683 #if KXLD_PIC_KEXTS
2684 /*******************************************************************************
2685 *******************************************************************************/
2686 static boolean_t
2687 target_supports_slideable_kexts(const KXLDObject *object)
2688 {
2689 check(object);
2690
2691 return (object->cputype != CPU_TYPE_I386 && object->include_kaslr_relocs);
2692 }
2693 #endif /* KXLD_PIC_KEXTS */
mirror of XNU