1/* Recover relocatibility for addresses computed from debug information.
2   Copyright (C) 2005-2009, 2012 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#include "libdwflP.h"
30#include <fcntl.h>
31#include <unistd.h>
32
33/* Since dwfl_report_elf lays out the sections already, this will only be
34   called when the section headers of the debuginfo file are being
35   consulted instead, or for the section placed at 0.  With binutils
36   strip-to-debug, the symbol table is in the debuginfo file and relocation
37   looks there.  */
38int
39dwfl_offline_section_address (Dwfl_Module *mod,
40			      void **userdata __attribute__ ((unused)),
41			      const char *modname __attribute__ ((unused)),
42			      Dwarf_Addr base __attribute__ ((unused)),
43			      const char *secname __attribute__ ((unused)),
44			      Elf32_Word shndx,
45			      const GElf_Shdr *shdr __attribute__ ((unused)),
46			      Dwarf_Addr *addr)
47{
48  assert (mod->e_type == ET_REL);
49  assert (shdr->sh_addr == 0);
50  assert (shdr->sh_flags & SHF_ALLOC);
51  assert (shndx != 0);
52
53  if (mod->debug.elf == NULL)
54    /* We are only here because sh_addr is zero even though layout is complete.
55       The first section in the first file under -e is placed at 0.  */
56    return 0;
57
58  /* The section numbers might not match between the two files.
59     The best we can rely on is the order of SHF_ALLOC sections.  */
60
61  Elf_Scn *ourscn = elf_getscn (mod->debug.elf, shndx);
62  Elf_Scn *scn = NULL;
63  uint_fast32_t skip_alloc = 0;
64  while ((scn = elf_nextscn (mod->debug.elf, scn)) != ourscn)
65    {
66      assert (scn != NULL);
67      GElf_Shdr shdr_mem;
68      GElf_Shdr *sh = gelf_getshdr (scn, &shdr_mem);
69      if (unlikely (sh == NULL))
70	return -1;
71      if (sh->sh_flags & SHF_ALLOC)
72	++skip_alloc;
73    }
74
75  scn = NULL;
76  while ((scn = elf_nextscn (mod->main.elf, scn)) != NULL)
77    {
78      GElf_Shdr shdr_mem;
79      GElf_Shdr *main_shdr = gelf_getshdr (scn, &shdr_mem);
80      if (unlikely (main_shdr == NULL))
81	return -1;
82      if ((main_shdr->sh_flags & SHF_ALLOC) && skip_alloc-- == 0)
83	{
84	  assert (main_shdr->sh_flags == shdr->sh_flags);
85	  *addr = main_shdr->sh_addr;
86	  return 0;
87	}
88    }
89
90  /* This should never happen.  */
91  return -1;
92}
93INTDEF (dwfl_offline_section_address)
94
95/* Forward declarations.  */
96static Dwfl_Module *process_elf (Dwfl *dwfl, const char *name,
97				 const char *file_name, int fd, Elf *elf);
98static Dwfl_Module *process_archive (Dwfl *dwfl, const char *name,
99				     const char *file_name, int fd, Elf *elf,
100				     int (*predicate) (const char *module,
101						       const char *file));
102
103/* Report one module for an ELF file, or many for an archive.
104   Always consumes ELF and FD.  */
105static Dwfl_Module *
106process_file (Dwfl *dwfl, const char *name, const char *file_name, int fd,
107	      Elf *elf, int (*predicate) (const char *module,
108					  const char *file))
109{
110  switch (elf_kind (elf))
111    {
112    default:
113    case ELF_K_NONE:
114      __libdwfl_seterrno (elf == NULL ? DWFL_E_LIBELF : DWFL_E_BADELF);
115      return NULL;
116
117    case ELF_K_ELF:
118      return process_elf (dwfl, name, file_name, fd, elf);
119
120    case ELF_K_AR:
121      return process_archive (dwfl, name, file_name, fd, elf, predicate);
122    }
123}
124
125/* Report the open ELF file as a module.  Always consumes ELF and FD.  */
126static Dwfl_Module *
127process_elf (Dwfl *dwfl, const char *name, const char *file_name, int fd,
128	     Elf *elf)
129{
130  Dwfl_Module *mod = __libdwfl_report_elf (dwfl, name, file_name, fd, elf,
131					   dwfl->offline_next_address, true,
132					   false);
133  if (mod != NULL)
134    {
135      /* If this is an ET_EXEC file with fixed addresses, the address range
136	 it consumed may or may not intersect with the arbitrary range we
137	 will use for relocatable modules.  Make sure we always use a free
138	 range for the offline allocations.  If this module did use
139	 offline_next_address, it may have rounded it up for the module's
140	 alignment requirements.  */
141      if ((dwfl->offline_next_address >= mod->low_addr
142	   || mod->low_addr - dwfl->offline_next_address < OFFLINE_REDZONE)
143	  && dwfl->offline_next_address < mod->high_addr + OFFLINE_REDZONE)
144	dwfl->offline_next_address = mod->high_addr + OFFLINE_REDZONE;
145
146      /* Don't keep the file descriptor around.  */
147      if (mod->main.fd != -1 && elf_cntl (mod->main.elf, ELF_C_FDREAD) == 0)
148	{
149	  close (mod->main.fd);
150	  mod->main.fd = -1;
151	}
152    }
153
154  return mod;
155}
156
157/* Always consumes MEMBER.  Returns elf_next result on success.
158   For errors returns ELF_C_NULL with *MOD set to null.  */
159static Elf_Cmd
160process_archive_member (Dwfl *dwfl, const char *name, const char *file_name,
161			int (*predicate) (const char *module, const char *file),
162			int fd, Elf *member, Dwfl_Module **mod)
163{
164  const Elf_Arhdr *h = elf_getarhdr (member);
165  if (unlikely (h == NULL))
166    {
167      __libdwfl_seterrno (DWFL_E_LIBELF);
168    fail:
169      elf_end (member);
170      *mod = NULL;
171      return ELF_C_NULL;
172    }
173
174  if (!strcmp (h->ar_name, "/") || !strcmp (h->ar_name, "//")
175      || !strcmp (h->ar_name, "/SYM64/"))
176    {
177    skip:;
178      /* Skip this and go to the next.  */
179      Elf_Cmd result = elf_next (member);
180      elf_end (member);
181      return result;
182    }
183
184  char *member_name;
185  if (unlikely (asprintf (&member_name, "%s(%s)", file_name, h->ar_name) < 0))
186    {
187    nomem:
188      __libdwfl_seterrno (DWFL_E_NOMEM);
189      elf_end (member);
190      *mod = NULL;
191      return ELF_C_NULL;
192    }
193
194  char *module_name = NULL;
195  if (name == NULL || name[0] == '\0')
196    name = h->ar_name;
197  else if (unlikely (asprintf (&module_name, "%s:%s", name, h->ar_name) < 0))
198    {
199      free (member_name);
200      goto nomem;
201    }
202  else
203    name = module_name;
204
205  if (predicate != NULL)
206    {
207      /* Let the predicate decide whether to use this one.  */
208      int want = (*predicate) (name, member_name);
209      if (want <= 0)
210	{
211	  free (member_name);
212	  free (module_name);
213	  if (unlikely (want < 0))
214	    {
215	      __libdwfl_seterrno (DWFL_E_CB);
216	      goto fail;
217	    }
218	  goto skip;
219	}
220    }
221
222  /* We let __libdwfl_report_elf cache the fd in mod->main.fd,
223     though it's the same fd for all the members.
224     On module teardown we will close it only on the last Elf reference.  */
225  *mod = process_file (dwfl, name, member_name, fd, member, predicate);
226  free (member_name);
227  free (module_name);
228
229  if (*mod == NULL)		/* process_file called elf_end.  */
230    return ELF_C_NULL;
231
232  /* Advance the archive-reading offset for the next iteration.  */
233  return elf_next (member);
234}
235
236/* Report each member of the archive as its own module.  */
237static Dwfl_Module *
238process_archive (Dwfl *dwfl, const char *name, const char *file_name, int fd,
239		 Elf *archive,
240		 int (*predicate) (const char *module, const char *file))
241
242{
243  Dwfl_Module *mod = NULL;
244  Elf *member = elf_begin (fd, ELF_C_READ_MMAP_PRIVATE, archive);
245  if (unlikely (member == NULL)) /* Empty archive.  */
246    {
247      __libdwfl_seterrno (DWFL_E_BADELF);
248      return NULL;
249    }
250
251  while (process_archive_member (dwfl, name, file_name, predicate,
252				 fd, member, &mod) != ELF_C_NULL)
253    member = elf_begin (fd, ELF_C_READ_MMAP_PRIVATE, archive);
254
255  /* We can drop the archive Elf handle even if we're still using members
256     in live modules.  When the last module's elf_end on a member returns
257     zero, that module will close FD.  If no modules survived the predicate,
258     we are all done with the file right here.  */
259  if (mod != NULL		/* If no modules, caller will clean up.  */
260      && elf_end (archive) == 0)
261    close (fd);
262
263  return mod;
264}
265
266Dwfl_Module *
267internal_function
268__libdwfl_report_offline (Dwfl *dwfl, const char *name,
269			  const char *file_name, int fd, bool closefd,
270			  int (*predicate) (const char *module,
271					    const char *file))
272{
273  Elf *elf;
274  Dwfl_Error error = __libdw_open_file (&fd, &elf, closefd, true);
275  if (error != DWFL_E_NOERROR)
276    {
277      __libdwfl_seterrno (error);
278      return NULL;
279    }
280  Dwfl_Module *mod = process_file (dwfl, name, file_name, fd, elf, predicate);
281  if (mod == NULL)
282    {
283      elf_end (elf);
284      if (closefd)
285	close (fd);
286    }
287  return mod;
288}
289
290Dwfl_Module *
291dwfl_report_offline (Dwfl *dwfl, const char *name,
292		     const char *file_name, int fd)
293{
294  if (dwfl == NULL)
295    return NULL;
296
297  bool closefd = false;
298  if (fd < 0)
299    {
300      closefd = true;
301      fd = open (file_name, O_RDONLY);
302      if (fd < 0)
303	{
304	  __libdwfl_seterrno (DWFL_E_ERRNO);
305	  return NULL;
306	}
307    }
308
309  return __libdwfl_report_offline (dwfl, name, file_name, fd, closefd, NULL);
310}
311INTDEF (dwfl_report_offline)
312