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 53#if KXLD_USER_OR_OBJECT 54static kern_return_t reorder_sections(KXLDSeg *seg, KXLDArray *section_order); 55static void reorder_section(KXLDArray *sects, u_int *sect_reorder_index, 56 KXLDSect **reorder_buffer, u_int reorder_buffer_index); 57#endif /* KXLD_USER_OR_OBJECT */ 58 59#if 0 60static KXLDSeg * get_segment_by_name(KXLDArray *segarray, const char *name); 61#endif 62 63#if KXLD_USER_OR_ILP32 64static kern_return_t seg_export_macho_header_32(const KXLDSeg *seg, u_char *buf, 65 u_long *header_offset, u_long header_size, u_long data_offset); 66#endif 67#if KXLD_USER_OR_LP64 68static kern_return_t seg_export_macho_header_64(const KXLDSeg *seg, u_char *buf, 69 u_long *header_offset, u_long header_size, u_long data_offset); 70#endif 71 72static KXLDSect * get_sect_by_index(const KXLDSeg *seg, u_int idx); 73 74#if KXLD_USER_OR_ILP32 75/******************************************************************************* 76*******************************************************************************/ 77kern_return_t 78kxld_seg_init_from_macho_32(KXLDSeg *seg, struct segment_command *src) 79{ 80 kern_return_t rval = KERN_FAILURE; 81 check(seg); 82 check(src); 83 84 strlcpy(seg->segname, src->segname, sizeof(seg->segname)); 85 seg->base_addr = src->vmaddr; 86 seg->link_addr = src->vmaddr; 87 seg->vmsize = src->vmsize; 88 seg->fileoff = src->fileoff; 89 seg->maxprot = src->maxprot; 90 seg->initprot = src->initprot; 91 seg->flags = src->flags; 92 93 rval = kxld_array_init(&seg->sects, sizeof(KXLDSect *), src->nsects); 94 require_noerr(rval, finish); 95 96 rval = KERN_SUCCESS; 97 98finish: 99 return rval; 100} 101#endif /* KXLD_USER_OR_ILP32 */ 102 103#if KXLD_USER_OR_LP64 104/******************************************************************************* 105*******************************************************************************/ 106kern_return_t 107kxld_seg_init_from_macho_64(KXLDSeg *seg, struct segment_command_64 *src) 108{ 109 kern_return_t rval = KERN_FAILURE; 110 check(seg); 111 check(src); 112 113 strlcpy(seg->segname, src->segname, sizeof(seg->segname)); 114 seg->base_addr = src->vmaddr; 115 seg->link_addr = src->vmaddr; 116 seg->vmsize = src->vmsize; 117 seg->fileoff = src->fileoff; 118 seg->maxprot = src->maxprot; 119 seg->initprot = src->initprot; 120 seg->flags = src->flags; 121 122 rval = kxld_array_init(&seg->sects, sizeof(KXLDSect *), src->nsects); 123 require_noerr(rval, finish); 124 125 rval = KERN_SUCCESS; 126 127finish: 128 return rval; 129} 130#endif /* KXLD_USER_OR_LP64 */ 131 132#if KXLD_USER_OR_OBJECT 133/******************************************************************************* 134*******************************************************************************/ 135kern_return_t 136kxld_seg_create_seg_from_sections(KXLDArray *segarray, KXLDArray *sectarray) 137{ 138 kern_return_t rval = KERN_FAILURE; 139 KXLDSeg *seg = NULL; 140 KXLDSect *sect = NULL; 141 KXLDSect **sectp = NULL; 142 u_int i = 0; 143 144 /* Initialize the segment array to one segment */ 145 146 rval = kxld_array_init(segarray, sizeof(KXLDSeg), 1); 147 require_noerr(rval, finish); 148 149 /* Initialize the segment */ 150 151 seg = kxld_array_get_item(segarray, 0); 152 seg->initprot = VM_PROT_ALL; 153 seg->maxprot = VM_PROT_ALL; 154 seg->link_addr = 0; 155 156 /* Add the sections to the segment */ 157 158 rval = kxld_array_init(&seg->sects, sizeof(KXLDSect *), sectarray->nitems); 159 require_noerr(rval, finish); 160 161 for (i = 0; i < sectarray->nitems; ++i) { 162 sect = kxld_array_get_item(sectarray, i); 163 sectp = kxld_array_get_item(&seg->sects, i); 164 165 *sectp = sect; 166 } 167 168 rval = KERN_SUCCESS; 169finish: 170 return rval; 171} 172 173/******************************************************************************* 174*******************************************************************************/ 175kern_return_t 176kxld_seg_finalize_object_segment(KXLDArray *segarray, KXLDArray *section_order, 177 u_long hdrsize) 178{ 179 kern_return_t rval = KERN_FAILURE; 180 KXLDSeg *seg = NULL; 181 KXLDSect *sect = NULL; 182 u_long sect_offset = 0; 183 u_int i = 0; 184 185 check(segarray); 186 check(section_order); 187 require_action(segarray->nitems == 1, finish, rval=KERN_FAILURE); 188 189 seg = kxld_array_get_item(segarray, 0); 190 191 /* Reorder the sections */ 192 193 rval = reorder_sections(seg, section_order); 194 require_noerr(rval, finish); 195 196 /* Set the initial link address at the end of the header pages */ 197 198 seg->link_addr = round_page(hdrsize); 199 200 /* Fix up all of the section addresses */ 201 202 sect_offset = (u_long) seg->link_addr; 203 for (i = 0; i < seg->sects.nitems; ++i) { 204 sect = *(KXLDSect **)kxld_array_get_item(&seg->sects, i); 205 206 sect->link_addr = kxld_sect_align_address(sect, sect_offset); 207 sect_offset = (u_long) (sect->link_addr + sect->size); 208 } 209 210 /* Finish initializing the segment */ 211 212 seg->vmsize = round_page(sect_offset) - seg->link_addr; 213 214 rval = KERN_SUCCESS; 215finish: 216 return rval; 217} 218 219/******************************************************************************* 220* The legacy section ordering used by kld was based of the order of sections 221* in the kernel file. To achieve the same layout, we save the kernel's 222* section ordering as an array of section names when the kernel file itself 223* is linked. Then, when kexts are linked with the KXLD_LEGACY_LAYOUT flag, 224* we refer to the kernel's section layout to order the kext's sections. 225* 226* The algorithm below is as follows. We iterate through all of the kernel's 227* sections grouped by segment name, so that we are processing all of the __TEXT 228* sections, then all of the __DATA sections, etc. We then iterate through the 229* kext's sections with a similar grouping, looking for sections that match 230* the current kernel's section. In this way, we order all of the matching 231* kext sections in the order in which they appear in the kernel, and then place 232* all remaining kext sections at the end of the current segment grouping in 233* the order in which they originally appeared. Sections that only appear in 234* the kernel are not created. segments that only appear in the kext are 235* left in their original ordering. 236* 237* An example: 238* 239* Kernel sections: 240* __TEXT,__text 241* __TEXT,__const 242* __DATA,__data 243* 244* Kext sections: 245* __TEXT,__const 246* __TEXT,__literal4 247* __TEXT,__text 248* __DATA,__const 249* __DATA,__data 250* 251* Reordered kext sections: 252* __TEXT,__text 253* __TEXT,__const 254* __TEXT,__literal4 255* __DATA,__data 256* __DATA,__const 257* 258* In the implementation below, we use a reorder buffer to hold pointers to the 259* sections of the current working segment. We scan this buffer looking for 260* matching sections, placing them in the segment's section index as we find them. 261* If this function must exit early, the segment's section index is left in an 262* unusable state. 263*******************************************************************************/ 264static kern_return_t 265reorder_sections(KXLDSeg *seg, KXLDArray *section_order) 266{ 267 kern_return_t rval = KERN_FAILURE; 268 KXLDSect *sect = NULL; 269 KXLDSect **reorder_buffer = NULL; 270 KXLDSectionName *section_name = NULL; 271 const char *segname = NULL; 272 u_int sect_index = 0, legacy_index = 0, sect_reorder_index = 0; 273 u_int i = 0, j = 0; 274 u_int sect_start = 0, sect_end = 0, legacy_start = 0, legacy_end = 0; 275 u_int nsects = 0; 276 277 check(seg); 278 check(section_order); 279 280 /* Allocate the reorder buffer with enough space to hold all of the 281 * sections. 282 */ 283 284 reorder_buffer = kxld_alloc( 285 seg->sects.nitems * sizeof(*reorder_buffer)); 286 require_action(reorder_buffer, finish, rval=KERN_RESOURCE_SHORTAGE); 287 288 while (legacy_index < section_order->nitems) { 289 290 /* Find the next group of sections with a common segment in the 291 * section_order array. 292 */ 293 294 legacy_start = legacy_index++; 295 legacy_end = legacy_index; 296 297 section_name = kxld_array_get_item(section_order, legacy_start); 298 segname = section_name->segname; 299 while (legacy_index < section_order->nitems) { 300 section_name = kxld_array_get_item(section_order, legacy_index); 301 if (!streq_safe(segname, section_name->segname, 302 sizeof(section_name->segname))) 303 { 304 break; 305 } 306 307 ++legacy_index; 308 ++legacy_end; 309 } 310 311 /* Find a group of sections in the kext that match the current 312 * section_order segment. 313 */ 314 315 sect_start = sect_index; 316 sect_end = sect_index; 317 318 while (sect_index < seg->sects.nitems) { 319 sect = *(KXLDSect **) kxld_array_get_item(&seg->sects, sect_index); 320 if (!streq_safe(segname, sect->segname, sizeof(sect->segname))) { 321 break; 322 } 323 324 ++sect_index; 325 ++sect_end; 326 } 327 nsects = sect_end - sect_start; 328 329 if (!nsects) continue; 330 331 /* Populate the reorder buffer with the current group of kext sections */ 332 333 for (i = sect_start; i < sect_end; ++i) { 334 reorder_buffer[i - sect_start] = 335 *(KXLDSect **) kxld_array_get_item(&seg->sects, i); 336 } 337 338 /* For each section_order section, scan the reorder buffer for a matching 339 * kext section. If one is found, copy it into the next slot in the 340 * segment's section index. 341 */ 342 343 sect_reorder_index = sect_start; 344 for (i = legacy_start; i < legacy_end; ++i) { 345 section_name = kxld_array_get_item(section_order, i); 346 sect = NULL; 347 348 for (j = 0; j < nsects; ++j) { 349 sect = reorder_buffer[j]; 350 if (!sect) continue; 351 352 if (streq_safe(section_name->sectname, sect->sectname, 353 sizeof(section_name->sectname))) 354 { 355 break; 356 } 357 358 sect = NULL; 359 } 360 361 if (sect) { 362 (void) reorder_section(&seg->sects, §_reorder_index, 363 reorder_buffer, j); 364 } 365 } 366 367 /* If any sections remain in the reorder buffer, they are not specified 368 * in the section_order array, so append them to the section index in 369 * in the order they are found. 370 */ 371 372 for (i = 0; i < nsects; ++i) { 373 if (!reorder_buffer[i]) continue; 374 reorder_section(&seg->sects, §_reorder_index, reorder_buffer, i); 375 } 376 } 377 378 rval = KERN_SUCCESS; 379 380finish: 381 382 if (reorder_buffer) { 383 kxld_free(reorder_buffer, seg->sects.nitems * sizeof(*reorder_buffer)); 384 reorder_buffer = NULL; 385 } 386 387 return rval; 388} 389 390/******************************************************************************* 391*******************************************************************************/ 392static void 393reorder_section(KXLDArray *sects, u_int *sect_reorder_index, 394 KXLDSect **reorder_buffer, u_int reorder_buffer_index) 395{ 396 KXLDSect **tmp = NULL; 397 398 tmp = kxld_array_get_item(sects, *sect_reorder_index); 399 400 *tmp = reorder_buffer[reorder_buffer_index]; 401 reorder_buffer[reorder_buffer_index]->sectnum = *sect_reorder_index; 402 reorder_buffer[reorder_buffer_index] = NULL; 403 404 ++(*sect_reorder_index); 405} 406 407/******************************************************************************* 408*******************************************************************************/ 409kern_return_t 410kxld_seg_init_linkedit(KXLDArray *segs) 411{ 412 kern_return_t rval = KERN_FAILURE; 413 KXLDSeg *seg = NULL; 414 KXLDSeg *le = NULL; 415 416 rval = kxld_array_resize(segs, 2); 417 require_noerr(rval, finish); 418 419 seg = kxld_array_get_item(segs, 0); 420 le = kxld_array_get_item(segs, 1); 421 422 strlcpy(le->segname, SEG_LINKEDIT, sizeof(le->segname)); 423 le->link_addr = round_page(seg->link_addr + seg->vmsize); 424 le->maxprot = VM_PROT_ALL; 425 le->initprot = VM_PROT_DEFAULT; 426 427 rval = KERN_SUCCESS; 428 429finish: 430 return rval; 431} 432#endif /* KXLD_USER_OR_OBJECT */ 433 434/******************************************************************************* 435*******************************************************************************/ 436void 437kxld_seg_clear(KXLDSeg *seg) 438{ 439 check(seg); 440 441 bzero(seg->segname, sizeof(seg->segname)); 442 seg->base_addr = 0; 443 seg->link_addr = 0; 444 seg->vmsize = 0; 445 seg->flags = 0; 446 seg->maxprot = 0; 447 seg->initprot = 0; 448 449 /* Don't clear the individual sections here because kxld_kext.c will take 450 * care of that. 451 */ 452 kxld_array_clear(&seg->sects); 453} 454 455/******************************************************************************* 456*******************************************************************************/ 457void 458kxld_seg_deinit(KXLDSeg *seg) 459{ 460 check(seg); 461 462 kxld_array_deinit(&seg->sects); 463 bzero(seg, sizeof(*seg)); 464} 465 466/******************************************************************************* 467*******************************************************************************/ 468kxld_size_t 469kxld_seg_get_vmsize(const KXLDSeg *seg) 470{ 471 check(seg); 472 473 return seg->vmsize; 474} 475 476/******************************************************************************* 477*******************************************************************************/ 478u_long 479kxld_seg_get_macho_header_size(const KXLDSeg *seg, boolean_t is_32_bit) 480{ 481 u_long size = 0; 482 483 check(seg); 484 485 if (is_32_bit) { 486 size += sizeof(struct segment_command); 487 } else { 488 size += sizeof(struct segment_command_64); 489 } 490 size += seg->sects.nitems * kxld_sect_get_macho_header_size(is_32_bit); 491 492 return size; 493} 494 495/******************************************************************************* 496*******************************************************************************/ 497/* This is no longer used, but may be useful some day... */ 498#if 0 499u_long 500kxld_seg_get_macho_data_size(const KXLDSeg *seg) 501{ 502 u_long size = 0; 503 u_int i = 0; 504 KXLDSect *sect = NULL; 505 506 check(seg); 507 508 for (i = 0; i < seg->sects.nitems; ++i) { 509 sect = get_sect_by_index(seg, i); 510 size = (u_long) kxld_sect_align_address(sect, size); 511 size += kxld_sect_get_macho_data_size(sect); 512 } 513 514 return round_page(size); 515} 516#endif 517 518/******************************************************************************* 519*******************************************************************************/ 520static KXLDSect * 521get_sect_by_index(const KXLDSeg *seg, u_int idx) 522{ 523 check(seg); 524 525 return *(KXLDSect **) kxld_array_get_item(&seg->sects, idx); 526} 527 528/******************************************************************************* 529*******************************************************************************/ 530kern_return_t 531kxld_seg_export_macho_to_file_buffer(const KXLDSeg *seg, u_char *buf, 532 u_long *header_offset, u_long header_size, 533 u_long *data_offset, u_long data_size, 534 boolean_t is_32_bit) 535{ 536 kern_return_t rval = KERN_FAILURE; 537 KXLDSect *sect = NULL; 538 u_long base_data_offset = *data_offset; 539 u_int i = 0; 540 struct segment_command *hdr32 = 541 (struct segment_command *) ((void *) (buf + *header_offset)); 542 struct segment_command_64 *hdr64 = 543 (struct segment_command_64 *) ((void *) (buf + *header_offset)); 544 545 check(seg); 546 check(buf); 547 check(header_offset); 548 check(data_offset); 549 550 /* Write out the header */ 551 552 KXLD_3264_FUNC(is_32_bit, rval, 553 seg_export_macho_header_32, seg_export_macho_header_64, 554 seg, buf, header_offset, header_size, *data_offset); 555 require_noerr(rval, finish); 556 557 /* Write out each section */ 558 559 for (i = 0; i < seg->sects.nitems; ++i) { 560 sect = get_sect_by_index(seg, i); 561 562 rval = kxld_sect_export_macho_to_file_buffer(sect, buf, header_offset, 563 header_size, data_offset, data_size, is_32_bit); 564 require_noerr(rval, finish); 565 } 566 567 /* Update the filesize */ 568 569 if (is_32_bit) { 570 hdr32->filesize = (uint32_t) (*data_offset - base_data_offset); 571 } else { 572 hdr64->filesize = (uint64_t) (*data_offset - base_data_offset); 573 } 574 575 *data_offset = round_page(*data_offset); 576 577 rval = KERN_SUCCESS; 578 579finish: 580 return rval; 581 582} 583 584/******************************************************************************* 585*******************************************************************************/ 586kern_return_t 587kxld_seg_export_macho_to_vm(const KXLDSeg *seg, u_char *buf, 588 u_long *header_offset, u_long header_size, 589 u_long data_size, kxld_addr_t file_link_addr, 590 boolean_t is_32_bit) 591{ 592 kern_return_t rval = KERN_FAILURE; 593 KXLDSect *sect = NULL; 594 u_long data_offset = (u_long) (seg->link_addr - file_link_addr); 595 u_int i = 0; 596 597 check(seg); 598 check(buf); 599 check(header_offset); 600 601 /* Write out the header */ 602 603 KXLD_3264_FUNC(is_32_bit, rval, 604 seg_export_macho_header_32, seg_export_macho_header_64, 605 seg, buf, header_offset, header_size, data_offset); 606 require_noerr(rval, finish); 607 608 /* Write out each section */ 609 610 for (i = 0; i < seg->sects.nitems; ++i) { 611 sect = get_sect_by_index(seg, i); 612 613 rval = kxld_sect_export_macho_to_vm(sect, buf, header_offset, 614 header_size, file_link_addr, data_size, is_32_bit); 615 require_noerr(rval, finish); 616 } 617 618 rval = KERN_SUCCESS; 619 620finish: 621 return rval; 622} 623 624#if KXLD_USER_OR_ILP32 625/******************************************************************************* 626*******************************************************************************/ 627static kern_return_t 628seg_export_macho_header_32(const KXLDSeg *seg, u_char *buf, 629 u_long *header_offset, u_long header_size, u_long data_offset) 630{ 631 kern_return_t rval = KERN_FAILURE; 632 struct segment_command *seghdr = NULL; 633 634 check(seg); 635 check(buf); 636 check(header_offset); 637 638 require_action(sizeof(*seghdr) <= header_size - *header_offset, finish, 639 rval=KERN_FAILURE); 640 seghdr = (struct segment_command *) ((void *) (buf + *header_offset)); 641 *header_offset += sizeof(*seghdr); 642 643 seghdr->cmd = LC_SEGMENT; 644 seghdr->cmdsize = (uint32_t) sizeof(*seghdr); 645 seghdr->cmdsize += 646 (uint32_t) (seg->sects.nitems * kxld_sect_get_macho_header_size(TRUE)); 647 strlcpy(seghdr->segname, seg->segname, sizeof(seghdr->segname)); 648 seghdr->vmaddr = (uint32_t) seg->link_addr; 649 seghdr->vmsize = (uint32_t) seg->vmsize; 650 seghdr->fileoff = (uint32_t) data_offset; 651 seghdr->filesize = (uint32_t) seg->vmsize; 652 seghdr->maxprot = seg->maxprot; 653 seghdr->initprot = seg->initprot; 654 seghdr->nsects = seg->sects.nitems; 655 seghdr->flags = 0; 656 657 rval = KERN_SUCCESS; 658 659finish: 660 return rval; 661} 662#endif /* KXLD_USER_OR_ILP32 */ 663 664#if KXLD_USER_OR_LP64 665/******************************************************************************* 666*******************************************************************************/ 667static kern_return_t 668seg_export_macho_header_64(const KXLDSeg *seg, u_char *buf, 669 u_long *header_offset, u_long header_size, u_long data_offset) 670{ 671 kern_return_t rval = KERN_FAILURE; 672 struct segment_command_64 *seghdr = NULL; 673 674 check(seg); 675 check(buf); 676 check(header_offset); 677 678 require_action(sizeof(*seghdr) <= header_size - *header_offset, finish, 679 rval=KERN_FAILURE); 680 seghdr = (struct segment_command_64 *) ((void *) (buf + *header_offset)); 681 *header_offset += sizeof(*seghdr); 682 683 seghdr->cmd = LC_SEGMENT_64; 684 seghdr->cmdsize = (uint32_t) sizeof(*seghdr); 685 seghdr->cmdsize += 686 (uint32_t) (seg->sects.nitems * kxld_sect_get_macho_header_size(FALSE)); 687 strlcpy(seghdr->segname, seg->segname, sizeof(seghdr->segname)); 688 seghdr->vmaddr = (uint64_t) seg->link_addr; 689 seghdr->vmsize = (uint64_t) seg->vmsize; 690 seghdr->fileoff = (uint64_t) data_offset; 691 seghdr->filesize = (uint64_t) seg->vmsize; 692 seghdr->maxprot = seg->maxprot; 693 seghdr->initprot = seg->initprot; 694 seghdr->nsects = seg->sects.nitems; 695 seghdr->flags = 0; 696 697 rval = KERN_SUCCESS; 698 699finish: 700 return rval; 701} 702#endif /* KXLD_USER_OR_LP64 */ 703 704/******************************************************************************* 705*******************************************************************************/ 706kern_return_t 707kxld_seg_add_section(KXLDSeg *seg, KXLDSect *sect) 708{ 709 kern_return_t rval = KERN_FAILURE; 710 KXLDSect **sectp = NULL; 711 u_int i; 712 713 check(seg); 714 check(sect); 715 require_action(streq_safe(seg->segname, sect->segname, sizeof(seg->segname)), 716 finish, rval=KERN_FAILURE); 717 718 /* Add the section into the section index */ 719 720 for (i = 0; i < seg->sects.nitems; ++i) { 721 sectp = kxld_array_get_item(&seg->sects, i); 722 if (NULL == *sectp) { 723 *sectp = sect; 724 break; 725 } 726 } 727 require_action(i < seg->sects.nitems, finish, rval=KERN_FAILURE); 728 729 rval = KERN_SUCCESS; 730 731finish: 732 733 return rval; 734} 735 736/******************************************************************************* 737*******************************************************************************/ 738kern_return_t 739kxld_seg_finish_init(KXLDSeg *seg) 740{ 741 kern_return_t rval = KERN_FAILURE; 742 u_int i = 0; 743 KXLDSect *sect = NULL; 744 kxld_addr_t maxaddr = 0; 745 kxld_size_t maxsize = 0; 746 747 if (seg->sects.nitems) { 748 for (i = 0; i < seg->sects.nitems; ++i) { 749 sect = get_sect_by_index(seg, i); 750 require_action(sect, finish, rval=KERN_FAILURE); 751 if (sect->base_addr > maxaddr) { 752 maxaddr = sect->base_addr; 753 maxsize = sect->size; 754 } 755 } 756 757 /* XXX Cross architecture linking will fail if the page size ever differs 758 * from 4096. (As of this writing, we're fine on i386, x86_64, arm, and 759 * arm64.) 760 */ 761 seg->vmsize = round_page(maxaddr + maxsize - seg->base_addr); 762 } 763 764 rval = KERN_SUCCESS; 765 766finish: 767 return rval; 768} 769 770/******************************************************************************* 771*******************************************************************************/ 772void 773kxld_seg_set_vm_protections(KXLDSeg *seg, boolean_t strict_protections) 774{ 775 /* This is unnecessary except to make the clang analyzer happy. When 776 * the analyzer no longer ignores nonnull attributes for if statements, 777 * we can remove this line. 778 */ 779 if (!seg) return; 780 781 if (strict_protections) { 782 if (streq_safe(seg->segname, SEG_TEXT, const_strlen(SEG_TEXT))) { 783 seg->initprot = TEXT_SEG_PROT; 784 seg->maxprot = TEXT_SEG_PROT; 785 } else { 786 seg->initprot = DATA_SEG_PROT; 787 seg->maxprot = DATA_SEG_PROT; 788 } 789 } else { 790 seg->initprot = VM_PROT_ALL; 791 seg->maxprot = VM_PROT_ALL; 792 } 793} 794 795/******************************************************************************* 796*******************************************************************************/ 797void 798kxld_seg_relocate(KXLDSeg *seg, kxld_addr_t link_addr) 799{ 800 KXLDSect *sect = NULL; 801 u_int i = 0; 802 803 seg->link_addr += link_addr; 804 for (i = 0; i < seg->sects.nitems; ++i) { 805 sect = get_sect_by_index(seg, i); 806 kxld_sect_relocate(sect, link_addr); 807 } 808} 809 810/******************************************************************************* 811*******************************************************************************/ 812void 813kxld_seg_populate_linkedit(KXLDSeg *seg, const KXLDSymtab *symtab, boolean_t is_32_bit 814#if KXLD_PIC_KEXTS 815 , const KXLDArray *locrelocs 816 , const KXLDArray *extrelocs 817 , boolean_t target_supports_slideable_kexts 818#endif /* KXLD_PIC_KEXTS */ 819 ) 820{ 821 u_long size = 0; 822 823 size += kxld_symtab_get_macho_data_size(symtab, is_32_bit); 824 825#if KXLD_PIC_KEXTS 826 if (target_supports_slideable_kexts) { 827 size += kxld_reloc_get_macho_data_size(locrelocs, extrelocs); 828 } 829#endif /* KXLD_PIC_KEXTS */ 830 831 seg->vmsize = round_page(size); 832} 833 834