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