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