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 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1988 AT&T */
28 /* All Rights Reserved */
29
30 /*
31 * This stuff used to live in cook.c, but was moved out to
32 * facilitate dual (Elf32 and Elf64) compilation. See block
33 * comment in cook.c for more info.
34 */
35
36 #include <string.h>
37 #include <ar.h>
38 #include <stdlib.h>
39 #include <errno.h>
40 #include <sys/sysmacros.h>
41 #include "decl.h"
42 #include "member.h"
43 #include "msg.h"
44
45 /*
46 * This module is compiled twice, the second time having
47 * -D_ELF64 defined. The following set of macros, along
48 * with machelf.h, represent the differences between the
49 * two compilations. Be careful *not* to add any class-
50 * dependent code (anything that has elf32 or elf64 in the
51 * name) to this code without hiding it behind a switch-
52 * able macro like these.
53 */
54 #if defined(_ELF64)
55 #define Snode Snode64
56 #define ELFCLASS ELFCLASS64
57 #define ElfField Elf64
58 #define _elf_snode_init _elf64_snode_init
59 #define _elf_prepscan _elf64_prepscan
60 #define _elf_cookscn _elf64_cookscn
61 #define _elf_mtype _elf64_mtype
62 #define _elf_msize _elf64_msize
63 #define elf_fsize elf64_fsize
64 #define _elf_snode _elf64_snode
65 #define _elf_ehdr _elf64_ehdr
66 #define elf_xlatetom elf64_xlatetom
67 #define _elf_phdr _elf64_phdr
68 #define _elf_shdr _elf64_shdr
69 #define _elf_prepscn _elf64_prepscn
70
71 #else /* Elf32 */
72 #define Snode Snode32
73 #define ELFCLASS ELFCLASS32
74 #define ElfField Elf32
75 #define _elf_snode_init _elf32_snode_init
76 #define _elf_prepscan _elf32_prepscan
77 #define _elf_cookscn _elf32_cookscn
78 #define _elf_mtype _elf32_mtype
79 #define _elf_msize _elf32_msize
80 #define elf_fsize elf32_fsize
81 #define _elf_snode _elf32_snode
82 #define _elf_ehdr _elf32_ehdr
83 #define elf_xlatetom elf32_xlatetom
84 #define _elf_phdr _elf32_phdr
85 #define _elf_shdr _elf32_shdr
86 #define _elf_prepscn _elf32_prepscn
87
88 #endif /* _ELF64 */
89
90
91 static Okay
_elf_prepscn(Elf * elf,size_t cnt)92 _elf_prepscn(Elf *elf, size_t cnt)
93 {
94 Elf_Scn * s;
95 Elf_Scn * end;
96
97 if (cnt == 0)
98 return (OK_YES);
99
100 if ((s = malloc(cnt * sizeof (Elf_Scn))) == 0) {
101 _elf_seterr(EMEM_SCN, errno);
102 return (OK_NO);
103 }
104 elf->ed_scntabsz = cnt;
105 end = s + cnt;
106 elf->ed_hdscn = s;
107 do {
108 *s = _elf_snode_init.sb_scn;
109 s->s_elf = elf;
110 s->s_next = s + 1;
111 s->s_index = s - elf->ed_hdscn;
112 s->s_shdr = (Shdr*)s->s_elf->ed_shdr + s->s_index;
113 ELFMUTEXINIT(&s->s_mutex);
114
115 /*
116 * Section has not yet been cooked!
117 *
118 * We don't cook a section until it's data is actually
119 * referenced.
120 */
121 s->s_myflags = 0;
122 } while (++s < end);
123
124 elf->ed_tlscn = --s;
125 s->s_next = 0;
126
127 /*
128 * Section index SHN_UNDEF (0) does not and cannot
129 * have a data buffer. Fix it here. Also mark the
130 * initial section as being allocated for the block
131 */
132
133 s = elf->ed_hdscn;
134 s->s_myflags = SF_ALLOC;
135 s->s_hdnode = 0;
136 s->s_tlnode = 0;
137 return (OK_YES);
138 }
139
140
141 Okay
_elf_cookscn(Elf_Scn * s)142 _elf_cookscn(Elf_Scn * s)
143 {
144 Elf * elf;
145 Shdr * sh;
146 register Dnode * d = &s->s_dnode;
147 size_t fsz, msz;
148 unsigned work;
149
150 s->s_hdnode = s->s_tlnode = d;
151 s->s_err = 0;
152 s->s_shflags = 0;
153 s->s_uflags = 0;
154
155
156 /*
157 * Prepare d_data for inspection, but don't actually
158 * translate data until needed. Leave the READY
159 * flag off. NOBITS sections see zero size.
160 */
161 elf = s->s_elf;
162 sh = s->s_shdr;
163
164 d->db_scn = s;
165 d->db_off = sh->sh_offset;
166 d->db_data.d_align = sh->sh_addralign;
167 d->db_data.d_version = elf->ed_version;
168 ELFACCESSDATA(work, _elf_work)
169 d->db_data.d_type = _elf_mtype(elf, sh->sh_type, work);
170 d->db_data.d_buf = 0;
171 d->db_data.d_off = 0;
172 fsz = elf_fsize(d->db_data.d_type, 1, elf->ed_version);
173 msz = _elf_msize(d->db_data.d_type, elf->ed_version);
174 d->db_data.d_size = MAX(sh->sh_size, (sh->sh_size / fsz) * msz);
175 d->db_shsz = sh->sh_size;
176 d->db_raw = 0;
177 d->db_buf = 0;
178 d->db_uflags = 0;
179 d->db_myflags = 0;
180 d->db_next = 0;
181
182 if (sh->sh_type != SHT_NOBITS)
183 d->db_fsz = sh->sh_size;
184 else
185 d->db_fsz = 0;
186
187 s->s_myflags |= SF_READY;
188
189 return (OK_YES);
190 }
191
192
193
194 Snode *
_elf_snode()195 _elf_snode()
196 {
197 register Snode *s;
198
199 if ((s = malloc(sizeof (Snode))) == 0) {
200 _elf_seterr(EMEM_SNODE, errno);
201 return (0);
202 }
203 *s = _elf_snode_init;
204 ELFMUTEXINIT(&s->sb_scn.s_mutex);
205 s->sb_scn.s_myflags = SF_ALLOC | SF_READY;
206 s->sb_scn.s_shdr = &s->sb_shdr;
207 return (s);
208 }
209
210
211
212 int
_elf_ehdr(Elf * elf,int inplace)213 _elf_ehdr(Elf * elf, int inplace)
214 {
215 register size_t fsz; /* field size */
216 Elf_Data dst, src;
217
218 fsz = elf_fsize(ELF_T_EHDR, 1, elf->ed_version);
219 if (fsz > elf->ed_fsz) {
220 _elf_seterr(EFMT_EHDRSZ, 0);
221 return (-1);
222 }
223 if (inplace && (fsz >= sizeof (Ehdr))) {
224 /*
225 * The translated Ehdr will fit over the original Ehdr.
226 */
227 /* LINTED */
228 elf->ed_ehdr = (Ehdr *)elf->ed_ident;
229 elf->ed_status = ES_COOKED;
230 } else {
231 elf->ed_ehdr = malloc(sizeof (Ehdr));
232 if (elf->ed_ehdr == 0) {
233 _elf_seterr(EMEM_EHDR, errno);
234 return (-1);
235 }
236 elf->ed_myflags |= EDF_EHALLOC;
237 }
238
239 /*
240 * Memory size >= fsz, because otherwise the memory version
241 * loses information and cannot accurately implement the
242 * file.
243 */
244
245 src.d_buf = (Elf_Void *)elf->ed_ident;
246 src.d_type = ELF_T_EHDR;
247 src.d_size = fsz;
248 src.d_version = elf->ed_version;
249 dst.d_buf = (Elf_Void *)elf->ed_ehdr;
250 dst.d_size = sizeof (Ehdr);
251 dst.d_version = EV_CURRENT;
252
253 if ((_elf_vm(elf, (size_t)0, fsz) != OK_YES) ||
254 (elf_xlatetom(&dst, &src, elf->ed_encode) == 0)) {
255 if (elf->ed_myflags & EDF_EHALLOC) {
256 elf->ed_myflags &= ~EDF_EHALLOC;
257 free(elf->ed_ehdr);
258 }
259 elf->ed_ehdr = 0;
260 return (-1);
261 }
262
263 if (((Ehdr*)elf->ed_ehdr)->e_ident[EI_CLASS] != ELFCLASS) {
264 _elf_seterr(EREQ_CLASS, 0);
265 if (elf->ed_myflags & EDF_EHALLOC) {
266 elf->ed_myflags &= ~EDF_EHALLOC;
267 free(elf->ed_ehdr);
268 }
269 elf->ed_ehdr = 0;
270 return (-1);
271 }
272
273 if (((Ehdr*)elf->ed_ehdr)->e_version != elf->ed_version) {
274 _elf_seterr(EFMT_VER2, 0);
275 if (elf->ed_myflags & EDF_EHALLOC) {
276 elf->ed_myflags &= ~EDF_EHALLOC;
277 free(elf->ed_ehdr);
278 }
279 elf->ed_ehdr = 0;
280 return (-1);
281 }
282
283 return (0);
284 }
285
286
287
288 int
_elf_phdr(Elf * elf,int inplace)289 _elf_phdr(Elf * elf, int inplace)
290 {
291 register size_t fsz, msz;
292 Elf_Data dst, src;
293 Ehdr * eh = elf->ed_ehdr; /* must be present */
294 unsigned work;
295
296 if (eh->e_phnum == 0)
297 return (0);
298
299 fsz = elf_fsize(ELF_T_PHDR, 1, elf->ed_version);
300 if (eh->e_phentsize != fsz) {
301 _elf_seterr(EFMT_PHDRSZ, 0);
302 return (-1);
303 }
304
305 fsz *= eh->e_phnum;
306 ELFACCESSDATA(work, _elf_work)
307 msz = _elf_msize(ELF_T_PHDR, work) * eh->e_phnum;
308 if ((eh->e_phoff == 0) ||
309 (elf->ed_fsz <= eh->e_phoff) ||
310 (elf->ed_fsz - eh->e_phoff < fsz)) {
311 _elf_seterr(EFMT_PHTAB, 0);
312 return (-1);
313 }
314
315 if (inplace && fsz >= msz && eh->e_phoff % sizeof (ElfField) == 0) {
316 elf->ed_phdr = (Elf_Void *)(elf->ed_ident + eh->e_phoff);
317 elf->ed_status = ES_COOKED;
318 } else {
319 if ((elf->ed_phdr = malloc(msz)) == 0) {
320 _elf_seterr(EMEM_PHDR, errno);
321 return (-1);
322 }
323 elf->ed_myflags |= EDF_PHALLOC;
324 }
325 src.d_buf = (Elf_Void *)(elf->ed_ident + eh->e_phoff);
326 src.d_type = ELF_T_PHDR;
327 src.d_size = fsz;
328 src.d_version = elf->ed_version;
329 dst.d_buf = elf->ed_phdr;
330 dst.d_size = msz;
331 dst.d_version = work;
332 if ((_elf_vm(elf, (size_t)eh->e_phoff, fsz) != OK_YES) ||
333 (elf_xlatetom(&dst, &src, elf->ed_encode) == 0)) {
334 if (elf->ed_myflags & EDF_PHALLOC) {
335 elf->ed_myflags &= ~EDF_PHALLOC;
336 free(elf->ed_phdr);
337 }
338 elf->ed_phdr = 0;
339 return (-1);
340 }
341 elf->ed_phdrsz = msz;
342 return (0);
343 }
344
345
346
347 int
_elf_shdr(Elf * elf,int inplace)348 _elf_shdr(Elf * elf, int inplace)
349 {
350 register size_t fsz, msz;
351 size_t scncnt;
352 Elf_Data dst, src;
353 register Ehdr *eh = elf->ed_ehdr; /* must be present */
354
355 if ((eh->e_shnum == 0) && (eh->e_shoff == 0))
356 return (0);
357
358 fsz = elf_fsize(ELF_T_SHDR, 1, elf->ed_version);
359 if (eh->e_shentsize != fsz) {
360 _elf_seterr(EFMT_SHDRSZ, 0);
361 return (-1);
362 }
363 /*
364 * If we are dealing with a file with 'extended section
365 * indexes' - then we need to load the first section
366 * header. The actual section count is stored in
367 * Shdr[0].sh_size.
368 */
369 if ((scncnt = eh->e_shnum) == 0) {
370 Shdr sh;
371 if ((eh->e_shoff == 0) ||
372 (elf->ed_fsz <= eh->e_shoff) ||
373 (elf->ed_fsz - eh->e_shoff < fsz)) {
374 _elf_seterr(EFMT_SHTAB, 0);
375 return (-1);
376 }
377 src.d_buf = (Elf_Void *)(elf->ed_ident + eh->e_shoff);
378 src.d_type = ELF_T_SHDR;
379 src.d_size = fsz;
380 src.d_version = elf->ed_version;
381 dst.d_buf = (Elf_Void *)&sh;
382 dst.d_size = sizeof (Shdr);
383 dst.d_version = EV_CURRENT;
384 if ((_elf_vm(elf, (size_t)eh->e_shoff, fsz) != OK_YES) ||
385 (elf_xlatetom(&dst, &src, elf->ed_encode) == 0)) {
386 return (-1);
387 }
388 scncnt = sh.sh_size;
389 }
390
391 fsz *= scncnt;
392 msz = scncnt * sizeof (Shdr);
393 if ((eh->e_shoff == 0) ||
394 (elf->ed_fsz <= eh->e_shoff) ||
395 (elf->ed_fsz - eh->e_shoff < fsz)) {
396 _elf_seterr(EFMT_SHTAB, 0);
397 return (-1);
398 }
399
400 if (inplace && (fsz >= msz) &&
401 ((eh->e_shoff % sizeof (ElfField)) == 0)) {
402 /* LINTED */
403 elf->ed_shdr = (Shdr *)(elf->ed_ident + eh->e_shoff);
404 elf->ed_status = ES_COOKED;
405 } else {
406 if ((elf->ed_shdr = malloc(msz)) == 0) {
407 _elf_seterr(EMEM_SHDR, errno);
408 return (-1);
409 }
410 elf->ed_myflags |= EDF_SHALLOC;
411 }
412 src.d_buf = (Elf_Void *)(elf->ed_ident + eh->e_shoff);
413 src.d_type = ELF_T_SHDR;
414 src.d_size = fsz;
415 src.d_version = elf->ed_version;
416 dst.d_buf = (Elf_Void *)elf->ed_shdr;
417 dst.d_size = msz;
418 dst.d_version = EV_CURRENT;
419 if ((_elf_vm(elf, (size_t)eh->e_shoff, fsz) != OK_YES) ||
420 (elf_xlatetom(&dst, &src, elf->ed_encode) == 0) ||
421 (_elf_prepscn(elf, scncnt) != OK_YES)) {
422 if (elf->ed_myflags & EDF_SHALLOC) {
423 elf->ed_myflags &= ~EDF_SHALLOC;
424 free(elf->ed_shdr);
425 }
426 elf->ed_shdr = 0;
427 return (-1);
428 }
429 return (0);
430 }
431