1/*
2 * Copyright (c) 2008 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 <mach/vm_prot.h>
30#include <mach-o/loader.h>
31#include <sys/types.h>
32
33#if KERNEL
34 #include <mach/vm_param.h>
35#else
36 #include <mach/mach_init.h>
37#endif /* KERNEL */
38
39#define DEBUG_ASSERT_COMPONENT_NAME_STRING "kxld"
40#include <AssertMacros.h>
41
42#include "kxld_reloc.h"
43#include "kxld_sect.h"
44#include "kxld_seg.h"
45#include "kxld_symtab.h"
46#include "kxld_util.h"
47
48#define MAX_SEGS 20
49
50#define TEXT_SEG_PROT (VM_PROT_READ | VM_PROT_EXECUTE)
51#define DATA_SEG_PROT (VM_PROT_READ | VM_PROT_WRITE)
52
53extern boolean_t isSplitKext;
54extern boolean_t isOldInterface;
55
56#if KXLD_USER_OR_OBJECT
57static kern_return_t reorder_sections(KXLDSeg *seg, KXLDArray *section_order);
58static void reorder_section(KXLDArray *sects, u_int *sect_reorder_index,
59 KXLDSect **reorder_buffer, u_int reorder_buffer_index);
60#endif /* KXLD_USER_OR_OBJECT */
61
62#if 0
63static KXLDSeg * get_segment_by_name(KXLDArray *segarray, const char *name);
64#endif
65
66#if KXLD_USER_OR_ILP32
67static kern_return_t seg_export_macho_header_32(const KXLDSeg *seg, u_char *buf,
68 u_long *header_offset, u_long header_size, u_long data_offset);
69#endif
70#if KXLD_USER_OR_LP64
71static kern_return_t seg_export_macho_header_64(const KXLDSeg *seg, u_char *buf,
72 u_long *header_offset, u_long header_size, u_long data_offset);
73#endif
74
75static KXLDSect * get_sect_by_index(const KXLDSeg *seg, u_int idx);
76
77#if KXLD_USER_OR_ILP32
78/*******************************************************************************
79*******************************************************************************/
80kern_return_t
81kxld_seg_init_from_macho_32(KXLDSeg *seg, struct segment_command *src)
82{
83 kern_return_t rval = KERN_FAILURE;
84 check(seg);
85 check(src);
86
87 strlcpy(seg->segname, src->segname, sizeof(seg->segname));
88 seg->base_addr = src->vmaddr;
89 seg->link_addr = src->vmaddr;
90 seg->vmsize = src->vmsize;
91 seg->fileoff = src->fileoff;
92 seg->maxprot = src->maxprot;
93 seg->initprot = src->initprot;
94 seg->flags = src->flags;
95
96 rval = kxld_array_init(&seg->sects, sizeof(KXLDSect *), src->nsects);
97 require_noerr(rval, finish);
98
99 rval = KERN_SUCCESS;
100
101finish:
102 return rval;
103}
104#endif /* KXLD_USER_OR_ILP32 */
105
106#if KXLD_USER_OR_LP64
107/*******************************************************************************
108*******************************************************************************/
109kern_return_t
110kxld_seg_init_from_macho_64(KXLDSeg *seg, struct segment_command_64 *src)
111{
112 kern_return_t rval = KERN_FAILURE;
113 check(seg);
114 check(src);
115
116 strlcpy(seg->segname, src->segname, sizeof(seg->segname));
117 seg->base_addr = src->vmaddr;
118 seg->link_addr = src->vmaddr;
119 seg->vmsize = src->vmsize;
120
121 seg->fileoff = src->fileoff;
122 seg->maxprot = src->maxprot;
123 seg->initprot = src->initprot;
124 seg->flags = src->flags;
125
126 rval = kxld_array_init(&seg->sects, sizeof(KXLDSect *), src->nsects);
127 require_noerr(rval, finish);
128
129 rval = KERN_SUCCESS;
130
131finish:
132 return rval;
133}
134#endif /* KXLD_USER_OR_LP64 */
135
136#if KXLD_USER_OR_OBJECT
137/*******************************************************************************
138*******************************************************************************/
139kern_return_t
140kxld_seg_create_seg_from_sections(KXLDArray *segarray, KXLDArray *sectarray)
141{
142 kern_return_t rval = KERN_FAILURE;
143 KXLDSeg *seg = NULL;
144 KXLDSect *sect = NULL;
145 KXLDSect **sectp = NULL;
146 u_int i = 0;
147
148 /* Initialize the segment array to one segment */
149
150 rval = kxld_array_init(segarray, sizeof(KXLDSeg), 1);
151 require_noerr(rval, finish);
152
153 /* Initialize the segment */
154
155 seg = kxld_array_get_item(segarray, 0);
156 seg->initprot = VM_PROT_ALL;
157 seg->maxprot = VM_PROT_ALL;
158 seg->link_addr = 0;
159
160 /* Add the sections to the segment */
161
162 rval = kxld_array_init(&seg->sects, sizeof(KXLDSect *), sectarray->nitems);
163 require_noerr(rval, finish);
164
165 for (i = 0; i < sectarray->nitems; ++i) {
166 sect = kxld_array_get_item(sectarray, i);
167 sectp = kxld_array_get_item(&seg->sects, i);
168
169 *sectp = sect;
170 }
171
172 rval = KERN_SUCCESS;
173finish:
174 return rval;
175}
176
177/*******************************************************************************
178*******************************************************************************/
179kern_return_t
180kxld_seg_finalize_object_segment(KXLDArray *segarray, KXLDArray *section_order,
181 u_long hdrsize)
182{
183 kern_return_t rval = KERN_FAILURE;
184 KXLDSeg *seg = NULL;
185 KXLDSect *sect = NULL;
186 u_long sect_offset = 0;
187 u_int i = 0;
188
189 check(segarray);
190 check(section_order);
191 require_action(segarray->nitems == 1, finish, rval=KERN_FAILURE);
192
193 seg = kxld_array_get_item(segarray, 0);
194
195 /* Reorder the sections */
196
197 rval = reorder_sections(seg, section_order);
198 require_noerr(rval, finish);
199
200 /* Set the initial link address at the end of the header pages */
201
202 seg->link_addr = kxld_round_page_cross_safe(hdrsize);
203
204 /* Fix up all of the section addresses */
205
206 sect_offset = (u_long) seg->link_addr;
207 for (i = 0; i < seg->sects.nitems; ++i) {
208 sect = *(KXLDSect **)kxld_array_get_item(&seg->sects, i);
209
210 sect->link_addr = kxld_sect_align_address(sect, sect_offset);
211 sect_offset = (u_long) (sect->link_addr + sect->size);
212 }
213
214 /* Finish initializing the segment */
215
216 seg->vmsize = kxld_round_page_cross_safe(sect_offset) - seg->link_addr;
217
218 rval = KERN_SUCCESS;
219finish:
220 return rval;
221}
222
223/*******************************************************************************
224* The legacy section ordering used by kld was based of the order of sections
225* in the kernel file. To achieve the same layout, we save the kernel's
226* section ordering as an array of section names when the kernel file itself
227* is linked. Then, when kexts are linked with the KXLD_LEGACY_LAYOUT flag,
228* we refer to the kernel's section layout to order the kext's sections.
229*
230* The algorithm below is as follows. We iterate through all of the kernel's
231* sections grouped by segment name, so that we are processing all of the __TEXT
232* sections, then all of the __DATA sections, etc. We then iterate through the
233* kext's sections with a similar grouping, looking for sections that match
234* the current kernel's section. In this way, we order all of the matching
235* kext sections in the order in which they appear in the kernel, and then place
236* all remaining kext sections at the end of the current segment grouping in
237* the order in which they originally appeared. Sections that only appear in
238* the kernel are not created. segments that only appear in the kext are
239* left in their original ordering.
240*
241* An example:
242*
243* Kernel sections:
244* __TEXT,__text
245* __TEXT,__const
246* __DATA,__data
247*
248* Kext sections:
249* __TEXT,__const
250* __TEXT,__literal4
251* __TEXT,__text
252* __DATA,__const
253* __DATA,__data
254*
255* Reordered kext sections:
256* __TEXT,__text
257* __TEXT,__const
258* __TEXT,__literal4
259* __DATA,__data
260* __DATA,__const
261*
262* In the implementation below, we use a reorder buffer to hold pointers to the
263* sections of the current working segment. We scan this buffer looking for
264* matching sections, placing them in the segment's section index as we find them.
265* If this function must exit early, the segment's section index is left in an
266* unusable state.
267*******************************************************************************/
268static kern_return_t
269reorder_sections(KXLDSeg *seg, KXLDArray *section_order)
270{
271 kern_return_t rval = KERN_FAILURE;
272 KXLDSect *sect = NULL;
273 KXLDSect **reorder_buffer = NULL;
274 KXLDSectionName *section_name = NULL;
275 const char *segname = NULL;
276 u_int sect_index = 0, legacy_index = 0, sect_reorder_index = 0;
277 u_int i = 0, j = 0;
278 u_int sect_start = 0, sect_end = 0, legacy_start = 0, legacy_end = 0;
279 u_int nsects = 0;
280
281 check(seg);
282 check(section_order);
283
284 /* Allocate the reorder buffer with enough space to hold all of the
285 * sections.
286 */
287
288 reorder_buffer = kxld_alloc(
289 seg->sects.nitems * sizeof(*reorder_buffer));
290 require_action(reorder_buffer, finish, rval=KERN_RESOURCE_SHORTAGE);
291
292 while (legacy_index < section_order->nitems) {
293
294 /* Find the next group of sections with a common segment in the
295 * section_order array.
296 */
297
298 legacy_start = legacy_index++;
299 legacy_end = legacy_index;
300
301 section_name = kxld_array_get_item(section_order, legacy_start);
302 segname = section_name->segname;
303 while (legacy_index < section_order->nitems) {
304 section_name = kxld_array_get_item(section_order, legacy_index);
305 if (!streq_safe(segname, section_name->segname,
306 sizeof(section_name->segname)))
307 {
308 break;
309 }
310
311 ++legacy_index;
312 ++legacy_end;
313 }
314
315 /* Find a group of sections in the kext that match the current
316 * section_order segment.
317 */
318
319 sect_start = sect_index;
320 sect_end = sect_index;
321
322 while (sect_index < seg->sects.nitems) {
323 sect = *(KXLDSect **) kxld_array_get_item(&seg->sects, sect_index);
324 if (!streq_safe(segname, sect->segname, sizeof(sect->segname))) {
325 break;
326 }
327
328 ++sect_index;
329 ++sect_end;
330 }
331 nsects = sect_end - sect_start;
332
333 if (!nsects) continue;
334
335 /* Populate the reorder buffer with the current group of kext sections */
336
337 for (i = sect_start; i < sect_end; ++i) {
338 reorder_buffer[i - sect_start] =
339 *(KXLDSect **) kxld_array_get_item(&seg->sects, i);
340 }
341
342 /* For each section_order section, scan the reorder buffer for a matching
343 * kext section. If one is found, copy it into the next slot in the
344 * segment's section index.
345 */
346
347 sect_reorder_index = sect_start;
348 for (i = legacy_start; i < legacy_end; ++i) {
349 section_name = kxld_array_get_item(section_order, i);
350 sect = NULL;
351
352 for (j = 0; j < nsects; ++j) {
353 sect = reorder_buffer[j];
354 if (!sect) continue;
355
356 if (streq_safe(section_name->sectname, sect->sectname,
357 sizeof(section_name->sectname)))
358 {
359 break;
360 }
361
362 sect = NULL;
363 }
364
365 if (sect) {
366 (void) reorder_section(&seg->sects, &sect_reorder_index,
367 reorder_buffer, j);
368 }
369 }
370
371 /* If any sections remain in the reorder buffer, they are not specified
372 * in the section_order array, so append them to the section index in
373 * in the order they are found.
374 */
375
376 for (i = 0; i < nsects; ++i) {
377 if (!reorder_buffer[i]) continue;
378 reorder_section(&seg->sects, &sect_reorder_index, reorder_buffer, i);
379 }
380 }
381
382 rval = KERN_SUCCESS;
383
384finish:
385
386 if (reorder_buffer) {
387 kxld_free(reorder_buffer, seg->sects.nitems * sizeof(*reorder_buffer));
388 reorder_buffer = NULL;
389 }
390
391 return rval;
392}
393
394/*******************************************************************************
395*******************************************************************************/
396static void
397reorder_section(KXLDArray *sects, u_int *sect_reorder_index,
398 KXLDSect **reorder_buffer, u_int reorder_buffer_index)
399{
400 KXLDSect **tmp = NULL;
401
402 tmp = kxld_array_get_item(sects, *sect_reorder_index);
403
404 *tmp = reorder_buffer[reorder_buffer_index];
405 reorder_buffer[reorder_buffer_index]->sectnum = *sect_reorder_index;
406 reorder_buffer[reorder_buffer_index] = NULL;
407
408 ++(*sect_reorder_index);
409}
410
411/*******************************************************************************
412*******************************************************************************/
413kern_return_t
414kxld_seg_init_linkedit(KXLDArray *segs)
415{
416 kern_return_t rval = KERN_FAILURE;
417 KXLDSeg *seg = NULL;
418 KXLDSeg *le = NULL;
419
420 rval = kxld_array_resize(segs, 2);
421 require_noerr(rval, finish);
422
423 seg = kxld_array_get_item(segs, 0);
424 le = kxld_array_get_item(segs, 1);
425
426 strlcpy(le->segname, SEG_LINKEDIT, sizeof(le->segname));
427 le->link_addr = kxld_round_page_cross_safe(seg->link_addr + seg->vmsize);
428 le->maxprot = VM_PROT_ALL;
429 le->initprot = VM_PROT_DEFAULT;
430
431 rval = KERN_SUCCESS;
432
433finish:
434 return rval;
435}
436#endif /* KXLD_USER_OR_OBJECT */
437
438/*******************************************************************************
439*******************************************************************************/
440void
441kxld_seg_clear(KXLDSeg *seg)
442{
443 check(seg);
444
445 bzero(seg->segname, sizeof(seg->segname));
446 seg->base_addr = 0;
447 seg->link_addr = 0;
448 seg->vmsize = 0;
449 seg->flags = 0;
450 seg->maxprot = 0;
451 seg->initprot = 0;
452
453 /* Don't clear the individual sections here because kxld_kext.c will take
454 * care of that.
455 */
456 kxld_array_clear(&seg->sects);
457}
458
459/*******************************************************************************
460*******************************************************************************/
461void
462kxld_seg_deinit(KXLDSeg *seg)
463{
464 check(seg);
465
466 kxld_array_deinit(&seg->sects);
467 bzero(seg, sizeof(*seg));
468}
469
470/*******************************************************************************
471*******************************************************************************/
472kxld_size_t
473kxld_seg_get_vmsize(const KXLDSeg *seg)
474{
475 check(seg);
476
477 return seg->vmsize;
478}
479
480/*******************************************************************************
481*******************************************************************************/
482u_long
483kxld_seg_get_macho_header_size(const KXLDSeg *seg, boolean_t is_32_bit)
484{
485 u_long size = 0;
486
487 check(seg);
488
489 if (is_32_bit) {
490 size += sizeof(struct segment_command);
491 } else {
492 size += sizeof(struct segment_command_64);
493 }
494 size += seg->sects.nitems * kxld_sect_get_macho_header_size(is_32_bit);
495
496 return size;
497}
498
499/*******************************************************************************
500*******************************************************************************/
501/* This is no longer used, but may be useful some day... */
502#if 0
503u_long
504kxld_seg_get_macho_data_size(const KXLDSeg *seg)
505{
506 u_long size = 0;
507 u_int i = 0;
508 KXLDSect *sect = NULL;
509
510 check(seg);
511
512 for (i = 0; i < seg->sects.nitems; ++i) {
513 sect = get_sect_by_index(seg, i);
514 size = (u_long) kxld_sect_align_address(sect, size);
515 size += kxld_sect_get_macho_data_size(sect);
516 }
517
518 return kxld_round_page_cross_safe(size);
519}
520#endif
521
522/*******************************************************************************
523*******************************************************************************/
524static KXLDSect *
525get_sect_by_index(const KXLDSeg *seg, u_int idx)
526{
527 check(seg);
528
529 return *(KXLDSect **) kxld_array_get_item(&seg->sects, idx);
530}
531
532/*******************************************************************************
533*******************************************************************************/
534kern_return_t
535kxld_seg_export_macho_to_file_buffer(const KXLDSeg *seg, u_char *buf,
536 u_long *header_offset, u_long header_size,
537 u_long *data_offset, u_long data_size,
538 boolean_t is_32_bit)
539{
540 kern_return_t rval = KERN_FAILURE;
541 KXLDSect *sect = NULL;
542 u_long base_data_offset = *data_offset;
543 u_int i = 0;
544 struct segment_command *hdr32 =
545 (struct segment_command *) ((void *) (buf + *header_offset));
546 struct segment_command_64 *hdr64 =
547 (struct segment_command_64 *) ((void *) (buf + *header_offset));
548
549 check(seg);
550 check(buf);
551 check(header_offset);
552 check(data_offset);
553
554 /* Write out the header */
555
556 KXLD_3264_FUNC(is_32_bit, rval,
557 seg_export_macho_header_32, seg_export_macho_header_64,
558 seg, buf, header_offset, header_size, *data_offset);
559 require_noerr(rval, finish);
560
561 /* Write out each section */
562
563 for (i = 0; i < seg->sects.nitems; ++i) {
564 sect = get_sect_by_index(seg, i);
565
566 rval = kxld_sect_export_macho_to_file_buffer(sect, buf, header_offset,
567 header_size, data_offset, data_size, is_32_bit);
568 require_noerr(rval, finish);
569 }
570
571 /* Update the filesize */
572
573 if (is_32_bit) {
574 hdr32->filesize = (uint32_t) (*data_offset - base_data_offset);
575 } else {
576 hdr64->filesize = (uint64_t) (*data_offset - base_data_offset);
577 }
578
579 *data_offset = (u_long)kxld_round_page_cross_safe(*data_offset);
580
581 rval = KERN_SUCCESS;
582
583finish:
584 return rval;
585
586}
587
588
589/*******************************************************************************
590*******************************************************************************/
591kern_return_t
592kxld_seg_export_macho_to_vm(const KXLDSeg *seg,
593 u_char *buf,
594 u_long *header_offset,
595 u_long header_size,
596 u_long data_size,
597 kxld_addr_t file_link_addr,
598 boolean_t is_32_bit)
599{
600 kern_return_t rval = KERN_FAILURE;
601 KXLDSect * sect = NULL;
602
603 // data_offset is used to set fileoff field in segment header
604 u_long data_offset;
605 u_int i = 0;
606
607 check(seg);
608 check(buf);
609 check(header_offset);
610
611 data_offset = (u_long) (seg->link_addr - file_link_addr);
612
613 /* Write out the header */
614
615 KXLD_3264_FUNC(is_32_bit, rval,
616 seg_export_macho_header_32, seg_export_macho_header_64,
617 seg,
618 buf,
619 header_offset, header_size, data_offset);
620 require_noerr(rval, finish);
621
622 /* Write out each section */
623
624 for (i = 0; i < seg->sects.nitems; ++i) {
625 sect = get_sect_by_index(seg, i);
626
627 rval = kxld_sect_export_macho_to_vm(sect, buf, header_offset,
628 header_size, file_link_addr, data_size, is_32_bit);
629 require_noerr(rval, finish);
630 }
631
632 rval = KERN_SUCCESS;
633
634finish:
635 return rval;
636}
637
638#if KXLD_USER_OR_ILP32
639/*******************************************************************************
640*******************************************************************************/
641static kern_return_t
642seg_export_macho_header_32(const KXLDSeg *seg, u_char *buf,
643 u_long *header_offset, u_long header_size, u_long data_offset)
644{
645 kern_return_t rval = KERN_FAILURE;
646 struct segment_command *seghdr = NULL;
647
648 check(seg);
649 check(buf);
650 check(header_offset);
651
652 require_action(sizeof(*seghdr) <= header_size - *header_offset, finish,
653 rval=KERN_FAILURE);
654 seghdr = (struct segment_command *) ((void *) (buf + *header_offset));
655 *header_offset += sizeof(*seghdr);
656
657 seghdr->cmd = LC_SEGMENT;
658 seghdr->cmdsize = (uint32_t) sizeof(*seghdr);
659 seghdr->cmdsize +=
660 (uint32_t) (seg->sects.nitems * kxld_sect_get_macho_header_size(TRUE));
661 strlcpy(seghdr->segname, seg->segname, sizeof(seghdr->segname));
662 seghdr->vmaddr = (uint32_t) seg->link_addr;
663 seghdr->vmsize = (uint32_t) seg->vmsize;
664 seghdr->fileoff = (uint32_t) data_offset;
665 seghdr->filesize = (uint32_t) seg->vmsize;
666 seghdr->maxprot = seg->maxprot;
667 seghdr->initprot = seg->initprot;
668 seghdr->nsects = seg->sects.nitems;
669 seghdr->flags = 0;
670
671#if SPLIT_KEXTS_DEBUG
672 {
673 kxld_log(kKxldLogLinking, kKxldLogErr,
674 "segname %s seghdr %p vmaddr %p vmsize 0x%02X %u fileoff 0x%02X %u <%s>",
675 seg->segname[0] ? seg->segname : "none",
676 (void *) seghdr,
677 (void *) ((uint64_t)seghdr->vmaddr),
678 seghdr->vmsize,
679 seghdr->vmsize,
680 seghdr->fileoff,
681 seghdr->fileoff,
682 __func__);
683 }
684#endif
685
686 rval = KERN_SUCCESS;
687
688finish:
689 return rval;
690}
691#endif /* KXLD_USER_OR_ILP32 */
692
693#if KXLD_USER_OR_LP64
694/*******************************************************************************
695*******************************************************************************/
696static kern_return_t
697seg_export_macho_header_64(const KXLDSeg *seg, u_char *buf,
698 u_long *header_offset, u_long header_size, u_long data_offset)
699{
700 kern_return_t rval = KERN_FAILURE;
701 struct segment_command_64 *seghdr = NULL;
702
703 check(seg);
704 check(buf);
705 check(header_offset);
706
707 require_action(sizeof(*seghdr) <= header_size - *header_offset, finish,
708 rval=KERN_FAILURE);
709
710#if SPLIT_KEXTS_DEBUG
711 {
712 struct mach_header_64 *mach;
713
714 mach = (struct mach_header_64 *) ((void *) buf);
715
716 if (mach->magic != MH_MAGIC_64) {
717 kxld_log(kKxldLogLinking, kKxldLogErr,
718 "bad macho header at %p <%s>",
719 (void *) mach, __func__);
720 goto finish;
721 }
722 }
723#endif
724
725 seghdr = (struct segment_command_64 *) ((void *) (buf + *header_offset));
726 *header_offset += sizeof(*seghdr);
727
728 seghdr->cmd = LC_SEGMENT_64;
729 seghdr->cmdsize = (uint32_t) sizeof(*seghdr);
730 seghdr->cmdsize +=
731 (uint32_t) (seg->sects.nitems * kxld_sect_get_macho_header_size(FALSE));
732 strlcpy(seghdr->segname, seg->segname, sizeof(seghdr->segname));
733 seghdr->vmaddr = (uint64_t) seg->link_addr;
734 seghdr->vmsize = (uint64_t) seg->vmsize;
735 seghdr->fileoff = (uint64_t) data_offset;
736 seghdr->filesize = (uint64_t) seg->vmsize;
737 seghdr->maxprot = seg->maxprot;
738 seghdr->initprot = seg->initprot;
739 seghdr->nsects = seg->sects.nitems;
740 seghdr->flags = 0;
741
742#if SPLIT_KEXTS_DEBUG
743 {
744 kxld_log(kKxldLogLinking, kKxldLogErr,
745 "%p >>> Start of %s seghdr (size %lu) <%s>",
746 (void *) seghdr,
747 seg->segname[0] ? seg->segname : "none",
748 sizeof(*seghdr),
749 __func__);
750 kxld_log(kKxldLogLinking, kKxldLogErr,
751 "%p <<< End of %s seghdr <%s>",
752 (void *) ((u_char *)seghdr + sizeof(*seghdr)),
753 seg->segname[0] ? seg->segname : "none",
754 __func__);
755
756 kxld_log(kKxldLogLinking, kKxldLogErr,
757 "%s seghdr, cmdsize %d vmaddr %p vmsize %p %llu fileoff %p %llu <%s>",
758 seg->segname[0] ? seg->segname : "none",
759 seghdr->cmdsize,
760 (void *) seghdr->vmaddr,
761 (void *) seghdr->vmsize,
762 seghdr->vmsize,
763 (void *) seghdr->fileoff,
764 seghdr->fileoff,
765 __func__);
766 }
767#endif
768
769 rval = KERN_SUCCESS;
770
771finish:
772 return rval;
773}
774#endif /* KXLD_USER_OR_LP64 */
775
776/*******************************************************************************
777*******************************************************************************/
778kern_return_t
779kxld_seg_add_section(KXLDSeg *seg, KXLDSect *sect)
780{
781 kern_return_t rval = KERN_FAILURE;
782 KXLDSect **sectp = NULL;
783 u_int i;
784
785 check(seg);
786 check(sect);
787 require_action(streq_safe(seg->segname, sect->segname, sizeof(seg->segname)),
788 finish, rval=KERN_FAILURE);
789
790 /* Add the section into the section index */
791
792 for (i = 0; i < seg->sects.nitems; ++i) {
793 sectp = kxld_array_get_item(&seg->sects, i);
794 if (NULL == *sectp) {
795 *sectp = sect;
796 break;
797 }
798 }
799 require_action(i < seg->sects.nitems, finish, rval=KERN_FAILURE);
800
801 rval = KERN_SUCCESS;
802
803finish:
804
805 return rval;
806}
807
808/*******************************************************************************
809*******************************************************************************/
810kern_return_t
811kxld_seg_finish_init(KXLDSeg *seg)
812{
813 kern_return_t rval = KERN_FAILURE;
814 u_int i = 0;
815 KXLDSect *sect = NULL;
816 kxld_addr_t maxaddr = 0;
817 kxld_size_t maxsize = 0;
818
819 /* If we already have a size for this segment (e.g. from the mach-o load
820 * command) then don't recalculate the segment size. This is safer since
821 * when we recalculate we are making assumptions about page alignment and
822 * padding that the kext mach-o file was built with. Better to trust the
823 * macho-o info, if we have it. If we don't (i.e. vmsize == 0) then add up
824 * the section sizes and take a best guess at page padding.
825 */
826 if ((seg->vmsize == 0) && (seg->sects.nitems)) {
827 for (i = 0; i < seg->sects.nitems; ++i) {
828 sect = get_sect_by_index(seg, i);
829 require_action(sect, finish, rval=KERN_FAILURE);
830 if (sect->base_addr > maxaddr) {
831 maxaddr = sect->base_addr;
832 maxsize = sect->size;
833 }
834 }
835 seg->vmsize = kxld_round_page_cross_safe(maxaddr +
836 maxsize - seg->base_addr);
837
838 }
839
840 rval = KERN_SUCCESS;
841
842finish:
843 return rval;
844}
845
846/*******************************************************************************
847*******************************************************************************/
848void
849kxld_seg_set_vm_protections(KXLDSeg *seg, boolean_t strict_protections)
850{
851 if (strict_protections) {
852 if (!strncmp(seg->segname, SEG_TEXT, sizeof(seg->segname))) {
853 seg->initprot = TEXT_SEG_PROT;
854 seg->maxprot = TEXT_SEG_PROT;
855 } else {
856 seg->initprot = DATA_SEG_PROT;
857 seg->maxprot = DATA_SEG_PROT;
858 }
859 } else {
860 seg->initprot = VM_PROT_ALL;
861 seg->maxprot = VM_PROT_ALL;
862 }
863}
864
865/*******************************************************************************
866*******************************************************************************/
867void
868kxld_seg_relocate(KXLDSeg *seg, kxld_addr_t link_addr)
869{
870 KXLDSect *sect = NULL;
871 u_int i = 0;
872 splitKextLinkInfo * link_info = (splitKextLinkInfo *) link_addr;
873 kxld_addr_t my_link_addr;
874
875 if (isOldInterface) {
876 seg->link_addr += link_addr;
877 }
878 else {
879 if (isSplitKext) {
880 // we have a split kext
881 if (kxld_seg_is_text_seg(seg)) {
882 // assumes this is the beginning of the kext
883 my_link_addr = link_info->vmaddr_TEXT;
884 seg->link_addr = my_link_addr;
885 }
886 else if (kxld_seg_is_text_exec_seg(seg)) {
887 my_link_addr = link_info->vmaddr_TEXT_EXEC;
888 seg->link_addr = my_link_addr;
889 // vmaddr_TEXT_EXEC is the actual vmaddr for this segment so we need
890 // to adjust for kxld_sect_relocate assuming the link addr is
891 // the address of the kext (macho header in __TEXT)
892 my_link_addr -= seg->base_addr;
893 }
894 else if (kxld_seg_is_data_seg(seg)) {
895 my_link_addr = link_info->vmaddr_DATA;
896 seg->link_addr = my_link_addr;
897 // vmaddr_DATA is the actual vmaddr for this segment so we need
898 // to adjust for kxld_sect_relocate assuming the link addr is
899 // the address of the kext (macho header in __TEXT)
900 my_link_addr -= seg->base_addr;
901 }
902 else if (kxld_seg_is_data_const_seg(seg)) {
903 my_link_addr = link_info->vmaddr_DATA_CONST;
904 seg->link_addr = my_link_addr;
905 // vmaddr_DATA_CONST is the actual vmaddr for this segment so we need
906 // to adjust for kxld_sect_relocate assuming the link addr is
907 // the address of the kext (macho header in __TEXT)
908 my_link_addr -= seg->base_addr;
909 }
910 else if (kxld_seg_is_llvm_cov_seg(seg)) {
911 my_link_addr = link_info->vmaddr_LLVM_COV;
912 seg->link_addr = my_link_addr;
913 // vmaddr_LLVM_COV is the actual vmaddr for this segment so we need
914 // to adjust for kxld_sect_relocate assuming the link addr is
915 // the address of the kext (macho header in __TEXT)
916 my_link_addr -= seg->base_addr;
917 }
918 else if (kxld_seg_is_linkedit_seg(seg)) {
919 my_link_addr = link_info->vmaddr_LINKEDIT;
920 seg->link_addr = my_link_addr;
921 // vmaddr_DATA is the actual vmaddr for this segment so we need
922 // to adjust for kxld_sect_relocate assuming the link addr is
923 // the address of the kext (macho header in __TEXT)
924 my_link_addr -= seg->base_addr;
925 }
926 else {
927 kxld_log(kKxldLogLinking, kKxldLogErr,
928 " not expecting this segment %s!!! <%s>",
929 seg->segname[0] ? seg->segname : "none",
930 __func__);
931 my_link_addr = link_info->vmaddr_TEXT;
932 seg->link_addr += my_link_addr;
933 }
934 }
935 else {
936 my_link_addr = link_info->vmaddr_TEXT;
937 seg->link_addr += my_link_addr;
938 }
939 }
940
941#if SPLIT_KEXTS_DEBUG
942 {
943 kxld_log(kKxldLogLinking, kKxldLogErr,
944 "%p >>> Start of %s segment (vmsize %llu) <%s>)",
945 (void *) seg->link_addr,
946 seg->segname[0] ? seg->segname : "none",
947 seg->vmsize,
948 __func__);
949 kxld_log(kKxldLogLinking, kKxldLogErr,
950 "%p <<< End of %s segment <%s>",
951 (void *) (seg->link_addr + seg->vmsize),
952 seg->segname[0] ? seg->segname : "none",
953 __func__);
954 }
955#endif
956
957 for (i = 0; i < seg->sects.nitems; ++i) {
958 sect = get_sect_by_index(seg, i);
959 if (isOldInterface) {
960 kxld_sect_relocate(sect, link_addr);
961 }
962 else {
963 kxld_sect_relocate(sect, my_link_addr);
964 }
965 }
966}
967
968/*******************************************************************************
969*******************************************************************************/
970void
971kxld_seg_populate_linkedit(KXLDSeg *seg, const KXLDSymtab *symtab, boolean_t is_32_bit
972#if KXLD_PIC_KEXTS
973 , const KXLDArray *locrelocs
974 , const KXLDArray *extrelocs
975 , boolean_t target_supports_slideable_kexts
976#endif /* KXLD_PIC_KEXTS */
977 , uint32_t splitinfolc_size
978 )
979{
980 u_long size = 0;
981
982 size += kxld_symtab_get_macho_data_size(symtab, is_32_bit);
983
984#if KXLD_PIC_KEXTS
985 if (target_supports_slideable_kexts) {
986 size += kxld_reloc_get_macho_data_size(locrelocs, extrelocs);
987 }
988#endif /* KXLD_PIC_KEXTS */
989
990 // 0 unless this is a split kext
991 size += splitinfolc_size;
992
993 seg->vmsize = kxld_round_page_cross_safe(size);
994}
995
996/*******************************************************************************
997 *******************************************************************************/
998boolean_t
999kxld_seg_is_split_seg(const KXLDSeg *seg)
1000{
1001 boolean_t result = FALSE;
1002
1003 check(seg);
1004 if (isSplitKext) {
1005 if (kxld_seg_is_data_seg(seg) || kxld_seg_is_linkedit_seg(seg) ||
1006 kxld_seg_is_text_exec_seg(seg) || kxld_seg_is_data_const_seg(seg) ||
1007 kxld_seg_is_llvm_cov_seg(seg)) {
1008 result = TRUE;
1009 }
1010 }
1011
1012 return result;
1013}
1014
1015boolean_t
1016kxld_seg_is_text_seg(const KXLDSeg *seg)
1017{
1018 boolean_t result = FALSE;
1019
1020 check(seg);
1021 result = !strncmp(seg->segname, SEG_TEXT, sizeof(seg->segname));
1022
1023 return result;
1024}
1025
1026boolean_t
1027kxld_seg_is_text_exec_seg(const KXLDSeg *seg)
1028{
1029 boolean_t result = FALSE;
1030
1031 check(seg);
1032 result = !strncmp(seg->segname, "__TEXT_EXEC", sizeof(seg->segname));
1033
1034 return result;
1035}
1036
1037boolean_t
1038kxld_seg_is_data_seg(const KXLDSeg *seg)
1039{
1040 boolean_t result = FALSE;
1041
1042 check(seg);
1043 result = !strncmp(seg->segname, SEG_DATA, sizeof(seg->segname));
1044
1045 return result;
1046}
1047
1048boolean_t
1049kxld_seg_is_data_const_seg(const KXLDSeg *seg)
1050{
1051 boolean_t result = FALSE;
1052
1053 check(seg);
1054 result = !strncmp(seg->segname, "__DATA_CONST", sizeof(seg->segname));
1055
1056 return result;
1057}
1058
1059boolean_t
1060kxld_seg_is_linkedit_seg(const KXLDSeg *seg)
1061{
1062 boolean_t result = FALSE;
1063
1064 check(seg);
1065 result = !strncmp(seg->segname, SEG_LINKEDIT, sizeof(seg->segname));
1066
1067 return result;
1068}
1069
1070boolean_t
1071kxld_seg_is_llvm_cov_seg(const KXLDSeg *seg)
1072{
1073 boolean_t result = FALSE;
1074
1075 check(seg);
1076 result = !strncmp(seg->segname, "__LLVM_COV", sizeof(seg->segname));
1077
1078 return result;
1079}
1080