The Tor Browser: comparison tools/profiler/AutoObjectMapper.cpp

--1:000000000000
+:4217123c65fc
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include <sys/mman.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include "mozilla/Assertions.h"
+#include "mozilla/NullPtr.h"
+#include "PlatformMacros.h"
+#include "AutoObjectMapper.h"
+#if defined(SPS_OS_android) && !defined(MOZ_WIDGET_GONK)
+# include <dlfcn.h>
+# include "mozilla/Types.h"
+// FIXME move these out of mozglue/linker/ElfLoader.h into their
+// own header, so as to avoid conflicts arising from two definitions
+// of Array
+extern "C" {
+MFBT_API size_t
+__dl_get_mappable_length(void *handle);
+MFBT_API void *
+__dl_mmap(void *handle, void *addr, size_t length, off_t offset);
+MFBT_API void
+__dl_munmap(void *handle, void *addr, size_t length);
+}
+// The following are for get_installation_lib_dir()
+# include "nsString.h"
+# include "nsDirectoryServiceUtils.h"
+# include "nsDirectoryServiceDefs.h"
+#endif
+// A helper function for creating failure error messages in
+// AutoObjectMapper*::Map.
+static void
+failedToMessage(void(*aLog)(const char*),
+const char* aHowFailed, std::string aFileName)
+{
+char buf[300];
+snprintf(buf, sizeof(buf), "AutoObjectMapper::Map: Failed to %s \'%s\'",
+aHowFailed, aFileName.c_str());
+buf[sizeof(buf)-1] = 0;
+aLog(buf);
+}
+AutoObjectMapperPOSIX::AutoObjectMapperPOSIX(void(*aLog)(const char*))
+: mImage(nullptr)
+, mSize(0)
+, mLog(aLog)
+, mIsMapped(false)
+{}
+AutoObjectMapperPOSIX::~AutoObjectMapperPOSIX() {
+if (!mIsMapped) {
+// There's nothing to do.
+MOZ_ASSERT(!mImage);
+MOZ_ASSERT(mSize == 0);
+return;
+}
+MOZ_ASSERT(mSize > 0);
+// The following assertion doesn't necessarily have to be true,
+// but we assume (reasonably enough) that no mmap facility would
+// be crazy enough to map anything at page zero.
+MOZ_ASSERT(mImage);
+munmap(mImage, mSize);
+}
+bool AutoObjectMapperPOSIX::Map(/*OUT*/void** start, /*OUT*/size_t* length,
+std::string fileName)
+{
+MOZ_ASSERT(!mIsMapped);
+int fd = open(fileName.c_str(), O_RDONLY);
+if (fd == -1) {
+failedToMessage(mLog, "open", fileName);
+return false;
+}
+struct stat st;
+int    err = fstat(fd, &st);
+size_t sz  = (err == 0) ? st.st_size : 0;
+if (err != 0 || sz == 0) {
+failedToMessage(mLog, "fstat", fileName);
+close(fd);
+return false;
+}
+void* image = mmap(nullptr, sz, PROT_READ, MAP_SHARED, fd, 0);
+if (image == MAP_FAILED) {
+failedToMessage(mLog, "mmap", fileName);
+close(fd);
+return false;
+}
+close(fd);
+mIsMapped = true;
+mImage = *start  = image;
+mSize  = *length = sz;
+return true;
+}
+#if defined(SPS_OS_android) && !defined(MOZ_WIDGET_GONK)
+// A helper function for AutoObjectMapperFaultyLib::Map.  Finds out
+// where the installation's lib directory is, since we'll have to look
+// in there to get hold of libmozglue.so.  Returned C string is heap
+// allocated and the caller must deallocate it.
+static char*
+get_installation_lib_dir()
+{
+nsCOMPtr<nsIProperties>
+directoryService(do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID));
+if (!directoryService) {
+return nullptr;
+}
+nsCOMPtr<nsIFile> greDir;
+nsresult rv = directoryService->Get(NS_GRE_DIR, NS_GET_IID(nsIFile),
+getter_AddRefs(greDir));
+if (NS_FAILED(rv)) return nullptr;
+nsCString path;
+rv = greDir->GetNativePath(path);
+if (NS_FAILED(rv)) {
+return nullptr;
+}
+return strdup(path.get());
+}
+AutoObjectMapperFaultyLib::AutoObjectMapperFaultyLib(void(*aLog)(const char*))
+: AutoObjectMapperPOSIX(aLog)
+, mHdl(nullptr)
+{}
+AutoObjectMapperFaultyLib::~AutoObjectMapperFaultyLib() {
+if (mHdl) {
+// We've got an object mapped by faulty.lib.  Unmap it via faulty.lib.
+MOZ_ASSERT(mSize > 0);
+// Assert on the basis that no valid mapping would start at page zero.
+MOZ_ASSERT(mImage);
+__dl_munmap(mHdl, mImage, mSize);
+dlclose(mHdl);
+// Stop assertions in ~AutoObjectMapperPOSIX from failing.
+mImage = nullptr;
+mSize  = 0;
+}
+// At this point the parent class destructor, ~AutoObjectMapperPOSIX,
+// gets called.  If that has something mapped in the normal way, it
+// will unmap it in the normal way.  Unfortunately there's no
+// obvious way to enforce the requirement that the object is mapped
+// either by faulty.lib or by the parent class, but not by both.
+}
+bool AutoObjectMapperFaultyLib::Map(/*OUT*/void** start, /*OUT*/size_t* length,
+std::string fileName)
+{
+MOZ_ASSERT(!mHdl);
+if (fileName == "libmozglue.so") {
+// Do (2) in the comment above.
+char* libdir = get_installation_lib_dir();
+if (libdir) {
+fileName = std::string(libdir) + "/lib/" + fileName;
+free(libdir);
+}
+// Hand the problem off to the standard mapper.
+return AutoObjectMapperPOSIX::Map(start, length, fileName);
+} else {
+// Do cases (1) and (3) in the comment above.  We have to
+// grapple with faulty.lib directly.
+void* hdl = dlopen(fileName.c_str(), RTLD_GLOBAL | RTLD_LAZY);
+if (!hdl) {
+failedToMessage(mLog, "get handle for ELF file", fileName);
+return false;
+}
+size_t sz = __dl_get_mappable_length(hdl);
+if (sz == 0) {
+dlclose(hdl);
+failedToMessage(mLog, "get size for ELF file", fileName);
+return false;
+}
+void* image = __dl_mmap(hdl, nullptr, sz, 0);
+if (image == MAP_FAILED) {
+dlclose(hdl);
+failedToMessage(mLog, "mmap ELF file", fileName);
+return false;
+}
+mHdl   = hdl;
+mImage = *start  = image;
+mSize  = *length = sz;
+return true;
+}
+}
+#endif // defined(SPS_OS_android) && !defined(MOZ_WIDGET_GONK)

The Tor Browser / file comparison

comparison: tools/profiler/AutoObjectMapper.cpp

tools/profiler/AutoObjectMapper.cpp