mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-06 04:35:04 +00:00
9bd60ea2d4
--HG-- extra : rebase_source : bd427749667ddd6641eff414879c3706a5cb5f5e
208 lines
5.9 KiB
C++
208 lines
5.9 KiB
C++
/* -*- 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)
|