Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0).

third_party/tcmalloc/chromium/src/base/elf_mem_image.cc

 // Copyright (c) 2008, Google Inc.
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
-// 
+//
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
 // Author: Paul Pluzhnikov
 //
-// Allow dynamic symbol lookup in the kernel VDSO page.
-//
-// VDSOSupport -- a class representing kernel VDSO (if present).
+// Allow dynamic symbol lookup in an in-memory Elf image.
 //
 
-#include "base/vdso_support.h"
+#include "base/elf_mem_image.h"
 
-#ifdef HAVE_VDSO_SUPPORT     // defined in vdso_support.h
+#ifdef HAVE_ELF_MEM_IMAGE  // defined in elf_mem_image.h
 
-#include <fcntl.h>
-#include <stddef.h>   // for std::ptrdiff_t
-
-#include "base/atomicops.h"  // for MemoryBarrier
+#include <stddef.h>   // for size_t, ptrdiff_t
 #include "base/logging.h"
-#include "base/linux_syscall_support.h"
-#include "base/dynamic_annotations.h"
-#include "base/basictypes.h"  // for COMPILE_ASSERT
-
-using base::subtle::MemoryBarrier;
-
-#ifndef AT_SYSINFO_EHDR
-#define AT_SYSINFO_EHDR 33
-#endif
 
 // From binutils/include/elf/common.h (this doesn't appear to be documented
 // anywhere else).
 //
 //   /* This flag appears in a Versym structure.  It means that the symbol
 //      is hidden, and is only visible with an explicit version number.
 //      This is a GNU extension.  */
 //   #define VERSYM_HIDDEN           0x8000
 //
 //   /* This is the mask for the rest of the Versym information.  */
@@ skipping 48 matching lines @@
 const T* GetTableElement(const ElfW(Ehdr) *ehdr,
                          ElfW(Off) table_offset,
                          ElfW(Word) element_size,
                          size_t index) {
   return reinterpret_cast<const T*>(reinterpret_cast<const char *>(ehdr)
                                     + table_offset
                                     + index * element_size);
 }
 }  // namespace
 
-const void *const VDSOSupport::kInvalidBase =
+const void *const ElfMemImage::kInvalidBase =
     reinterpret_cast<const void *>(~0L);
 
