1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1988 AT&T 24 * All Rights Reserved 25 * 26 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 27 * Use is subject to license terms. 28 */ 29 30 /* 31 * This file contains the functions responsible for opening the output file 32 * image, associating the appropriate input elf structures with the new image, 33 * and obtaining new elf structures to define the new image. 34 */ 35 #include <stdio.h> 36 #include <sys/stat.h> 37 #include <fcntl.h> 38 #include <link.h> 39 #include <errno.h> 40 #include <string.h> 41 #include <limits.h> 42 #include <debug.h> 43 #include <unistd.h> 44 #include "msg.h" 45 #include "_libld.h" 46 47 /* 48 * Determine a least common multiplier. Input sections contain an alignment 49 * requirement, which elf_update() uses to insure that the section is aligned 50 * correctly off of the base of the elf image. We must also insure that the 51 * sections mapping is congruent with this alignment requirement. For each 52 * input section associated with a loadable segment determine whether the 53 * segments alignment must be adjusted to compensate for a sections alignment 54 * requirements. 55 */ 56 Xword 57 ld_lcm(Xword a, Xword b) 58 { 59 Xword _r, _a, _b; 60 61 if ((_a = a) == 0) 62 return (b); 63 if ((_b = b) == 0) 64 return (a); 65 66 if (_a > _b) 67 _a = b, _b = a; 68 while ((_r = _b % _a) != 0) 69 _b = _a, _a = _r; 70 return ((a / _a) * b); 71 } 72 73 /* 74 * Open the output file and insure the correct access modes. 75 */ 76 uintptr_t 77 ld_open_outfile(Ofl_desc * ofl) 78 { 79 mode_t mode; 80 struct stat status; 81 82 /* 83 * Determine the required file mode from the type of output file we 84 * are creating. 85 */ 86 mode = (ofl->ofl_flags & (FLG_OF_EXEC | FLG_OF_SHAROBJ)) 87 ? 0777 : 0666; 88 89 /* Determine if the output file already exists */ 90 if (stat(ofl->ofl_name, &status) == 0) { 91 if ((status.st_mode & S_IFMT) != S_IFREG) { 92 /* 93 * It is not a regular file, so don't delete it 94 * or allow it to be deleted. This allows root 95 * users to specify /dev/null output file for 96 * verification links. 97 */ 98 ofl->ofl_flags1 |= FLG_OF1_NONREG; 99 } else { 100 /* 101 * It's a regular file, so unlink it. In standard 102 * Unix fashion, the old file will continue to 103 * exist until its link count drops to 0 and no 104 * process has the file open. In the meantime, we 105 * create a new file (inode) under the same name, 106 * available for new use. 107 * 108 * The advantage of this policy is that creating 109 * a new executable or sharable library does not 110 * corrupt existing processes using the old file. 111 * A possible disadvantage is that if the existing 112 * file has a (link_count > 1), the other names will 113 * continue to reference the old inode, thus 114 * breaking the link. 115 * 116 * A subtlety here is that POSIX says we are not 117 * supposed to replace a non-writable file, which 118 * is something that unlink() is happy to do. The 119 * only 100% reliable test against this is to open 120 * the file for non-destructive write access. If the 121 * open succeeds, we are clear to unlink it, and if 122 * not, then the error generated is the error we 123 * need to report. 124 */ 125 if ((ofl->ofl_fd = open(ofl->ofl_name, O_RDWR, 126 mode)) < 0) { 127 int err = errno; 128 129 if (err != ENOENT) { 130 eprintf(ofl->ofl_lml, ERR_FATAL, 131 MSG_INTL(MSG_SYS_OPEN), 132 ofl->ofl_name, strerror(err)); 133 return (S_ERROR); 134 } 135 } else { 136 (void) close(ofl->ofl_fd); 137 } 138 139 if ((unlink(ofl->ofl_name) == -1) && 140 (errno != ENOENT)) { 141 int err = errno; 142 143 eprintf(ofl->ofl_lml, ERR_FATAL, 144 MSG_INTL(MSG_SYS_UNLINK), 145 ofl->ofl_name, strerror(err)); 146 return (S_ERROR); 147 } 148 } 149 } 150 151 /* 152 * Open (or create) the output file name (ofl_fd acts as a global 153 * flag to ldexit() signifying whether the output file should be 154 * removed or not on error). 155 */ 156 if ((ofl->ofl_fd = open(ofl->ofl_name, O_RDWR | O_CREAT | O_TRUNC, 157 mode)) < 0) { 158 int err = errno; 159 160 eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), 161 ofl->ofl_name, strerror(err)); 162 return (S_ERROR); 163 } 164 165 return (1); 166 } 167 168 169 /* 170 * If we are creating a memory model we need to update the present memory image. 171 * Use elf_update(ELF_C_NULL) to calculate the offset of each section and their 172 * associated data buffers. From this information determine what padding is 173 * required. 174 * 175 * Two actions are necessary to convert the present disc image into a memory 176 * image: 177 * 178 * - Loadable segments must be padded so that the next segment virtual 179 * address and file offset are the same. 180 * 181 * - NOBITS sections must be converted into allocated, null filled sections. 182 */ 183 static uintptr_t 184 pad_outfile(Ofl_desc *ofl) 185 { 186 Aliste idx1; 187 off_t offset; 188 Elf_Scn *oscn = 0; 189 Sg_desc *sgp; 190 Ehdr *ehdr; 191 192 /* 193 * Update all the elf structures. This will assign offsets to the 194 * section headers and data buffers as they relate to the new image. 195 */ 196 if (elf_update(ofl->ofl_welf, ELF_C_NULL) == -1) { 197 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_UPDATE), 198 ofl->ofl_name); 199 return (S_ERROR); 200 } 201 if ((ehdr = elf_getehdr(ofl->ofl_welf)) == NULL) { 202 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_GETEHDR), 203 ofl->ofl_name); 204 return (S_ERROR); 205 } 206 207 /* 208 * Initialize the offset by skipping the Elf header and program 209 * headers. 210 */ 211 offset = ehdr->e_phoff + (ehdr->e_phnum * ehdr->e_phentsize); 212 213 /* 214 * Traverse the segment list looking for loadable segments. 215 */ 216 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) { 217 Phdr *phdr = &(sgp->sg_phdr); 218 Os_desc *osp; 219 Aliste idx2; 220 221 /* 222 * If we've already processed a loadable segment, the `scn' 223 * variable will be initialized to the last section that was 224 * part of that segment. Add sufficient padding to this section 225 * to cause the next segments virtual address and file offset to 226 * be the same. 227 */ 228 if (oscn && (phdr->p_type == PT_LOAD)) { 229 Elf_Data * data; 230 size_t size; 231 232 size = (size_t)(S_ROUND(offset, phdr->p_align) - 233 offset); 234 235 if ((data = elf_newdata(oscn)) == NULL) { 236 eprintf(ofl->ofl_lml, ERR_ELF, 237 MSG_INTL(MSG_ELF_NEWDATA), ofl->ofl_name); 238 return (S_ERROR); 239 } 240 if ((data->d_buf = libld_calloc(size, 1)) == 0) 241 return (S_ERROR); 242 243 data->d_type = ELF_T_BYTE; 244 data->d_size = size; 245 data->d_align = 1; 246 data->d_version = ofl->ofl_dehdr->e_version; 247 } 248 249 /* 250 * Traverse the output sections for this segment calculating the 251 * offset of each section. Retain the final section descriptor 252 * as this will be where any padding buffer will be added. 253 */ 254 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) { 255 Shdr *shdr = osp->os_shdr; 256 257 offset = (off_t)S_ROUND(offset, shdr->sh_addralign); 258 offset += shdr->sh_size; 259 260 /* 261 * If this is a NOBITS output section convert all of 262 * its associated input sections into real, null filled, 263 * data buffers, and change the section to PROGBITS. 264 */ 265 if (shdr->sh_type == SHT_NOBITS) 266 shdr->sh_type = SHT_PROGBITS; 267 } 268 269 /* 270 * If this is a loadable segment retain the last output section 271 * descriptor. This acts both as a flag that a loadable 272 * segment has been seen, and as the segment to which a padding 273 * buffer will be added. 274 */ 275 if (phdr->p_type == PT_LOAD) 276 oscn = osp->os_scn; 277 } 278 return (1); 279 } 280 281 /* 282 * Create an output section. The first instance of an input section triggers 283 * the creation of a new output section. 284 */ 285 static uintptr_t 286 create_outsec(Ofl_desc *ofl, Sg_desc *sgp, Os_desc *osp, Word ptype, int shidx, 287 Boolean fixalign) 288 { 289 Elf_Scn *scn; 290 Shdr *shdr; 291 292 /* 293 * Get a section descriptor for the section. 294 */ 295 if ((scn = elf_newscn(ofl->ofl_welf)) == NULL) { 296 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_NEWSCN), 297 ofl->ofl_name); 298 return (S_ERROR); 299 } 300 osp->os_scn = scn; 301 302 /* 303 * Get a new section header table entry and copy the pertinent 304 * information from the in-core descriptor. 305 */ 306 if ((shdr = elf_getshdr(scn)) == NULL) { 307 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_GETSHDR), 308 ofl->ofl_name); 309 return (S_ERROR); 310 } 311 *shdr = *(osp->os_shdr); 312 osp->os_shdr = shdr; 313 314 /* 315 * If this is the first section within a loadable segment, and the 316 * alignment needs to be updated, record this section. 317 */ 318 if ((fixalign == TRUE) && (ptype == PT_LOAD) && (shidx == 1)) 319 sgp->sg_fscn = scn; 320 321 /* 322 * If not building a relocatable object, remove any of the 323 * following flags, as they have been acted upon and are not 324 * meaningful in the output: 325 * SHF_ORDERED, SHF_LINK_ORDER, SHF_GROUP 326 * For relocatable objects, we allow them to propagate to 327 * the output object to be handled by the next linker that 328 * sees them. 329 */ 330 if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) 331 osp->os_shdr->sh_flags &= ~(ALL_SHF_ORDER|SHF_GROUP); 332 333 /* 334 * If this is a TLS section, save it so that the PT_TLS program header 335 * information can be established after the output image has been 336 * initially created. At this point, all TLS input sections are ordered 337 * as they will appear in the output image. 338 */ 339 if ((ofl->ofl_flags & FLG_OF_TLSPHDR) && 340 (osp->os_shdr->sh_flags & SHF_TLS) && 341 (aplist_append(&ofl->ofl_ostlsseg, osp, 342 AL_CNT_OFL_OSTLSSEG) == NULL)) 343 return (S_ERROR); 344 345 return (0); 346 } 347 348 /* 349 * Create the elf structures that allow the input data to be associated with the 350 * new image: 351 * 352 * - define the new elf image using elf_begin(), 353 * 354 * - obtain an elf header for the image, 355 * 356 * - traverse the input segments and create a program header array to define 357 * the required segments, 358 * 359 * - traverse the output sections for each segment assigning a new section 360 * descriptor and section header for each, 361 * 362 * - traverse the input sections associated with each output section and 363 * assign a new data descriptor to each (each output section becomes a 364 * linked list of input data buffers). 365 */ 366 uintptr_t 367 ld_create_outfile(Ofl_desc *ofl) 368 { 369 Sg_desc *sgp; 370 Os_desc *osp; 371 Is_desc *isp; 372 Elf_Data *tlsdata = 0; 373 Aliste idx1; 374 ofl_flag_t flags = ofl->ofl_flags; 375 ofl_flag_t flags1 = ofl->ofl_flags1; 376 size_t ndx; 377 Elf_Cmd cmd; 378 Boolean fixalign = FALSE; 379 int fd, nseg = 0, shidx, dataidx, ptloadidx = 0; 380 381 DBG_CALL(Dbg_basic_create(ofl->ofl_lml)); 382 383 /* 384 * If DF_1_NOHDR or FLG_OF1_VADDR were set, 385 * we need to do alignment adjustment. 386 */ 387 if ((flags1 & FLG_OF1_VADDR) || 388 (ofl->ofl_dtflags_1 & DF_1_NOHDR)) { 389 fixalign = TRUE; 390 } 391 392 if (flags1 & FLG_OF1_MEMORY) { 393 cmd = ELF_C_IMAGE; 394 fd = 0; 395 } else { 396 fd = ofl->ofl_fd; 397 cmd = ELF_C_WRITE; 398 } 399 400 /* 401 * If there are any ordered sections, handle them here. 402 */ 403 if ((ofl->ofl_ordered != NULL) && 404 (ld_sort_ordered(ofl) == S_ERROR)) 405 return (S_ERROR); 406 407 /* 408 * Tell the access library about our new temporary file. 409 */ 410 if ((ofl->ofl_welf = elf_begin(fd, cmd, 0)) == NULL) { 411 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_BEGIN), 412 ofl->ofl_name); 413 return (S_ERROR); 414 } 415 416 /* 417 * Obtain a new Elf header. 418 */ 419 if ((ofl->ofl_nehdr = elf_newehdr(ofl->ofl_welf)) == NULL) { 420 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_NEWEHDR), 421 ofl->ofl_name); 422 return (S_ERROR); 423 } 424 ofl->ofl_nehdr->e_machine = ofl->ofl_dehdr->e_machine; 425 426 DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD)); 427 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) { 428 int frst = 0; 429 Phdr *phdr = &(sgp->sg_phdr); 430 Word ptype = phdr->p_type; 431 Aliste idx2; 432 433 /* 434 * Count the number of segments that will go in the program 435 * header table. If a segment is empty, ignore it. 436 */ 437 if (!(flags & FLG_OF_RELOBJ)) { 438 /* 439 * If the program header type belongs to the os range, 440 * the resulting object is ELFOSABI_SOLARIS. 441 */ 442 if ((ptype >= PT_LOOS) && (ptype <= PT_HIOS)) 443 ofl->ofl_flags |= FLG_OF_OSABI; 444 445 if (ptype == PT_PHDR) { 446 /* 447 * If we are generating an interp section (and 448 * thus an associated PT_INTERP program header 449 * entry) also generate a PT_PHDR program header 450 * entry. This allows the kernel to generate 451 * the appropriate aux vector entries to pass to 452 * the interpreter (refer to exec/elf/elf.c). 453 * Note that if an image was generated with an 454 * interp section, but no associated PT_PHDR 455 * program header entry, the kernel will simply 456 * pass the interpreter an open file descriptor 457 * when the image is executed). 458 */ 459 if (ofl->ofl_osinterp) 460 nseg++; 461 } else if (ptype == PT_INTERP) { 462 if (ofl->ofl_osinterp) 463 nseg++; 464 } else if (ptype == PT_DYNAMIC) { 465 if (flags & FLG_OF_DYNAMIC) 466 nseg++; 467 } else if (ptype == PT_TLS) { 468 if (flags & FLG_OF_TLSPHDR) 469 nseg++; 470 } else if (ptype == PT_SUNW_UNWIND) { 471 if (ofl->ofl_unwindhdr) 472 nseg++; 473 } else if (ptype == PT_SUNWDTRACE) { 474 if (ofl->ofl_dtracesym) 475 nseg++; 476 } else if (ptype == PT_SUNWCAP) { 477 if (ofl->ofl_oscap) 478 nseg++; 479 } else if (ptype == PT_SUNWSTACK) { 480 if ((sgp->sg_flags & FLG_SG_DISABLED) == 0) 481 nseg++; 482 } else if (sgp->sg_flags & FLG_SG_EMPTY) { 483 nseg++; 484 } else if (sgp->sg_osdescs != NULL) { 485 if ((sgp->sg_flags & FLG_SG_PHREQ) == 0) { 486 /* 487 * If this is a segment for which 488 * we are not making a program header, 489 * don't increment nseg 490 */ 491 ptype = (sgp->sg_phdr).p_type = PT_NULL; 492 } else if (ptype != PT_NULL) 493 nseg++; 494 } 495 } 496 497 /* 498 * Establish any processing unique to the first loadable 499 * segment. 500 */ 501 if ((ptype == PT_LOAD) && (ptloadidx == 0)) { 502 ptloadidx++; 503 504 /* 505 * If the first loadable segment is not supposed to 506 * include the ELF or program headers, alignments 507 * of the following segments need to be fixed, 508 * plus a .dynamic FLAGS1 setting is required. 509 */ 510 if (ofl->ofl_dtflags_1 & DF_1_NOHDR) 511 fixalign = TRUE; 512 } 513 514 shidx = 0; 515 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) { 516 Aliste idx3; 517 int os_isdescs_idx; 518 519 dataidx = 0; 520 521 OS_ISDESCS_TRAVERSE(os_isdescs_idx, osp, idx3, isp) { 522 Elf_Data *data; 523 Ifl_desc *ifl = isp->is_file; 524 525 /* 526 * An input section in the list that has 527 * been previously marked to be discarded 528 * should be completely ignored. 529 */ 530 if (isp->is_flags & FLG_IS_DISCARD) 531 continue; 532 533 /* 534 * At this point we know whether a section has 535 * been referenced. If it hasn't, and the whole 536 * file hasn't been referenced (which would have 537 * been caught in ignore_section_processing()), 538 * give a diagnostic (-D unused,detail) or 539 * discard the section if -zignore is in effect. 540 */ 541 if (ifl && 542 (((ifl->ifl_flags & FLG_IF_FILEREF) == 0) || 543 ((ptype == PT_LOAD) && 544 ((isp->is_flags & FLG_IS_SECTREF) == 0) && 545 (isp->is_shdr->sh_size > 0)))) { 546 Lm_list *lml = ofl->ofl_lml; 547 548 if (ifl->ifl_flags & FLG_IF_IGNORE) { 549 isp->is_flags |= FLG_IS_DISCARD; 550 DBG_CALL(Dbg_unused_sec(lml, 551 isp)); 552 continue; 553 } else { 554 DBG_CALL(Dbg_unused_sec(lml, 555 isp)); 556 } 557 } 558 559 /* 560 * If this section provides no data, and isn't 561 * referenced, then it can be discarded as well. 562 * Note, if this is the first input section 563 * associated to an output section, let it 564 * through, there may be a legitimate reason why 565 * the user wants a null section. Discarding 566 * additional sections is intended to remove the 567 * empty clutter the compilers have a habit of 568 * creating. Don't provide an unused diagnostic 569 * as these sections aren't typically the users 570 * creation. 571 */ 572 if (ifl && dataidx && 573 ((isp->is_flags & FLG_IS_SECTREF) == 0) && 574 (isp->is_shdr->sh_size == 0)) { 575 isp->is_flags |= FLG_IS_DISCARD; 576 continue; 577 } 578 579 /* 580 * The first input section triggers the creation 581 * of the associated output section. 582 */ 583 if (osp->os_scn == NULL) { 584 shidx++; 585 586 if (create_outsec(ofl, sgp, osp, ptype, 587 shidx, fixalign) == S_ERROR) 588 return (S_ERROR); 589 } 590 591 dataidx++; 592 593 /* 594 * Create a new output data buffer for each 595 * input data buffer, thus linking the new 596 * buffers to the new elf output structures. 597 * Simply make the new data buffers point to 598 * the old data. 599 */ 600 if ((data = elf_newdata(osp->os_scn)) == NULL) { 601 eprintf(ofl->ofl_lml, ERR_ELF, 602 MSG_INTL(MSG_ELF_NEWDATA), 603 ofl->ofl_name); 604 return (S_ERROR); 605 } 606 *data = *(isp->is_indata); 607 isp->is_indata = data; 608 609 if ((fixalign == TRUE) && (ptype == PT_LOAD) && 610 (shidx == 1) && (dataidx == 1)) 611 data->d_align = sgp->sg_align; 612 613 /* 614 * Save the first TLS data buffer, as this is 615 * the start of the TLS segment. Realign this 616 * buffer based on the alignment requirements 617 * of all the TLS input sections. 618 */ 619 if ((flags & FLG_OF_TLSPHDR) && 620 (isp->is_shdr->sh_flags & SHF_TLS)) { 621 if (tlsdata == 0) 622 tlsdata = data; 623 tlsdata->d_align = 624 ld_lcm(tlsdata->d_align, 625 isp->is_shdr->sh_addralign); 626 } 627 628 #if defined(_ELF64) && defined(_ILP32) 629 /* 630 * 4106312, the 32-bit ELF64 version of ld 631 * needs to be able to create large .bss 632 * sections. The d_size member of Elf_Data 633 * only allows 32-bits in _ILP32, so we build 634 * multiple data-items that each fit into 32- 635 * bits. libelf (4106398) can summ these up 636 * into a 64-bit quantity. This only works 637 * for NOBITS sections which don't have any 638 * real data to maintain and don't require 639 * large file support. 640 */ 641 if (isp->is_shdr->sh_type == SHT_NOBITS) { 642 Xword sz = isp->is_shdr->sh_size; 643 644 while (sz >> 32) { 645 data->d_size = SIZE_MAX; 646 sz -= (Xword)SIZE_MAX; 647 648 data = elf_newdata(osp->os_scn); 649 if (data == NULL) 650 return (S_ERROR); 651 } 652 data->d_size = (size_t)sz; 653 } 654 #endif 655 656 /* 657 * If this segment requires rounding realign the 658 * first data buffer associated with the first 659 * section. 660 */ 661 if ((frst++ == 0) && 662 (sgp->sg_flags & FLG_SG_ROUND)) { 663 Xword align; 664 665 if (data->d_align) 666 align = (Xword) 667 S_ROUND(data->d_align, 668 sgp->sg_round); 669 else 670 align = sgp->sg_round; 671 672 data->d_align = (size_t)align; 673 } 674 } 675 676 /* 677 * Clear the szoutrels counter so that it can be used 678 * again in the building of relocs. See machrel.c. 679 */ 680 osp->os_szoutrels = 0; 681 } 682 } 683 684 /* 685 * Did we use ELF features from the osabi range? If so, 686 * update the ELF header osabi fields. If this doesn't happen, 687 * those fields remain 0, reflecting a generic System V ELF ABI. 688 */ 689 if (ofl->ofl_flags & FLG_OF_OSABI) { 690 ofl->ofl_nehdr->e_ident[EI_OSABI] = ELFOSABI_SOLARIS; 691 ofl->ofl_nehdr->e_ident[EI_ABIVERSION] = EAV_SUNW_CURRENT; 692 } 693 694 /* 695 * Build an empty PHDR. 696 */ 697 if (nseg) { 698 if ((ofl->ofl_phdr = elf_newphdr(ofl->ofl_welf, 699 nseg)) == NULL) { 700 eprintf(ofl->ofl_lml, ERR_ELF, 701 MSG_INTL(MSG_ELF_NEWPHDR), ofl->ofl_name); 702 return (S_ERROR); 703 } 704 } 705 706 /* 707 * If we need to generate a memory model, pad the image. 708 */ 709 if (flags1 & FLG_OF1_MEMORY) { 710 if (pad_outfile(ofl) == S_ERROR) 711 return (S_ERROR); 712 } 713 714 /* 715 * After all the basic input file processing, all data pointers are 716 * referencing two types of memory: 717 * 718 * - allocated memory, ie. elf structures, internal link editor 719 * structures, and any new sections that have been created. 720 * 721 * - original input file mmap'ed memory, ie. the actual data 722 * sections of the input file images. 723 * 724 * Up until now, the only memory modifications have been carried out on 725 * the allocated memory. Before carrying out any relocations, write the 726 * new output file image and reassign any necessary data pointers to the 727 * output files memory image. This insures that any relocation 728 * modifications are made to the output file image and not to the input 729 * file image, thus preventing the creation of dirty pages and reducing 730 * the overall swap space requirement. 731 * 732 * Write out the elf structure so as to create the new file image. 733 */ 734 if ((ofl->ofl_size = (size_t)elf_update(ofl->ofl_welf, 735 ELF_C_WRIMAGE)) == (size_t)-1) { 736 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_UPDATE), 737 ofl->ofl_name); 738 return (S_ERROR); 739 } 740 741 /* 742 * Initialize the true `ofl' information with the memory images address 743 * and size. This will be used to write() out the image once any 744 * relocation processing has been completed. We also use this image 745 * information to setup a new Elf descriptor, which is used to obtain 746 * all the necessary elf pointers within the new output image. 747 */ 748 if ((ofl->ofl_elf = elf_begin(0, ELF_C_IMAGE, 749 ofl->ofl_welf)) == NULL) { 750 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_BEGIN), 751 ofl->ofl_name); 752 return (S_ERROR); 753 } 754 if ((ofl->ofl_nehdr = elf_getehdr(ofl->ofl_elf)) == NULL) { 755 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_GETEHDR), 756 ofl->ofl_name); 757 return (S_ERROR); 758 } 759 if (!(flags & FLG_OF_RELOBJ)) 760 if ((ofl->ofl_phdr = elf_getphdr(ofl->ofl_elf)) == NULL) { 761 eprintf(ofl->ofl_lml, ERR_ELF, 762 MSG_INTL(MSG_ELF_GETPHDR), ofl->ofl_name); 763 return (S_ERROR); 764 } 765 766 /* 767 * Reinitialize the section descriptors, section headers and obtain new 768 * output data buffer pointers (these will be used to perform any 769 * relocations). 770 */ 771 ndx = 0; 772 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) { 773 Phdr *_phdr = &(sgp->sg_phdr); 774 Os_desc *osp; 775 Aliste idx2; 776 Boolean recorded = FALSE; 777 778 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) { 779 /* 780 * Make sure that an output section was originally 781 * created. Input sections that had been marked as 782 * discarded may have made an output section 783 * unnecessary. Remove this alist entry so that 784 * future output section descriptor processing doesn't 785 * have to compensate for this empty section. 786 */ 787 if (osp->os_scn == NULL) { 788 aplist_delete(sgp->sg_osdescs, &idx2); 789 continue; 790 } 791 if ((osp->os_scn = 792 elf_getscn(ofl->ofl_elf, ++ndx)) == NULL) { 793 eprintf(ofl->ofl_lml, ERR_ELF, 794 MSG_INTL(MSG_ELF_GETSCN), ofl->ofl_name, 795 ndx); 796 return (S_ERROR); 797 } 798 if ((osp->os_shdr = 799 elf_getshdr(osp->os_scn)) == NULL) { 800 eprintf(ofl->ofl_lml, ERR_ELF, 801 MSG_INTL(MSG_ELF_GETSHDR), ofl->ofl_name); 802 return (S_ERROR); 803 } 804 if ((fixalign == TRUE) && sgp->sg_fscn && 805 (recorded == FALSE)) { 806 size_t fndx; 807 Elf_Scn *scn; 808 809 scn = sgp->sg_fscn; 810 if ((fndx = elf_ndxscn(scn)) == SHN_UNDEF) { 811 eprintf(ofl->ofl_lml, ERR_ELF, 812 MSG_INTL(MSG_ELF_NDXSCN), 813 ofl->ofl_name); 814 return (S_ERROR); 815 } 816 if (ndx == fndx) { 817 sgp->sg_fscn = osp->os_scn; 818 recorded = TRUE; 819 } 820 } 821 822 if ((osp->os_outdata = 823 elf_getdata(osp->os_scn, NULL)) == NULL) { 824 eprintf(ofl->ofl_lml, ERR_ELF, 825 MSG_INTL(MSG_ELF_GETDATA), ofl->ofl_name); 826 return (S_ERROR); 827 } 828 829 /* 830 * If this section is part of a loadable segment insure 831 * that the segments alignment is appropriate. 832 */ 833 if (_phdr->p_type == PT_LOAD) { 834 _phdr->p_align = ld_lcm(_phdr->p_align, 835 osp->os_shdr->sh_addralign); 836 } 837 } 838 } 839 return (1); 840 } 841