1 /* Return the next data element from the section after possibly converting it.
2 Copyright (C) 1998-2005, 2006, 2007 Red Hat, Inc.
3 This file is part of Red Hat elfutils.
4 Written by Ulrich Drepper <drepper@redhat.com>, 1998.
5
6 Red Hat elfutils is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by the
8 Free Software Foundation; version 2 of the License.
9
10 Red Hat elfutils is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
14
15 You should have received a copy of the GNU General Public License along
16 with Red Hat elfutils; if not, write to the Free Software Foundation,
17 Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
18
19 In addition, as a special exception, Red Hat, Inc. gives You the
20 additional right to link the code of Red Hat elfutils with code licensed
21 under any Open Source Initiative certified open source license
22 (http://www.opensource.org/licenses/index.php) which requires the
23 distribution of source code with any binary distribution and to
24 distribute linked combinations of the two. Non-GPL Code permitted under
25 this exception must only link to the code of Red Hat elfutils through
26 those well defined interfaces identified in the file named EXCEPTION
27 found in the source code files (the "Approved Interfaces"). The files
28 of Non-GPL Code may instantiate templates or use macros or inline
29 functions from the Approved Interfaces without causing the resulting
30 work to be covered by the GNU General Public License. Only Red Hat,
31 Inc. may make changes or additions to the list of Approved Interfaces.
32 Red Hat's grant of this exception is conditioned upon your not adding
33 any new exceptions. If you wish to add a new Approved Interface or
34 exception, please contact Red Hat. You must obey the GNU General Public
35 License in all respects for all of the Red Hat elfutils code and other
36 code used in conjunction with Red Hat elfutils except the Non-GPL Code
37 covered by this exception. If you modify this file, you may extend this
38 exception to your version of the file, but you are not obligated to do
39 so. If you do not wish to provide this exception without modification,
40 you must delete this exception statement from your version and license
41 this file solely under the GPL without exception.
42
43 Red Hat elfutils is an included package of the Open Invention Network.
44 An included package of the Open Invention Network is a package for which
45 Open Invention Network licensees cross-license their patents. No patent
46 license is granted, either expressly or impliedly, by designation as an
47 included package. Should you wish to participate in the Open Invention
48 Network licensing program, please visit www.openinventionnetwork.com
49 <http://www.openinventionnetwork.com>. */
50
51 #ifdef HAVE_CONFIG_H
52 # include <config.h>
53 #endif
54
55 #include <errno.h>
56 #include <stddef.h>
57 #include <string.h>
58 #include <unistd.h>
59
60 #include "libelfP.h"
61 #include <system.h>
62 #include "common.h"
63 #include "elf-knowledge.h"
64
65
66 #define TYPEIDX(Sh_Type) \
67 (Sh_Type >= SHT_NULL && Sh_Type < SHT_NUM \
68 ? Sh_Type \
69 : (Sh_Type >= SHT_GNU_HASH && Sh_Type <= SHT_HISUNW \
70 ? SHT_NUM + Sh_Type - SHT_GNU_HASH \
71 : 0))
72
73 /* Associate section types with libelf types. */
74 static const Elf_Type shtype_map[EV_NUM - 1][TYPEIDX (SHT_HISUNW) + 1] =
75 {
76 [EV_CURRENT - 1] =
77 {
78 [SHT_SYMTAB] = ELF_T_SYM,
79 [SHT_RELA] = ELF_T_RELA,
80 [SHT_HASH] = ELF_T_WORD,
81 [SHT_DYNAMIC] = ELF_T_DYN,
82 [SHT_REL] = ELF_T_REL,
83 [SHT_DYNSYM] = ELF_T_SYM,
84 [SHT_INIT_ARRAY] = ELF_T_ADDR,
85 [SHT_FINI_ARRAY] = ELF_T_ADDR,
86 [SHT_PREINIT_ARRAY] = ELF_T_ADDR,
87 [SHT_GROUP] = ELF_T_WORD,
88 [SHT_SYMTAB_SHNDX] = ELF_T_WORD,
89 [SHT_NOTE] = ELF_T_NHDR,
90 [TYPEIDX (SHT_GNU_verdef)] = ELF_T_VDEF,
91 [TYPEIDX (SHT_GNU_verneed)] = ELF_T_VNEED,
92 [TYPEIDX (SHT_GNU_versym)] = ELF_T_HALF,
93 [TYPEIDX (SHT_SUNW_syminfo)] = ELF_T_SYMINFO,
94 [TYPEIDX (SHT_SUNW_move)] = ELF_T_MOVE,
95 [TYPEIDX (SHT_GNU_LIBLIST)] = ELF_T_LIB,
96 [TYPEIDX (SHT_GNU_HASH)] = ELF_T_GNUHASH,
97 }
98 };
99
100 #if !ALLOW_UNALIGNED
101 /* Associate libelf types with their internal alignment requirements. */
102 const uint_fast8_t __libelf_type_aligns[EV_NUM - 1][ELFCLASSNUM - 1][ELF_T_NUM] =
103 {
104 # define TYPE_ALIGNS(Bits) \
105 { \
106 [ELF_T_ADDR] = __alignof__ (ElfW2(Bits,Addr)), \
107 [ELF_T_HALF] = __alignof__ (ElfW2(Bits,Half)), \
108 [ELF_T_WORD] = __alignof__ (ElfW2(Bits,Word)), \
109 [ELF_T_SYM] = __alignof__ (ElfW2(Bits,Sym)), \
110 [ELF_T_SYMINFO] = __alignof__ (ElfW2(Bits,Syminfo)), \
111 [ELF_T_REL] = __alignof__ (ElfW2(Bits,Rel)), \
112 [ELF_T_RELA] = __alignof__ (ElfW2(Bits,Rela)), \
113 [ELF_T_DYN] = __alignof__ (ElfW2(Bits,Dyn)), \
114 [ELF_T_VDEF] = __alignof__ (ElfW2(Bits,Verdef)), \
115 [ELF_T_VDAUX] = __alignof__ (ElfW2(Bits,Verdaux)), \
116 [ELF_T_VNEED] = __alignof__ (ElfW2(Bits,Verneed)), \
117 [ELF_T_VNAUX] = __alignof__ (ElfW2(Bits,Vernaux)), \
118 [ELF_T_MOVE] = __alignof__ (ElfW2(Bits,Move)), \
119 [ELF_T_LIB] = __alignof__ (ElfW2(Bits,Lib)), \
120 [ELF_T_NHDR] = __alignof__ (ElfW2(Bits,Nhdr)), \
121 }
122 [EV_CURRENT - 1] =
123 {
124 [ELFCLASS32 - 1] = TYPE_ALIGNS (32),
125 [ELFCLASS64 - 1] = TYPE_ALIGNS (64),
126 }
127 # undef TYPE_ALIGNS
128 };
129 #endif
130
131
132 /* Convert the data in the current section. */
133 static void
convert_data(Elf_Scn * scn,int version,int eclass,int data,size_t size,Elf_Type type)134 convert_data (Elf_Scn *scn, int version __attribute__ ((unused)), int eclass,
135 int data, size_t size, Elf_Type type)
136 {
137 const size_t align = __libelf_type_align (eclass, type);
138
139 if (data == MY_ELFDATA)
140 {
141 if (((((size_t) (char *) scn->rawdata_base)) & (align - 1)) == 0)
142 /* No need to copy, we can use the raw data. */
143 scn->data_base = scn->rawdata_base;
144 else
145 {
146 scn->data_base = (char *) malloc (size);
147 if (scn->data_base == NULL)
148 {
149 __libelf_seterrno (ELF_E_NOMEM);
150 return;
151 }
152
153 /* The copy will be appropriately aligned for direct access. */
154 memcpy (scn->data_base, scn->rawdata_base, size);
155 }
156 }
157 else
158 {
159 xfct_t fp;
160
161 scn->data_base = (char *) malloc (size);
162 if (scn->data_base == NULL)
163 {
164 __libelf_seterrno (ELF_E_NOMEM);
165 return;
166 }
167
168 /* Get the conversion function. */
169 #if EV_NUM != 2
170 fp = __elf_xfctstom[version - 1][__libelf_version - 1][eclass - 1][type];
171 #else
172 fp = __elf_xfctstom[0][0][eclass - 1][type];
173 #endif
174
175 fp (scn->data_base, scn->rawdata_base, size, 0);
176 }
177
178 scn->data_list.data.d.d_buf = scn->data_base;
179 scn->data_list.data.d.d_size = size;
180 scn->data_list.data.d.d_type = type;
181 scn->data_list.data.d.d_off = scn->rawdata.d.d_off;
182 scn->data_list.data.d.d_align = scn->rawdata.d.d_align;
183 scn->data_list.data.d.d_version = scn->rawdata.d.d_version;
184
185 scn->data_list.data.s = scn;
186 }
187
188
189 /* Store the information for the raw data in the `rawdata' element. */
190 int
191 internal_function
__libelf_set_rawdata_wrlock(Elf_Scn * scn)192 __libelf_set_rawdata_wrlock (Elf_Scn *scn)
193 {
194 size_t offset;
195 size_t size;
196 size_t align;
197 int type;
198 Elf *elf = scn->elf;
199
200 if (elf->class == ELFCLASS32)
201 {
202 Elf32_Shdr *shdr
203 = scn->shdr.e32 ?: __elf32_getshdr_wrlock (scn);
204
205 if (shdr == NULL)
206 /* Something went terribly wrong. */
207 return 1;
208
209 offset = shdr->sh_offset;
210 size = shdr->sh_size;
211 type = shdr->sh_type;
212 align = shdr->sh_addralign;
213 }
214 else
215 {
216 Elf64_Shdr *shdr
217 = scn->shdr.e64 ?: __elf64_getshdr_wrlock (scn);
218
219 if (shdr == NULL)
220 /* Something went terribly wrong. */
221 return 1;
222
223 offset = shdr->sh_offset;
224 size = shdr->sh_size;
225 type = shdr->sh_type;
226 align = shdr->sh_addralign;
227 }
228
229 /* If the section has no data (for whatever reason), leave the `d_buf'
230 pointer NULL. */
231 if (size != 0 && type != SHT_NOBITS)
232 {
233 /* First a test whether the section is valid at all. */
234 size_t entsize;
235
236 if (type == SHT_HASH)
237 {
238 GElf_Ehdr ehdr_mem;
239 GElf_Ehdr *ehdr = __gelf_getehdr_rdlock (elf, &ehdr_mem);
240 entsize = SH_ENTSIZE_HASH (ehdr);
241 }
242 else
243 {
244 Elf_Type t = shtype_map[LIBELF_EV_IDX][TYPEIDX (type)];
245 if (t == ELF_T_VDEF || t == ELF_T_NHDR
246 || (t == ELF_T_GNUHASH && elf->class == ELFCLASS64))
247 entsize = 1;
248 else
249 entsize = __libelf_type_sizes[LIBELF_EV_IDX][elf->class - 1][t];
250 }
251
252 /* We assume it is an array of bytes if it is none of the structured
253 sections we know of. */
254 if (entsize == 0)
255 entsize = 1;
256
257 if (unlikely (size % entsize != 0))
258 {
259 __libelf_seterrno (ELF_E_INVALID_DATA);
260 return 1;
261 }
262
263 /* We can use the mapped or loaded data if available. */
264 if (elf->map_address != NULL)
265 {
266 /* First see whether the information in the section header is
267 valid and it does not ask for too much. */
268 if (unlikely (offset + size > elf->maximum_size))
269 {
270 /* Something is wrong. */
271 __libelf_seterrno (ELF_E_INVALID_SECTION_HEADER);
272 return 1;
273 }
274
275 scn->rawdata_base = scn->rawdata.d.d_buf
276 = (char *) elf->map_address + elf->start_offset + offset;
277 }
278 else if (likely (elf->fildes != -1))
279 {
280 /* We have to read the data from the file. Allocate the needed
281 memory. */
282 scn->rawdata_base = scn->rawdata.d.d_buf
283 = (char *) malloc (size);
284 if (scn->rawdata.d.d_buf == NULL)
285 {
286 __libelf_seterrno (ELF_E_NOMEM);
287 return 1;
288 }
289
290 ssize_t n = pread_retry (elf->fildes, scn->rawdata.d.d_buf, size,
291 elf->start_offset + offset);
292 if (unlikely ((size_t) n != size))
293 {
294 /* Cannot read the data. */
295 free (scn->rawdata.d.d_buf);
296 scn->rawdata_base = scn->rawdata.d.d_buf = NULL;
297 __libelf_seterrno (ELF_E_READ_ERROR);
298 return 1;
299 }
300 }
301 else
302 {
303 /* The file descriptor is already closed, we cannot get the data
304 anymore. */
305 __libelf_seterrno (ELF_E_FD_DISABLED);
306 return 1;
307 }
308 }
309
310 scn->rawdata.d.d_size = size;
311 /* Some broken ELF ABI for 64-bit machines use the wrong hash table
312 entry size. See elf-knowledge.h for more information. */
313 if (type == SHT_HASH && elf->class == ELFCLASS64)
314 {
315 GElf_Ehdr ehdr_mem;
316 GElf_Ehdr *ehdr = __gelf_getehdr_rdlock (elf, &ehdr_mem);
317 scn->rawdata.d.d_type
318 = (SH_ENTSIZE_HASH (ehdr) == 4 ? ELF_T_WORD : ELF_T_XWORD);
319 }
320 else
321 scn->rawdata.d.d_type = shtype_map[LIBELF_EV_IDX][TYPEIDX (type)];
322 scn->rawdata.d.d_off = 0;
323 scn->rawdata.d.d_align = align;
324 if (elf->class == ELFCLASS32
325 || (offsetof (struct Elf, state.elf32.ehdr)
326 == offsetof (struct Elf, state.elf64.ehdr)))
327 scn->rawdata.d.d_version =
328 elf->state.elf32.ehdr->e_ident[EI_VERSION];
329 else
330 scn->rawdata.d.d_version =
331 elf->state.elf64.ehdr->e_ident[EI_VERSION];
332
333 scn->rawdata.s = scn;
334
335 scn->data_read = 1;
336
337 /* We actually read data from the file. At least we tried. */
338 scn->flags |= ELF_F_FILEDATA;
339
340 return 0;
341 }
342
343 int
344 internal_function
__libelf_set_rawdata(Elf_Scn * scn)345 __libelf_set_rawdata (Elf_Scn *scn)
346 {
347 int result;
348
349 if (scn == NULL)
350 return 1;
351
352 rwlock_wrlock (scn->elf->lock);
353 result = __libelf_set_rawdata_wrlock (scn);
354 rwlock_unlock (scn->elf->lock);
355
356 return result;
357 }
358
359 Elf_Data *
360 internal_function
__elf_getdata_rdlock(scn,data)361 __elf_getdata_rdlock (scn, data)
362 Elf_Scn *scn;
363 Elf_Data *data;
364 {
365 Elf_Data *result = NULL;
366 Elf *elf;
367 int locked = 0;
368
369 if (scn == NULL)
370 return NULL;
371
372 if (unlikely (scn->elf->kind != ELF_K_ELF))
373 {
374 __libelf_seterrno (ELF_E_INVALID_HANDLE);
375 return NULL;
376 }
377
378 /* We will need this multiple times later on. */
379 elf = scn->elf;
380
381 /* If `data' is not NULL this means we are not addressing the initial
382 data in the file. But this also means this data is already read
383 (since otherwise it is not possible to have a valid `data' pointer)
384 and all the data structures are initialized as well. In this case
385 we can simply walk the list of data records. */
386 if (data != NULL)
387 {
388 Elf_Data_List *runp;
389
390 /* It is not possible that if DATA is not NULL the first entry is
391 returned. But this also means that there must be a first data
392 entry. */
393 if (scn->data_list_rear == NULL
394 /* The section the reference data is for must match the section
395 parameter. */
396 || unlikely (((Elf_Data_Scn *) data)->s != scn))
397 {
398 __libelf_seterrno (ELF_E_DATA_MISMATCH);
399 goto out;
400 }
401
402 /* We start searching with the first entry. */
403 runp = &scn->data_list;
404
405 while (1)
406 {
407 /* If `data' does not match any known record punt. */
408 if (runp == NULL)
409 {
410 __libelf_seterrno (ELF_E_DATA_MISMATCH);
411 goto out;
412 }
413
414 if (&runp->data.d == data)
415 /* Found the entry. */
416 break;
417
418 runp = runp->next;
419 }
420
421 /* Return the data for the next data record. */
422 result = runp->next ? &runp->next->data.d : NULL;
423 goto out;
424 }
425
426 /* If the data for this section was not yet initialized do it now. */
427 if (scn->data_read == 0)
428 {
429 /* We cannot acquire a write lock while we are holding a read
430 lock. Therefore give up the read lock and then get the write
431 lock. But this means that the data could meanwhile be
432 modified, therefore start the tests again. */
433 rwlock_unlock (elf->lock);
434 rwlock_wrlock (elf->lock);
435 locked = 1;
436
437 /* Read the data from the file. There is always a file (or
438 memory region) associated with this descriptor since
439 otherwise the `data_read' flag would be set. */
440 if (scn->data_read == 0 && __libelf_set_rawdata_wrlock (scn) != 0)
441 /* Something went wrong. The error value is already set. */
442 goto out;
443 }
444
445 /* At this point we know the raw data is available. But it might be
446 empty in case the section has size zero (for whatever reason).
447 Now create the converted data in case this is necessary. */
448 if (scn->data_list_rear == NULL)
449 {
450 if (scn->rawdata.d.d_buf != NULL && scn->rawdata.d.d_size > 0)
451 {
452 if (!locked)
453 {
454 rwlock_unlock (elf->lock);
455 rwlock_wrlock (elf->lock);
456 if (scn->data_list_rear != NULL)
457 goto pass;
458 }
459
460 /* Convert according to the version and the type. */
461 convert_data (scn, __libelf_version, elf->class,
462 (elf->class == ELFCLASS32
463 || (offsetof (struct Elf, state.elf32.ehdr)
464 == offsetof (struct Elf, state.elf64.ehdr))
465 ? elf->state.elf32.ehdr->e_ident[EI_DATA]
466 : elf->state.elf64.ehdr->e_ident[EI_DATA]),
467 scn->rawdata.d.d_size, scn->rawdata.d.d_type);
468 }
469 else
470 /* This is an empty or NOBITS section. There is no buffer but
471 the size information etc is important. */
472 scn->data_list.data.d = scn->rawdata.d;
473
474 scn->data_list_rear = &scn->data_list;
475 }
476
477 /* If no data is present we cannot return any. */
478 if (scn->data_list_rear != NULL)
479 pass:
480 /* Return the first data element in the list. */
481 result = &scn->data_list.data.d;
482
483 out:
484 return result;
485 }
486
487 Elf_Data *
elf_getdata(scn,data)488 elf_getdata (scn, data)
489 Elf_Scn *scn;
490 Elf_Data *data;
491 {
492 Elf_Data *result;
493
494 if (scn == NULL)
495 return NULL;
496
497 rwlock_rdlock (scn->elf->lock);
498 result = __elf_getdata_rdlock (scn, data);
499 rwlock_unlock (scn->elf->lock);
500
501 return result;
502 }
503 INTDEF(elf_getdata)
504