| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2008, Google Inc. | |
| 2 // All rights reserved. | |
| 3 // | |
| 4 // Redistribution and use in source and binary forms, with or without | |
| 5 // modification, are permitted provided that the following conditions are | |
| 6 // met: | |
| 7 // | |
| 8 // * Redistributions of source code must retain the above copyright | |
| 9 // notice, this list of conditions and the following disclaimer. | |
| 10 // * Redistributions in binary form must reproduce the above | |
| 11 // copyright notice, this list of conditions and the following disclaimer | |
| 12 // in the documentation and/or other materials provided with the | |
| 13 // distribution. | |
| 14 // * Neither the name of Google Inc. nor the names of its | |
| 15 // contributors may be used to endorse or promote products derived from | |
| 16 // this software without specific prior written permission. | |
| 17 // | |
| 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 29 | |
| 30 // --- | |
| 31 // Author: Paul Pluzhnikov | |
| 32 // | |
| 33 // Allow dynamic symbol lookup in an in-memory Elf image. | |
| 34 // | |
| 35 | |
| 36 #include "base/elf_mem_image.h" | |
| 37 | |
| 38 #ifdef HAVE_ELF_MEM_IMAGE // defined in elf_mem_image.h | |
| 39 | |
| 40 #include <stddef.h> // for size_t, ptrdiff_t | |
| 41 #include "base/logging.h" | |
| 42 | |
| 43 // From binutils/include/elf/common.h (this doesn't appear to be documented | |
| 44 // anywhere else). | |
| 45 // | |
| 46 // /* This flag appears in a Versym structure. It means that the symbol | |
| 47 // is hidden, and is only visible with an explicit version number. | |
| 48 // This is a GNU extension. */ | |
| 49 // #define VERSYM_HIDDEN 0x8000 | |
| 50 // | |
| 51 // /* This is the mask for the rest of the Versym information. */ | |
| 52 // #define VERSYM_VERSION 0x7fff | |
| 53 | |
| 54 #define VERSYM_VERSION 0x7fff | |
| 55 | |
| 56 namespace base { | |
| 57 | |
| 58 namespace { | |
| 59 template <int N> class ElfClass { | |
| 60 public: | |
| 61 static const int kElfClass = -1; | |
| 62 static int ElfBind(const ElfW(Sym) *) { | |
| 63 CHECK(false); // << "Unexpected word size"; | |
| 64 return 0; | |
| 65 } | |
| 66 static int ElfType(const ElfW(Sym) *) { | |
| 67 CHECK(false); // << "Unexpected word size"; | |
| 68 return 0; | |
| 69 } | |
| 70 }; | |
| 71 | |
| 72 template <> class ElfClass<32> { | |
| 73 public: | |
| 74 static const int kElfClass = ELFCLASS32; | |
| 75 static int ElfBind(const ElfW(Sym) *symbol) { | |
| 76 return ELF32_ST_BIND(symbol->st_info); | |
| 77 } | |
| 78 static int ElfType(const ElfW(Sym) *symbol) { | |
| 79 return ELF32_ST_TYPE(symbol->st_info); | |
| 80 } | |
| 81 }; | |
| 82 | |
| 83 template <> class ElfClass<64> { | |
| 84 public: | |
| 85 static const int kElfClass = ELFCLASS64; | |
| 86 static int ElfBind(const ElfW(Sym) *symbol) { | |
| 87 return ELF64_ST_BIND(symbol->st_info); | |
| 88 } | |
| 89 static int ElfType(const ElfW(Sym) *symbol) { | |
| 90 return ELF64_ST_TYPE(symbol->st_info); | |
| 91 } | |
| 92 }; | |
| 93 | |
| 94 typedef ElfClass<__WORDSIZE> CurrentElfClass; | |
| 95 | |
| 96 // Extract an element from one of the ELF tables, cast it to desired type. | |
| 97 // This is just a simple arithmetic and a glorified cast. | |
| 98 // Callers are responsible for bounds checking. | |
| 99 template <class T> | |
| 100 const T* GetTableElement(const ElfW(Ehdr) *ehdr, | |
| 101 ElfW(Off) table_offset, | |
| 102 ElfW(Word) element_size, | |
| 103 size_t index) { | |
| 104 return reinterpret_cast<const T*>(reinterpret_cast<const char *>(ehdr) | |
| 105 + table_offset | |
| 106 + index * element_size); | |
| 107 } | |
| 108 } // namespace | |
| 109 | |
| 110 const void *const ElfMemImage::kInvalidBase = | |
| 111 reinterpret_cast<const void *>(~0L); | |
| 112 | |
| 113 ElfMemImage::ElfMemImage(const void *base) { | |
| 114 CHECK(base != kInvalidBase); | |
| 115 Init(base); | |
| 116 } | |
| 117 | |
| 118 int ElfMemImage::GetNumSymbols() const { | |
| 119 if (!hash_) { | |
| 120 return 0; | |
| 121 } | |
| 122 // See http://www.caldera.com/developers/gabi/latest/ch5.dynamic.html#hash | |
| 123 return hash_[1]; | |
| 124 } | |
| 125 | |
| 126 const ElfW(Sym) *ElfMemImage::GetDynsym(int index) const { | |
| 127 CHECK_LT(index, GetNumSymbols()); | |
| 128 return dynsym_ + index; | |
| 129 } | |
| 130 | |
| 131 const ElfW(Versym) *ElfMemImage::GetVersym(int index) const { | |
| 132 CHECK_LT(index, GetNumSymbols()); | |
| 133 return versym_ + index; | |
| 134 } | |
| 135 | |
| 136 const ElfW(Phdr) *ElfMemImage::GetPhdr(int index) const { | |
| 137 CHECK_LT(index, ehdr_->e_phnum); | |
| 138 return GetTableElement<ElfW(Phdr)>(ehdr_, | |
| 139 ehdr_->e_phoff, | |
| 140 ehdr_->e_phentsize, | |
| 141 index); | |
| 142 } | |
| 143 | |
| 144 const char *ElfMemImage::GetDynstr(ElfW(Word) offset) const { | |
| 145 CHECK_LT(offset, strsize_); | |
| 146 return dynstr_ + offset; | |
| 147 } | |
| 148 | |
| 149 const void *ElfMemImage::GetSymAddr(const ElfW(Sym) *sym) const { | |
| 150 if (sym->st_shndx == SHN_UNDEF || sym->st_shndx >= SHN_LORESERVE) { | |
| 151 // Symbol corresponds to "special" (e.g. SHN_ABS) section. | |
| 152 return reinterpret_cast<const void *>(sym->st_value); | |
| 153 } | |
| 154 CHECK_LT(link_base_, sym->st_value); | |
| 155 return GetTableElement<char>(ehdr_, 0, 1, sym->st_value) - link_base_; | |
| 156 } | |
| 157 | |
| 158 const ElfW(Verdef) *ElfMemImage::GetVerdef(int index) const { | |
| 159 CHECK_LE(index, verdefnum_); | |
| 160 const ElfW(Verdef) *version_definition = verdef_; | |
| 161 while (version_definition->vd_ndx < index && version_definition->vd_next) { | |
| 162 const char *const version_definition_as_char = | |
| 163 reinterpret_cast<const char *>(version_definition); | |
| 164 version_definition = | |
| 165 reinterpret_cast<const ElfW(Verdef) *>(version_definition_as_char + | |
| 166 version_definition->vd_next); | |
| 167 } | |
| 168 return version_definition->vd_ndx == index ? version_definition : NULL; | |
| 169 } | |
| 170 | |
| 171 const ElfW(Verdaux) *ElfMemImage::GetVerdefAux( | |
| 172 const ElfW(Verdef) *verdef) const { | |
| 173 return reinterpret_cast<const ElfW(Verdaux) *>(verdef+1); | |
| 174 } | |
| 175 | |
| 176 const char *ElfMemImage::GetVerstr(ElfW(Word) offset) const { | |
| 177 CHECK_LT(offset, strsize_); | |
| 178 return dynstr_ + offset; | |
| 179 } | |
| 180 | |
| 181 void ElfMemImage::Init(const void *base) { | |
| 182 ehdr_ = NULL; | |
| 183 dynsym_ = NULL; | |
| 184 dynstr_ = NULL; | |
| 185 versym_ = NULL; | |
| 186 verdef_ = NULL; | |
| 187 hash_ = NULL; | |
| 188 strsize_ = 0; | |
| 189 verdefnum_ = 0; | |
| 190 link_base_ = ~0L; // Sentinel: PT_LOAD .p_vaddr can't possibly be this. | |
| 191 if (!base) { | |
| 192 return; | |
| 193 } | |
| 194 const intptr_t base_as_uintptr_t = reinterpret_cast<uintptr_t>(base); | |
| 195 // Fake VDSO has low bit set. | |
| 196 const bool fake_vdso = ((base_as_uintptr_t & 1) != 0); | |
| 197 base = reinterpret_cast<const void *>(base_as_uintptr_t & ~1); | |
| 198 const char *const base_as_char = reinterpret_cast<const char *>(base); | |
| 199 if (base_as_char[EI_MAG0] != ELFMAG0 || base_as_char[EI_MAG1] != ELFMAG1 || | |
| 200 base_as_char[EI_MAG2] != ELFMAG2 || base_as_char[EI_MAG3] != ELFMAG3) { | |
| 201 RAW_DCHECK(false, "no ELF magic"); // at %p", base); | |
| 202 return; | |
| 203 } | |
| 204 int elf_class = base_as_char[EI_CLASS]; | |
| 205 if (elf_class != CurrentElfClass::kElfClass) { | |
| 206 DCHECK_EQ(elf_class, CurrentElfClass::kElfClass); | |
| 207 return; | |
| 208 } | |
| 209 switch (base_as_char[EI_DATA]) { | |
| 210 case ELFDATA2LSB: { | |
| 211 if (__LITTLE_ENDIAN != __BYTE_ORDER) { | |
| 212 DCHECK_EQ(__LITTLE_ENDIAN, __BYTE_ORDER); // << ": wrong byte order"; | |
| 213 return; | |
| 214 } | |
| 215 break; | |
| 216 } | |
| 217 case ELFDATA2MSB: { | |
| 218 if (__BIG_ENDIAN != __BYTE_ORDER) { | |
| 219 DCHECK_EQ(__BIG_ENDIAN, __BYTE_ORDER); // << ": wrong byte order"; | |
| 220 return; | |
| 221 } | |
| 222 break; | |
| 223 } | |
| 224 default: { | |
| 225 RAW_DCHECK(false, "unexpected data encoding"); // << base_as_char[EI_DATA]
; | |
| 226 return; | |
| 227 } | |
| 228 } | |
| 229 | |
| 230 ehdr_ = reinterpret_cast<const ElfW(Ehdr) *>(base); | |
| 231 const ElfW(Phdr) *dynamic_program_header = NULL; | |
| 232 for (int i = 0; i < ehdr_->e_phnum; ++i) { | |
| 233 const ElfW(Phdr) *const program_header = GetPhdr(i); | |
| 234 switch (program_header->p_type) { | |
| 235 case PT_LOAD: | |
| 236 if (link_base_ == ~0L) { | |
| 237 link_base_ = program_header->p_vaddr; | |
| 238 } | |
| 239 break; | |
| 240 case PT_DYNAMIC: | |
| 241 dynamic_program_header = program_header; | |
| 242 break; | |
| 243 } | |
| 244 } | |
| 245 if (link_base_ == ~0L || !dynamic_program_header) { | |
| 246 RAW_DCHECK(~0L != link_base_, "no PT_LOADs in VDSO"); | |
| 247 RAW_DCHECK(dynamic_program_header, "no PT_DYNAMIC in VDSO"); | |
| 248 // Mark this image as not present. Can not recur infinitely. | |
| 249 Init(0); | |
| 250 return; | |
| 251 } | |
| 252 ptrdiff_t relocation = | |
| 253 base_as_char - reinterpret_cast<const char *>(link_base_); | |
| 254 ElfW(Dyn) *dynamic_entry = | |
| 255 reinterpret_cast<ElfW(Dyn) *>(dynamic_program_header->p_vaddr + | |
| 256 relocation); | |
| 257 for (; dynamic_entry->d_tag != DT_NULL; ++dynamic_entry) { | |
| 258 ElfW(Xword) value = dynamic_entry->d_un.d_val; | |
| 259 if (fake_vdso) { | |
| 260 // A complication: in the real VDSO, dynamic entries are not relocated | |
| 261 // (it wasn't loaded by a dynamic loader). But when testing with a | |
| 262 // "fake" dlopen()ed vdso library, the loader relocates some (but | |
| 263 // not all!) of them before we get here. | |
| 264 if (dynamic_entry->d_tag == DT_VERDEF) { | |
| 265 // The only dynamic entry (of the ones we care about) libc-2.3.6 | |
| 266 // loader doesn't relocate. | |
| 267 value += relocation; | |
| 268 } | |
| 269 } else { | |
| 270 // Real VDSO. Everything needs to be relocated. | |
| 271 value += relocation; | |
| 272 } | |
| 273 switch (dynamic_entry->d_tag) { | |
| 274 case DT_HASH: | |
| 275 hash_ = reinterpret_cast<ElfW(Word) *>(value); | |
| 276 break; | |
| 277 case DT_SYMTAB: | |
| 278 dynsym_ = reinterpret_cast<ElfW(Sym) *>(value); | |
| 279 break; | |
| 280 case DT_STRTAB: | |
| 281 dynstr_ = reinterpret_cast<const char *>(value); | |
| 282 break; | |
| 283 case DT_VERSYM: | |
| 284 versym_ = reinterpret_cast<ElfW(Versym) *>(value); | |
| 285 break; | |
| 286 case DT_VERDEF: | |
| 287 verdef_ = reinterpret_cast<ElfW(Verdef) *>(value); | |
| 288 break; | |
| 289 case DT_VERDEFNUM: | |
| 290 verdefnum_ = dynamic_entry->d_un.d_val; | |
| 291 break; | |
| 292 case DT_STRSZ: | |
| 293 strsize_ = dynamic_entry->d_un.d_val; | |
| 294 break; | |
| 295 default: | |
| 296 // Unrecognized entries explicitly ignored. | |
| 297 break; | |
| 298 } | |
| 299 } | |
| 300 if (!hash_ || !dynsym_ || !dynstr_ || !versym_ || | |
| 301 !verdef_ || !verdefnum_ || !strsize_) { | |
| 302 RAW_DCHECK(hash_, "invalid VDSO (no DT_HASH)"); | |
| 303 RAW_DCHECK(dynsym_, "invalid VDSO (no DT_SYMTAB)"); | |
| 304 RAW_DCHECK(dynstr_, "invalid VDSO (no DT_STRTAB)"); | |
| 305 RAW_DCHECK(versym_, "invalid VDSO (no DT_VERSYM)"); | |
| 306 RAW_DCHECK(verdef_, "invalid VDSO (no DT_VERDEF)"); | |
| 307 RAW_DCHECK(verdefnum_, "invalid VDSO (no DT_VERDEFNUM)"); | |
| 308 RAW_DCHECK(strsize_, "invalid VDSO (no DT_STRSZ)"); | |
| 309 // Mark this image as not present. Can not recur infinitely. | |
| 310 Init(0); | |
| 311 return; | |
| 312 } | |
| 313 } | |
| 314 | |
| 315 bool ElfMemImage::LookupSymbol(const char *name, | |
| 316 const char *version, | |
| 317 int type, | |
| 318 SymbolInfo *info) const { | |
| 319 for (SymbolIterator it = begin(); it != end(); ++it) { | |
| 320 if (strcmp(it->name, name) == 0 && strcmp(it->version, version) == 0 && | |
| 321 CurrentElfClass::ElfType(it->symbol) == type) { | |
| 322 if (info) { | |
| 323 *info = *it; | |
| 324 } | |
| 325 return true; | |
| 326 } | |
| 327 } | |
| 328 return false; | |
| 329 } | |
| 330 | |
| 331 bool ElfMemImage::LookupSymbolByAddress(const void *address, | |
| 332 SymbolInfo *info_out) const { | |
| 333 for (SymbolIterator it = begin(); it != end(); ++it) { | |
| 334 const char *const symbol_start = | |
| 335 reinterpret_cast<const char *>(it->address); | |
| 336 const char *const symbol_end = symbol_start + it->symbol->st_size; | |
| 337 if (symbol_start <= address && address < symbol_end) { | |
| 338 if (info_out) { | |
| 339 // Client wants to know details for that symbol (the usual case). | |
| 340 if (CurrentElfClass::ElfBind(it->symbol) == STB_GLOBAL) { | |
| 341 // Strong symbol; just return it. | |
| 342 *info_out = *it; | |
| 343 return true; | |
| 344 } else { | |
| 345 // Weak or local. Record it, but keep looking for a strong one. | |
| 346 *info_out = *it; | |
| 347 } | |
| 348 } else { | |
| 349 // Client only cares if there is an overlapping symbol. | |
| 350 return true; | |
| 351 } | |
| 352 } | |
| 353 } | |
| 354 return false; | |
| 355 } | |
| 356 | |
| 357 ElfMemImage::SymbolIterator::SymbolIterator(const void *const image, int index) | |
| 358 : index_(index), image_(image) { | |
| 359 } | |
| 360 | |
| 361 const ElfMemImage::SymbolInfo *ElfMemImage::SymbolIterator::operator->() const { | |
| 362 return &info_; | |
| 363 } | |
| 364 | |
| 365 const ElfMemImage::SymbolInfo& ElfMemImage::SymbolIterator::operator*() const { | |
| 366 return info_; | |
| 367 } | |
| 368 | |
| 369 bool ElfMemImage::SymbolIterator::operator==(const SymbolIterator &rhs) const { | |
| 370 return this->image_ == rhs.image_ && this->index_ == rhs.index_; | |
| 371 } | |
| 372 | |
| 373 bool ElfMemImage::SymbolIterator::operator!=(const SymbolIterator &rhs) const { | |
| 374 return !(*this == rhs); | |
| 375 } | |
| 376 | |
| 377 ElfMemImage::SymbolIterator &ElfMemImage::SymbolIterator::operator++() { | |
| 378 this->Update(1); | |
| 379 return *this; | |
| 380 } | |
| 381 | |
| 382 ElfMemImage::SymbolIterator ElfMemImage::begin() const { | |
| 383 SymbolIterator it(this, 0); | |
| 384 it.Update(0); | |
| 385 return it; | |
| 386 } | |
| 387 | |
| 388 ElfMemImage::SymbolIterator ElfMemImage::end() const { | |
| 389 return SymbolIterator(this, GetNumSymbols()); | |
| 390 } | |
| 391 | |
| 392 void ElfMemImage::SymbolIterator::Update(int increment) { | |
| 393 const ElfMemImage *image = reinterpret_cast<const ElfMemImage *>(image_); | |
| 394 CHECK(image->IsPresent() || increment == 0); | |
| 395 if (!image->IsPresent()) { | |
| 396 return; | |
| 397 } | |
| 398 index_ += increment; | |
| 399 if (index_ >= image->GetNumSymbols()) { | |
| 400 index_ = image->GetNumSymbols(); | |
| 401 return; | |
| 402 } | |
| 403 const ElfW(Sym) *symbol = image->GetDynsym(index_); | |
| 404 const ElfW(Versym) *version_symbol = image->GetVersym(index_); | |
| 405 CHECK(symbol && version_symbol); | |
| 406 const char *const symbol_name = image->GetDynstr(symbol->st_name); | |
| 407 const ElfW(Versym) version_index = version_symbol[0] & VERSYM_VERSION; | |
| 408 const ElfW(Verdef) *version_definition = NULL; | |
| 409 const char *version_name = ""; | |
| 410 if (symbol->st_shndx == SHN_UNDEF) { | |
| 411 // Undefined symbols reference DT_VERNEED, not DT_VERDEF, and | |
| 412 // version_index could well be greater than verdefnum_, so calling | |
| 413 // GetVerdef(version_index) may trigger assertion. | |
| 414 } else { | |
| 415 version_definition = image->GetVerdef(version_index); | |
| 416 } | |
| 417 if (version_definition) { | |
| 418 // I am expecting 1 or 2 auxiliary entries: 1 for the version itself, | |
| 419 // optional 2nd if the version has a parent. | |
| 420 CHECK_LE(1, version_definition->vd_cnt); | |
| 421 CHECK_LE(version_definition->vd_cnt, 2); | |
| 422 const ElfW(Verdaux) *version_aux = image->GetVerdefAux(version_definition); | |
| 423 version_name = image->GetVerstr(version_aux->vda_name); | |
| 424 } | |
| 425 info_.name = symbol_name; | |
| 426 info_.version = version_name; | |
| 427 info_.address = image->GetSymAddr(symbol); | |
| 428 info_.symbol = symbol; | |
| 429 } | |
| 430 | |
| 431 } // namespace base | |
| 432 | |
| 433 #endif // HAVE_ELF_MEM_IMAGE | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 9667026:
Revert 126020 - Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0). (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/