wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 886722 - Rename log/debug to LOG/DEBUG_LOG in faulty.lib. r=nfroyd

Browse Source
This commit is contained in:
Mike Hommey 2013-06-27 09:35:49 +09:00
parent a682d7fe75
commit 8fd281dcec
8 changed files with 175 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
mozglue/linker/CustomElf.cpp
View File

@ -62,7 +62,7 @@ namespace {
void debug_phdr(const char *type, const Phdr *phdr)
{
debug("%s @0x%08" PRIxAddr " ("
DEBUG_LOG("%s @0x%08" PRIxAddr " ("
"filesz: 0x%08" PRIxAddr ", "
"memsz: 0x%08" PRIxAddr ", "
"offset: 0x%08" PRIxAddr ", "
@ -102,7 +102,7 @@ private:
TemporaryRef<LibHandle>
CustomElf::Load(Mappable *mappable, const char *path, int flags)
{
debug("CustomElf::Load(\"%s\", 0x%x) = ...", path, flags);
DEBUG_LOG("CustomElf::Load(\"%s\", 0x%x) = ...", path, flags);
if (!mappable)
return NULL;
/* Keeping a RefPtr of the CustomElf is going to free the appropriate
@ -142,14 +142,14 @@ CustomElf::Load(Mappable *mappable, const char *path, int flags)
if (!dyn) {
dyn = phdr;
} else {
log("%s: Multiple PT_DYNAMIC segments detected", elf->GetPath());
LOG("%s: Multiple PT_DYNAMIC segments detected", elf->GetPath());
return NULL;
}
break;
case PT_TLS:
debug_phdr("PT_TLS", phdr);
if (phdr->p_memsz) {
log("%s: TLS is not supported", elf->GetPath());
LOG("%s: TLS is not supported", elf->GetPath());
return NULL;
}
break;
@ -158,24 +158,24 @@ CustomElf::Load(Mappable *mappable, const char *path, int flags)
// Skip on Android until bug 706116 is fixed
#ifndef ANDROID
if (phdr->p_flags & PF_X) {
log("%s: Executable stack is not supported", elf->GetPath());
LOG("%s: Executable stack is not supported", elf->GetPath());
return NULL;
}
#endif
break;
default:
debug("%s: Warning: program header type #%d not handled",
DEBUG_LOG("%s: Warning: program header type #%d not handled",
elf->GetPath(), phdr->p_type);
}
}
if (min_vaddr != 0) {
log("%s: Unsupported minimal virtual address: 0x%08" PRIxAddr,
LOG("%s: Unsupported minimal virtual address: 0x%08" PRIxAddr,
elf->GetPath(), min_vaddr);
return NULL;
}
if (!dyn) {
log("%s: No PT_DYNAMIC segment found", elf->GetPath());
LOG("%s: No PT_DYNAMIC segment found", elf->GetPath());
return NULL;
}
@ -194,7 +194,7 @@ CustomElf::Load(Mappable *mappable, const char *path, int flags)
if ((elf->base == MAP_FAILED) ||
(mmap(elf->base, max_vaddr, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0) != elf->base)) {
log("%s: Failed to mmap", elf->GetPath());
LOG("%s: Failed to mmap", elf->GetPath());
return NULL;
}
@ -219,14 +219,14 @@ CustomElf::Load(Mappable *mappable, const char *path, int flags)
return NULL;
elf->stats("oneLibLoaded");
debug("CustomElf::Load(\"%s\", 0x%x) = %p", path, flags,
DEBUG_LOG("CustomElf::Load(\"%s\", 0x%x) = %p", path, flags,
static_cast<void *>(elf));
return elf;
}
CustomElf::~CustomElf()
{
debug("CustomElf::~CustomElf(%p [\"%s\"])",
DEBUG_LOG("CustomElf::~CustomElf(%p [\"%s\"])",
reinterpret_cast<void *>(this), GetPath());
CallFini();
/* Normally, __cxa_finalize is called by the .fini function. However,
@ -270,7 +270,7 @@ CustomElf::GetSymbolPtr(const char *symbol, unsigned long hash) const
void *ptr = NULL;
if (sym && sym->st_shndx != SHN_UNDEF)
ptr = GetPtr(sym->st_value);
debug("CustomElf::GetSymbolPtr(%p [\"%s\"], \"%s\") = %p",
DEBUG_LOG("CustomElf::GetSymbolPtr(%p [\"%s\"], \"%s\") = %p",
reinterpret_cast<const void *>(this), GetPath(), symbol, ptr);
return ptr;
}
@ -316,7 +316,7 @@ CustomElf::GetSymbolPtrInDeps(const char *symbol) const
* anyways. Moreover, on android, the main binary is dalvik. */
#ifdef __GLIBC__
sym = dlsym(RTLD_DEFAULT, symbol);
debug("dlsym(RTLD_DEFAULT, \"%s\") = %p", symbol, sym);
DEBUG_LOG("dlsym(RTLD_DEFAULT, \"%s\") = %p", symbol, sym);
if (sym)
return sym;
#endif
@ -379,7 +379,7 @@ bool
CustomElf::LoadSegment(const Phdr *pt_load) const
{
if (pt_load->p_type != PT_LOAD) {
debug("%s: Elf::LoadSegment only takes PT_LOAD program headers", GetPath());
DEBUG_LOG("%s: Elf::LoadSegment only takes PT_LOAD program headers", GetPath());
return false;;
}
@ -393,7 +393,7 @@ CustomElf::LoadSegment(const Phdr *pt_load) const
do {
Addr align_offset = pt_load->p_vaddr & (align - 1);
where = GetPtr(pt_load->p_vaddr - align_offset);
debug("%s: Loading segment @%p %c%c%c", GetPath(), where,
DEBUG_LOG("%s: Loading segment @%p %c%c%c", GetPath(), where,
prot & PROT_READ ? 'r' : '-',
prot & PROT_WRITE ? 'w' : '-',
prot & PROT_EXEC ? 'x' : '-');
@ -408,15 +408,15 @@ CustomElf::LoadSegment(const Phdr *pt_load) const
* (p_vaddr == 0). But subsequent segments may not be 16k aligned
* and fail to mmap. In such case, try to mmap again at the p_align
* boundary instead of page boundary. */
debug("%s: Failed to mmap, retrying", GetPath());
DEBUG_LOG("%s: Failed to mmap, retrying", GetPath());
align = pt_load->p_align;
} while (1);
if (mapped != where) {
if (mapped == MAP_FAILED) {
log("%s: Failed to mmap", GetPath());
LOG("%s: Failed to mmap", GetPath());
} else {
log("%s: Didn't map at the expected location (wanted: %p, got: %p)",
LOG("%s: Didn't map at the expected location (wanted: %p, got: %p)",
GetPath(), where, mapped);
}
return false;
@ -446,7 +446,7 @@ CustomElf::LoadSegment(const Phdr *pt_load) const
Addr next_page = (file_end + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
if (mem_end > next_page) {
if (mprotect(GetPtr(next_page), mem_end - next_page, prot) < 0) {
log("%s: Failed to mprotect", GetPath());
LOG("%s: Failed to mprotect", GetPath());
return false;
}
}
@ -458,7 +458,7 @@ namespace {
void debug_dyn(const char *type, const Dyn *dyn)
{
debug("%s 0x%08" PRIxAddr, type, dyn->d_un.d_val);
DEBUG_LOG("%s 0x%08" PRIxAddr, type, dyn->d_un.d_val);
}
} /* anonymous namespace */
@ -497,12 +497,12 @@ CustomElf::InitDyn(const Phdr *pt_dyn)
case DT_SYMENT:
debug_dyn("DT_SYMENT", dyn);
if (dyn->d_un.d_val != sizeof(Sym)) {
log("%s: Unsupported DT_SYMENT", GetPath());
LOG("%s: Unsupported DT_SYMENT", GetPath());
return false;
}
break;
case DT_TEXTREL:
log("%s: Text relocations are not supported", GetPath());
LOG("%s: Text relocations are not supported", GetPath());
return false;
case DT_STRSZ: /* Ignored */
debug_dyn("DT_STRSZ", dyn);
@ -510,7 +510,7 @@ CustomElf::InitDyn(const Phdr *pt_dyn)
case UNSUPPORTED_RELOC():
case UNSUPPORTED_RELOC(SZ):
case UNSUPPORTED_RELOC(ENT):
log("%s: Unsupported relocations", GetPath());
LOG("%s: Unsupported relocations", GetPath());
return false;
case RELOC():
debug_dyn(STR_RELOC(), dyn);
@ -523,7 +523,7 @@ CustomElf::InitDyn(const Phdr *pt_dyn)
case RELOC(ENT):
debug_dyn(STR_RELOC(ENT), dyn);
if (dyn->d_un.d_val != sizeof(Reloc)) {
log("%s: Unsupported DT_RELENT", GetPath());
LOG("%s: Unsupported DT_RELENT", GetPath());
return false;
}
break;
@ -564,7 +564,7 @@ CustomElf::InitDyn(const Phdr *pt_dyn)
break;
case DT_PLTREL:
if (dyn->d_un.d_val != RELOC()) {
log("%s: Error: DT_PLTREL is not " STR_RELOC(), GetPath());
LOG("%s: Error: DT_PLTREL is not " STR_RELOC(), GetPath());
return false;
}
break;
@ -573,13 +573,13 @@ CustomElf::InitDyn(const Phdr *pt_dyn)
Addr flags = dyn->d_un.d_val;
/* Treat as a DT_TEXTREL tag */
if (flags & DF_TEXTREL) {
log("%s: Text relocations are not supported", GetPath());
LOG("%s: Text relocations are not supported", GetPath());
return false;
}
/* we can treat this like having a DT_SYMBOLIC tag */
flags &= ~DF_SYMBOLIC;
if (flags)
log("%s: Warning: unhandled flags #%" PRIxAddr" not handled",
LOG("%s: Warning: unhandled flags #%" PRIxAddr" not handled",
GetPath(), flags);
}
break;
@ -602,21 +602,21 @@ CustomElf::InitDyn(const Phdr *pt_dyn)
/* Ignored */
break;
default:
log("%s: Warning: dynamic header type #%" PRIxAddr" not handled",
LOG("%s: Warning: dynamic header type #%" PRIxAddr" not handled",
GetPath(), dyn->d_tag);
}
}
if (!buckets || !symnum) {
log("%s: Missing or broken DT_HASH", GetPath());
LOG("%s: Missing or broken DT_HASH", GetPath());
return false;
}
if (!strtab) {
log("%s: Missing DT_STRTAB", GetPath());
LOG("%s: Missing DT_STRTAB", GetPath());
return false;
}
if (!symtab) {
log("%s: Missing DT_SYMTAB", GetPath());
LOG("%s: Missing DT_SYMTAB", GetPath());
return false;
}
@ -637,7 +637,7 @@ CustomElf::InitDyn(const Phdr *pt_dyn)
bool
CustomElf::Relocate()
{
debug("Relocate %s @%p", GetPath(), static_cast<void *>(base));
DEBUG_LOG("Relocate %s @%p", GetPath(), static_cast<void *>(base));
for (Array<Reloc>::iterator rel = relocations.begin();
rel < relocations.end(); ++rel) {
/* Location of the relocation */
@ -661,7 +661,7 @@ CustomElf::Relocate()
}
if (symptr == NULL)
log("%s: Warning: relocation to NULL @0x%08" PRIxAddr,
LOG("%s: Warning: relocation to NULL @0x%08" PRIxAddr,
GetPath(), rel->r_offset);
/* Apply relocation */
@ -675,7 +675,7 @@ CustomElf::Relocate()
*(const char **) ptr = (const char *)symptr + rel->GetAddend(base);
break;
default:
log("%s: Unsupported relocation type: 0x%" PRIxAddr,
LOG("%s: Unsupported relocation type: 0x%" PRIxAddr,
GetPath(), ELF_R_TYPE(rel->r_info));
return false;
}
@ -694,7 +694,7 @@ CustomElf::RelocateJumps()
/* Only R_*_JMP_SLOT relocations are expected */
if (ELF_R_TYPE(rel->r_info) != R_JMP_SLOT) {
log("%s: Jump relocation type mismatch", GetPath());
LOG("%s: Jump relocation type mismatch", GetPath());
return false;
}
@ -707,7 +707,7 @@ CustomElf::RelocateJumps()
symptr = GetSymbolPtrInDeps(strtab.GetStringAt(sym.st_name));
if (symptr == NULL) {
log("%s: %s: relocation to NULL @0x%08" PRIxAddr " for symbol \"%s\"",
LOG("%s: %s: relocation to NULL @0x%08" PRIxAddr " for symbol \"%s\"",
GetPath(),
(ELF_ST_BIND(sym.st_info) == STB_WEAK) ? "Warning" : "Error",
rel->r_offset, strtab.GetStringAt(sym.st_name));

2
mozglue/linker/CustomElf.h
View File

@ -142,7 +142,7 @@ private:
void (*func)(void);
} f;
f.ptr = ptr;
debug("%s: Calling function @%p", GetPath(), ptr);
DEBUG_LOG("%s: Calling function @%p", GetPath(), ptr);
f.func();
}

44
mozglue/linker/ElfLoader.cpp
View File

@ -233,12 +233,12 @@ SystemElf::Load(const char *path, int flags)
/* The Android linker returns a handle when the file name matches an
* already loaded library, even when the full path doesn't exist */
if (path && path[0] == '/' && (access(path, F_OK) == -1)){
debug("dlopen(\"%s\", 0x%x) = %p", path, flags, (void *)NULL);
DEBUG_LOG("dlopen(\"%s\", 0x%x) = %p", path, flags, (void *)NULL);
return NULL;
}
void *handle = dlopen(path, flags);
debug("dlopen(\"%s\", 0x%x) = %p", path, flags, handle);
DEBUG_LOG("dlopen(\"%s\", 0x%x) = %p", path, flags, handle);
ElfLoader::Singleton.lastError = dlerror();
if (handle) {
SystemElf *elf = new SystemElf(path, handle);
@ -252,7 +252,7 @@ SystemElf::~SystemElf()
{
if (!dlhandle)
return;
debug("dlclose(%p [\"%s\"])", dlhandle, GetPath());
DEBUG_LOG("dlclose(%p [\"%s\"])", dlhandle, GetPath());
dlclose(dlhandle);
ElfLoader::Singleton.lastError = dlerror();
ElfLoader::Singleton.Forget(this);
@ -262,7 +262,7 @@ void *
SystemElf::GetSymbolPtr(const char *symbol) const
{
void *sym = dlsym(dlhandle, symbol);
debug("dlsym(%p [\"%s\"], \"%s\") = %p", dlhandle, GetPath(), symbol, sym);
DEBUG_LOG("dlsym(%p [\"%s\"], \"%s\") = %p", dlhandle, GetPath(), symbol, sym);
ElfLoader::Singleton.lastError = dlerror();
return sym;
}
@ -353,7 +353,7 @@ ElfLoader::Load(const char *path, int flags, LibHandle *parent)
handle = SystemElf::Load(name, flags);
delete [] abs_path;
debug("ElfLoader::Load(\"%s\", 0x%x, %p [\"%s\"]) = %p", requested_path, flags,
DEBUG_LOG("ElfLoader::Load(\"%s\", 0x%x, %p [\"%s\"]) = %p", requested_path, flags,
reinterpret_cast<void *>(parent), parent ? parent->GetPath() : "",
static_cast<void *>(handle));
@ -420,13 +420,13 @@ ElfLoader::Forget(LibHandle *handle)
{
LibHandleList::iterator it = std::find(handles.begin(), handles.end(), handle);
if (it != handles.end()) {
debug("ElfLoader::Forget(%p [\"%s\"])", reinterpret_cast<void *>(handle),
DEBUG_LOG("ElfLoader::Forget(%p [\"%s\"])", reinterpret_cast<void *>(handle),
handle->GetPath());
if (dbg && !handle->IsSystemElf())
dbg.Remove(static_cast<CustomElf *>(handle));
handles.erase(it);
} else {
debug("ElfLoader::Forget(%p [\"%s\"]): Handle not found",
DEBUG_LOG("ElfLoader::Forget(%p [\"%s\"]): Handle not found",
reinterpret_cast<void *>(handle), handle->GetPath());
}
}
@ -459,11 +459,11 @@ ElfLoader::~ElfLoader()
for (LibHandleList::reverse_iterator it = list.rbegin();
it < list.rend(); ++it) {
if ((*it)->IsSystemElf()) {
debug("ElfLoader::~ElfLoader(): Remaining handle for \"%s\" "
DEBUG_LOG("ElfLoader::~ElfLoader(): Remaining handle for \"%s\" "
"[%d direct refs, %d refs total]", (*it)->GetPath(),
(*it)->DirectRefCount(), (*it)->refCount());
} else {
debug("ElfLoader::~ElfLoader(): Unexpected remaining handle for \"%s\" "
DEBUG_LOG("ElfLoader::~ElfLoader(): Unexpected remaining handle for \"%s\" "
"[%d direct refs, %d refs total]", (*it)->GetPath(),
(*it)->DirectRefCount(), (*it)->refCount());
/* Not removing, since it could have references to other libraries,
@ -521,7 +521,7 @@ void
ElfLoader::DestructorCaller::Call()
{
if (destructor) {
debug("ElfLoader::DestructorCaller::Call(%p, %p, %p)",
DEBUG_LOG("ElfLoader::DestructorCaller::Call(%p, %p, %p)",
FunctionPtr(destructor), object, dso_handle);
destructor(object);
destructor = NULL;
@ -610,7 +610,7 @@ ElfLoader::DebuggerHelper::DebuggerHelper(): dbg(NULL)
}
if (!phdrs) {
debug("Couldn't find program headers");
DEBUG_LOG("Couldn't find program headers");
return;
}
@ -625,20 +625,20 @@ ElfLoader::DebuggerHelper::DebuggerHelper(): dbg(NULL)
/* If program headers aren't mapped, try to map them */
int fd = open("/proc/self/exe", O_RDONLY);
if (fd == -1) {
debug("Failed to open /proc/self/exe");
DEBUG_LOG("Failed to open /proc/self/exe");
return;
}
mem.Assign(mmap(base, PAGE_SIZE, PROT_READ, MAP_PRIVATE, fd, 0), PAGE_SIZE);
/* If we don't manage to map at the right address, just give up. */
if (mem != base) {
debug("Couldn't read program headers");
DEBUG_LOG("Couldn't read program headers");
return;
}
}
/* Sanity check: the first bytes at the base address should be an ELF
* header. */
if (!Elf::Ehdr::validate(base)) {
debug("Couldn't find program base");
DEBUG_LOG("Couldn't find program base");
return;
}
@ -657,7 +657,7 @@ ElfLoader::DebuggerHelper::DebuggerHelper(): dbg(NULL)
dyns.Init(base + phdr->p_vaddr, phdr->p_filesz);
}
if (!dyns) {
debug("Failed to find PT_DYNAMIC section in program");
DEBUG_LOG("Failed to find PT_DYNAMIC section in program");
return;
}
@ -668,7 +668,7 @@ ElfLoader::DebuggerHelper::DebuggerHelper(): dbg(NULL)
break;
}
}
debug("DT_DEBUG points at %p", static_cast<void *>(dbg));
DEBUG_LOG("DT_DEBUG points at %p", static_cast<void *>(dbg));
}
/**
@ -938,7 +938,7 @@ SEGVHandler::~SEGVHandler()
void SEGVHandler::handler(int signum, siginfo_t *info, void *context)
{
//ASSERT(signum == SIGSEGV);
debug("Caught segmentation fault @%p", info->si_addr);
DEBUG_LOG("Caught segmentation fault @%p", info->si_addr);
/* Check whether we segfaulted in the address space of a CustomElf. We're
* only expecting that to happen as an access error. */
@ -946,7 +946,7 @@ void SEGVHandler::handler(int signum, siginfo_t *info, void *context)
mozilla::RefPtr<LibHandle> handle =
ElfLoader::Singleton.GetHandleByPtr(info->si_addr);
if (handle && !handle->IsSystemElf()) {
debug("Within the address space of a CustomElf");
DEBUG_LOG("Within the address space of a CustomElf");
CustomElf *elf = static_cast<CustomElf *>(static_cast<LibHandle *>(handle));
if (elf->mappable->ensure(info->si_addr))
return;
@ -956,20 +956,20 @@ void SEGVHandler::handler(int signum, siginfo_t *info, void *context)
/* Redispatch to the registered handler */
SEGVHandler &that = ElfLoader::Singleton;
if (that.action.sa_flags & SA_SIGINFO) {
debug("Redispatching to registered handler @%p",
DEBUG_LOG("Redispatching to registered handler @%p",
FunctionPtr(that.action.sa_sigaction));
that.action.sa_sigaction(signum, info, context);
} else if (that.action.sa_handler == SIG_DFL) {
debug("Redispatching to default handler");
DEBUG_LOG("Redispatching to default handler");
/* Reset the handler to the default one, and trigger it. */
sys_sigaction(signum, &that.action, NULL);
raise(signum);
} else if (that.action.sa_handler != SIG_IGN) {
debug("Redispatching to registered handler @%p",
DEBUG_LOG("Redispatching to registered handler @%p",
FunctionPtr(that.action.sa_handler));
that.action.sa_handler(signum);
} else {
debug("Ignoring");
DEBUG_LOG("Ignoring");
}
}

16
mozglue/linker/Logging.h
View File

@ -7,7 +7,7 @@
#ifdef ANDROID
#include <android/log.h>
#define log(...) __android_log_print(ANDROID_LOG_ERROR, "GeckoLinker", __VA_ARGS__)
#define LOG(...) __android_log_print(ANDROID_LOG_ERROR, "GeckoLinker", __VA_ARGS__)
#else
#include <cstdio>
@ -24,22 +24,22 @@
#define MOZ_CONCAT1(a, b) MOZ_CONCAT2(a, b)
#define MOZ_CONCAT(a, b) MOZ_CONCAT1(a, b)
/* Some magic to choose between log1 and logm depending on the number of
/* Some magic to choose between LOG1 and LOGm depending on the number of
* arguments */
#define MOZ_CHOOSE_LOG(...) \
MOZ_MACRO_GLUE(MOZ_CONCAT(log, MOZ_ONE_OR_MORE_ARGS(__VA_ARGS__)), \
MOZ_MACRO_GLUE(MOZ_CONCAT(LOG, MOZ_ONE_OR_MORE_ARGS(__VA_ARGS__)), \
(__VA_ARGS__))
#define log1(format) fprintf(stderr, format "\n")
#define logm(format, ...) fprintf(stderr, format "\n", __VA_ARGS__)
#define log(...) MOZ_CHOOSE_LOG(__VA_ARGS__)
#define LOG1(format) fprintf(stderr, format "\n")
#define LOGm(format, ...) fprintf(stderr, format "\n", __VA_ARGS__)
#define LOG(...) MOZ_CHOOSE_LOG(__VA_ARGS__)
#endif
#ifdef MOZ_DEBUG_LINKER
#define debug log
#define DEBUG_LOG LOG
#else
#define debug(...)
#define DEBUG_LOG(...)
#endif
/* HAVE_64BIT_OS is not defined when building host tools, so use

56
mozglue/linker/Mappable.cpp
View File

@ -77,7 +77,7 @@ MappableExtractFile::Create(const char *name, Zip *zip, Zip::Stream *stream)
{
const char *cachePath = getenv("MOZ_LINKER_CACHE");
if (!cachePath || !*cachePath) {
log("Warning: MOZ_LINKER_EXTRACT is set, but not MOZ_LINKER_CACHE; "
LOG("Warning: MOZ_LINKER_EXTRACT is set, but not MOZ_LINKER_CACHE; "
"not extracting");
return NULL;
}
@ -89,30 +89,30 @@ MappableExtractFile::Create(const char *name, Zip *zip, Zip::Stream *stream)
struct stat zipStat;
stat(zip->GetName(), &zipStat);
if (cacheStat.st_mtime > zipStat.st_mtime) {
debug("Reusing %s", static_cast<char *>(path));
DEBUG_LOG("Reusing %s", static_cast<char *>(path));
return MappableFile::Create(path);
}
}
debug("Extracting to %s", static_cast<char *>(path));
DEBUG_LOG("Extracting to %s", static_cast<char *>(path));
AutoCloseFD fd;
fd = open(path, O_TRUNC | O_RDWR | O_CREAT | O_NOATIME,
S_IRUSR | S_IWUSR);
if (fd == -1) {
log("Couldn't open %s to decompress library", path.get());
LOG("Couldn't open %s to decompress library", path.get());
return NULL;
}
AutoUnlinkFile file;
file = path.forget();
if (stream->GetType() == Zip::Stream::DEFLATE) {
if (ftruncate(fd, stream->GetUncompressedSize()) == -1) {
log("Couldn't ftruncate %s to decompress library", file.get());
LOG("Couldn't ftruncate %s to decompress library", file.get());
return NULL;
}
/* Map the temporary file for use as inflate buffer */
MappedPtr buffer(::mmap(NULL, stream->GetUncompressedSize(), PROT_WRITE,
MAP_SHARED, fd, 0), stream->GetUncompressedSize());
if (buffer == MAP_FAILED) {
log("Couldn't map %s to decompress library", file.get());
LOG("Couldn't map %s to decompress library", file.get());
return NULL;
}
@ -120,41 +120,41 @@ MappableExtractFile::Create(const char *name, Zip *zip, Zip::Stream *stream)
/* Decompress */
if (inflateInit2(&zStream, -MAX_WBITS) != Z_OK) {
log("inflateInit failed: %s", zStream.msg);
LOG("inflateInit failed: %s", zStream.msg);
return NULL;
}
if (inflate(&zStream, Z_FINISH) != Z_STREAM_END) {
log("inflate failed: %s", zStream.msg);
LOG("inflate failed: %s", zStream.msg);
return NULL;
}
if (inflateEnd(&zStream) != Z_OK) {
log("inflateEnd failed: %s", zStream.msg);
LOG("inflateEnd failed: %s", zStream.msg);
return NULL;
}
if (zStream.total_out != stream->GetUncompressedSize()) {
log("File not fully uncompressed! %ld / %d", zStream.total_out,
LOG("File not fully uncompressed! %ld / %d", zStream.total_out,
static_cast<unsigned int>(stream->GetUncompressedSize()));
return NULL;
}
} else if (stream->GetType() == Zip::Stream::STORE) {
SeekableZStream zStream;
if (!zStream.Init(stream->GetBuffer(), stream->GetSize())) {
log("Couldn't initialize SeekableZStream for %s", name);
LOG("Couldn't initialize SeekableZStream for %s", name);
return NULL;
}
if (ftruncate(fd, zStream.GetUncompressedSize()) == -1) {
log("Couldn't ftruncate %s to decompress library", file.get());
LOG("Couldn't ftruncate %s to decompress library", file.get());
return NULL;
}
MappedPtr buffer(::mmap(NULL, zStream.GetUncompressedSize(), PROT_WRITE,
MAP_SHARED, fd, 0), zStream.GetUncompressedSize());
if (buffer == MAP_FAILED) {
log("Couldn't map %s to decompress library", file.get());
LOG("Couldn't map %s to decompress library", file.get());
return NULL;
}
if (!zStream.Decompress(buffer, 0, zStream.GetUncompressedSize())) {
log("%s: failed to decompress", name);
LOG("%s: failed to decompress", name);
return NULL;
}
} else {
@ -213,7 +213,7 @@ public:
::mmap(reinterpret_cast<char *>(buf) + ((length + PAGE_SIZE - 1) & PAGE_MASK),
PAGE_SIZE, PROT_NONE, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS,
-1, 0);
debug("Decompression buffer of size %d in ashmem \"%s\", mapped @%p",
DEBUG_LOG("Decompression buffer of size %d in ashmem \"%s\", mapped @%p",
length, str, buf);
return new _MappableBuffer(fd.forget(), buf, length);
}
@ -231,7 +231,7 @@ public:
void *buf = ::mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (buf != MAP_FAILED) {
debug("Decompression buffer of size %ld in \"%s\", mapped @%p",
DEBUG_LOG("Decompression buffer of size %ld in \"%s\", mapped @%p",
length, path, buf);
return new _MappableBuffer(fd.forget(), buf, length);
}
@ -300,26 +300,26 @@ MappableDeflate::mmap(const void *addr, size_t length, int prot, int flags, off_
zStream.avail_out = missing;
if ((*buffer == zStream.next_out) &&
(inflateInit2(&zStream, -MAX_WBITS) != Z_OK)) {
log("inflateInit failed: %s", zStream.msg);
LOG("inflateInit failed: %s", zStream.msg);
return MAP_FAILED;
}
int ret = inflate(&zStream, Z_SYNC_FLUSH);
if (ret < 0) {
log("inflate failed: %s", zStream.msg);
LOG("inflate failed: %s", zStream.msg);
return MAP_FAILED;
}
if (ret == Z_NEED_DICT) {
log("zstream requires a dictionary. %s", zStream.msg);
LOG("zstream requires a dictionary. %s", zStream.msg);
return MAP_FAILED;
}
zStream.avail_out = avail_out - missing + zStream.avail_out;
if (ret == Z_STREAM_END) {
if (inflateEnd(&zStream) != Z_OK) {
log("inflateEnd failed: %s", zStream.msg);
LOG("inflateEnd failed: %s", zStream.msg);
return MAP_FAILED;
}
if (zStream.total_out != buffer->GetLength()) {
log("File not fully uncompressed! %ld / %d", zStream.total_out,
LOG("File not fully uncompressed! %ld / %d", zStream.total_out,
static_cast<unsigned int>(buffer->GetLength()));
return MAP_FAILED;
}
@ -329,7 +329,7 @@ MappableDeflate::mmap(const void *addr, size_t length, int prot, int flags, off_
if (prot & PROT_EXEC) {
/* We just extracted data that may be executed in the future.
* We thus need to ensure Instruction and Data cache coherency. */
debug("cacheflush(%p, %p)", *buffer + offset, *buffer + (offset + length));
DEBUG_LOG("cacheflush(%p, %p)", *buffer + offset, *buffer + (offset + length));
cacheflush(reinterpret_cast<uintptr_t>(*buffer + offset),
reinterpret_cast<uintptr_t>(*buffer + (offset + length)), 0);
}
@ -445,7 +445,7 @@ private:
bool
MappableSeekableZStream::ensure(const void *addr)
{
debug("ensure @%p", addr);
DEBUG_LOG("ensure @%p", addr);
void *addrPage = reinterpret_cast<void *>
(reinterpret_cast<uintptr_t>(addr) & PAGE_MASK);
/* Find the mapping corresponding to the given page */
@ -499,7 +499,7 @@ MappableSeekableZStream::ensure(const void *addr)
if (map->prot & PROT_EXEC) {
/* We just extracted data that may be executed in the future.
* We thus need to ensure Instruction and Data cache coherency. */
debug("cacheflush(%p, %p)", *buffer + chunkStart, *buffer + (chunkStart + length));
DEBUG_LOG("cacheflush(%p, %p)", *buffer + chunkStart, *buffer + (chunkStart + length));
cacheflush(reinterpret_cast<uintptr_t>(*buffer + chunkStart),
reinterpret_cast<uintptr_t>(*buffer + (chunkStart + length)), 0);
}
@ -526,11 +526,11 @@ MappableSeekableZStream::ensure(const void *addr)
length = reinterpret_cast<uintptr_t>(end)
- reinterpret_cast<uintptr_t>(start);
debug("mprotect @%p, 0x%" PRIxSize ", 0x%x", start, length, map->prot);
DEBUG_LOG("mprotect @%p, 0x%" PRIxSize ", 0x%x", start, length, map->prot);
if (mprotect(const_cast<void *>(start), length, map->prot) == 0)
return true;
log("mprotect failed");
LOG("mprotect failed");
return false;
}
@ -538,7 +538,7 @@ void
MappableSeekableZStream::stats(const char *when, const char *name) const
{
size_t nEntries = zStream.GetChunksNum();
debug("%s: %s; %" PRIdSize "/%" PRIdSize " chunks decompressed",
DEBUG_LOG("%s: %s; %" PRIdSize "/%" PRIdSize " chunks decompressed",
name, when, chunkAvailNum, nEntries);
size_t len = 64;
@ -551,7 +551,7 @@ MappableSeekableZStream::stats(const char *when, const char *name) const
if ((j == len) || (i == nEntries - 1)) {
map[j + 1] = ']';
map[j + 2] = '\0';
debug("%s", static_cast<char *>(map));
DEBUG_LOG("%s", static_cast<char *>(map));
j = 0;
}
}

16
mozglue/linker/SeekableZStream.cpp
View File

@ -19,7 +19,7 @@ SeekableZStream::Init(const void *buf, size_t length)
{
const SeekableZStreamHeader *header = SeekableZStreamHeader::validate(buf);
if (!header) {
log("Not a seekable zstream");
LOG("Not a seekable zstream");
return false;
}
@ -41,7 +41,7 @@ SeekableZStream::Init(const void *buf, size_t length)
(lastChunkSize == 0) ||
(lastChunkSize > chunkSize) ||
(length < totalSize)) {
log("Malformed or broken seekable zstream");
LOG("Malformed or broken seekable zstream");
return false;
}
@ -66,7 +66,7 @@ bool
SeekableZStream::DecompressChunk(void *where, size_t chunk, size_t length)
{
if (chunk >= offsetTable.numElements()) {
log("DecompressChunk: chunk #%" PRIdSize " out of range [0-%" PRIdSize ")",
LOG("DecompressChunk: chunk #%" PRIdSize " out of range [0-%" PRIdSize ")",
chunk, offsetTable.numElements());
return false;
}
@ -78,7 +78,7 @@ SeekableZStream::DecompressChunk(void *where, size_t chunk, size_t length)
if (length == 0 || length > chunkLen)
length = chunkLen;
debug("DecompressChunk #%" PRIdSize " @%p (%" PRIdSize "/% " PRIdSize ")",
DEBUG_LOG("DecompressChunk #%" PRIdSize " @%p (%" PRIdSize "/% " PRIdSize ")",
chunk, where, length, chunkLen);
z_stream zStream;
memset(&zStream, 0, sizeof(zStream));
@ -90,21 +90,21 @@ SeekableZStream::DecompressChunk(void *where, size_t chunk, size_t length)
/* Decompress chunk */
if (inflateInit2(&zStream, windowBits) != Z_OK) {
log("inflateInit failed: %s", zStream.msg);
LOG("inflateInit failed: %s", zStream.msg);
return false;
}
if (dictionary && inflateSetDictionary(&zStream, dictionary,
dictionary.numElements()) != Z_OK) {
log("inflateSetDictionary failed: %s", zStream.msg);
LOG("inflateSetDictionary failed: %s", zStream.msg);
return false;
}
if (inflate(&zStream, (length == chunkLen) ? Z_FINISH : Z_SYNC_FLUSH)
!= (length == chunkLen) ? Z_STREAM_END : Z_OK) {
log("inflate failed: %s", zStream.msg);
LOG("inflate failed: %s", zStream.msg);
return false;
}
if (inflateEnd(&zStream) != Z_OK) {
log("inflateEnd failed: %s", zStream.msg);
LOG("inflateEnd failed: %s", zStream.msg);
return false;
}
if (filter)

32
mozglue/linker/Zip.cpp
View File

@ -18,25 +18,25 @@ Zip::Create(const char *filename)
/* Open and map the file in memory */
AutoCloseFD fd(open(filename, O_RDONLY));
if (fd == -1) {
log("Error opening %s: %s", filename, strerror(errno));
LOG("Error opening %s: %s", filename, strerror(errno));
return NULL;
}
struct stat st;
if (fstat(fd, &st) == -1) {
log("Error stating %s: %s", filename, strerror(errno));
LOG("Error stating %s: %s", filename, strerror(errno));
return NULL;
}
size_t size = st.st_size;
if (size <= sizeof(CentralDirectoryEnd)) {
log("Error reading %s: too short", filename);
LOG("Error reading %s: too short", filename);
return NULL;
}
void *mapped = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if (mapped == MAP_FAILED) {
log("Error mmapping %s: %s", filename, strerror(errno));
LOG("Error mmapping %s: %s", filename, strerror(errno));
return NULL;
}
debug("Mapped %s @%p", filename, mapped);
DEBUG_LOG("Mapped %s @%p", filename, mapped);
return Create(filename, mapped, size);
}
@ -49,7 +49,7 @@ Zip::Create(const char *filename, void *mapped, size_t size)
// If neither the first Local File entry nor central directory entries
// have been found, the zip was invalid.
if (!zip->nextFile && !zip->entries) {
log("%s - Invalid zip", filename);
LOG("%s - Invalid zip", filename);
return NULL;
}
@ -76,7 +76,7 @@ Zip::~Zip()
ZipCollection::Forget(this);
if (name) {
munmap(mapped, size);
debug("Unmapped %s @%p", name, mapped);
DEBUG_LOG("Unmapped %s @%p", name, mapped);
free(name);
}
}
@ -84,7 +84,7 @@ Zip::~Zip()
bool
Zip::GetStream(const char *path, Zip::Stream *out) const
{
debug("%s - GetFile %s", name, path);
DEBUG_LOG("%s - GetFile %s", name, path);
/* Fast path: if the Local File header on store matches, we can return the
* corresponding stream right away.
* However, the Local File header may not contain enough information, in
@ -97,7 +97,7 @@ Zip::GetStream(const char *path, Zip::Stream *out) const
* normal condition for the bit to be set). */
if (nextFile && nextFile->GetName().Equals(path) &&
!entries && (nextFile->compressedSize != 0)) {
debug("%s - %s was next file: fast path", name, path);
DEBUG_LOG("%s - %s was next file: fast path", name, path);
/* Fill Stream info from Local File header content */
const char *data = reinterpret_cast<const char *>(nextFile->GetData());
out->compressedBuf = data;
@ -120,14 +120,14 @@ Zip::GetStream(const char *path, Zip::Stream *out) const
* Directory for the entry corresponding to the given path */
if (!nextDir || !nextDir->GetName().Equals(path)) {
const DirectoryEntry *entry = GetFirstEntry();
debug("%s - Scan directory entries in search for %s", name, path);
DEBUG_LOG("%s - Scan directory entries in search for %s", name, path);
while (entry && !entry->GetName().Equals(path)) {
entry = entry->GetNext();
}
nextDir = entry;
}
if (!nextDir) {
debug("%s - Couldn't find %s", name, path);
DEBUG_LOG("%s - Couldn't find %s", name, path);
return false;
}
@ -136,7 +136,7 @@ Zip::GetStream(const char *path, Zip::Stream *out) const
nextFile = LocalFile::validate(static_cast<const char *>(mapped)
+ nextDir->offset);
if (!nextFile) {
log("%s - Couldn't find the Local File header for %s", name, path);
LOG("%s - Couldn't find the Local File header for %s", name, path);
return false;
}
@ -167,14 +167,14 @@ Zip::GetFirstEntry() const
for (; _end > mapped && !end; _end--)
end = CentralDirectoryEnd::validate(_end);
if (!end) {
log("%s - Couldn't find end of central directory record", name);
LOG("%s - Couldn't find end of central directory record", name);
return NULL;
}
entries = DirectoryEntry::validate(static_cast<const char *>(mapped)
+ end->offset);
if (!entries) {
log("%s - Couldn't find central directory record", name);
LOG("%s - Couldn't find central directory record", name);
}
return entries;
}
@ -202,12 +202,12 @@ ZipCollection::Register(Zip *zip)
void
ZipCollection::Forget(Zip *zip)
{
debug("ZipCollection::Forget(\"%s\")", zip->GetName());
DEBUG_LOG("ZipCollection::Forget(\"%s\")", zip->GetName());
std::vector<Zip *>::iterator it = std::find(Singleton.zips.begin(),
Singleton.zips.end(), zip);
if (*it == zip) {
Singleton.zips.erase(it);
} else {
debug("ZipCollection::Forget: didn't find \"%s\" in bookkeeping", zip->GetName());
DEBUG_LOG("ZipCollection::Forget: didn't find \"%s\" in bookkeeping", zip->GetName());
}
}

54
mozglue/linker/szip.cpp
View File

@ -128,7 +128,7 @@ public:
{
if (!size || !Resize(size))
return;
debug("Creating dictionary");
DEBUG_LOG("Creating dictionary");
piece *origBufPieces = reinterpret_cast<piece *>(
static_cast<void *>(inBuf));
std::map<piece, int> stats;
@ -208,7 +208,7 @@ int SzipDecompress::run(const char *name, Buffer &origBuf,
{
size_t origSize = origBuf.GetLength();
if (origSize < sizeof(SeekableZStreamHeader)) {
log("%s is not compressed", name);
LOG("%s is not compressed", name);
return 0;
}
@ -220,7 +220,7 @@ int SzipDecompress::run(const char *name, Buffer &origBuf,
/* Give enough room for the uncompressed data */
if (!outBuf.Resize(size)) {
log("Error resizing %s: %s", outName, strerror(errno));
LOG("Error resizing %s: %s", outName, strerror(errno));
return 1;
}
@ -236,20 +236,20 @@ int SzipCompress::run(const char *name, Buffer &origBuf,
{
size_t origSize = origBuf.GetLength();
if (origSize == 0) {
log("Won't compress %s: it's empty", name);
LOG("Won't compress %s: it's empty", name);
return 1;
}
if (SeekableZStreamHeader::validate(origBuf)) {
log("Skipping %s: it's already a szip", name);
LOG("Skipping %s: it's already a szip", name);
return 0;
}
bool compressed = false;
log("Size = %" PRIuSize, origSize);
LOG("Size = %" PRIuSize, origSize);
/* Allocate a buffer the size of the uncompressed data: we don't want
* a compressed file larger than that anyways. */
if (!outBuf.Resize(origSize)) {
log("Couldn't allocate output buffer: %s", strerror(errno));
LOG("Couldn't allocate output buffer: %s", strerror(errno));
return 1;
}
@ -272,7 +272,7 @@ int SzipCompress::run(const char *name, Buffer &origBuf,
FilteredBuffer *filteredTmp = NULL;
Buffer tmpBuf;
if (f != SeekableZStream::NONE) {
debug("Applying filter \"%s\"", filterName[f]);
DEBUG_LOG("Applying filter \"%s\"", filterName[f]);
filteredTmp = new FilteredBuffer();
filteredTmp->Filter(origBuf, f, chunkSize);
origData = filteredTmp;
@ -283,7 +283,7 @@ int SzipCompress::run(const char *name, Buffer &origBuf,
filteredBuf = filteredTmp;
break;
}
debug("Compressing with no dictionary");
DEBUG_LOG("Compressing with no dictionary");
if (do_compress(*origData, tmpBuf, NULL, 0, f) == 0) {
if (tmpBuf.GetLength() < outBuf.GetLength()) {
outBuf.Fill(tmpBuf);
@ -313,7 +313,7 @@ int SzipCompress::run(const char *name, Buffer &origBuf,
Buffer tmpBuf;
for (size_t d = firstDictSize; d <= lastDictSize; d += 4096) {
debug("Compressing with dictionary of size %" PRIuSize, d);
DEBUG_LOG("Compressing with dictionary of size %" PRIuSize, d);
if (do_compress(*origData, tmpBuf, static_cast<unsigned char *>(dict)
+ SzipCompress::winSize - d, d, filter))
continue;
@ -327,16 +327,16 @@ int SzipCompress::run(const char *name, Buffer &origBuf,
if (!compressed) {
outBuf.Fill(origBuf);
log("Not compressed");
LOG("Not compressed");
return 0;
}
if (dictSize == (size_t) -1)
dictSize = 0;
debug("Used filter \"%s\" and dictionary size of %" PRIuSize,
DEBUG_LOG("Used filter \"%s\" and dictionary size of %" PRIuSize,
filterName[filter], dictSize);
log("Compressed size is %" PRIuSize, outBuf.GetLength());
LOG("Compressed size is %" PRIuSize, outBuf.GetLength());
/* Sanity check */
Buffer tmpBuf;
@ -346,11 +346,11 @@ int SzipCompress::run(const char *name, Buffer &origBuf,
size_t size = tmpBuf.GetLength();
if (size != origSize) {
log("Compression error: %" PRIuSize " != %" PRIuSize, size, origSize);
LOG("Compression error: %" PRIuSize " != %" PRIuSize, size, origSize);
return 1;
}
if (memcmp(static_cast<void *>(origBuf), static_cast<void *>(tmpBuf), size)) {
log("Compression error: content mismatch");
LOG("Compression error: content mismatch");
return 1;
}
return 0;
@ -377,7 +377,7 @@ int SzipCompress::do_compress(Buffer &origBuf, Buffer &outBuf,
/* Allocate a buffer the size of the uncompressed data: we don't want
* a compressed file larger than that anyways. */
if (!outBuf.Resize(origSize)) {
log("Couldn't allocate output buffer: %s", strerror(errno));
LOG("Couldn't allocate output buffer: %s", strerror(errno));
return 1;
}
@ -441,7 +441,7 @@ int SzipCompress::do_compress(Buffer &origBuf, Buffer &outBuf,
MOZ_ASSERT(header->totalSize == offset);
if (!outBuf.Resize(offset)) {
log("Error truncating output: %s", strerror(errno));
LOG("Error truncating output: %s", strerror(errno));
return 1;
}
@ -480,7 +480,7 @@ int main(int argc, char* argv[])
break;
if (!GetSize(firstArg[0], &chunkSize) || !chunkSize ||
(chunkSize % 4096) || (chunkSize > maxChunkSize)) {
log("Invalid chunk size");
LOG("Invalid chunk size");
return 1;
}
} else if (strcmp(firstArg[0], "-f") == 0) {
@ -497,7 +497,7 @@ int main(int argc, char* argv[])
}
}
if (!matched) {
log("Invalid filter");
LOG("Invalid filter");
return 1;
}
} else if (strcmp(firstArg[0], "-D") == 0) {
@ -508,14 +508,14 @@ int main(int argc, char* argv[])
if (strcmp(firstArg[0], "auto") == 0) {
dictSize = -1;
} else if (!GetSize(firstArg[0], &dictSize) || (dictSize >= 1 << 16)) {
log("Invalid dictionary size");
LOG("Invalid dictionary size");
return 1;
}
}
}
if (argc != 2 || !firstArg[0]) {
log("usage: %s [-d] [-c CHUNKSIZE] [-f FILTER] [-D DICTSIZE] file",
LOG("usage: %s [-d] [-c CHUNKSIZE] [-f FILTER] [-D DICTSIZE] file",
argv[0]);
return 1;
}
@ -524,11 +524,11 @@ int main(int argc, char* argv[])
action = new SzipCompress(chunkSize, filter, dictSize);
} else {
if (chunkSize) {
log("-c is incompatible with -d");
LOG("-c is incompatible with -d");
return 1;
}
if (dictSize) {
log("-D is incompatible with -d");
LOG("-D is incompatible with -d");
return 1;
}
action = new SzipDecompress();
@ -542,13 +542,13 @@ int main(int argc, char* argv[])
{
FileBuffer origBuf;
if (!origBuf.Init(firstArg[0])) {
log("Couldn't open %s: %s", firstArg[0], strerror(errno));
LOG("Couldn't open %s: %s", firstArg[0], strerror(errno));
return 1;
}
ret = fstat(origBuf.getFd(), &st);
if (ret == -1) {
log("Couldn't stat %s: %s", firstArg[0], strerror(errno));
LOG("Couldn't stat %s: %s", firstArg[0], strerror(errno));
return 1;
}
@ -556,14 +556,14 @@ int main(int argc, char* argv[])
/* Mmap the original file */
if (!origBuf.Resize(origSize)) {
log("Couldn't mmap %s: %s", firstArg[0], strerror(errno));
LOG("Couldn't mmap %s: %s", firstArg[0], strerror(errno));
return 1;
}
/* Create the compressed file */
FileBuffer outBuf;
if (!outBuf.Init(tmpOut.c_str(), true)) {
log("Couldn't open %s: %s", tmpOut.c_str(), strerror(errno));
LOG("Couldn't open %s: %s", tmpOut.c_str(), strerror(errno));
return 1;
}