Branch data Line data Source code
1 : : /* Report a module to libdwfl based on ELF program headers.
2 : : Copyright (C) 2005-2010 Red Hat, Inc.
3 : : This file is part of elfutils.
4 : :
5 : : This file is free software; you can redistribute it and/or modify
6 : : it under the terms of either
7 : :
8 : : * the GNU Lesser General Public License as published by the Free
9 : : Software Foundation; either version 3 of the License, or (at
10 : : your option) any later version
11 : :
12 : : or
13 : :
14 : : * the GNU General Public License as published by the Free
15 : : Software Foundation; either version 2 of the License, or (at
16 : : your option) any later version
17 : :
18 : : or both in parallel, as here.
19 : :
20 : : elfutils is distributed in the hope that it will be useful, but
21 : : WITHOUT ANY WARRANTY; without even the implied warranty of
22 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 : : General Public License for more details.
24 : :
25 : : You should have received copies of the GNU General Public License and
26 : : the GNU Lesser General Public License along with this program. If
27 : : not, see <http://www.gnu.org/licenses/>. */
28 : :
29 : : #ifdef HAVE_CONFIG_H
30 : : # include <config.h>
31 : : #endif
32 : :
33 : : #include "libdwflP.h"
34 : : #include <fcntl.h>
35 : : #include <unistd.h>
36 : :
37 : :
38 : : /* We start every ET_REL module at a moderately aligned boundary.
39 : : This keeps the low addresses easy to read compared to a layout
40 : : starting at 0 (as when using -e). It also makes it unlikely
41 : : that a middle section will have a larger alignment and require
42 : : rejiggering (see below). */
43 : : #define REL_MIN_ALIGN ((GElf_Xword) 0x100)
44 : :
45 : : bool
46 : : internal_function
47 : 608 : __libdwfl_elf_address_range (Elf *elf, GElf_Addr base, bool add_p_vaddr,
48 : : bool sanity, GElf_Addr *vaddrp,
49 : : GElf_Addr *address_syncp, GElf_Addr *startp,
50 : : GElf_Addr *endp, GElf_Addr *biasp,
51 : : GElf_Half *e_typep)
52 : : {
53 : 608 : GElf_Ehdr ehdr_mem, *ehdr = gelf_getehdr (elf, &ehdr_mem);
54 [ - + ]: 608 : if (ehdr == NULL)
55 : : {
56 : 0 : elf_error:
57 : 0 : __libdwfl_seterrno (DWFL_E_LIBELF);
58 : 0 : return false;
59 : : }
60 : :
61 : 608 : GElf_Addr vaddr = 0;
62 : 608 : GElf_Addr address_sync = 0;
63 : 608 : GElf_Addr start = 0, end = 0, bias = 0;
64 [ + + + ]: 608 : switch (ehdr->e_type)
65 : : {
66 : 169 : case ET_REL:
67 : : /* For a relocatable object, we do an arbitrary section layout.
68 : : By updating the section header in place, we leave the layout
69 : : information to be found by relocation. */
70 : :
71 : 169 : start = end = base = (base + REL_MIN_ALIGN - 1) & -REL_MIN_ALIGN;
72 : :
73 : 169 : bool first = true;
74 : 169 : Elf_Scn *scn = NULL;
75 [ + + ]: 790302 : while ((scn = elf_nextscn (elf, scn)) != NULL)
76 : 790133 : {
77 : 790133 : GElf_Shdr shdr_mem;
78 : 790133 : GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
79 [ + - ]: 790133 : if (unlikely (shdr == NULL))
80 : : goto elf_error;
81 : :
82 [ + + ]: 790133 : if (shdr->sh_flags & SHF_ALLOC)
83 : : {
84 [ - + ]: 1242 : const GElf_Xword align = shdr->sh_addralign ?: 1;
85 : 1242 : const GElf_Addr next = (end + align - 1) & -align;
86 [ + + ]: 1242 : if (shdr->sh_addr == 0
87 : : /* Once we've started doing layout we have to do it all,
88 : : unless we just laid out the first section at 0 when
89 : : it already was at 0. */
90 [ + - ][ - + ]: 15 : || (bias == 0 && end > start && end != next))
91 : : {
92 : 1227 : shdr->sh_addr = next;
93 [ + + ]: 1227 : if (end == base)
94 : : /* This is the first section assigned a location.
95 : : Use its aligned address as the module's base. */
96 : : start = base = shdr->sh_addr;
97 [ - + ]: 984 : else if (unlikely (base & (align - 1)))
98 : : {
99 : : /* If BASE has less than the maximum alignment of
100 : : any section, we eat more than the optimal amount
101 : : of padding and so make the module's apparent
102 : : size come out larger than it would when placed
103 : : at zero. So reset the layout with a better base. */
104 : :
105 : 0 : start = end = base = (base + align - 1) & -align;
106 : 0 : Elf_Scn *prev_scn = NULL;
107 : 0 : do
108 : : {
109 : 0 : prev_scn = elf_nextscn (elf, prev_scn);
110 : 0 : GElf_Shdr prev_shdr_mem;
111 : 0 : GElf_Shdr *prev_shdr = gelf_getshdr (prev_scn,
112 : : &prev_shdr_mem);
113 [ # # ]: 0 : if (unlikely (prev_shdr == NULL))
114 : 0 : goto elf_error;
115 [ # # ]: 0 : if (prev_shdr->sh_flags & SHF_ALLOC)
116 : : {
117 : 0 : const GElf_Xword prev_align
118 [ # # ]: 0 : = prev_shdr->sh_addralign ?: 1;
119 : :
120 : 0 : prev_shdr->sh_addr
121 : 0 : = (end + prev_align - 1) & -prev_align;
122 : 0 : end = prev_shdr->sh_addr + prev_shdr->sh_size;
123 : :
124 [ # # ]: 0 : if (unlikely (! gelf_update_shdr (prev_scn,
125 : : prev_shdr)))
126 : : goto elf_error;
127 : : }
128 : : }
129 [ # # ]: 0 : while (prev_scn != scn);
130 : 0 : continue;
131 : : }
132 : :
133 : 1227 : end = shdr->sh_addr + shdr->sh_size;
134 [ + + ]: 1227 : if (likely (shdr->sh_addr != 0)
135 [ + - ]: 984 : && unlikely (! gelf_update_shdr (scn, shdr)))
136 : : goto elf_error;
137 : : }
138 : : else
139 : : {
140 : : /* The address is already assigned. Just track it. */
141 [ + - ][ + + ]: 15 : if (first || end < shdr->sh_addr + shdr->sh_size)
142 : 3 : end = shdr->sh_addr + shdr->sh_size;
143 [ + - ][ - + ]: 15 : if (first || bias > shdr->sh_addr)
144 : : /* This is the lowest address in the module. */
145 : 0 : bias = shdr->sh_addr;
146 : :
147 [ - + ]: 15 : if ((shdr->sh_addr - bias + base) & (align - 1))
148 : : /* This section winds up misaligned using BASE.
149 : : Adjust BASE upwards to make it congruent to
150 : : the lowest section address in the file modulo ALIGN. */
151 : 0 : base = (((base + align - 1) & -align)
152 : 0 : + (bias & (align - 1)));
153 : : }
154 : :
155 : : first = false;
156 : : }
157 : : }
158 : :
159 [ - + ]: 169 : if (bias != 0)
160 : : {
161 : : /* The section headers had nonzero sh_addr values. The layout
162 : : was already done. We've just collected the total span.
163 : : Now just compute the bias from the requested base. */
164 : 0 : start = base;
165 : 0 : end = end - bias + start;
166 : 0 : bias = start - bias;
167 : : }
168 : 608 : break;
169 : :
170 : : /* Everything else has to have program headers. */
171 : :
172 : 274 : case ET_EXEC:
173 : : case ET_CORE:
174 : : /* An assigned base address is meaningless for these. */
175 : 274 : base = 0;
176 : 274 : add_p_vaddr = true;
177 : 439 : FALLTHROUGH;
178 : 439 : case ET_DYN:
179 : 439 : default:;
180 : 439 : size_t phnum;
181 [ + - ]: 439 : if (unlikely (elf_getphdrnum (elf, &phnum) != 0))
182 : : goto elf_error;
183 [ + + ]: 1117 : for (size_t i = 0; i < phnum; ++i)
184 : : {
185 : 1116 : GElf_Phdr phdr_mem, *ph = gelf_getphdr (elf, i, &phdr_mem);
186 [ - + ]: 1116 : if (unlikely (ph == NULL))
187 : 0 : goto elf_error;
188 [ + + ]: 1116 : if (ph->p_type == PT_LOAD)
189 : : {
190 : 438 : vaddr = ph->p_vaddr & -ph->p_align;
191 : 438 : address_sync = ph->p_vaddr + ph->p_memsz;
192 : 438 : break;
193 : : }
194 : : }
195 [ + + ]: 439 : if (add_p_vaddr)
196 : : {
197 : 435 : start = base + vaddr;
198 : 435 : bias = base;
199 : : }
200 : : else
201 : : {
202 : 4 : start = base;
203 : 4 : bias = base - vaddr;
204 : : }
205 : :
206 [ + + ]: 2233 : for (size_t i = phnum; i-- > 0;)
207 : : {
208 : 2232 : GElf_Phdr phdr_mem, *ph = gelf_getphdr (elf, i, &phdr_mem);
209 [ - + ]: 2232 : if (unlikely (ph == NULL))
210 : 0 : goto elf_error;
211 [ + + ]: 2232 : if (ph->p_type == PT_LOAD
212 [ + - ]: 438 : && ph->p_vaddr + ph->p_memsz > 0)
213 : : {
214 : 438 : end = bias + (ph->p_vaddr + ph->p_memsz);
215 : 438 : break;
216 : : }
217 : : }
218 : :
219 [ - + ]: 439 : if (end == 0 && sanity)
220 : : {
221 : 0 : __libdwfl_seterrno (DWFL_E_NO_PHDR);
222 : 0 : return false;
223 : : }
224 : : break;
225 : : }
226 [ + + ]: 608 : if (vaddrp)
227 : 570 : *vaddrp = vaddr;
228 [ + + ]: 608 : if (address_syncp)
229 : 570 : *address_syncp = address_sync;
230 [ + - ]: 608 : if (startp)
231 : 608 : *startp = start;
232 [ + - ]: 608 : if (endp)
233 : 608 : *endp = end;
234 [ + + ]: 608 : if (biasp)
235 : 570 : *biasp = bias;
236 [ + + ]: 608 : if (e_typep)
237 : 570 : *e_typep = ehdr->e_type;
238 : : return true;
239 : : }
240 : :
241 : : Dwfl_Module *
242 : : internal_function
243 : 570 : __libdwfl_report_elf (Dwfl *dwfl, const char *name, const char *file_name,
244 : : int fd, Elf *elf, GElf_Addr base, bool add_p_vaddr,
245 : : bool sanity)
246 : : {
247 : 570 : GElf_Addr vaddr, address_sync, start, end, bias;
248 : 570 : GElf_Half e_type;
249 [ + - ]: 570 : if (! __libdwfl_elf_address_range (elf, base, add_p_vaddr, sanity, &vaddr,
250 : : &address_sync, &start, &end, &bias,
251 : : &e_type))
252 : : return NULL;
253 : 570 : Dwfl_Module *m = INTUSE(dwfl_report_module) (dwfl, name, start, end);
254 [ + - ]: 570 : if (m != NULL)
255 : : {
256 [ + - ]: 570 : if (m->main.name == NULL)
257 : : {
258 : 570 : m->main.name = strdup (file_name);
259 : 570 : m->main.fd = fd;
260 : : }
261 [ # # # # ]: 0 : else if ((fd >= 0 && m->main.fd != fd)
262 [ # # ]: 0 : || strcmp (m->main.name, file_name))
263 : : {
264 : 0 : overlap:
265 : 0 : m->gc = true;
266 : 0 : __libdwfl_seterrno (DWFL_E_OVERLAP);
267 : 0 : return NULL;
268 : : }
269 : :
270 : : /* Preinstall the open ELF handle for the module. */
271 [ + - ]: 570 : if (m->main.elf == NULL)
272 : : {
273 : 570 : m->main.elf = elf;
274 : 570 : m->main.vaddr = vaddr;
275 : 570 : m->main.address_sync = address_sync;
276 : 570 : m->main_bias = bias;
277 : 570 : m->e_type = e_type;
278 : : }
279 : : else
280 : : {
281 : 0 : elf_end (elf);
282 [ # # ]: 0 : if (m->main_bias != bias
283 [ # # # # ]: 0 : || m->main.vaddr != vaddr || m->main.address_sync != address_sync)
284 : : goto overlap;
285 : : }
286 : : }
287 : : return m;
288 : : }
289 : :
290 : : Dwfl_Module *
291 : 4 : dwfl_report_elf (Dwfl *dwfl, const char *name, const char *file_name, int fd,
292 : : GElf_Addr base, bool add_p_vaddr)
293 : : {
294 : 4 : bool closefd = false;
295 [ + - ]: 4 : if (fd < 0)
296 : : {
297 : 4 : closefd = true;
298 : 4 : fd = open (file_name, O_RDONLY);
299 [ - + ]: 4 : if (fd < 0)
300 : : {
301 : 0 : __libdwfl_seterrno (DWFL_E_ERRNO);
302 : 0 : return NULL;
303 : : }
304 : : }
305 : :
306 : 4 : Elf *elf;
307 : 4 : Dwfl_Error error = __libdw_open_file (&fd, &elf, closefd, false);
308 [ - + ]: 4 : if (error != DWFL_E_NOERROR)
309 : : {
310 : 0 : __libdwfl_seterrno (error);
311 : 0 : return NULL;
312 : : }
313 : :
314 : 4 : Dwfl_Module *mod = __libdwfl_report_elf (dwfl, name, file_name,
315 : : fd, elf, base, add_p_vaddr, true);
316 [ - + ]: 4 : if (mod == NULL)
317 : : {
318 : 0 : elf_end (elf);
319 [ # # ]: 0 : if (closefd)
320 : 0 : close (fd);
321 : : }
322 : :
323 : : return mod;
324 : : }
325 : : INTDEF (dwfl_report_elf)
326 : : NEW_VERSION (dwfl_report_elf, ELFUTILS_0.156)
327 : :
328 : : #ifdef SYMBOL_VERSIONING
329 : : Dwfl_Module *
330 : : _compat_without_add_p_vaddr_dwfl_report_elf (Dwfl *dwfl, const char *name,
331 : : const char *file_name, int fd,
332 : : GElf_Addr base);
333 : : COMPAT_VERSION_NEWPROTO (dwfl_report_elf, ELFUTILS_0.122, without_add_p_vaddr)
334 : :
335 : : Dwfl_Module *
336 : : _compat_without_add_p_vaddr_dwfl_report_elf (Dwfl *dwfl, const char *name,
337 : : const char *file_name, int fd,
338 : : GElf_Addr base)
339 : : {
340 : : return dwfl_report_elf (dwfl, name, file_name, fd, base, true);
341 : : }
342 : : #endif
|
