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