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 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Copyright (c) 1988 AT&T 29 * All Rights Reserved 30 */ 31 32 /* 33 * Copyright (c) 2018, Joyent, Inc. 34 */ 35 36 #include <memory.h> 37 #include <malloc.h> 38 #include <limits.h> 39 40 #include <sgs.h> 41 #include "decl.h" 42 #include "msg.h" 43 44 /* 45 * This module is compiled twice, the second time having 46 * -D_ELF64 defined. The following set of macros, along 47 * with machelf.h, represent the differences between the 48 * two compilations. Be careful *not* to add any class- 49 * dependent code (anything that has elf32 or elf64 in the 50 * name) to this code without hiding it behind a switch- 51 * able macro like these. 52 */ 53 #if defined(_ELF64) 54 55 #define FSZ_LONG ELF64_FSZ_XWORD 56 #define ELFCLASS ELFCLASS64 57 #define _elf_snode_init _elf64_snode_init 58 #define _elfxx_cookscn _elf64_cookscn 59 #define _elf_upd_lib _elf64_upd_lib 60 #define elf_fsize elf64_fsize 61 #define _elf_entsz _elf64_entsz 62 #define _elf_msize _elf64_msize 63 #define _elf_upd_usr _elf64_upd_usr 64 #define wrt wrt64 65 #define elf_xlatetof elf64_xlatetof 66 #define _elfxx_update _elf64_update 67 #define _elfxx_swap_wrimage _elf64_swap_wrimage 68 69 #else /* ELF32 */ 70 71 #define FSZ_LONG ELF32_FSZ_WORD 72 #define ELFCLASS ELFCLASS32 73 #define _elf_snode_init _elf32_snode_init 74 #define _elfxx_cookscn _elf32_cookscn 75 #define _elf_upd_lib _elf32_upd_lib 76 #define elf_fsize elf32_fsize 77 #define _elf_entsz _elf32_entsz 78 #define _elf_msize _elf32_msize 79 #define _elf_upd_usr _elf32_upd_usr 80 #define wrt wrt32 81 #define elf_xlatetof elf32_xlatetof 82 #define _elfxx_update _elf32_update 83 #define _elfxx_swap_wrimage _elf32_swap_wrimage 84 85 #endif /* ELF64 */ 86 87 88 #if !(defined(_LP64) && defined(_ELF64)) 89 #define TEST_SIZE 90 91 /* 92 * Handle the decision of whether the current linker can handle the 93 * desired object size, and if not, which error to issue. 94 * 95 * Input is the desired size. On failure, an error has been issued 96 * and 0 is returned. On success, 1 is returned. 97 */ 98 static int 99 test_size(Lword hi) 100 { 101 #ifndef _LP64 /* 32-bit linker */ 102 /* 103 * A 32-bit libelf is limited to a 2GB output file. This limit 104 * is due to the fact that off_t is a signed value, and that 105 * libelf cannot support large file support: 106 * - ABI reasons 107 * - Memory use generally is 2x output file size anyway, 108 * so lifting the file size limit will just send 109 * you crashing into the 32-bit VM limit. 110 * If the output is an ELFCLASS64 object, or an ELFCLASS32 object 111 * under 4GB, switching to the 64-bit version of libelf will help. 112 * However, an ELFCLASS32 object must not exceed 4GB. 113 */ 114 if (hi > INT_MAX) { /* Bigger than 2GB */ 115 #ifndef _ELF64 116 /* ELFCLASS32 object is fundamentally too big? */ 117 if (hi > UINT_MAX) { 118 _elf_seterr(EFMT_FBIG_CLASS32, 0); 119 return (0); 120 } 121 #endif /* _ELF64 */ 122 123 /* Should switch to the 64-bit libelf? */ 124 _elf_seterr(EFMT_FBIG_LARGEFILE, 0); 125 return (0); 126 } 127 #endif /* !_LP64 */ 128 129 130 #if defined(_LP64) && !defined(_ELF64) /* 64-bit linker, ELFCLASS32 */ 131 /* 132 * A 64-bit linker can produce any size output 133 * file, but if the resulting file is ELFCLASS32, 134 * it must not exceed 4GB. 135 */ 136 if (hi > UINT_MAX) { 137 _elf_seterr(EFMT_FBIG_CLASS32, 0); 138 return (0); 139 } 140 #endif 141 142 return (1); 143 } 144 #endif /* TEST_SIZE */ 145 146 /* 147 * Output file update 148 * These functions walk an Elf structure, update its information, 149 * and optionally write the output file. Because the application 150 * may control of the output file layout, two upd_... routines 151 * exist. They're similar but too different to merge cleanly. 152 * 153 * The library defines a "dirty" bit to force parts of the file 154 * to be written on update. These routines ignore the dirty bit 155 * and do everything. A minimal update routine might be useful 156 * someday. 157 */ 158 159 static size_t 160 _elf_upd_lib(Elf * elf) 161 { 162 Lword hi; 163 Lword hibit; 164 Elf_Scn * s; 165 register Lword sz; 166 Ehdr * eh = elf->ed_ehdr; 167 unsigned ver = eh->e_version; 168 register char *p = (char *)eh->e_ident; 169 size_t scncnt; 170 171 /* 172 * Ehdr and Phdr table go first 173 */ 174 p[EI_MAG0] = ELFMAG0; 175 p[EI_MAG1] = ELFMAG1; 176 p[EI_MAG2] = ELFMAG2; 177 p[EI_MAG3] = ELFMAG3; 178 p[EI_CLASS] = ELFCLASS; 179 /* LINTED */ 180 p[EI_VERSION] = (Byte)ver; 181 hi = elf_fsize(ELF_T_EHDR, 1, ver); 182 /* LINTED */ 183 eh->e_ehsize = (Half)hi; 184 if (eh->e_phnum != 0) { 185 /* LINTED */ 186 eh->e_phentsize = (Half)elf_fsize(ELF_T_PHDR, 1, ver); 187 /* LINTED */ 188 eh->e_phoff = (Off)hi; 189 hi += eh->e_phentsize * eh->e_phnum; 190 } else { 191 eh->e_phoff = 0; 192 eh->e_phentsize = 0; 193 } 194 195 /* 196 * Obtain the first section header. Typically, this section has NULL 197 * contents, however in the case of Extended ELF Sections this section 198 * is used to hold an alternative e_shnum, e_shstrndx and e_phnum. 199 * On initial allocation (see _elf_snode) the elements of this section 200 * would have been zeroed. The e_shnum is initialized later, after the 201 * section header count has been determined. The e_shstrndx and 202 * e_phnum may have already been initialized by the caller (for example, 203 * gelf_update_shdr() in mcs(1)). 204 */ 205 if ((s = elf->ed_hdscn) == 0) { 206 eh->e_shnum = 0; 207 scncnt = 0; 208 } else { 209 s = s->s_next; 210 scncnt = 1; 211 } 212 213 /* 214 * Loop through sections. Compute section size before changing hi. 215 * Allow null buffers for NOBITS. 216 */ 217 hibit = 0; 218 for (; s != 0; s = s->s_next) { 219 register Dnode *d; 220 register Lword fsz, j; 221 Shdr *sh = s->s_shdr; 222 223 scncnt++; 224 if (sh->sh_type == SHT_NULL) { 225 *sh = _elf_snode_init.sb_shdr; 226 continue; 227 } 228 229 if ((s->s_myflags & SF_READY) == 0) 230 (void) _elfxx_cookscn(s); 231 232 sh->sh_addralign = 1; 233 if ((sz = (Lword)_elf_entsz(elf, sh->sh_type, ver)) != 0) 234 /* LINTED */ 235 sh->sh_entsize = (Half)sz; 236 sz = 0; 237 for (d = s->s_hdnode; d != 0; d = d->db_next) { 238 if ((fsz = elf_fsize(d->db_data.d_type, 239 1, ver)) == 0) 240 return (0); 241 242 j = _elf_msize(d->db_data.d_type, ver); 243 fsz *= (d->db_data.d_size / j); 244 d->db_osz = (size_t)fsz; 245 if ((j = d->db_data.d_align) > 1) { 246 if (j > sh->sh_addralign) 247 sh->sh_addralign = (Xword)j; 248 249 if (sz % j != 0) 250 sz += j - sz % j; 251 } 252 d->db_data.d_off = (off_t)sz; 253 d->db_xoff = sz; 254 sz += fsz; 255 } 256 257 sh->sh_size = (Xword) sz; 258 /* 259 * We want to take into account the offsets for NOBITS 260 * sections and let the "sh_offsets" point to where 261 * the section would 'conceptually' fit within 262 * the file (as required by the ABI). 263 * 264 * But - we must also make sure that the NOBITS does 265 * not take up any actual space in the file. We preserve 266 * the actual offset into the file in the 'hibit' variable. 267 * When we come to the first non-NOBITS section after a 268 * encountering a NOBITS section the hi counter is restored 269 * to its proper place in the file. 270 */ 271 if (sh->sh_type == SHT_NOBITS) { 272 if (hibit == 0) 273 hibit = hi; 274 } else { 275 if (hibit) { 276 hi = hibit; 277 hibit = 0; 278 } 279 } 280 j = sh->sh_addralign; 281 if ((fsz = hi % j) != 0) 282 hi += j - fsz; 283 284 /* LINTED */ 285 sh->sh_offset = (Off)hi; 286 hi += sz; 287 } 288 289 /* 290 * if last section was a 'NOBITS' section then we need to 291 * restore the 'hi' counter to point to the end of the last 292 * non 'NOBITS' section. 293 */ 294 if (hibit) { 295 hi = hibit; 296 hibit = 0; 297 } 298 299 /* 300 * Shdr table last 301 */ 302 if (scncnt != 0) { 303 if (hi % FSZ_LONG != 0) 304 hi += FSZ_LONG - hi % FSZ_LONG; 305 /* LINTED */ 306 eh->e_shoff = (Off)hi; 307 /* 308 * If we are using 'extended sections' then the 309 * e_shnum is stored in the sh_size field of the 310 * first section header. 311 * 312 * NOTE: we set e_shnum to '0' because it's specified 313 * this way in the gABI, and in the hopes that 314 * this will cause less problems to unaware 315 * tools then if we'd set it to SHN_XINDEX (0xffff). 316 */ 317 if (scncnt < SHN_LORESERVE) 318 eh->e_shnum = scncnt; 319 else { 320 Shdr *sh; 321 sh = (Shdr *)elf->ed_hdscn->s_shdr; 322 sh->sh_size = scncnt; 323 eh->e_shnum = 0; 324 } 325 /* LINTED */ 326 eh->e_shentsize = (Half)elf_fsize(ELF_T_SHDR, 1, ver); 327 hi += eh->e_shentsize * scncnt; 328 } else { 329 eh->e_shoff = 0; 330 eh->e_shentsize = 0; 331 } 332 333 #ifdef TEST_SIZE 334 if (test_size(hi) == 0) 335 return (0); 336 #endif 337 338 return ((size_t)hi); 339 } 340 341 342 343 static size_t 344 _elf_upd_usr(Elf * elf) 345 { 346 Lword hi; 347 Elf_Scn * s; 348 register Lword sz; 349 Ehdr * eh = elf->ed_ehdr; 350 unsigned ver = eh->e_version; 351 register char *p = (char *)eh->e_ident; 352 size_t scncnt; 353 354 /* 355 * Ehdr and Phdr table go first 356 */ 357 p[EI_MAG0] = ELFMAG0; 358 p[EI_MAG1] = ELFMAG1; 359 p[EI_MAG2] = ELFMAG2; 360 p[EI_MAG3] = ELFMAG3; 361 p[EI_CLASS] = ELFCLASS; 362 /* LINTED */ 363 p[EI_VERSION] = (Byte)ver; 364 hi = elf_fsize(ELF_T_EHDR, 1, ver); 365 /* LINTED */ 366 eh->e_ehsize = (Half)hi; 367 368 /* 369 * If phnum is zero, phoff "should" be zero too, 370 * but the application is responsible for it. 371 * Allow a non-zero value here and update the 372 * hi water mark accordingly. 373 */ 374 375 if (eh->e_phnum != 0) 376 /* LINTED */ 377 eh->e_phentsize = (Half)elf_fsize(ELF_T_PHDR, 1, ver); 378 else 379 eh->e_phentsize = 0; 380 if ((sz = eh->e_phoff + eh->e_phentsize * eh->e_phnum) > hi) 381 hi = sz; 382 383 /* 384 * Loop through sections, skipping index zero. 385 * Compute section size before changing hi. 386 * Allow null buffers for NOBITS. 387 */ 388 389 if ((s = elf->ed_hdscn) == 0) { 390 eh->e_shnum = 0; 391 scncnt = 0; 392 } else { 393 scncnt = 1; 394 s = s->s_next; 395 } 396 for (; s != 0; s = s->s_next) { 397 register Dnode *d; 398 register Lword fsz, j; 399 Shdr *sh = s->s_shdr; 400 401 if ((s->s_myflags & SF_READY) == 0) 402 (void) _elfxx_cookscn(s); 403 404 ++scncnt; 405 sz = 0; 406 for (d = s->s_hdnode; d != 0; d = d->db_next) { 407 if ((fsz = elf_fsize(d->db_data.d_type, 1, 408 ver)) == 0) 409 return (0); 410 j = _elf_msize(d->db_data.d_type, ver); 411 fsz *= (d->db_data.d_size / j); 412 d->db_osz = (size_t)fsz; 413 414 if ((sh->sh_type != SHT_NOBITS) && 415 ((j = (d->db_data.d_off + d->db_osz)) > sz)) 416 sz = j; 417 } 418 if (sh->sh_size < sz) { 419 _elf_seterr(EFMT_SCNSZ, 0); 420 return (0); 421 } 422 if ((sh->sh_type != SHT_NOBITS) && 423 (hi < sh->sh_offset + sh->sh_size)) 424 hi = sh->sh_offset + sh->sh_size; 425 } 426 427 /* 428 * Shdr table last. Comment above for phnum/phoff applies here. 429 */ 430 if (scncnt != 0) { 431 /* LINTED */ 432 eh->e_shentsize = (Half)elf_fsize(ELF_T_SHDR, 1, ver); 433 if (scncnt < SHN_LORESERVE) { 434 eh->e_shnum = scncnt; 435 } else { 436 Shdr *sh; 437 sh = (Shdr *)elf->ed_hdscn->s_shdr; 438 sh->sh_size = scncnt; 439 eh->e_shnum = 0; 440 } 441 } else { 442 eh->e_shentsize = 0; 443 } 444 445 if ((sz = eh->e_shoff + eh->e_shentsize * scncnt) > hi) 446 hi = sz; 447 448 #ifdef TEST_SIZE 449 if (test_size(hi) == 0) 450 return (0); 451 #endif 452 453 return ((size_t)hi); 454 } 455 456 457 static size_t 458 wrt(Elf * elf, Xword outsz, unsigned fill, int update_cmd) 459 { 460 Elf_Data dst, src; 461 unsigned flag; 462 Xword hi, sz; 463 char *image; 464 Elf_Scn *s; 465 Ehdr *eh = elf->ed_ehdr; 466 unsigned ver = eh->e_version; 467 unsigned encode; 468 int byte; 469 _elf_execfill_func_t *execfill_func; 470 471 /* 472 * If this is an ELF_C_WRIMAGE write, then we encode into the 473 * byte order of the system we are running on rather than that of 474 * of the object. For ld.so.1, this is the same order, but 475 * for 'ld', it might not be in the case where we are cross 476 * linking an object for a different target. In this later case, 477 * the linker-host byte order is necessary so that the linker can 478 * manipulate the resulting image. It is expected that the linker 479 * will call elf_swap_wrimage() if necessary to convert the image 480 * to the target byte order. 481 */ 482 encode = (update_cmd == ELF_C_WRIMAGE) ? _elf_sys_encoding() : 483 eh->e_ident[EI_DATA]; 484 485 /* 486 * Two issues can cause trouble for the output file. 487 * First, begin() with ELF_C_RDWR opens a file for both 488 * read and write. On the write update(), the library 489 * has to read everything it needs before truncating 490 * the file. Second, using mmap for both read and write 491 * is too tricky. Consequently, the library disables mmap 492 * on the read side. Using mmap for the output saves swap 493 * space, because that mapping is SHARED, not PRIVATE. 494 * 495 * If the file is write-only, there can be nothing of 496 * interest to bother with. 497 * 498 * The following reads the entire file, which might be 499 * more than necessary. Better safe than sorry. 500 */ 501 502 if ((elf->ed_myflags & EDF_READ) && 503 (_elf_vm(elf, (size_t)0, elf->ed_fsz) != OK_YES)) 504 return (0); 505 506 flag = elf->ed_myflags & EDF_WRALLOC; 507 if ((image = _elf_outmap(elf->ed_fd, outsz, &flag)) == 0) 508 return (0); 509 510 if (flag == 0) 511 elf->ed_myflags |= EDF_IMALLOC; 512 513 /* 514 * If an error occurs below, a "dirty" bit may be cleared 515 * improperly. To save a second pass through the file, 516 * this code sets the dirty bit on the elf descriptor 517 * when an error happens, assuming that will "cover" any 518 * accidents. 519 */ 520 521 /* 522 * Hi is needed only when 'fill' is non-zero. 523 * Fill is non-zero only when the library 524 * calculates file/section/data buffer offsets. 525 * The lib guarantees they increase monotonically. 526 * That guarantees proper filling below. 527 */ 528 529 530 /* 531 * Ehdr first 532 */ 533 534 src.d_buf = (Elf_Void *)eh; 535 src.d_type = ELF_T_EHDR; 536 src.d_size = sizeof (Ehdr); 537 src.d_version = EV_CURRENT; 538 dst.d_buf = (Elf_Void *)image; 539 dst.d_size = eh->e_ehsize; 540 dst.d_version = ver; 541 if (elf_xlatetof(&dst, &src, encode) == 0) 542 return (0); 543 elf->ed_ehflags &= ~ELF_F_DIRTY; 544 hi = eh->e_ehsize; 545 546 /* 547 * Phdr table if one exists 548 */ 549 550 if (eh->e_phnum != 0) { 551 unsigned work; 552 /* 553 * Unlike other library data, phdr table is 554 * in the user version. Change src buffer 555 * version here, fix it after translation. 556 */ 557 558 src.d_buf = (Elf_Void *)elf->ed_phdr; 559 src.d_type = ELF_T_PHDR; 560 src.d_size = elf->ed_phdrsz; 561 ELFACCESSDATA(work, _elf_work) 562 src.d_version = work; 563 dst.d_buf = (Elf_Void *)(image + eh->e_phoff); 564 dst.d_size = eh->e_phnum * eh->e_phentsize; 565 hi = (Xword)(eh->e_phoff + dst.d_size); 566 if (elf_xlatetof(&dst, &src, encode) == 0) { 567 elf->ed_uflags |= ELF_F_DIRTY; 568 return (0); 569 } 570 elf->ed_phflags &= ~ELF_F_DIRTY; 571 src.d_version = EV_CURRENT; 572 } 573 574 /* 575 * Loop through sections 576 */ 577 578 ELFACCESSDATA(byte, _elf_byte); 579 ELFACCESSDATA(execfill_func, _elf_execfill_func); 580 for (s = elf->ed_hdscn; s != 0; s = s->s_next) { 581 register Dnode *d, *prevd; 582 Xword off = 0; 583 Shdr *sh = s->s_shdr; 584 char *start = image + sh->sh_offset; 585 char *here; 586 _elf_execfill_func_t *execfill; 587 588 /* Only use the execfill function on SHF_EXECINSTR sections */ 589 execfill = (sh->sh_flags & SHF_EXECINSTR) ? 590 execfill_func : NULL; 591 592 /* 593 * Just "clean" DIRTY flag for "empty" sections. Even if 594 * NOBITS needs padding, the next thing in the 595 * file will provide it. (And if this NOBITS is 596 * the last thing in the file, no padding needed.) 597 */ 598 if ((sh->sh_type == SHT_NOBITS) || 599 (sh->sh_type == SHT_NULL)) { 600 d = s->s_hdnode, prevd = 0; 601 for (; d != 0; prevd = d, d = d->db_next) 602 d->db_uflags &= ~ELF_F_DIRTY; 603 continue; 604 } 605 /* 606 * Clear out the memory between the end of the last 607 * section and the begining of this section. 608 */ 609 if (fill && (sh->sh_offset > hi)) { 610 sz = sh->sh_offset - hi; 611 (void) memset(start - sz, byte, sz); 612 } 613 614 615 for (d = s->s_hdnode, prevd = 0; 616 d != 0; prevd = d, d = d->db_next) { 617 d->db_uflags &= ~ELF_F_DIRTY; 618 here = start + d->db_data.d_off; 619 620 /* 621 * Clear out the memory between the end of the 622 * last update and the start of this data buffer. 623 * 624 * These buffers represent input sections that have 625 * been concatenated into an output section, so if 626 * the output section is executable (SHF_EXECINSTR) 627 * and a fill function has been registered, use the 628 * function. Otherwise, use the fill byte. 629 */ 630 if (fill && (d->db_data.d_off > off)) { 631 sz = (Xword)(d->db_data.d_off - off); 632 if (execfill != NULL) 633 (* execfill)(start, 634 here - start - sz, sz); 635 else 636 (void) memset(here - sz, byte, sz); 637 } 638 639 if ((d->db_myflags & DBF_READY) == 0) { 640 SCNLOCK(s); 641 if (_elf_locked_getdata(s, &prevd->db_data) != 642 &d->db_data) { 643 elf->ed_uflags |= ELF_F_DIRTY; 644 SCNUNLOCK(s); 645 return (0); 646 } 647 SCNUNLOCK(s); 648 } 649 dst.d_buf = (Elf_Void *)here; 650 dst.d_size = d->db_osz; 651 652 /* 653 * Copy the translated bits out to the destination 654 * image. 655 */ 656 if (elf_xlatetof(&dst, &d->db_data, encode) == 0) { 657 elf->ed_uflags |= ELF_F_DIRTY; 658 return (0); 659 } 660 661 off = (Xword)(d->db_data.d_off + dst.d_size); 662 } 663 hi = sh->sh_offset + sh->sh_size; 664 } 665 666 /* 667 * Shdr table last 668 */ 669 670 if (fill && (eh->e_shoff > hi)) { 671 sz = eh->e_shoff - hi; 672 (void) memset(image + hi, byte, sz); 673 } 674 675 src.d_type = ELF_T_SHDR; 676 src.d_size = sizeof (Shdr); 677 dst.d_buf = (Elf_Void *)(image + eh->e_shoff); 678 dst.d_size = eh->e_shentsize; 679 for (s = elf->ed_hdscn; s != 0; s = s->s_next) { 680 assert((uintptr_t)dst.d_buf < ((uintptr_t)image + outsz)); 681 s->s_shflags &= ~ELF_F_DIRTY; 682 s->s_uflags &= ~ELF_F_DIRTY; 683 src.d_buf = s->s_shdr; 684 685 if (elf_xlatetof(&dst, &src, encode) == 0) { 686 elf->ed_uflags |= ELF_F_DIRTY; 687 return (0); 688 } 689 690 dst.d_buf = (char *)dst.d_buf + eh->e_shentsize; 691 } 692 /* 693 * ELF_C_WRIMAGE signifyes that we build the memory image, but 694 * that we do not actually write it to disk. This is used 695 * by ld(1) to build up a full image of an elf file and then 696 * to process the file before it's actually written out to 697 * disk. This saves ld(1) the overhead of having to write 698 * the image out to disk twice. 699 */ 700 if (update_cmd == ELF_C_WRIMAGE) { 701 elf->ed_uflags &= ~ELF_F_DIRTY; 702 elf->ed_wrimage = image; 703 elf->ed_wrimagesz = outsz; 704 return (outsz); 705 } 706 707 if (_elf_outsync(elf->ed_fd, image, outsz, 708 ((elf->ed_myflags & EDF_IMALLOC) ? 0 : 1)) != 0) { 709 elf->ed_uflags &= ~ELF_F_DIRTY; 710 elf->ed_myflags &= ~EDF_IMALLOC; 711 return (outsz); 712 } 713 714 elf->ed_uflags |= ELF_F_DIRTY; 715 return (0); 716 } 717 718 719 720 721 /* 722 * The following is a private interface between the linkers (ld & ld.so.1) 723 * and libelf: 724 * 725 * elf_update(elf, ELF_C_WRIMAGE) 726 * This will cause full image representing the elf file 727 * described by the elf pointer to be built in memory. If the 728 * elf pointer has a valid file descriptor associated with it 729 * we will attempt to build the memory image from mmap()'ed 730 * storage. If the elf descriptor does not have a valid 731 * file descriptor (opened with elf_begin(0, ELF_C_IMAGE, 0)) 732 * then the image will be allocated from dynamic memory (malloc()). 733 * 734 * elf_update() will return the size of the memory image built 735 * when sucessful. 736 * 737 * When a subsequent call to elf_update() with ELF_C_WRITE as 738 * the command is performed it will sync the image created 739 * by ELF_C_WRIMAGE to disk (if fd available) and 740 * free the memory allocated. 741 */ 742 743 off_t 744 _elfxx_update(Elf * elf, Elf_Cmd cmd) 745 { 746 size_t sz; 747 unsigned u; 748 Ehdr *eh = elf->ed_ehdr; 749 750 ELFWLOCK(elf) 751 switch (cmd) { 752 default: 753 _elf_seterr(EREQ_UPDATE, 0); 754 ELFUNLOCK(elf) 755 return (-1); 756 757 case ELF_C_WRIMAGE: 758 if ((elf->ed_myflags & EDF_WRITE) == 0) { 759 _elf_seterr(EREQ_UPDWRT, 0); 760 ELFUNLOCK(elf) 761 return (-1); 762 } 763 break; 764 case ELF_C_WRITE: 765 if ((elf->ed_myflags & EDF_WRITE) == 0) { 766 _elf_seterr(EREQ_UPDWRT, 0); 767 ELFUNLOCK(elf) 768 return (-1); 769 } 770 if (elf->ed_wrimage) { 771 if (elf->ed_myflags & EDF_WRALLOC) { 772 free(elf->ed_wrimage); 773 /* 774 * The size is still returned even 775 * though nothing is actually written 776 * out. This is just to be consistant 777 * with the rest of the interface. 778 */ 779 sz = elf->ed_wrimagesz; 780 elf->ed_wrimage = 0; 781 elf->ed_wrimagesz = 0; 782 ELFUNLOCK(elf); 783 return ((off_t)sz); 784 } 785 sz = _elf_outsync(elf->ed_fd, elf->ed_wrimage, 786 elf->ed_wrimagesz, 787 (elf->ed_myflags & EDF_IMALLOC ? 0 : 1)); 788 elf->ed_myflags &= ~EDF_IMALLOC; 789 elf->ed_wrimage = 0; 790 elf->ed_wrimagesz = 0; 791 ELFUNLOCK(elf); 792 return ((off_t)sz); 793 } 794 /* FALLTHROUGH */ 795 case ELF_C_NULL: 796 break; 797 } 798 799 if (eh == 0) { 800 _elf_seterr(ESEQ_EHDR, 0); 801 ELFUNLOCK(elf) 802 return (-1); 803 } 804 805 if ((u = eh->e_version) > EV_CURRENT) { 806 _elf_seterr(EREQ_VER, 0); 807 ELFUNLOCK(elf) 808 return (-1); 809 } 810 811 if (u == EV_NONE) 812 eh->e_version = EV_CURRENT; 813 814 if ((u = eh->e_ident[EI_DATA]) == ELFDATANONE) { 815 unsigned encode; 816 817 ELFACCESSDATA(encode, _elf_encode) 818 if (encode == ELFDATANONE) { 819 _elf_seterr(EREQ_ENCODE, 0); 820 ELFUNLOCK(elf) 821 return (-1); 822 } 823 /* LINTED */ 824 eh->e_ident[EI_DATA] = (Byte)encode; 825 } 826 827 u = 1; 828 if (elf->ed_uflags & ELF_F_LAYOUT) { 829 sz = _elf_upd_usr(elf); 830 u = 0; 831 } else 832 sz = _elf_upd_lib(elf); 833 834 if ((sz != 0) && ((cmd == ELF_C_WRITE) || (cmd == ELF_C_WRIMAGE))) 835 sz = wrt(elf, (Xword)sz, u, cmd); 836 837 if (sz == 0) { 838 ELFUNLOCK(elf) 839 return (-1); 840 } 841 842 ELFUNLOCK(elf) 843 return ((off_t)sz); 844 } 845 846 847 /* 848 * When wrt() processes an ELF_C_WRIMAGE request, the resulting image 849 * gets the byte order (encoding) of the platform running the linker 850 * rather than that of the target host. This allows the linker to modify 851 * the image, prior to flushing it to the output file. This routine 852 * is used to re-translate such an image into the byte order of the 853 * target host. 854 */ 855 int 856 _elfxx_swap_wrimage(Elf *elf) 857 { 858 Elf_Data dst, src; 859 Elf_Scn *s; 860 Ehdr *eh; 861 Half e_phnum; 862 unsigned ver; 863 unsigned encode; 864 865 /* 866 * Ehdr first 867 */ 868 869 ELFWLOCK(elf); 870 eh = elf->ed_ehdr; 871 e_phnum = eh->e_phnum; 872 ver = eh->e_version; 873 encode = eh->e_ident[EI_DATA]; 874 875 src.d_buf = dst.d_buf = (Elf_Void *)eh; 876 src.d_type = dst.d_type = ELF_T_EHDR; 877 src.d_size = dst.d_size = sizeof (Ehdr); 878 src.d_version = dst.d_version = ver; 879 if (elf_xlatetof(&dst, &src, encode) == 0) { 880 ELFUNLOCK(elf); 881 return (1); 882 } 883 884 /* 885 * Phdr table if one exists 886 */ 887 888 if (e_phnum != 0) { 889 unsigned work; 890 /* 891 * Unlike other library data, phdr table is 892 * in the user version. 893 */ 894 895 src.d_buf = dst.d_buf = (Elf_Void *)elf->ed_phdr; 896 src.d_type = dst.d_type = ELF_T_PHDR; 897 src.d_size = dst.d_size = elf->ed_phdrsz; 898 ELFACCESSDATA(work, _elf_work) 899 src.d_version = dst.d_version = work; 900 if (elf_xlatetof(&dst, &src, encode) == 0) { 901 ELFUNLOCK(elf); 902 return (1); 903 } 904 } 905 906 /* 907 * Loop through sections 908 */ 909 910 for (s = elf->ed_hdscn; s != 0; s = s->s_next) { 911 register Dnode *d, *prevd; 912 Shdr *sh = s->s_shdr; 913 914 if ((sh->sh_type == SHT_NOBITS) || (sh->sh_type == SHT_NULL)) 915 continue; 916 917 for (d = s->s_hdnode, prevd = 0; 918 d != 0; prevd = d, d = d->db_next) { 919 920 if ((d->db_myflags & DBF_READY) == 0) { 921 SCNLOCK(s); 922 if (_elf_locked_getdata(s, &prevd->db_data) != 923 &d->db_data) { 924 SCNUNLOCK(s); 925 ELFUNLOCK(elf); 926 return (1); 927 } 928 SCNUNLOCK(s); 929 } 930 931 dst = d->db_data; 932 if (elf_xlatetof(&dst, &d->db_data, encode) == 0) { 933 ELFUNLOCK(elf); 934 return (1); 935 } 936 } 937 } 938 939 /* 940 * Shdr table 941 */ 942 943 src.d_type = dst.d_type = ELF_T_SHDR; 944 src.d_version = dst.d_version = ver; 945 for (s = elf->ed_hdscn; s != 0; s = s->s_next) { 946 src.d_buf = dst.d_buf = s->s_shdr; 947 src.d_size = dst.d_size = sizeof (Shdr); 948 if (elf_xlatetof(&dst, &src, encode) == 0) { 949 ELFUNLOCK(elf); 950 return (1); 951 } 952 } 953 954 ELFUNLOCK(elf); 955 return (0); 956 } 957 958 959 960 #ifndef _ELF64 961 /* class-independent, only needs to be compiled once */ 962 963 off_t 964 elf_update(Elf *elf, Elf_Cmd cmd) 965 { 966 if (elf == 0) 967 return (-1); 968 969 if (elf->ed_class == ELFCLASS32) 970 return (_elf32_update(elf, cmd)); 971 else if (elf->ed_class == ELFCLASS64) { 972 return (_elf64_update(elf, cmd)); 973 } 974 975 _elf_seterr(EREQ_CLASS, 0); 976 return (-1); 977 } 978 979 int 980 _elf_swap_wrimage(Elf *elf) 981 { 982 if (elf == 0) 983 return (0); 984 985 if (elf->ed_class == ELFCLASS32) 986 return (_elf32_swap_wrimage(elf)); 987 988 if (elf->ed_class == ELFCLASS64) 989 return (_elf64_swap_wrimage(elf)); 990 991 _elf_seterr(EREQ_CLASS, 0); 992 return (0); 993 } 994 995 /* 996 * 4106312, 4106398, This is an ad-hoc means for the 32-bit 997 * Elf64 version of libld.so.3 to get around the limitation 998 * of a 32-bit d_off field. This is only intended to be 999 * used by libld to relocate symbols in large NOBITS sections. 1000 */ 1001 Elf64_Off 1002 _elf_getxoff(Elf_Data * d) 1003 { 1004 return (((Dnode *)d)->db_xoff); 1005 } 1006 #endif /* !_ELF64 */ 1007