63860cb8fd
The major components of the rewrite: - Completely remove the qemu shared library code. Nobody was using it and it appears to have broken at some point. - Adds the ability to enable/disable different options independently. - Adds a new option that can enable the backtrace on alloc/free when a process gets a specific signal. - Adds a new way to enable malloc debug. If a special property is set, and the process has an environment variable set, then debug malloc will be enabled. This allows something that might be a derivative of app_process to be started with an environment variable being enabled. - get_malloc_leak_info() used to return one element for each pointer that had the exact same backtrace. The new version returns information for every one of the pointers with same backtrace. It turns out ddms already automatically coalesces these, so the old method simply hid the fact that there where multiple pointers with the same amount of backtrace. - Moved all of the malloc debug specific code into the library. Nothing related to the malloc debug data structures remains in libc. - Removed the calls to the debug malloc cleanup routine. Instead, I added an atexit call with the debug malloc cleanup routine. This gets around most problems related to the timing of doing the cleanup. The new properties and environment variables: libc.debug.malloc.options Set by option name (such as "backtrace"). Setting this to a bad value will cause a usage statement to be printed to the log. libc.debug.malloc.program Same as before. If this is set, then only the program named will be launched with malloc debug enabled. This is not a complete match, but if any part of the property is in the program name, malloc debug is enabled. libc.debug.malloc.env_enabled If set, then malloc debug is only enabled if the running process has the environment variable LIBC_DEBUG_MALLOC_ENABLE set. Bug: 19145921 Change-Id: I7b0e58cc85cc6d4118173fe1f8627a391b64c0d7
110 lines
2.6 KiB
C++
110 lines
2.6 KiB
C++
/*
|
|
* Copyright (C) 2015 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <errno.h>
|
|
#include <stdarg.h>
|
|
|
|
#include <string>
|
|
|
|
#include <android-base/stringprintf.h>
|
|
#include <log/log.h>
|
|
#include <log/logger.h>
|
|
|
|
// Forward declarations.
|
|
class Backtrace;
|
|
struct EventTagMap;
|
|
struct AndroidLogEntry;
|
|
|
|
std::string g_fake_log_buf;
|
|
|
|
std::string g_fake_log_print;
|
|
|
|
void resetLogs() {
|
|
g_fake_log_buf = "";
|
|
g_fake_log_print = "";
|
|
}
|
|
|
|
std::string getFakeLogBuf() {
|
|
return g_fake_log_buf;
|
|
}
|
|
|
|
std::string getFakeLogPrint() {
|
|
return g_fake_log_print;
|
|
}
|
|
|
|
extern "C" int __libc_format_log(int priority, const char* tag, const char* format, ...) {
|
|
g_fake_log_print += std::to_string(priority) + ' ';
|
|
g_fake_log_print += tag;
|
|
g_fake_log_print += ' ';
|
|
|
|
va_list ap;
|
|
va_start(ap, format);
|
|
android::base::StringAppendV(&g_fake_log_print, format, ap);
|
|
va_end(ap);
|
|
|
|
g_fake_log_print += '\n';
|
|
|
|
return 0;
|
|
}
|
|
|
|
extern "C" int __android_log_buf_write(int bufId, int prio, const char* tag, const char* msg) {
|
|
g_fake_log_buf += std::to_string(bufId) + ' ' + std::to_string(prio) + ' ';
|
|
g_fake_log_buf += tag;
|
|
g_fake_log_buf += ' ';
|
|
g_fake_log_buf += msg;
|
|
return 1;
|
|
}
|
|
|
|
extern "C" int __android_log_print(int prio, const char* tag, const char* fmt, ...) {
|
|
g_fake_log_print += std::to_string(prio) + ' ';
|
|
g_fake_log_print += tag;
|
|
g_fake_log_print += ' ';
|
|
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
android::base::StringAppendV(&g_fake_log_print, fmt, ap);
|
|
va_end(ap);
|
|
|
|
g_fake_log_print += '\n';
|
|
|
|
return 1;
|
|
}
|
|
|
|
extern "C" log_id_t android_name_to_log_id(const char*) {
|
|
return LOG_ID_SYSTEM;
|
|
}
|
|
|
|
extern "C" struct logger_list* android_logger_list_open(log_id_t, int, unsigned int, pid_t) {
|
|
errno = EACCES;
|
|
return nullptr;
|
|
}
|
|
|
|
extern "C" int android_logger_list_read(struct logger_list*, struct log_msg*) {
|
|
return 0;
|
|
}
|
|
|
|
extern "C" EventTagMap* android_openEventTagMap(const char*) {
|
|
return nullptr;
|
|
}
|
|
|
|
extern "C" int android_log_processBinaryLogBuffer(
|
|
struct logger_entry*,
|
|
AndroidLogEntry*, const EventTagMap*, char*, int) {
|
|
return 0;
|
|
}
|
|
|
|
extern "C" void android_logger_list_free(struct logger_list*) {
|
|
}
|