-const void *VDSOSupport::vdso_base_ = kInvalidBase;
-VDSOSupport::GetCpuFn VDSOSupport::getcpu_fn_ = &InitAndGetCPU;
-
-VDSOSupport::ElfMemImage::ElfMemImage(const void *base) {
+ElfMemImage::ElfMemImage(const void *base) {
   CHECK(base != kInvalidBase);
   Init(base);
 }
 
-int VDSOSupport::ElfMemImage::GetNumSymbols() const {
+int ElfMemImage::GetNumSymbols() const {
   if (!hash_) {
     return 0;
   }
   // See http://www.caldera.com/developers/gabi/latest/ch5.dynamic.html#hash
   return hash_[1];
 }
 
-const ElfW(Sym) *VDSOSupport::ElfMemImage::GetDynsym(int index) const {
+const ElfW(Sym) *ElfMemImage::GetDynsym(int index) const {
   CHECK_LT(index, GetNumSymbols());
   return dynsym_ + index;
 }
 
-const ElfW(Versym) *VDSOSupport::ElfMemImage::GetVersym(int index) const {
+const ElfW(Versym) *ElfMemImage::GetVersym(int index) const {
   CHECK_LT(index, GetNumSymbols());
   return versym_ + index;
 }
 
-const ElfW(Phdr) *VDSOSupport::ElfMemImage::GetPhdr(int index) const {
+const ElfW(Phdr) *ElfMemImage::GetPhdr(int index) const {
   CHECK_LT(index, ehdr_->e_phnum);
   return GetTableElement<ElfW(Phdr)>(ehdr_,
                                      ehdr_->e_phoff,
                                      ehdr_->e_phentsize,
                                      index);
 }
 
-const char *VDSOSupport::ElfMemImage::GetDynstr(ElfW(Word) offset) const {
+const char *ElfMemImage::GetDynstr(ElfW(Word) offset) const {
   CHECK_LT(offset, strsize_);
   return dynstr_ + offset;
 }
 
-const void *VDSOSupport::ElfMemImage::GetSymAddr(const ElfW(Sym) *sym) const {
+const void *ElfMemImage::GetSymAddr(const ElfW(Sym) *sym) const {
   if (sym->st_shndx == SHN_UNDEF || sym->st_shndx >= SHN_LORESERVE) {
     // Symbol corresponds to "special" (e.g. SHN_ABS) section.
     return reinterpret_cast<const void *>(sym->st_value);
   }
   CHECK_LT(link_base_, sym->st_value);
   return GetTableElement<char>(ehdr_, 0, 1, sym->st_value) - link_base_;
 }
 
-const ElfW(Verdef) *VDSOSupport::ElfMemImage::GetVerdef(int index) const {
+const ElfW(Verdef) *ElfMemImage::GetVerdef(int index) const {
   CHECK_LE(index, verdefnum_);
   const ElfW(Verdef) *version_definition = verdef_;
   while (version_definition->vd_ndx < index && version_definition->vd_next) {
     const char *const version_definition_as_char =
         reinterpret_cast<const char *>(version_definition);
     version_definition =
         reinterpret_cast<const ElfW(Verdef) *>(version_definition_as_char +
                                                version_definition->vd_next);
   }
   return version_definition->vd_ndx == index ? version_definition : NULL;
 }
 
-const ElfW(Verdaux) *VDSOSupport::ElfMemImage::GetVerdefAux(
+const ElfW(Verdaux) *ElfMemImage::GetVerdefAux(
     const ElfW(Verdef) *verdef) const {
   return reinterpret_cast<const ElfW(Verdaux) *>(verdef+1);
 }
 
-const char *VDSOSupport::ElfMemImage::GetVerstr(ElfW(Word) offset) const {
+const char *ElfMemImage::GetVerstr(ElfW(Word) offset) const {
   CHECK_LT(offset, strsize_);
   return dynstr_ + offset;
 }
 
-void VDSOSupport::ElfMemImage::Init(const void *base) {
+void ElfMemImage::Init(const void *base) {
   ehdr_      = NULL;
   dynsym_    = NULL;
   dynstr_    = NULL;
   versym_    = NULL;
   verdef_    = NULL;
   hash_      = NULL;
   strsize_   = 0;
   verdefnum_ = 0;
   link_base_ = ~0L;  // Sentinel: PT_LOAD .p_vaddr can't possibly be this.
   if (!base) {
@@ skipping 50 matching lines @@
         break;
     }
   }
   if (link_base_ == ~0L || !dynamic_program_header) {
     RAW_DCHECK(~0L != link_base_, "no PT_LOADs in VDSO");
     RAW_DCHECK(dynamic_program_header, "no PT_DYNAMIC in VDSO");
     // Mark this image as not present. Can not recur infinitely.
     Init(0);
     return;
   }
-  std::ptrdiff_t relocation =
+  ptrdiff_t relocation =
       base_as_char - reinterpret_cast<const char *>(link_base_);
   ElfW(Dyn) *dynamic_entry =
       reinterpret_cast<ElfW(Dyn) *>(dynamic_program_header->p_vaddr +
                                     relocation);
   for (; dynamic_entry->d_tag != DT_NULL; ++dynamic_entry) {
     ElfW(Xword) value = dynamic_entry->d_un.d_val;
     if (fake_vdso) {
       // A complication: in the real VDSO, dynamic entries are not relocated
       // (it wasn't loaded by a dynamic loader). But when testing with a
       // "fake" dlopen()ed vdso library, the loader relocates some (but
@@ skipping 42 matching lines @@
     RAW_DCHECK(versym_, "invalid VDSO (no DT_VERSYM)");
     RAW_DCHECK(verdef_, "invalid VDSO (no DT_VERDEF)");
     RAW_DCHECK(verdefnum_, "invalid VDSO (no DT_VERDEFNUM)");
     RAW_DCHECK(strsize_, "invalid VDSO (no DT_STRSZ)");
     // Mark this image as not present. Can not recur infinitely.
     Init(0);
     return;
   }
 }
 
-VDSOSupport::VDSOSupport()
-    // If vdso_base_ is still set to kInvalidBase, we got here
-    // before VDSOSupport::Init has been called. Call it now.
-    : image_(vdso_base_ == kInvalidBase ? Init() : vdso_base_) {
-}
-
-// NOTE: we can't use GoogleOnceInit() below, because we can be
-// called by tcmalloc, and none of the *once* stuff may be functional yet.
-//
-// In addition, we hope that the VDSOSupportHelper constructor
-// causes this code to run before there are any threads, and before
-// InitGoogle() has executed any chroot or setuid calls.
-//
-// Finally, even if there is a race here, it is harmless, because
-// the operation should be idempotent.
-const void *VDSOSupport::Init() {
-  if (vdso_base_ == kInvalidBase) {
-    // Valgrind zaps AT_SYSINFO_EHDR and friends from the auxv[]
-    // on stack, and so glibc works as if VDSO was not present.
-    // But going directly to kernel via /proc/self/auxv below bypasses
-    // Valgrind zapping. So we check for Valgrind separately.
-    if (RunningOnValgrind()) {
-      vdso_base_ = NULL;
-      getcpu_fn_ = &GetCPUViaSyscall;
-      return NULL;
-    }
-    int fd = open("/proc/self/auxv", O_RDONLY);
-    if (fd == -1) {
-      // Kernel too old to have a VDSO.
-      vdso_base_ = NULL;
-      getcpu_fn_ = &GetCPUViaSyscall;
-      return NULL;
-    }
-    ElfW(auxv_t) aux;
-    while (read(fd, &aux, sizeof(aux)) == sizeof(aux)) {
-      if (aux.a_type == AT_SYSINFO_EHDR) {
-        COMPILE_ASSERT(sizeof(vdso_base_) == sizeof(aux.a_un.a_val),
-                       unexpected_sizeof_pointer_NE_sizeof_a_val);
-        vdso_base_ = reinterpret_cast<void *>(aux.a_un.a_val);
-        break;
-      }
-    }
-    close(fd);
-    if (vdso_base_ == kInvalidBase) {
-      // Didn't find AT_SYSINFO_EHDR in auxv[].
-      vdso_base_ = NULL;
-    }
-  }
-  GetCpuFn fn = &GetCPUViaSyscall;  // default if VDSO not present.
-  if (vdso_base_) {
-    VDSOSupport vdso;
-    SymbolInfo info;
-    if (vdso.LookupSymbol("__vdso_getcpu", "LINUX_2.6", STT_FUNC, &info)) {
-      // Casting from an int to a pointer is not legal C++.  To emphasize
-      // this, we use a C-style cast rather than a C++-style cast.
-      fn = (GetCpuFn)(info.address);
-    }
-  }
-  // Subtle: this code runs outside of any locks; prevent compiler
-  // from assigning to getcpu_fn_ more than once.
-  base::subtle::MemoryBarrier();
-  getcpu_fn_ = fn;
-  return vdso_base_;
-}
-
-const void *VDSOSupport::SetBase(const void *base) {
-  const void *old_base = vdso_base_;
-  vdso_base_ = base;
-  image_.Init(base);
-  // Also reset getcpu_fn_, so GetCPU could be tested with simulated VDSO.
-  getcpu_fn_ = &InitAndGetCPU;
-  return old_base;
-}
-
-bool VDSOSupport::LookupSymbol(const char *name,
+bool ElfMemImage::LookupSymbol(const char *name,
                                const char *version,
                                int type,
                                SymbolInfo *info) const {
   for (SymbolIterator it = begin(); it != end(); ++it) {
     if (strcmp(it->name, name) == 0 && strcmp(it->version, version) == 0 &&
         CurrentElfClass::ElfType(it->symbol) == type) {
       if (info) {
         *info = *it;
       }
       return true;
     }
   }
   return false;
 }
 
-bool VDSOSupport::LookupSymbolByAddress(const void *address,
+bool ElfMemImage::LookupSymbolByAddress(const void *address,
                                         SymbolInfo *info_out) const {
   for (SymbolIterator it = begin(); it != end(); ++it) {
     const char *const symbol_start =
         reinterpret_cast<const char *>(it->address);
     const char *const symbol_end = symbol_start + it->symbol->st_size;
     if (symbol_start <= address && address < symbol_end) {
       if (info_out) {
         // Client wants to know details for that symbol (the usual case).
         if (CurrentElfClass::ElfBind(it->symbol) == STB_GLOBAL) {
           // Strong symbol; just return it.
           *info_out = *it;
           return true;
         } else {
           // Weak or local. Record it, but keep looking for a strong one.
           *info_out = *it;
         }
       } else {
         // Client only cares if there is an overlapping symbol.
         return true;
       }
     }
   }
   return false;
 }
 
-VDSOSupport::SymbolIterator::SymbolIterator(const void *const image, int index)
+ElfMemImage::SymbolIterator::SymbolIterator(const void *const image, int index)
     : index_(index), image_(image) {
 }
 
-const VDSOSupport::SymbolInfo *VDSOSupport::SymbolIterator::operator->() const {
+const ElfMemImage::SymbolInfo *ElfMemImage::SymbolIterator::operator->() const {
   return &info_;
 }
 
-const VDSOSupport::SymbolInfo& VDSOSupport::SymbolIterator::operator*() const {
+const ElfMemImage::SymbolInfo& ElfMemImage::SymbolIterator::operator*() const {
   return info_;
 }
 
-bool VDSOSupport::SymbolIterator::operator==(const SymbolIterator &rhs) const {
+bool ElfMemImage::SymbolIterator::operator==(const SymbolIterator &rhs) const {
   return this->image_ == rhs.image_ && this->index_ == rhs.index_;
 }
 
-bool VDSOSupport::SymbolIterator::operator!=(const SymbolIterator &rhs) const {
+bool ElfMemImage::SymbolIterator::operator!=(const SymbolIterator &rhs) const {
   return !(*this == rhs);
 }
 
-VDSOSupport::SymbolIterator &VDSOSupport::SymbolIterator::operator++() {
+ElfMemImage::SymbolIterator &ElfMemImage::SymbolIterator::operator++() {
   this->Update(1);
   return *this;
 }
 
-VDSOSupport::SymbolIterator VDSOSupport::begin() const {
-  SymbolIterator it(&image_, 0);
+ElfMemImage::SymbolIterator ElfMemImage::begin() const {
+  SymbolIterator it(this, 0);
   it.Update(0);
   return it;
 }
 
-VDSOSupport::SymbolIterator VDSOSupport::end() const {
-  return SymbolIterator(&image_, image_.GetNumSymbols());
+ElfMemImage::SymbolIterator ElfMemImage::end() const {
+  return SymbolIterator(this, GetNumSymbols());
 }
 
-void VDSOSupport::SymbolIterator::Update(int increment) {
+void ElfMemImage::SymbolIterator::Update(int increment) {
   const ElfMemImage *image = reinterpret_cast<const ElfMemImage *>(image_);
   CHECK(image->IsPresent() || increment == 0);
   if (!image->IsPresent()) {
     return;
   }
   index_ += increment;
   if (index_ >= image->GetNumSymbols()) {
     index_ = image->GetNumSymbols();
     return;
   }
@@ skipping 18 matching lines @@
     CHECK_LE(version_definition->vd_cnt, 2);
     const ElfW(Verdaux) *version_aux = image->GetVerdefAux(version_definition);
     version_name = image->GetVerstr(version_aux->vda_name);
   }
   info_.name    = symbol_name;
   info_.version = version_name;
   info_.address = image->GetSymAddr(symbol);
   info_.symbol  = symbol;
 }
 
-// NOLINT on 'long' because this routine mimics kernel api.
-long VDSOSupport::GetCPUViaSyscall(unsigned *cpu, void *, void *) { // NOLINT
-#if defined(__NR_getcpu)
-  return sys_getcpu(cpu, NULL, NULL);
-#else
-  // x86_64 never implemented sys_getcpu(), except as a VDSO call.
-  errno = ENOSYS;
-  return -1;
-#endif
-}
+}  // namespace base
 
-// Use fast __vdso_getcpu if available.
-long VDSOSupport::InitAndGetCPU(unsigned *cpu, void *x, void *y) { // NOLINT
-  Init();
-  CHECK_NE(getcpu_fn_, &InitAndGetCPU); // << "Init() did not set getcpu_fn_";
-  return (*getcpu_fn_)(cpu, x, y);
-}
-
-// This function must be very fast, and may be called from very
-// low level (e.g. tcmalloc). Hence I avoid things like
-// GoogleOnceInit() and ::operator new.
-int GetCPU(void) {
-  unsigned cpu;
-  int ret_code = (*VDSOSupport::getcpu_fn_)(&cpu, NULL, NULL);
-  return ret_code == 0 ? cpu : ret_code;
-}
-
-// We need to make sure VDSOSupport::Init() is called before
-// the main() runs, since it might do something like setuid or
-// chroot.  If VDSOSupport
-// is used in any global constructor, this will happen, since
-// VDSOSupport's constructor calls Init.  But if not, we need to
-// ensure it here, with a global constructor of our own.  This
-// is an allowed exception to the normal rule against non-trivial
-// global constructors.
-static class VDSOInitHelper {
- public:
-  VDSOInitHelper() { VDSOSupport::Init(); }
-} vdso_init_helper;
-}
-
-#endif  // HAVE_VDSO_SUPPORT
+#endif  // HAVE_ELF_MEM_IMAGE