Merge "Only allow system to write to existing input nodes."
diff --git a/adb/adb_utils.cpp b/adb/adb_utils.cpp
index 5a3b401..7afa616 100644
--- a/adb/adb_utils.cpp
+++ b/adb/adb_utils.cpp
@@ -313,3 +313,15 @@
void AdbCloser::Close(int fd) {
adb_close(fd);
}
+
+int usage(const char* fmt, ...) {
+ fprintf(stderr, "adb: ");
+
+ va_list ap;
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+ va_end(ap);
+
+ fprintf(stderr, "\n");
+ return 1;
+}
diff --git a/adb/adb_utils.h b/adb/adb_utils.h
index 16317e0..2b59034 100644
--- a/adb/adb_utils.h
+++ b/adb/adb_utils.h
@@ -21,6 +21,8 @@
#include <android-base/macros.h>
+int usage(const char*, ...);
+
void close_stdin();
bool getcwd(std::string* cwd);
diff --git a/adb/bugreport.cpp b/adb/bugreport.cpp
index 9b59d05..b7e76a6 100644
--- a/adb/bugreport.cpp
+++ b/adb/bugreport.cpp
@@ -182,11 +182,8 @@
DISALLOW_COPY_AND_ASSIGN(BugreportStandardStreamsCallback);
};
-// Implemented in commandline.cpp
-int usage();
-
int Bugreport::DoIt(TransportType transport_type, const char* serial, int argc, const char** argv) {
- if (argc > 2) return usage();
+ if (argc > 2) return usage("usage: adb bugreport [PATH]");
// Gets bugreportz version.
std::string bugz_stdout, bugz_stderr;
diff --git a/adb/commandline.cpp b/adb/commandline.cpp
index 2befa0c..3b2df2e 100644
--- a/adb/commandline.cpp
+++ b/adb/commandline.cpp
@@ -231,11 +231,6 @@
// clang-format on
}
-int usage() {
- help();
- return 1;
-}
-
#if defined(_WIN32)
// Implemented in sysdeps_win32.cpp.
@@ -1235,7 +1230,7 @@
}
static int restore(int argc, const char** argv) {
- if (argc != 2) return usage();
+ if (argc != 2) return usage("restore requires an argument");
const char* filename = argv[1];
int tarFd = adb_open(filename, O_RDONLY);
@@ -1443,19 +1438,19 @@
/* this is a special flag used only when the ADB client launches the ADB Server */
is_daemon = 1;
} else if (!strcmp(argv[0], "--reply-fd")) {
- if (argc < 2) return usage();
+ if (argc < 2) return usage("--reply-fd requires an argument");
const char* reply_fd_str = argv[1];
argc--;
argv++;
ack_reply_fd = strtol(reply_fd_str, nullptr, 10);
if (!_is_valid_ack_reply_fd(ack_reply_fd)) {
fprintf(stderr, "adb: invalid reply fd \"%s\"\n", reply_fd_str);
- return usage();
+ return 1;
}
} else if (!strncmp(argv[0], "-p", 2)) {
const char* product = nullptr;
if (argv[0][2] == '\0') {
- if (argc < 2) return usage();
+ if (argc < 2) return usage("-p requires an argument");
product = argv[1];
argc--;
argv++;
@@ -1465,13 +1460,13 @@
gProductOutPath = find_product_out_path(product);
if (gProductOutPath.empty()) {
fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product);
- return usage();
+ return 1;
}
} else if (argv[0][0]=='-' && argv[0][1]=='s') {
if (isdigit(argv[0][2])) {
serial = argv[0] + 2;
} else {
- if (argc < 2 || argv[0][2] != '\0') return usage();
+ if (argc < 2 || argv[0][2] != '\0') return usage("-s requires an argument");
serial = argv[1];
argc--;
argv++;
@@ -1484,7 +1479,7 @@
gListenAll = 1;
} else if (!strncmp(argv[0], "-H", 2)) {
if (argv[0][2] == '\0') {
- if (argc < 2) return usage();
+ if (argc < 2) return usage("-H requires an argument");
server_host_str = argv[1];
argc--;
argv++;
@@ -1493,7 +1488,7 @@
}
} else if (!strncmp(argv[0], "-P", 2)) {
if (argv[0][2] == '\0') {
- if (argc < 2) return usage();
+ if (argc < 2) return usage("-P requires an argument");
server_port_str = argv[1];
argc--;
argv++;
@@ -1501,7 +1496,7 @@
server_port_str = argv[0] + 2;
}
} else if (!strcmp(argv[0], "-L")) {
- if (argc < 2) return usage();
+ if (argc < 2) return usage("-L requires an argument");
server_socket_str = argv[1];
argc--;
argv++;
@@ -1566,7 +1561,7 @@
if (no_daemon || is_daemon) {
if (is_daemon && (ack_reply_fd == -1)) {
fprintf(stderr, "reply fd for adb server to client communication not specified.\n");
- return usage();
+ return 1;
}
r = adb_server_main(is_daemon, server_socket_str, ack_reply_fd);
} else {
@@ -1579,7 +1574,8 @@
}
if (argc == 0) {
- return usage();
+ help();
+ return 1;
}
/* handle wait-for-* prefix */
@@ -1696,7 +1692,7 @@
}
}
else if (!strcmp(argv[0], "sideload")) {
- if (argc != 2) return usage();
+ if (argc != 2) return usage("sideload requires an argument");
if (adb_sideload_host(argv[1])) {
return 1;
} else {
@@ -1730,7 +1726,7 @@
bool reverse = !strcmp(argv[0], "reverse");
++argv;
--argc;
- if (argc < 1) return usage();
+ if (argc < 1) return usage("%s requires an argument", argv[0]);
// Determine the <host-prefix> for this command.
std::string host_prefix;
@@ -1750,24 +1746,24 @@
std::string cmd, error;
if (strcmp(argv[0], "--list") == 0) {
- if (argc != 1) return usage();
+ if (argc != 1) return usage("--list doesn't take any arguments");
return adb_query_command(host_prefix + ":list-forward");
} else if (strcmp(argv[0], "--remove-all") == 0) {
- if (argc != 1) return usage();
+ if (argc != 1) return usage("--remove-all doesn't take any arguments");
cmd = host_prefix + ":killforward-all";
} else if (strcmp(argv[0], "--remove") == 0) {
// forward --remove <local>
- if (argc != 2) return usage();
+ if (argc != 2) return usage("--remove requires an argument");
cmd = host_prefix + ":killforward:" + argv[1];
} else if (strcmp(argv[0], "--no-rebind") == 0) {
// forward --no-rebind <local> <remote>
- if (argc != 3) return usage();
+ if (argc != 3) return usage("--no-rebind takes two arguments");
if (forward_targets_are_valid(argv[1], argv[2], &error)) {
cmd = host_prefix + ":forward:norebind:" + argv[1] + ";" + argv[2];
}
} else {
// forward <local> <remote>
- if (argc != 2) return usage();
+ if (argc != 2) return usage("forward takes two arguments");
if (forward_targets_are_valid(argv[0], argv[1], &error)) {
cmd = host_prefix + ":forward:" + argv[0] + ";" + argv[1];
}
@@ -1796,7 +1792,7 @@
}
/* do_sync_*() commands */
else if (!strcmp(argv[0], "ls")) {
- if (argc != 2) return usage();
+ if (argc != 2) return usage("ls requires an argument");
return do_sync_ls(argv[1]) ? 0 : 1;
}
else if (!strcmp(argv[0], "push")) {
@@ -1805,7 +1801,7 @@
const char* dst = nullptr;
parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, ©_attrs);
- if (srcs.empty() || !dst) return usage();
+ if (srcs.empty() || !dst) return usage("push requires an argument");
return do_sync_push(srcs, dst) ? 0 : 1;
}
else if (!strcmp(argv[0], "pull")) {
@@ -1814,22 +1810,22 @@
const char* dst = ".";
parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, ©_attrs);
- if (srcs.empty()) return usage();
+ if (srcs.empty()) return usage("pull requires an argument");
return do_sync_pull(srcs, dst, copy_attrs) ? 0 : 1;
}
else if (!strcmp(argv[0], "install")) {
- if (argc < 2) return usage();
+ if (argc < 2) return usage("install requires an argument");
if (_use_legacy_install()) {
return install_app_legacy(transport_type, serial, argc, argv);
}
return install_app(transport_type, serial, argc, argv);
}
else if (!strcmp(argv[0], "install-multiple")) {
- if (argc < 2) return usage();
+ if (argc < 2) return usage("install-multiple requires an argument");
return install_multiple_app(transport_type, serial, argc, argv);
}
else if (!strcmp(argv[0], "uninstall")) {
- if (argc < 2) return usage();
+ if (argc < 2) return usage("uninstall requires an argument");
if (_use_legacy_install()) {
return uninstall_app_legacy(transport_type, serial, argc, argv);
}
@@ -1852,12 +1848,12 @@
// A local path or "android"/"data" arg was specified.
src = argv[1];
} else {
- return usage();
+ return usage("usage: adb sync [-l] [PARTITION]");
}
if (src != "" &&
src != "system" && src != "data" && src != "vendor" && src != "oem") {
- return usage();
+ return usage("don't know how to sync %s partition", src.c_str());
}
std::string system_src_path = product_file("system");
@@ -1909,7 +1905,7 @@
return restore(argc, argv);
}
else if (!strcmp(argv[0], "keygen")) {
- if (argc < 2) return usage();
+ if (argc != 2) return usage("keygen requires an argument");
// Always print key generation information for keygen command.
adb_trace_enable(AUTH);
return adb_auth_keygen(argv[1]);
@@ -1926,11 +1922,11 @@
/* "adb /?" is a common idiom under Windows */
- else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) {
+ else if (!strcmp(argv[0], "--help") || !strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) {
help();
return 0;
}
- else if (!strcmp(argv[0], "version")) {
+ else if (!strcmp(argv[0], "--version") || !strcmp(argv[0], "version")) {
fprintf(stdout, "%s", adb_version().c_str());
return 0;
}
@@ -1961,12 +1957,12 @@
std::string err;
return adb_query_command("host:reconnect-offline");
} else {
- return usage();
+ return usage("usage: adb reconnect [device|offline]");
}
}
}
- usage();
+ usage("unknown command %s", argv[0]);
return 1;
}
diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 58eaed7..2889356 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -18,10 +18,12 @@
#include <dirent.h>
#include <fcntl.h>
#include <stdlib.h>
-#include <syscall.h>
+#include <sys/capability.h>
+#include <sys/prctl.h>
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/un.h>
+#include <syscall.h>
#include <unistd.h>
#include <limits>
@@ -51,24 +53,25 @@
using android::base::unique_fd;
using android::base::StringPrintf;
-static bool pid_contains_tid(pid_t pid, pid_t tid) {
- std::string task_path = StringPrintf("/proc/%d/task/%d", pid, tid);
- return access(task_path.c_str(), F_OK) == 0;
+static bool pid_contains_tid(int pid_proc_fd, pid_t tid) {
+ struct stat st;
+ std::string task_path = StringPrintf("task/%d", tid);
+ return fstatat(pid_proc_fd, task_path.c_str(), &st, 0) == 0;
}
// Attach to a thread, and verify that it's still a member of the given process
-static bool ptrace_seize_thread(pid_t pid, pid_t tid, std::string* error) {
+static bool ptrace_seize_thread(int pid_proc_fd, pid_t tid, std::string* error) {
if (ptrace(PTRACE_SEIZE, tid, 0, 0) != 0) {
*error = StringPrintf("failed to attach to thread %d: %s", tid, strerror(errno));
return false;
}
// Make sure that the task we attached to is actually part of the pid we're dumping.
- if (!pid_contains_tid(pid, tid)) {
+ if (!pid_contains_tid(pid_proc_fd, tid)) {
if (ptrace(PTRACE_DETACH, tid, 0, 0) != 0) {
PLOG(FATAL) << "failed to detach from thread " << tid;
}
- *error = StringPrintf("thread %d is not in process %d", tid, pid);
+ *error = StringPrintf("thread %d is not in process", tid);
return false;
}
@@ -190,6 +193,24 @@
_exit(1);
}
+static void drop_capabilities() {
+ __user_cap_header_struct capheader;
+ memset(&capheader, 0, sizeof(capheader));
+ capheader.version = _LINUX_CAPABILITY_VERSION_3;
+ capheader.pid = 0;
+
+ __user_cap_data_struct capdata[2];
+ memset(&capdata, 0, sizeof(capdata));
+
+ if (capset(&capheader, &capdata[0]) == -1) {
+ PLOG(FATAL) << "failed to drop capabilities";
+ }
+
+ if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) != 0) {
+ PLOG(FATAL) << "failed to set PR_SET_NO_NEW_PRIVS";
+ }
+}
+
static void check_process(int proc_fd, pid_t expected_pid) {
android::procinfo::ProcessInfo proc_info;
if (!android::procinfo::GetProcessInfoFromProcPidFd(proc_fd, &proc_info)) {
@@ -263,7 +284,7 @@
check_process(target_proc_fd, target);
std::string attach_error;
- if (!ptrace_seize_thread(target, main_tid, &attach_error)) {
+ if (!ptrace_seize_thread(target_proc_fd, main_tid, &attach_error)) {
LOG(FATAL) << attach_error;
}
@@ -304,6 +325,7 @@
}
int signo = siginfo.si_signo;
+ bool fatal_signal = signo != DEBUGGER_SIGNAL;
bool backtrace = false;
uintptr_t abort_address = 0;
@@ -319,17 +341,16 @@
// Now that we have the signal that kicked things off, attach all of the
// sibling threads, and then proceed.
- bool fatal_signal = signo != DEBUGGER_SIGNAL;
- std::set<pid_t> siblings;
std::set<pid_t> attached_siblings;
- if (fatal_signal || backtrace) {
+ {
+ std::set<pid_t> siblings;
if (!android::procinfo::GetProcessTids(target, &siblings)) {
PLOG(FATAL) << "failed to get process siblings";
}
siblings.erase(main_tid);
for (pid_t sibling_tid : siblings) {
- if (!ptrace_seize_thread(target, sibling_tid, &attach_error)) {
+ if (!ptrace_seize_thread(target_proc_fd, sibling_tid, &attach_error)) {
LOG(WARNING) << attach_error;
} else {
attached_siblings.insert(sibling_tid);
@@ -337,20 +358,29 @@
}
}
+ std::unique_ptr<BacktraceMap> backtrace_map(BacktraceMap::Create(main_tid));
+ if (!backtrace_map) {
+ LOG(FATAL) << "failed to create backtrace map";
+ }
+
+ // Collect the list of open files.
+ OpenFilesList open_files;
+ if (!backtrace) {
+ populate_open_files_list(target, &open_files);
+ }
+
+ // Drop our capabilities now that we've attached to the threads we care about.
+ drop_capabilities();
+
check_process(target_proc_fd, target);
// TODO: Use seccomp to lock ourselves down.
- std::unique_ptr<BacktraceMap> backtrace_map(BacktraceMap::Create(main_tid));
std::string amfd_data;
if (backtrace) {
dump_backtrace(output_fd.get(), backtrace_map.get(), target, main_tid, attached_siblings, 0);
} else {
- // Collect the list of open files.
- OpenFilesList open_files;
- populate_open_files_list(target, &open_files);
-
engrave_tombstone(output_fd.get(), backtrace_map.get(), open_files, target, main_tid,
attached_siblings, abort_address, fatal_signal ? &amfd_data : nullptr);
}
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index e7503e9..002e940 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -40,10 +40,10 @@
using android::base::unique_fd;
#if defined(__LP64__)
-#define CRASHER_PATH "/system/xbin/crasher64"
+#define CRASHER_PATH "/system/bin/crasher64"
#define ARCH_SUFFIX "64"
#else
-#define CRASHER_PATH "/system/xbin/crasher"
+#define CRASHER_PATH "/system/bin/crasher"
#define ARCH_SUFFIX ""
#endif
@@ -192,7 +192,7 @@
std::string type = "wait-" + crash_type;
StartProcess([type]() {
execl(CRASHER_PATH, CRASHER_PATH, type.c_str(), nullptr);
- err(1, "exec failed");
+ exit(errno);
});
}
@@ -216,7 +216,9 @@
FAIL() << "failed to wait for crasher: " << strerror(errno);
}
- if (!WIFSIGNALED(status)) {
+ if (WIFEXITED(status)) {
+ FAIL() << "crasher failed to exec: " << strerror(WEXITSTATUS(status));
+ } else if (!WIFSIGNALED(status)) {
FAIL() << "crasher didn't terminate via a signal";
}
ASSERT_EQ(signo, WTERMSIG(status));
diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index 9469bbd..38a7be3 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -39,6 +39,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <sys/capability.h>
#include <sys/mman.h>
#include <sys/prctl.h>
#include <sys/socket.h>
@@ -207,7 +208,7 @@
}
// Don't use fork(2) to avoid calling pthread_atfork handlers.
- int forkpid = clone(nullptr, nullptr, SIGCHLD, nullptr);
+ int forkpid = clone(nullptr, nullptr, 0, nullptr);
if (forkpid == -1) {
__libc_format_log(ANDROID_LOG_FATAL, "libc", "failed to fork in debuggerd signal handler: %s",
strerror(errno));
@@ -216,6 +217,11 @@
close(pipefds[0]);
close(pipefds[1]);
+ // Set all of the ambient capability bits we can, so that crash_dump can ptrace us.
+ for (unsigned long i = 0; prctl(PR_CAPBSET_READ, i, 0, 0, 0) != -1; ++i) {
+ prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_RAISE, i, 0, 0);
+ }
+
char buf[10];
snprintf(buf, sizeof(buf), "%d", thread_info->crashing_tid);
execl(CRASH_DUMP_PATH, CRASH_DUMP_NAME, buf, nullptr);
@@ -242,10 +248,12 @@
close(pipefds[0]);
// Don't leave a zombie child.
- siginfo_t child_siginfo;
- if (TEMP_FAILURE_RETRY(waitid(P_PID, forkpid, &child_siginfo, WEXITED)) != 0) {
+ int status;
+ if (TEMP_FAILURE_RETRY(waitpid(forkpid, &status, __WCLONE)) == -1 && errno != ECHILD) {
__libc_format_log(ANDROID_LOG_FATAL, "libc", "failed to wait for crash_dump helper: %s",
strerror(errno));
+ } else if (WIFSTOPPED(status) || WIFSIGNALED(status)) {
+ __libc_format_log(ANDROID_LOG_FATAL, "libc", "crash_dump helper crashed or stopped");
thread_info->crash_dump_started = false;
}
}
diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index e7f1a07..a4a0b52 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1303,6 +1303,36 @@
return num;
}
+static std::string fb_fix_numeric_var(std::string var) {
+ // Some bootloaders (angler, for example), send spurious leading whitespace.
+ var = android::base::Trim(var);
+ // Some bootloaders (hammerhead, for example) use implicit hex.
+ // This code used to use strtol with base 16.
+ if (!android::base::StartsWith(var, "0x")) var = "0x" + var;
+ return var;
+}
+
+static unsigned fb_get_flash_block_size(Transport* transport, std::string name) {
+ std::string sizeString;
+ if (!fb_getvar(transport, name.c_str(), &sizeString)) {
+ /* This device does not report flash block sizes, so return 0 */
+ return 0;
+ }
+ sizeString = fb_fix_numeric_var(sizeString);
+
+ unsigned size;
+ if (!android::base::ParseUint(sizeString, &size)) {
+ fprintf(stderr, "Couldn't parse %s '%s'.\n", name.c_str(), sizeString.c_str());
+ return 0;
+ }
+ if (size < 4096 || (size & (size - 1)) != 0) {
+ fprintf(stderr, "Invalid %s %u: must be a power of 2 and at least 4096.\n",
+ name.c_str(), size);
+ return 0;
+ }
+ return size;
+}
+
static void fb_perform_format(Transport* transport,
const char* partition, int skip_if_not_supported,
const char* type_override, const char* size_override,
@@ -1345,11 +1375,7 @@
}
partition_size = size_override;
}
- // Some bootloaders (angler, for example), send spurious leading whitespace.
- partition_size = android::base::Trim(partition_size);
- // Some bootloaders (hammerhead, for example) use implicit hex.
- // This code used to use strtol with base 16.
- if (!android::base::StartsWith(partition_size, "0x")) partition_size = "0x" + partition_size;
+ partition_size = fb_fix_numeric_var(partition_size);
gen = fs_get_generator(partition_type);
if (!gen) {
@@ -1370,7 +1396,12 @@
}
fd = fileno(tmpfile());
- if (fs_generator_generate(gen, fd, size, initial_dir)) {
+
+ unsigned eraseBlkSize, logicalBlkSize;
+ eraseBlkSize = fb_get_flash_block_size(transport, "erase-block-size");
+ logicalBlkSize = fb_get_flash_block_size(transport, "logical-block-size");
+
+ if (fs_generator_generate(gen, fd, size, initial_dir, eraseBlkSize, logicalBlkSize)) {
fprintf(stderr, "Cannot generate image: %s\n", strerror(errno));
close(fd);
return;
diff --git a/fastboot/fs.cpp b/fastboot/fs.cpp
index 9b73165..5d9ccfe 100644
--- a/fastboot/fs.cpp
+++ b/fastboot/fs.cpp
@@ -14,18 +14,21 @@
#include <ext4_utils/make_ext4fs.h>
#include <sparse/sparse.h>
-static int generate_ext4_image(int fd, long long partSize, const std::string& initial_dir)
+static int generate_ext4_image(int fd, long long partSize, const std::string& initial_dir,
+ unsigned eraseBlkSize, unsigned logicalBlkSize)
{
if (initial_dir.empty()) {
- make_ext4fs_sparse_fd(fd, partSize, NULL, NULL);
+ make_ext4fs_sparse_fd_align(fd, partSize, NULL, NULL, eraseBlkSize, logicalBlkSize);
} else {
- make_ext4fs_sparse_fd_directory(fd, partSize, NULL, NULL, initial_dir.c_str());
+ make_ext4fs_sparse_fd_directory_align(fd, partSize, NULL, NULL, initial_dir.c_str(),
+ eraseBlkSize, logicalBlkSize);
}
return 0;
}
#ifdef USE_F2FS
-static int generate_f2fs_image(int fd, long long partSize, const std::string& initial_dir)
+static int generate_f2fs_image(int fd, long long partSize, const std::string& initial_dir,
+ unsigned /* unused */, unsigned /* unused */)
{
if (!initial_dir.empty()) {
fprintf(stderr, "Unable to set initial directory on F2FS filesystem\n");
@@ -39,7 +42,8 @@
const char* fs_type; //must match what fastboot reports for partition type
//returns 0 or error value
- int (*generate)(int fd, long long partSize, const std::string& initial_dir);
+ int (*generate)(int fd, long long partSize, const std::string& initial_dir,
+ unsigned eraseBlkSize, unsigned logicalBlkSize);
} generators[] = {
{ "ext4", generate_ext4_image},
@@ -58,7 +62,7 @@
}
int fs_generator_generate(const struct fs_generator* gen, int tmpFileNo, long long partSize,
- const std::string& initial_dir)
+ const std::string& initial_dir, unsigned eraseBlkSize, unsigned logicalBlkSize)
{
- return gen->generate(tmpFileNo, partSize, initial_dir);
+ return gen->generate(tmpFileNo, partSize, initial_dir, eraseBlkSize, logicalBlkSize);
}
diff --git a/fastboot/fs.h b/fastboot/fs.h
index 0a68507..0a5f5a4 100644
--- a/fastboot/fs.h
+++ b/fastboot/fs.h
@@ -8,6 +8,6 @@
const struct fs_generator* fs_get_generator(const std::string& fs_type);
int fs_generator_generate(const struct fs_generator* gen, int tmpFileNo, long long partSize,
- const std::string& initial_dir);
+ const std::string& initial_dir, unsigned eraseBlkSize = 0, unsigned logicalBlkSize = 0);
#endif
diff --git a/init/builtins.cpp b/init/builtins.cpp
index 965a81f..2388edc 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -265,10 +265,14 @@
if (!svc) {
return -1;
}
- if (!svc->Start()) {
+ if (!start_waiting_for_exec()) {
return -1;
}
- waiting_for_exec = true;
+ if (!svc->Start()) {
+ stop_waiting_for_exec();
+ ServiceManager::GetInstance().RemoveService(*svc);
+ return -1;
+ }
return 0;
}
@@ -1018,7 +1022,7 @@
<< "\") failed: value too long";
return -1;
}
- if (!wait_property(name, value)) {
+ if (!start_waiting_for_property(name, value)) {
LOG(ERROR) << "do_wait_for_prop(\"" << name << "\", \"" << value
<< "\") failed: init already in waiting";
return -1;
diff --git a/init/init.cpp b/init/init.cpp
index c8c18d2..43f601f 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -82,7 +82,7 @@
const char *ENV[32];
-bool waiting_for_exec = false;
+static std::unique_ptr<Timer> waiting_for_exec(nullptr);
static int epoll_fd = -1;
@@ -131,7 +131,24 @@
return -1;
}
-bool wait_property(const char *name, const char *value)
+bool start_waiting_for_exec()
+{
+ if (waiting_for_exec) {
+ return false;
+ }
+ waiting_for_exec.reset(new Timer());
+ return true;
+}
+
+void stop_waiting_for_exec()
+{
+ if (waiting_for_exec) {
+ LOG(INFO) << "Wait for exec took " << *waiting_for_exec;
+ waiting_for_exec.reset();
+ }
+}
+
+bool start_waiting_for_property(const char *name, const char *value)
{
if (waiting_for_prop) {
return false;
@@ -142,7 +159,8 @@
wait_prop_value = value;
waiting_for_prop.reset(new Timer());
} else {
- LOG(INFO) << "wait_property(\"" << name << "\", \"" << value << "\"): already set";
+ LOG(INFO) << "start_waiting_for_property(\""
+ << name << "\", \"" << value << "\"): already set";
}
return true;
}
diff --git a/init/init.h b/init/init.h
index 4e4da32..3768c02 100644
--- a/init/init.h
+++ b/init/init.h
@@ -23,7 +23,6 @@
class Service;
extern const char *ENV[32];
-extern bool waiting_for_exec;
extern std::string default_console;
extern struct selabel_handle *sehandle;
extern struct selabel_handle *sehandle_prop;
@@ -36,6 +35,10 @@
int add_environment(const char* key, const char* val);
-bool wait_property(const char *name, const char *value);
+bool start_waiting_for_exec();
+
+void stop_waiting_for_exec();
+
+bool start_waiting_for_property(const char *name, const char *value);
#endif /* _INIT_INIT_H */
diff --git a/init/service.cpp b/init/service.cpp
index 0f7f62f..e186f27 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -997,7 +997,7 @@
}
if (svc->Reap()) {
- waiting_for_exec = false;
+ stop_waiting_for_exec();
RemoveService(*svc);
}
diff --git a/init/ueventd.cpp b/init/ueventd.cpp
index 361b925..915afbd 100644
--- a/init/ueventd.cpp
+++ b/init/ueventd.cpp
@@ -60,9 +60,18 @@
cb.func_log = selinux_klog_callback;
selinux_set_callback(SELINUX_CB_LOG, cb);
- std::string hardware = property_get("ro.hardware");
-
ueventd_parse_config_file("/ueventd.rc");
+ ueventd_parse_config_file("/vendor/ueventd.rc");
+ ueventd_parse_config_file("/odm/ueventd.rc");
+
+ /*
+ * keep the current product name base configuration so
+ * we remain backwards compatible and allow it to override
+ * everything
+ * TODO: cleanup platform ueventd.rc to remove vendor specific
+ * device node entries (b/34968103)
+ */
+ std::string hardware = property_get("ro.hardware");
ueventd_parse_config_file(android::base::StringPrintf("/ueventd.%s.rc", hardware.c_str()).c_str());
device_init();
diff --git a/libcutils/fs_config.c b/libcutils/fs_config.c
index 013999a..b701bba 100644
--- a/libcutils/fs_config.c
+++ b/libcutils/fs_config.c
@@ -177,11 +177,8 @@
CAP_MASK_LONG(CAP_SETPCAP),
"system/bin/webview_zygote64" },
- { 00755, AID_ROOT, AID_SHELL, CAP_MASK_LONG(CAP_SYS_PTRACE),
- "system/bin/crash_dump32" },
- { 00755, AID_ROOT, AID_SHELL, CAP_MASK_LONG(CAP_SYS_PTRACE),
- "system/bin/crash_dump64" },
-
+ { 00755, AID_ROOT, AID_SHELL, 0, "system/bin/crash_dump32" },
+ { 00755, AID_ROOT, AID_SHELL, 0, "system/bin/crash_dump64" },
{ 00755, AID_ROOT, AID_SHELL, 0, "system/bin/debuggerd" },
{ 00750, AID_ROOT, AID_ROOT, 0, "system/bin/uncrypt" },
{ 00750, AID_ROOT, AID_ROOT, 0, "system/bin/install-recovery.sh" },
diff --git a/liblog/Android.bp b/liblog/Android.bp
index 747fcc8..310dbf4 100644
--- a/liblog/Android.bp
+++ b/liblog/Android.bp
@@ -15,13 +15,17 @@
//
liblog_sources = [
+ "config_read.c",
+ "config_write.c",
+ "local_logger.c",
"log_event_list.c",
"log_event_write.c",
- "logger_write.c",
- "config_write.c",
- "logger_name.c",
- "logger_lock.c",
"log_ratelimit.cpp",
+ "logger_lock.c",
+ "logger_name.c",
+ "logger_read.c",
+ "logger_write.c",
+ "logprint.c",
]
liblog_host_sources = [
"fake_log_device.c",
@@ -29,15 +33,12 @@
]
liblog_target_sources = [
"event_tag_map.cpp",
- "config_read.c",
"log_time.cpp",
"properties.c",
- "logprint.c",
"pmsg_reader.c",
"pmsg_writer.c",
"logd_reader.c",
"logd_writer.c",
- "logger_read.c",
]
// Shared and static library for host and device
diff --git a/liblog/README b/liblog/README
index 610338c..40a39ad 100644
--- a/liblog/README
+++ b/liblog/README
@@ -108,6 +108,11 @@
int android_log_destroy(android_log_context *ctx)
+ #include <log/log_frontend.h>
+
+ int android_set_log_frontend(int frontend_flag)
+ int android_get_log_frontend()
+
Link with -llog
DESCRIPTION
@@ -162,6 +167,13 @@
when opening the sub-log. It is recommended to open the log
ANDROID_LOG_RDONLY in these cases.
+ android_set_log_frontend() selects frontend filters. Argument is either
+ LOGGER_DEFAULT, LOGGER_LOGD, LOGGER_NULL or LOGGER_LOCAL. Log to logger
+ daemon for default or logd, drop contents on floor, or log into local
+ memory respectively. Both android_set_log_frontend() and
+ android_get_log_frontend() return the current frontend mask, or a
+ negative errno for any problems.
+
ERRORS
If messages fail, a negative error code will be returned to the caller.
@@ -194,4 +206,4 @@
- 17 Oct 2016 LIBLOG(3)
+ 08 Feb 2017 LIBLOG(3)
diff --git a/liblog/config_read.c b/liblog/config_read.c
index 1f54152..b9a281b 100644
--- a/liblog/config_read.c
+++ b/liblog/config_read.c
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#include <log/log_frontend.h>
+
#include "config_read.h"
#include "logger.h"
@@ -52,11 +54,35 @@
}
LIBLOG_HIDDEN void __android_log_config_read() {
-#if (FAKE_LOG_DEVICE == 0)
- extern struct android_log_transport_read logdLoggerRead;
- extern struct android_log_transport_read pmsgLoggerRead;
+ if (__android_log_frontend & LOGGER_LOCAL) {
+ extern struct android_log_transport_read localLoggerRead;
- __android_log_add_transport(&__android_log_transport_read, &logdLoggerRead);
- __android_log_add_transport(&__android_log_persist_read, &pmsgLoggerRead);
+ __android_log_add_transport(&__android_log_transport_read,
+ &localLoggerRead);
+ }
+
+#if (FAKE_LOG_DEVICE == 0)
+ if ((__android_log_frontend == LOGGER_DEFAULT) ||
+ (__android_log_frontend & LOGGER_LOGD)) {
+ extern struct android_log_transport_read logdLoggerRead;
+ extern struct android_log_transport_read pmsgLoggerRead;
+
+ __android_log_add_transport(&__android_log_transport_read,
+ &logdLoggerRead);
+ __android_log_add_transport(&__android_log_persist_read,
+ &pmsgLoggerRead);
+ }
#endif
}
+
+LIBLOG_HIDDEN void __android_log_config_read_close() {
+ struct android_log_transport_read *transport;
+ struct listnode *n;
+
+ read_transport_for_each_safe(transport, n, &__android_log_transport_read) {
+ list_remove(&transport->node);
+ }
+ read_transport_for_each_safe(transport, n, &__android_log_persist_read) {
+ list_remove(&transport->node);
+ }
+}
diff --git a/liblog/config_read.h b/liblog/config_read.h
index 49a3b75..892e80d 100644
--- a/liblog/config_read.h
+++ b/liblog/config_read.h
@@ -28,22 +28,31 @@
#define read_transport_for_each(transp, transports) \
for ((transp) = node_to_item((transports)->next, \
- struct android_log_transport_read, node); \
- ((transp) != node_to_item(transports, \
- struct android_log_transport_read, node)); \
+ struct android_log_transport_read, node); \
+ ((transp) != node_to_item((transports), \
+ struct android_log_transport_read, \
+ node)) && \
+ ((transp) != node_to_item((transp)->node.next, \
+ struct android_log_transport_read, \
+ node)); \
(transp) = node_to_item((transp)->node.next, \
- struct android_log_transport_read, node)) \
+ struct android_log_transport_read, node))
#define read_transport_for_each_safe(transp, n, transports) \
for ((transp) = node_to_item((transports)->next, \
- struct android_log_transport_read, node), \
+ struct android_log_transport_read, node), \
(n) = (transp)->node.next; \
- ((transp) != node_to_item(transports, \
- struct android_log_transport_read, node)); \
- (transp) = node_to_item(n, struct android_log_transport_read, node), \
+ ((transp) != node_to_item((transports), \
+ struct android_log_transport_read, \
+ node)) && \
+ ((transp) != node_to_item((n), struct android_log_transport_read, \
+ node)); \
+ (transp) = node_to_item((n), struct android_log_transport_read, \
+ node), \
(n) = (transp)->node.next)
LIBLOG_HIDDEN void __android_log_config_read();
+LIBLOG_HIDDEN void __android_log_config_read_close();
__END_DECLS
diff --git a/liblog/config_write.c b/liblog/config_write.c
index d689f63..583dcff 100644
--- a/liblog/config_write.c
+++ b/liblog/config_write.c
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#include <log/log_frontend.h>
+
#include "config_write.h"
#include "logger.h"
@@ -52,15 +54,42 @@
}
LIBLOG_HIDDEN void __android_log_config_write() {
+ if (__android_log_frontend & LOGGER_LOCAL) {
+ extern struct android_log_transport_write localLoggerWrite;
+
+ __android_log_add_transport(&__android_log_transport_write,
+ &localLoggerWrite);
+ }
+
+ if ((__android_log_frontend == LOGGER_DEFAULT) ||
+ (__android_log_frontend & LOGGER_LOGD)) {
#if (FAKE_LOG_DEVICE == 0)
- extern struct android_log_transport_write logdLoggerWrite;
- extern struct android_log_transport_write pmsgLoggerWrite;
+ extern struct android_log_transport_write logdLoggerWrite;
+ extern struct android_log_transport_write pmsgLoggerWrite;
- __android_log_add_transport(&__android_log_transport_write, &logdLoggerWrite);
- __android_log_add_transport(&__android_log_persist_write, &pmsgLoggerWrite);
+ __android_log_add_transport(&__android_log_transport_write,
+ &logdLoggerWrite);
+ __android_log_add_transport(&__android_log_persist_write,
+ &pmsgLoggerWrite);
#else
- extern struct android_log_transport_write fakeLoggerWrite;
+ extern struct android_log_transport_write fakeLoggerWrite;
- __android_log_add_transport(&__android_log_transport_write, &fakeLoggerWrite);
+ __android_log_add_transport(&__android_log_transport_write,
+ &fakeLoggerWrite);
#endif
+ }
+}
+
+LIBLOG_HIDDEN void __android_log_config_write_close() {
+ struct android_log_transport_write *transport;
+ struct listnode *n;
+
+ write_transport_for_each_safe(transport, n, &__android_log_transport_write) {
+ transport->logMask = 0;
+ list_remove(&transport->node);
+ }
+ write_transport_for_each_safe(transport, n, &__android_log_persist_write) {
+ transport->logMask = 0;
+ list_remove(&transport->node);
+ }
}
diff --git a/liblog/config_write.h b/liblog/config_write.h
index 3b01a9a..8825411 100644
--- a/liblog/config_write.h
+++ b/liblog/config_write.h
@@ -29,21 +29,30 @@
#define write_transport_for_each(transp, transports) \
for ((transp) = node_to_item((transports)->next, \
struct android_log_transport_write, node); \
- ((transp) != node_to_item(transports, \
- struct android_log_transport_write, node)); \
+ ((transp) != node_to_item((transports), \
+ struct android_log_transport_write, \
+ node)) && \
+ ((transp) != node_to_item((transp)->node.next, \
+ struct android_log_transport_write, \
+ node)); \
(transp) = node_to_item((transp)->node.next, \
- struct android_log_transport_write, node)) \
+ struct android_log_transport_write, node))
#define write_transport_for_each_safe(transp, n, transports) \
for ((transp) = node_to_item((transports)->next, \
struct android_log_transport_write, node), \
(n) = (transp)->node.next; \
- ((transp) != node_to_item(transports, \
- struct android_log_transport_write, node)); \
- (transp) = node_to_item(n, struct android_log_transport_write, node), \
+ ((transp) != node_to_item((transports), \
+ struct android_log_transport_write, \
+ node)) && \
+ ((transp) != node_to_item((n), struct android_log_transport_write, \
+ node)); \
+ (transp) = node_to_item((n), struct android_log_transport_write, \
+ node), \
(n) = (transp)->node.next)
LIBLOG_HIDDEN void __android_log_config_write();
+LIBLOG_HIDDEN void __android_log_config_write_close();
__END_DECLS
diff --git a/liblog/fake_log_device.c b/liblog/fake_log_device.c
index 957129e..1d7a157 100644
--- a/liblog/fake_log_device.c
+++ b/liblog/fake_log_device.c
@@ -612,7 +612,12 @@
bail:
unlock();
- return vector[0].iov_len + vector[1].iov_len + vector[2].iov_len;
+ int len = 0;
+ for (i = 0; i < count; ++i) {
+ len += vector[i].iov_len;
+ }
+ return len;
+
error:
unlock();
return -1;
diff --git a/liblog/fake_writer.c b/liblog/fake_writer.c
index dab8bc5..2350673 100644
--- a/liblog/fake_writer.c
+++ b/liblog/fake_writer.c
@@ -46,9 +46,19 @@
int i;
for (i = 0; i < LOG_ID_MAX; i++) {
- char buf[sizeof("/dev/log_security")];
+ /*
+ * Known maximum size string, plus an 8 character margin to deal with
+ * possible independent changes to android_log_id_to_name().
+ */
+ char buf[sizeof("/dev/log_security") + 8];
+ if (logFds[i] >= 0) {
+ continue;
+ }
snprintf(buf, sizeof(buf), "/dev/log_%s", android_log_id_to_name(i));
logFds[i] = fakeLogOpen(buf, O_WRONLY);
+ if (logFds[i] < 0) {
+ fprintf(stderr, "fakeLogOpen(%s, O_WRONLY) failed\n", buf);
+ }
}
return 0;
}
@@ -66,16 +76,28 @@
struct iovec *vec, size_t nr)
{
ssize_t ret;
- int logFd;
+ size_t i;
+ int logFd, len;
if (/*(int)log_id >= 0 &&*/ (int)log_id >= (int)LOG_ID_MAX) {
- return -EBADF;
+ return -EINVAL;
+ }
+
+ len = 0;
+ for (i = 0; i < nr; ++i) {
+ len += vec[i].iov_len;
+ }
+
+ if (len > LOGGER_ENTRY_MAX_PAYLOAD) {
+ len = LOGGER_ENTRY_MAX_PAYLOAD;
}
logFd = logFds[(int)log_id];
ret = TEMP_FAILURE_RETRY(fakeLogWritev(logFd, vec, nr));
if (ret < 0) {
ret = -errno;
+ } else if (ret > len) {
+ ret = len;
}
return ret;
diff --git a/liblog/include/log/log_frontend.h b/liblog/include/log/log_frontend.h
new file mode 100644
index 0000000..9527779
--- /dev/null
+++ b/liblog/include/log/log_frontend.h
@@ -0,0 +1,34 @@
+/*
+**
+** Copyright 2017, The Android Open Source Project
+**
+** This file is dual licensed. It may be redistributed and/or modified
+** under the terms of the Apache 2.0 License OR version 2 of the GNU
+** General Public License.
+*/
+
+#ifndef _LIBS_LOG_FRONTEND_H
+#define _LIBS_LOG_FRONTEND_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Logging frontends, bit mask to select features. Function returns selection.
+ */
+#define LOGGER_DEFAULT 0x0
+#define LOGGER_LOGD 0x1
+#define LOGGER_KERNEL 0x2 /* Reserved/Deprecated */
+#define LOGGER_NULL 0x4 /* Does not release resources of other selections */
+#define LOGGER_LOCAL 0x8 /* logs sent to local memory */
+
+/* Both return the selected frontend flag mask, or negative errno */
+int android_set_log_frontend(int frontend_flag);
+int android_get_log_frontend();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LIBS_LOG_FRONTEND_H */
diff --git a/liblog/include/log/log_radio.h b/liblog/include/log/log_radio.h
index 30a73f2..430e522 100644
--- a/liblog/include/log/log_radio.h
+++ b/liblog/include/log/log_radio.h
@@ -38,6 +38,10 @@
/* --------------------------------------------------------------------- */
+#ifndef __predict_false
+#define __predict_false(exp) __builtin_expect((exp) != 0, 0)
+#endif
+
/*
* Simplified macro to send a verbose radio log message using current LOG_TAG.
*/
diff --git a/liblog/include/log/log_read.h b/liblog/include/log/log_read.h
index 5b5eebc..6a44b56 100644
--- a/liblog/include/log/log_read.h
+++ b/liblog/include/log/log_read.h
@@ -251,7 +251,11 @@
#define ANDROID_LOG_WRONLY O_WRONLY
#define ANDROID_LOG_RDWR O_RDWR
#define ANDROID_LOG_ACCMODE O_ACCMODE
+#ifndef O_NONBLOCK
+#define ANDROID_LOG_NONBLOCK 0x00000800
+#else
#define ANDROID_LOG_NONBLOCK O_NONBLOCK
+#endif
#if __ANDROID_USE_LIBLOG_READER_INTERFACE > 2
#define ANDROID_LOG_WRAP 0x40000000 /* Block until buffer about to wrap */
#define ANDROID_LOG_WRAP_DEFAULT_TIMEOUT 7200 /* 2 hour default */
diff --git a/liblog/include/log/log_system.h b/liblog/include/log/log_system.h
index 8c1ec96..394a106 100644
--- a/liblog/include/log/log_system.h
+++ b/liblog/include/log/log_system.h
@@ -36,6 +36,10 @@
#endif
#endif
+#ifndef __predict_false
+#define __predict_false(exp) __builtin_expect((exp) != 0, 0)
+#endif
+
/*
* Simplified macro to send a verbose system log message using current LOG_TAG.
*/
diff --git a/liblog/local_logger.c b/liblog/local_logger.c
new file mode 100644
index 0000000..d504342
--- /dev/null
+++ b/liblog/local_logger.c
@@ -0,0 +1,556 @@
+/*
+ * Copyright (C) 2017 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 <fcntl.h>
+#include <pthread.h>
+#if !defined(__MINGW32__)
+#include <pwd.h>
+#endif
+#include <sched.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <log/uio.h>
+
+#include <cutils/list.h> /* template, no library dependency */
+#include <log/log_frontend.h>
+#include <private/android_filesystem_config.h>
+#include <private/android_logger.h>
+#include <system/thread_defs.h>
+
+#include "config_read.h"
+#include "config_write.h"
+#include "log_portability.h"
+#include "logger.h"
+
+static const char baseServiceName[] = "android.logd";
+
+static int writeToLocalInit();
+static int writeToLocalAvailable(log_id_t logId);
+static void writeToLocalReset();
+static int writeToLocalWrite(log_id_t logId, struct timespec *ts,
+ struct iovec *vec, size_t nr);
+
+LIBLOG_HIDDEN struct android_log_transport_write localLoggerWrite = {
+ .node = { &localLoggerWrite.node, &localLoggerWrite.node },
+ .context.private = NULL,
+ .name = "local",
+ .available = writeToLocalAvailable,
+ .open = writeToLocalInit,
+ .close = writeToLocalReset,
+ .write = writeToLocalWrite,
+};
+
+static int writeToLocalVersion(struct android_log_logger *logger,
+ struct android_log_transport_context *transp);
+static int writeToLocalRead(struct android_log_logger_list *logger_list,
+ struct android_log_transport_context *transp,
+ struct log_msg *log_msg);
+static int writeToLocalPoll(struct android_log_logger_list *logger_list,
+ struct android_log_transport_context *transp);
+static void writeToLocalClose(struct android_log_logger_list *logger_list,
+ struct android_log_transport_context *transp);
+static int writeToLocalClear(struct android_log_logger *logger,
+ struct android_log_transport_context *transp);
+static ssize_t writeToLocalGetSize(
+ struct android_log_logger *logger,
+ struct android_log_transport_context *transp);
+static ssize_t writeToLocalSetSize(
+ struct android_log_logger *logger,
+ struct android_log_transport_context *transp __unused,
+ size_t size);
+static ssize_t writeToLocalGetReadbleSize(
+ struct android_log_logger *logger,
+ struct android_log_transport_context *transp);
+
+struct android_log_transport_read localLoggerRead = {
+ .node = { &localLoggerRead.node, &localLoggerRead.node },
+ .name = "local",
+ .available = writeToLocalAvailable,
+ .version = writeToLocalVersion,
+ .read = writeToLocalRead,
+ .poll = writeToLocalPoll,
+ .close = writeToLocalClose,
+ .clear = writeToLocalClear,
+ .getSize = writeToLocalGetSize,
+ .setSize = writeToLocalSetSize,
+ .getReadableSize = writeToLocalGetReadbleSize,
+ .getPrune = NULL,
+ .setPrune = NULL,
+ .getStats = NULL,
+};
+
+struct LogBufferElement {
+ struct listnode node;
+ log_id_t logId;
+ pid_t tid;
+ log_time timestamp;
+ unsigned short len;
+ char msg[];
+};
+
+static const size_t MAX_SIZE_DEFAULT = 32768;
+
+/*
+ * Number of log buffers we support with the following assumption:
+ * . . .
+ * LOG_ID_SECURITY = 5, // security logs go to the system logs only
+ * LOG_ID_KERNEL = 6, // place last, third-parties can not use it
+ * LOG_ID_MAX
+ * } log_id_t;
+ *
+ * Confirm the following should <log/log_id.h> be adjusted in the future.
+ */
+#define NUMBER_OF_LOG_BUFFERS ((LOG_ID_SECURITY == (LOG_ID_MAX - 2)) ? \
+ LOG_ID_SECURITY : \
+ LOG_ID_KERNEL)
+#define BLOCK_LOG_BUFFERS(id) (((id) == LOG_ID_SECURITY) || \
+ ((id) == LOG_ID_KERNEL))
+
+static struct LogBuffer {
+ struct listnode head;
+ pthread_rwlock_t listLock;
+ char *serviceName; /* Also indicates ready by having a value */
+ /* Order and proximity important for memset */
+ size_t number[NUMBER_OF_LOG_BUFFERS]; /* clear memset */
+ size_t size[NUMBER_OF_LOG_BUFFERS]; /* clear memset */
+ size_t totalSize[NUMBER_OF_LOG_BUFFERS]; /* init memset */
+ size_t maxSize[NUMBER_OF_LOG_BUFFERS]; /* init MAX_SIZE_DEFAULT */
+ struct listnode *last[NUMBER_OF_LOG_BUFFERS]; /* init &head */
+} logbuf = {
+ .head = { &logbuf.head, &logbuf.head },
+ .listLock = PTHREAD_RWLOCK_INITIALIZER,
+};
+
+static void LogBufferInit(struct LogBuffer *log) {
+ size_t i;
+
+ pthread_rwlock_wrlock(&log->listLock);
+ list_init(&log->head);
+ memset(log->number, 0,
+ sizeof(log->number) + sizeof(log->size) + sizeof(log->totalSize));
+ for (i = 0; i < NUMBER_OF_LOG_BUFFERS; ++i) {
+ log->maxSize[i] = MAX_SIZE_DEFAULT;
+ log->last[i] = &log->head;
+ }
+#ifdef __BIONIC__
+ asprintf(&log->serviceName, "%s@%d:%d", baseServiceName,
+ __android_log_uid(), getpid());
+#else
+ char buffer[sizeof(baseServiceName) + 1 + 5 + 1 + 5 + 8];
+ snprintf(buffer, sizeof(buffer), "%s@%d:%d", baseServiceName,
+ __android_log_uid(), getpid());
+ log->serviceName = strdup(buffer);
+#endif
+ pthread_rwlock_unlock(&log->listLock);
+}
+
+static void LogBufferClear(struct LogBuffer *log) {
+ size_t i;
+ struct listnode *node;
+
+ pthread_rwlock_wrlock(&log->listLock);
+ memset(log->number, 0, sizeof(log->number) + sizeof(log->size));
+ for (i = 0; i < NUMBER_OF_LOG_BUFFERS; ++i) {
+ log->last[i] = &log->head;
+ }
+ while ((node = list_head(&log->head)) != &log->head) {
+ struct LogBufferElement *element;
+
+ element = node_to_item(node, struct LogBufferElement, node);
+ list_remove(node);
+ free(element);
+ }
+ pthread_rwlock_unlock(&log->listLock);
+}
+
+static inline void LogBufferFree(struct LogBuffer *log) {
+ pthread_rwlock_wrlock(&log->listLock);
+ free(log->serviceName);
+ log->serviceName = NULL;
+ pthread_rwlock_unlock(&log->listLock);
+ LogBufferClear(log);
+}
+
+static int LogBufferLog(struct LogBuffer *log,
+ struct LogBufferElement *element) {
+ log_id_t logId = element->logId;
+
+ pthread_rwlock_wrlock(&log->listLock);
+ log->number[logId]++;
+ log->size[logId] += element->len;
+ log->totalSize[logId] += element->len;
+ /* prune entry(s) until enough space is available */
+ if (log->last[logId] == &log->head) {
+ log->last[logId] = list_tail(&log->head);
+ }
+ while (log->size[logId] > log->maxSize[logId]) {
+ struct listnode *node = log->last[logId];
+ struct LogBufferElement *e;
+ struct android_log_logger_list *logger_list;
+
+ e = node_to_item(node, struct LogBufferElement, node);
+ log->number[logId]--;
+ log->size[logId] -= e->len;
+ logger_list_rdlock();
+ logger_list_for_each(logger_list) {
+ struct android_log_transport_context *transp;
+
+ transport_context_for_each(transp, logger_list) {
+ if ((transp->transport == &localLoggerRead) &&
+ (transp->context.node == node)) {
+ if (node == &log->head) {
+ transp->context.node = &log->head;
+ } else {
+ transp->context.node = node->next;
+ }
+ }
+ }
+ }
+ logger_list_unlock();
+ if (node != &log->head) {
+ log->last[logId] = node->prev;
+ }
+ list_remove(node);
+ free(e);
+ }
+ /* add entry to list */
+ list_add_head(&log->head, &element->node);
+ /* ToDo: wake up all readers */
+ pthread_rwlock_unlock(&log->listLock);
+
+ return element->len;
+}
+
+/*
+ * return zero if permitted to log directly to logd,
+ * return 1 if binder server started and
+ * return negative error number if failed to start binder server.
+ */
+static int writeToLocalInit() {
+ pthread_attr_t attr;
+ struct LogBuffer *log;
+
+ if (writeToLocalAvailable(LOG_ID_MAIN) < 0) {
+ return -EPERM;
+ }
+
+ log = &logbuf;
+ if (!log->serviceName) {
+ LogBufferInit(log);
+ }
+
+ if (!log->serviceName) {
+ LogBufferFree(log);
+ return -ENOMEM;
+ }
+
+ return EPERM; /* successful local-only logging */
+}
+
+static void writeToLocalReset() {
+ LogBufferFree(&logbuf);
+}
+
+static int writeToLocalAvailable(log_id_t logId) {
+#if !defined(__MINGW32__)
+ uid_t uid;
+#endif
+
+ if ((logId >= NUMBER_OF_LOG_BUFFERS) || BLOCK_LOG_BUFFERS(logId)) {
+ return -EINVAL;
+ }
+
+ /* Android hard coded permitted, system goes to logd */
+#if !defined(__MINGW32__)
+ if (__android_log_frontend == LOGGER_DEFAULT) {
+ uid = __android_log_uid();
+ if ((uid < AID_APP) && (getpwuid(uid) != NULL)) {
+ return -EPERM;
+ }
+ }
+#endif
+
+ /* ToDo: Ask package manager for LOGD permissions */
+ /* Assume we do _not_ have permissions to go to LOGD, so must go local */
+ return 0;
+}
+
+static int writeToLocalWrite(log_id_t logId, struct timespec *ts,
+ struct iovec *vec, size_t nr) {
+ size_t len, i;
+ struct LogBufferElement *element;
+
+ if ((logId >= NUMBER_OF_LOG_BUFFERS) || BLOCK_LOG_BUFFERS(logId)) {
+ return -EINVAL;
+ }
+
+ len = 0;
+ for (i = 0; i < nr; ++i) {
+ len += vec[i].iov_len;
+ }
+
+ if (len > LOGGER_ENTRY_MAX_PAYLOAD) {
+ len = LOGGER_ENTRY_MAX_PAYLOAD;
+ }
+ element = (struct LogBufferElement *)calloc(1,
+ sizeof(struct LogBufferElement) + len + 1);
+ if (!element) {
+ return errno ? -errno : -ENOMEM;
+ }
+ element->timestamp.tv_sec = ts->tv_sec;
+ element->timestamp.tv_nsec = ts->tv_nsec;
+#ifdef __BIONIC__
+ element->tid = gettid();
+#else
+ element->tid = getpid();
+#endif
+ element->logId = logId;
+ element->len = len;
+
+ char *cp = element->msg;
+ for (i = 0; i < nr; ++i) {
+ size_t iov_len = vec[i].iov_len;
+ if (iov_len > len) {
+ iov_len = len;
+ }
+ memcpy(cp, vec[i].iov_base, iov_len);
+ len -= iov_len;
+ if (len == 0) {
+ break;
+ }
+ cp += iov_len;
+ }
+
+ return LogBufferLog(&logbuf, element);
+}
+
+static int writeToLocalVersion(
+ struct android_log_logger *logger __unused,
+ struct android_log_transport_context *transp __unused) {
+ return 3;
+}
+
+/* within reader lock, serviceName already validated */
+static struct listnode *writeToLocalNode(
+ struct android_log_logger_list *logger_list,
+ struct android_log_transport_context *transp) {
+ struct listnode *node;
+ unsigned logMask;
+ unsigned int tail;
+
+ node = transp->context.node;
+ if (node) {
+ return node;
+ }
+
+ if (!logger_list->tail) {
+ return transp->context.node = &logbuf.head;
+ }
+
+ logMask = transp->logMask;
+ tail = logger_list->tail;
+
+ for (node = list_head(&logbuf.head); node != &logbuf.head; node = node->next) {
+ struct LogBufferElement *element;
+ log_id_t logId;
+
+ element = node_to_item(node, struct LogBufferElement, node);
+ logId = element->logId;
+
+ if ((logMask & (1 << logId)) && !--tail) {
+ node = node->next;
+ break;
+ }
+ }
+ return transp->context.node = node;
+}
+
+static int writeToLocalRead(
+ struct android_log_logger_list *logger_list,
+ struct android_log_transport_context *transp,
+ struct log_msg *log_msg) {
+ int ret;
+ struct listnode *node;
+ unsigned logMask;
+
+ pthread_rwlock_rdlock(&logbuf.listLock);
+ if (!logbuf.serviceName) {
+ pthread_rwlock_unlock(&logbuf.listLock);
+ return (logger_list->mode & ANDROID_LOG_NONBLOCK) ? -ENODEV : 0;
+ }
+
+ logMask = transp->logMask;
+
+ node = writeToLocalNode(logger_list, transp);
+
+ ret = 0;
+
+ while (node != list_head(&logbuf.head)) {
+ struct LogBufferElement *element;
+ log_id_t logId;
+
+ node = node->prev;
+ element = node_to_item(node, struct LogBufferElement, node);
+ logId = element->logId;
+
+ if (logMask & (1 << logId)) {
+ ret = log_msg->entry_v3.len = element->len;
+ log_msg->entry_v3.hdr_size = sizeof(log_msg->entry_v3);
+ log_msg->entry_v3.pid = getpid();
+ log_msg->entry_v3.tid = element->tid;
+ log_msg->entry_v3.sec = element->timestamp.tv_sec;
+ log_msg->entry_v3.nsec = element->timestamp.tv_nsec;
+ log_msg->entry_v3.lid = logId;
+ memcpy(log_msg->entry_v3.msg, element->msg, ret);
+ ret += log_msg->entry_v3.hdr_size;
+ break;
+ }
+ }
+
+ transp->context.node = node;
+
+ /* ToDo: if blocking, and no entry, put reader to sleep */
+ pthread_rwlock_unlock(&logbuf.listLock);
+ return ret;
+}
+
+static int writeToLocalPoll(
+ struct android_log_logger_list *logger_list,
+ struct android_log_transport_context *transp) {
+ int ret = (logger_list->mode & ANDROID_LOG_NONBLOCK) ? -ENODEV : 0;
+
+ pthread_rwlock_rdlock(&logbuf.listLock);
+
+ if (logbuf.serviceName) {
+ unsigned logMask = transp->logMask;
+ struct listnode *node = writeToLocalNode(logger_list, transp);
+
+ ret = (node != list_head(&logbuf.head));
+ if (ret) {
+ do {
+ ret = !!(logMask & (1 << (node_to_item(node->prev,
+ struct LogBufferElement,
+ node))->logId));
+ } while (!ret && ((node = node->prev) != list_head(&logbuf.head)));
+ }
+
+ transp->context.node = node;
+ }
+
+ pthread_rwlock_unlock(&logbuf.listLock);
+
+ return ret;
+}
+
+static void writeToLocalClose(
+ struct android_log_logger_list *logger_list __unused,
+ struct android_log_transport_context *transp) {
+ pthread_rwlock_wrlock(&logbuf.listLock);
+ transp->context.node = list_head(&logbuf.head);
+ pthread_rwlock_unlock(&logbuf.listLock);
+}
+
+static int writeToLocalClear(
+ struct android_log_logger *logger,
+ struct android_log_transport_context *unused __unused) {
+ log_id_t logId = logger->logId;
+ struct listnode *node, *n;
+
+ if ((logId >= NUMBER_OF_LOG_BUFFERS) || BLOCK_LOG_BUFFERS(logId)) {
+ return -EINVAL;
+ }
+
+ pthread_rwlock_wrlock(&logbuf.listLock);
+ logbuf.number[logId] = 0;
+ logbuf.last[logId] = &logbuf.head;
+ list_for_each_safe(node, n, &logbuf.head) {
+ struct LogBufferElement *element;
+ element = node_to_item(node, struct LogBufferElement, node);
+
+ if (logId == element->logId) {
+ struct android_log_logger_list *logger_list;
+
+ logger_list_rdlock();
+ logger_list_for_each(logger_list) {
+ struct android_log_transport_context *transp;
+
+ transport_context_for_each(transp, logger_list) {
+ if ((transp->transport == &localLoggerRead) &&
+ (transp->context.node == node)) {
+ transp->context.node = node->next;
+ }
+ }
+ }
+ logger_list_unlock();
+ list_remove(node);
+ free(element);
+ }
+ }
+
+ pthread_rwlock_unlock(&logbuf.listLock);
+
+ return 0;
+}
+
+static ssize_t writeToLocalGetSize(
+ struct android_log_logger *logger,
+ struct android_log_transport_context *transp __unused) {
+ ssize_t ret = -EINVAL;
+ log_id_t logId = logger->logId;
+
+ if ((logId < NUMBER_OF_LOG_BUFFERS) && !BLOCK_LOG_BUFFERS(logId)) {
+ pthread_rwlock_rdlock(&logbuf.listLock);
+ ret = logbuf.maxSize[logId];
+ pthread_rwlock_unlock(&logbuf.listLock);
+ }
+
+ return ret;
+}
+
+static ssize_t writeToLocalSetSize(
+ struct android_log_logger *logger,
+ struct android_log_transport_context *transp __unused,
+ size_t size) {
+ ssize_t ret = -EINVAL;
+
+ if ((size > LOGGER_ENTRY_MAX_LEN) || (size < (4 * 1024 * 1024))) {
+ log_id_t logId = logger->logId;
+ if ((logId < NUMBER_OF_LOG_BUFFERS) || !BLOCK_LOG_BUFFERS(logId)) {
+ pthread_rwlock_wrlock(&logbuf.listLock);
+ ret = logbuf.maxSize[logId] = size;
+ pthread_rwlock_unlock(&logbuf.listLock);
+ }
+ }
+
+ return ret;
+}
+
+static ssize_t writeToLocalGetReadbleSize(
+ struct android_log_logger *logger,
+ struct android_log_transport_context *transp __unused) {
+ ssize_t ret = -EINVAL;
+ log_id_t logId = logger->logId;
+
+ if ((logId < NUMBER_OF_LOG_BUFFERS) && !BLOCK_LOG_BUFFERS(logId)) {
+ pthread_rwlock_rdlock(&logbuf.listLock);
+ ret = logbuf.serviceName ? (ssize_t)logbuf.size[logId] : -EBADF;
+ pthread_rwlock_unlock(&logbuf.listLock);
+ }
+
+ return ret;
+}
diff --git a/liblog/logger.h b/liblog/logger.h
index 50d1cb4..d94cd14 100644
--- a/liblog/logger.h
+++ b/liblog/logger.h
@@ -39,14 +39,16 @@
struct android_log_transport_write {
struct listnode node;
- const char *name;
- unsigned logMask; /* cache of available success */
+ const char *name; /* human name to describe the transport */
+ unsigned logMask; /* mask cache of available() success */
union android_log_context context; /* Initialized by static allocation */
- int (*available)(log_id_t logId);
- int (*open)();
- void (*close)();
- int (*write)(log_id_t logId, struct timespec *ts, struct iovec *vec, size_t nr);
+ int (*available)(log_id_t logId); /* Does not cause resources to be taken */
+ int (*open)(); /* can be called multiple times, reusing current resources */
+ void (*close)(); /* free up resources */
+ /* write log to transport, returns number of bytes propagated, or -errno */
+ int (*write)(log_id_t logId, struct timespec *ts,
+ struct iovec *vec, size_t nr);
};
struct android_log_logger_list;
@@ -55,22 +57,23 @@
struct android_log_transport_read {
struct listnode node;
- const char *name;
+ const char *name; /* human name to describe the transport */
+ /* Does not cause resources to be taken */
int (*available)(log_id_t logId);
int (*version)(struct android_log_logger *logger,
struct android_log_transport_context *transp);
+ /* Release resources taken by the following interfaces */
void (*close)(struct android_log_logger_list *logger_list,
struct android_log_transport_context *transp);
-
/*
- * Expect all to instantiate open on any call, so we do not have
- * an expicit open call
+ * Expect all to instantiate open automagically on any call,
+ * so we do not have an explicit open call.
*/
int (*read)(struct android_log_logger_list *logger_list,
struct android_log_transport_context *transp,
struct log_msg *log_msg);
- /* Assumption is only called if not ANDROID_LOG_NONBLOCK */
+ /* Must only be called if not ANDROID_LOG_NONBLOCK (blocking) */
int (*poll)(struct android_log_logger_list *logger_list,
struct android_log_transport_context *transp);
@@ -96,6 +99,7 @@
};
struct android_log_logger_list {
+ struct listnode node;
struct listnode logger;
struct listnode transport;
int mode;
@@ -117,9 +121,9 @@
struct android_log_logger_list *parent;
struct android_log_transport_read *transport;
- unsigned logMask;
- int ret;
- struct log_msg logMsg; /* valid is logMsg.len != 0 */
+ unsigned logMask; /* mask of requested log buffers */
+ int ret; /* return value associated with following data */
+ struct log_msg logMsg; /* peek at upcoming data, valid if logMsg.len != 0 */
};
/* assumes caller has structures read-locked, single threaded, or fenced */
@@ -143,6 +147,41 @@
(logp) = node_to_item((logp)->node.next, \
struct android_log_logger, node))
+/*
+ * Global list of log readers.
+ *
+ * Usage case: search out transport contexts for all readers
+ */
+
+LIBLOG_HIDDEN struct listnode __android_log_readers;
+
+#if defined(_WIN32)
+#define logger_list_rdlock()
+#define logger_list_wrlock()
+#define logger_list_unlock()
+#else
+LIBLOG_HIDDEN pthread_rwlock_t __android_log_readers_lock;
+
+#define logger_list_rdlock() pthread_rwlock_rdlock(&__android_log_readers_lock)
+#define logger_list_wrlock() pthread_rwlock_wrlock(&__android_log_readers_lock)
+#define logger_list_unlock() pthread_rwlock_unlock(&__android_log_readers_lock)
+#endif
+
+/* Must be called with logger_list_rdlock() or logger_list_wrlock() held */
+#define logger_list_for_each(logger_list) \
+ for ((logger_list) = node_to_item(&__android_log_readers, \
+ struct android_log_logger_list, \
+ node); \
+ (logger_list) != node_to_item(&__android_log_readers, \
+ struct android_log_logger_list, \
+ node) && \
+ (logger_list) != node_to_item((logger_list)->node.next, \
+ struct android_log_logger_list, \
+ node); \
+ (logger_list) = node_to_item((logger_list)->node.next, \
+ struct android_log_logger_list, \
+ node))
+
/* OS specific dribs and drabs */
#if defined(_WIN32)
@@ -157,6 +196,8 @@
LIBLOG_HIDDEN int __android_log_trylock();
LIBLOG_HIDDEN void __android_log_unlock();
+LIBLOG_HIDDEN int __android_log_frontend;
+
__END_DECLS
#endif /* _LIBLOG_LOGGER_H__ */
diff --git a/liblog/logger_read.c b/liblog/logger_read.c
index c3cb7ad..7e50a23 100644
--- a/liblog/logger_read.c
+++ b/liblog/logger_read.c
@@ -228,6 +228,13 @@
LOGGER_LIST_FUNCTION(logger_list, -ENODEV, setPrune, buf, len);
}
+LIBLOG_HIDDEN struct listnode __android_log_readers =
+ { &__android_log_readers, &__android_log_readers };
+#if !defined(_WIN32)
+LIBLOG_HIDDEN pthread_rwlock_t __android_log_readers_lock =
+ PTHREAD_RWLOCK_INITIALIZER;
+#endif
+
LIBLOG_ABI_PUBLIC struct logger_list *android_logger_list_alloc(
int mode,
unsigned int tail,
@@ -246,6 +253,10 @@
logger_list->tail = tail;
logger_list->pid = pid;
+ logger_list_wrlock();
+ list_add_tail(&__android_log_readers, &logger_list->node);
+ logger_list_unlock();
+
return (struct logger_list *)logger_list;
}
@@ -267,6 +278,10 @@
logger_list->start = start;
logger_list->pid = pid;
+ logger_list_wrlock();
+ list_add_tail(&__android_log_readers, &logger_list->node);
+ logger_list_unlock();
+
return (struct logger_list *)logger_list;
}
@@ -502,6 +517,10 @@
return;
}
+ logger_list_wrlock();
+ list_remove(&logger_list_internal->node);
+ logger_list_unlock();
+
while (!list_empty(&logger_list_internal->transport)) {
struct listnode *node = list_head(&logger_list_internal->transport);
struct android_log_transport_context *transp =
diff --git a/liblog/logger_write.c b/liblog/logger_write.c
index 1a2d506..e149e68 100644
--- a/liblog/logger_write.c
+++ b/liblog/logger_write.c
@@ -25,9 +25,11 @@
#endif
#include <log/event_tag_map.h>
+#include <log/log_frontend.h>
#include <private/android_filesystem_config.h>
#include <private/android_logger.h>
+#include "config_read.h" /* __android_log_config_read_close() definition */
#include "config_write.h"
#include "log_portability.h"
#include "logger.h"
@@ -170,6 +172,8 @@
}
}
+ __android_log_config_write_close();
+
#if defined(__ANDROID__)
/*
* Additional risk here somewhat mitigated by immediately unlock flushing
@@ -343,7 +347,7 @@
}
}
/* tag must be nul terminated */
- if (strnlen(tag, len) >= len) {
+ if (tag && strnlen(tag, len) >= len) {
tag = NULL;
}
@@ -514,6 +518,14 @@
strcpy(buf, "Unspecified assertion failed");
}
+ // Log assertion failures to stderr for the benefit of "adb shell" users
+ // and gtests (http://b/23675822).
+ struct iovec iov[2] = {
+ { buf, strlen(buf) },
+ { (char*) "\n", 1 },
+ };
+ TEMP_FAILURE_RETRY(writev(2, iov, 2));
+
__android_log_write(ANDROID_LOG_FATAL, tag, buf);
abort(); /* abort so we have a chance to debug the situation */
/* NOTREACHED */
@@ -610,3 +622,87 @@
return write_to_log(LOG_ID_SECURITY, vec, 4);
}
+
+static int __write_to_log_null(log_id_t log_id, struct iovec* vec, size_t nr)
+{
+ size_t len, i;
+
+ if ((log_id < LOG_ID_MIN) || (log_id >= LOG_ID_MAX)) {
+ return -EINVAL;
+ }
+
+ for (len = i = 0; i < nr; ++i) {
+ len += vec[i].iov_len;
+ }
+ if (!len) {
+ return -EINVAL;
+ }
+ return len;
+}
+
+/* Following functions need access to our internal write_to_log status */
+
+LIBLOG_HIDDEN int __android_log_frontend;
+
+LIBLOG_ABI_PUBLIC int android_set_log_frontend(int frontend_flag)
+{
+ int retval;
+
+ if (frontend_flag < 0) {
+ return -EINVAL;
+ }
+
+ retval = LOGGER_NULL;
+
+ __android_log_lock();
+
+ if (frontend_flag & LOGGER_NULL) {
+ write_to_log = __write_to_log_null;
+
+ __android_log_unlock();
+
+ return retval;
+ }
+
+ __android_log_frontend &= LOGGER_LOCAL | LOGGER_LOGD;
+
+ frontend_flag &= LOGGER_LOCAL | LOGGER_LOGD;
+
+ if (__android_log_frontend != frontend_flag) {
+ __android_log_frontend = frontend_flag;
+ __android_log_config_write_close();
+ __android_log_config_read_close();
+
+ write_to_log = __write_to_log_init;
+ /* generically we only expect these two values for write_to_log */
+ } else if ((write_to_log != __write_to_log_init) &&
+ (write_to_log != __write_to_log_daemon)) {
+ write_to_log = __write_to_log_init;
+ }
+
+ retval = __android_log_frontend;
+
+ __android_log_unlock();
+
+ return retval;
+}
+
+LIBLOG_ABI_PUBLIC int android_get_log_frontend()
+{
+ int ret = LOGGER_DEFAULT;
+
+ __android_log_lock();
+ if (write_to_log == __write_to_log_null) {
+ ret = LOGGER_NULL;
+ } else {
+ __android_log_frontend &= LOGGER_LOCAL | LOGGER_LOGD;
+ ret = __android_log_frontend;
+ if ((write_to_log != __write_to_log_init) &&
+ (write_to_log != __write_to_log_daemon)) {
+ ret = -EINVAL;
+ }
+ }
+ __android_log_unlock();
+
+ return ret;
+}
diff --git a/liblog/logprint.c b/liblog/logprint.c
index 18af9de..e61850d 100644
--- a/liblog/logprint.c
+++ b/liblog/logprint.c
@@ -16,13 +16,20 @@
*/
#define _GNU_SOURCE /* for asprintf */
+#ifndef __MINGW32__
+#define HAVE_STRSEP
+#endif
-#include <arpa/inet.h>
+//#ifndef __MINGW32__
+//#include <arpa/inet.h>
+//#endif
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <inttypes.h>
+#ifndef __MINGW32__
#include <pwd.h>
+#endif
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
@@ -40,6 +47,10 @@
#define MS_PER_NSEC 1000000
#define US_PER_NSEC 1000
+#ifndef MIN
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+#endif
+
typedef struct FilterInfo_t {
char *mTag;
android_LogPriority mPri;
@@ -216,7 +227,11 @@
p_ret->year_output = false;
p_ret->zone_output = false;
p_ret->epoch_output = false;
+#ifdef __ANDROID__
p_ret->monotonic_output = android_log_clockid() == CLOCK_MONOTONIC;
+#else
+ p_ret->monotonic_output = false;
+#endif
p_ret->uid_output = false;
p_ret->descriptive_output = false;
descriptive_output = false;
@@ -322,6 +337,7 @@
else if (strcmp(formatString, "monotonic") == 0) format = FORMAT_MODIFIER_MONOTONIC;
else if (strcmp(formatString, "uid") == 0) format = FORMAT_MODIFIER_UID;
else if (strcmp(formatString, "descriptive") == 0) format = FORMAT_MODIFIER_DESCRIPT;
+#ifndef __MINGW32__
else {
extern char *tzname[2];
static const char gmt[] = "GMT";
@@ -353,6 +369,7 @@
}
free(cp);
}
+#endif
return format;
}
@@ -411,7 +428,7 @@
/*
* Presently HAVE_STRNDUP is never defined, so the second case is always taken
- * Darwin doesn't have strnup, everything else does
+ * Darwin doesn't have strndup, everything else does
*/
#ifdef HAVE_STRNDUP
tagName = strndup(filterExpression, tagNameLength);
@@ -433,6 +450,27 @@
return -1;
}
+#ifndef HAVE_STRSEP
+/* KISS replacement helper for below */
+static char* strsep(char** stringp, const char* delim)
+{
+ char* token;
+ char* ret = *stringp;
+
+ if (!ret || !*ret) {
+ return NULL;
+ }
+ token = strpbrk(ret, delim);
+ if (token) {
+ *token = '\0';
+ ++token;
+ } else {
+ token = ret + strlen(ret);
+ }
+ *stringp = token;
+ return ret;
+}
+#endif
/**
* filterString: a comma/whitespace-separated set of filter expressions
@@ -444,7 +482,6 @@
* Assumes single threaded execution
*
*/
-
LIBLOG_ABI_PUBLIC int android_log_addFilterString(
AndroidLogFormat *p_format,
const char *filterString)
@@ -728,6 +765,7 @@
}
}
}
+ outCount = 0;
lval = 0;
switch (type) {
case EVENT_TYPE_INT:
@@ -953,7 +991,7 @@
LIBLOG_ABI_PUBLIC int android_log_processBinaryLogBuffer(
struct logger_entry *buf,
AndroidLogEntry *entry,
- const EventTagMap *map,
+ const EventTagMap *map __unused,
char *messageBuf, int messageBufLen)
{
size_t inCount;
@@ -995,11 +1033,12 @@
inCount -= 4;
entry->tagLen = 0;
+ entry->tag = NULL;
+#ifdef __ANDROID__
if (map != NULL) {
entry->tag = android_lookupEventTag_len(map, &entry->tagLen, tagIndex);
- } else {
- entry->tag = NULL;
}
+#endif
/*
* If we don't have a map, or didn't find the tag number in the map,
@@ -1024,9 +1063,11 @@
*/
const char* fmtStr = NULL;
size_t fmtLen = 0;
+#ifdef __ANDROID__
if (descriptive_output && map) {
fmtStr = android_lookupEventFormat_len(map, &fmtLen, tagIndex);
}
+#endif
char* outBuf = messageBuf;
size_t outRemaining = messageBufLen - 1; /* leave one for nul byte */
@@ -1250,6 +1291,7 @@
return (long long)now->tv_sec * NS_PER_SEC + now->tv_nsec;
}
+#ifdef __ANDROID__
static void convertMonotonic(struct timespec *result,
const AndroidLogEntry *entry)
{
@@ -1482,6 +1524,7 @@
result->tv_nsec = entry->tv_nsec;
subTimespec(result, result, &convert);
}
+#endif
/**
* Formats a log message into a buffer
@@ -1529,6 +1572,7 @@
*/
now = entry->tv_sec;
nsec = entry->tv_nsec;
+#if __ANDROID__
if (p_format->monotonic_output) {
// prevent convertMonotonic from being called if logd is monotonic
if (android_log_clockid() != CLOCK_MONOTONIC) {
@@ -1538,6 +1582,7 @@
nsec = time.tv_nsec;
}
}
+#endif
if (now < 0) {
nsec = NS_PER_SEC - nsec;
}
@@ -1591,13 +1636,18 @@
* This code is Android specific, bionic guarantees that
* calls to non-reentrant getpwuid() are thread safe.
*/
+#if !defined(__MINGW32__)
+#if (FAKE_LOG_DEVICE == 0)
#ifndef __BIONIC__
#warning "This code assumes that getpwuid is thread safe, only true with Bionic!"
#endif
+#endif
struct passwd* pwd = getpwuid(entry->uid);
if (pwd && (strlen(pwd->pw_name) <= 5)) {
snprintf(uid, sizeof(uid), "%5s:", pwd->pw_name);
- } else {
+ } else
+#endif
+ {
// Not worth parsing package list, names all longer than 5
snprintf(uid, sizeof(uid), "%5d:", entry->uid);
}
diff --git a/liblog/pmsg_writer.c b/liblog/pmsg_writer.c
index c1c068e..5e4ff98 100644
--- a/liblog/pmsg_writer.c
+++ b/liblog/pmsg_writer.c
@@ -285,6 +285,7 @@
__android_log_unlock();
} else if (pmsgOpen() < 0) {
__android_log_unlock();
+ free(cp);
return -EBADF;
}
}
diff --git a/liblog/tests/Android.mk b/liblog/tests/Android.mk
index 097befc..cfea452 100644
--- a/liblog/tests/Android.mk
+++ b/liblog/tests/Android.mk
@@ -55,7 +55,8 @@
-fno-builtin \
test_src_files := \
- liblog_test.cpp \
+ liblog_test_default.cpp \
+ liblog_test_local.cpp \
log_id_test.cpp \
log_radio_test.cpp \
log_read_test.cpp \
@@ -111,6 +112,7 @@
LOCAL_CXX_STL := libc++
LOCAL_SHARED_LIBRARIES := liblog libcutils libbase
LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
+LOCAL_LDLIBS_linux := -lrt
include $(BUILD_HOST_NATIVE_TEST)
endif # ifeq ($(HOST_OS)-$(HOST_ARCH),$(filter $(HOST_OS)-$(HOST_ARCH),linux-x86 linux-x86_64))
diff --git a/liblog/tests/liblog_benchmark.cpp b/liblog/tests/liblog_benchmark.cpp
index dc411c3..dac84eb 100644
--- a/liblog/tests/liblog_benchmark.cpp
+++ b/liblog/tests/liblog_benchmark.cpp
@@ -27,6 +27,7 @@
#include <android-base/file.h>
#include <cutils/sockets.h>
#include <log/event_tag_map.h>
+#include <log/log_frontend.h>
#include <private/android_logger.h>
#include "benchmark.h"
@@ -80,10 +81,29 @@
}
BENCHMARK(BM_log_maximum);
+static void set_log_null() {
+ android_set_log_frontend(LOGGER_NULL);
+}
+
+static void set_log_default() {
+ android_set_log_frontend(LOGGER_DEFAULT);
+}
+
+static void BM_log_maximum_null(int iters) {
+ set_log_null();
+ BM_log_maximum(iters);
+ set_log_default();
+}
+BENCHMARK(BM_log_maximum_null);
+
/*
- * Measure the time it takes to submit the android logging call using
- * discrete acquisition under light load. Expect this to be a pair of
- * syscall periods (2us).
+ * Measure the time it takes to collect the time using
+ * discrete acquisition (StartBenchmarkTiming() -> StopBenchmarkTiming())
+ * under light load. Expect this to be a syscall period (2us) or
+ * data read time if zero-syscall.
+ *
+ * vdso support in the kernel and the library can allow
+ * clock_gettime to be zero-syscall.
*/
static void BM_clock_overhead(int iters) {
for (int i = 0; i < iters; ++i) {
@@ -468,19 +488,94 @@
BENCHMARK(BM_pmsg_long_unaligned1);
/*
- * Measure the time it takes to submit the android logging call using
- * discrete acquisition under light load. Expect this to be a dozen or so
- * syscall periods (40us).
+ * Measure the time it takes to form sprintf plus time using
+ * discrete acquisition (StartBenchmarkTiming() -> StopBenchmarkTiming())
+ * under light load. Expect this to be a syscall period (2us) or sprintf
+ * time if zero-syscall time.
*/
-static void BM_log_overhead(int iters) {
+/* helper function */
+static void test_print(const char *fmt, ...) {
+ va_list ap;
+ char buf[1024];
+
+ va_start(ap, fmt);
+ vsnprintf(buf, sizeof(buf), fmt, ap);
+ va_end(ap);
+}
+
+#define logd_yield() sched_yield() // allow logd to catch up
+#define logd_sleep() usleep(50) // really allow logd to catch up
+
+/* performance test */
+static void BM_sprintf_overhead(int iters) {
+ for (int i = 0; i < iters; ++i) {
+ StartBenchmarkTiming();
+ test_print("BM_sprintf_overhead:%d", i);
+ StopBenchmarkTiming();
+ logd_yield();
+ }
+}
+BENCHMARK(BM_sprintf_overhead);
+
+/*
+ * Measure the time it takes to submit the android printing logging call
+ * using discrete acquisition discrete acquisition (StartBenchmarkTiming() ->
+ * StopBenchmarkTiming()) under light load. Expect this to be a dozen or so
+ * syscall periods (40us) plus time to run *printf
+ */
+static void BM_log_print_overhead(int iters) {
for (int i = 0; i < iters; ++i) {
StartBenchmarkTiming();
__android_log_print(ANDROID_LOG_INFO, "BM_log_overhead", "%d", i);
StopBenchmarkTiming();
- usleep(1000);
+ logd_yield();
}
}
-BENCHMARK(BM_log_overhead);
+BENCHMARK(BM_log_print_overhead);
+
+/*
+ * Measure the time it takes to submit the android event logging call
+ * using discrete acquisition (StartBenchmarkTiming() -> StopBenchmarkTiming())
+ * under light load. Expect this to be a dozen or so syscall periods (40us)
+ */
+static void BM_log_event_overhead(int iters) {
+ for (unsigned long long i = 0; i < (unsigned)iters; ++i) {
+ StartBenchmarkTiming();
+ __android_log_btwrite(0, EVENT_TYPE_LONG, &i, sizeof(i));
+ StopBenchmarkTiming();
+ logd_yield();
+ }
+}
+BENCHMARK(BM_log_event_overhead);
+
+static void BM_log_event_overhead_null(int iters) {
+ set_log_null();
+ BM_log_event_overhead(iters);
+ set_log_default();
+}
+BENCHMARK(BM_log_event_overhead_null);
+
+/*
+ * Measure the time it takes to submit the android event logging call
+ * using discrete acquisition (StartBenchmarkTiming() -> StopBenchmarkTiming())
+ * under very-light load (<1% CPU utilization).
+ */
+static void BM_log_light_overhead(int iters) {
+ for (unsigned long long i = 0; i < (unsigned)iters; ++i) {
+ StartBenchmarkTiming();
+ __android_log_btwrite(0, EVENT_TYPE_LONG, &i, sizeof(i));
+ StopBenchmarkTiming();
+ usleep(10000);
+ }
+}
+BENCHMARK(BM_log_light_overhead);
+
+static void BM_log_light_overhead_null(int iters) {
+ set_log_null();
+ BM_log_light_overhead(iters);
+ set_log_default();
+}
+BENCHMARK(BM_log_light_overhead_null);
static void caught_latency(int /*signum*/)
{
diff --git a/liblog/tests/liblog_test.cpp b/liblog/tests/liblog_test.cpp
index 5faf8e1..bc0ea4c 100644
--- a/liblog/tests/liblog_test.cpp
+++ b/liblog/tests/liblog_test.cpp
@@ -37,9 +37,32 @@
#include <gtest/gtest.h>
#include <log/logprint.h>
#include <log/log_event_list.h>
+#include <log/log_frontend.h>
#include <private/android_filesystem_config.h>
#include <private/android_logger.h>
+#ifndef TEST_PREFIX
+#ifdef __ANDROID__ // make sure we always run code if compiled for android
+#define TEST_PREFIX
+#endif
+#endif
+
+#if (!defined(USING_LOGGER_DEFAULT) || !defined(USING_LOGGER_LOCAL))
+#ifdef liblog // a binary clue that we are overriding the test names
+// Does not support log reading blocking feature yet
+// Does not support LOG_ID_SECURITY (unless we set LOGGER_LOCAL | LOGGER_LOGD)
+// Assume some common aspects are tested by USING_LOGGER_DEFAULT:
+// Does not need to _retest_ pmsg functionality
+// Does not need to _retest_ property handling as it is a higher function
+// Does not need to _retest_ event mapping functionality
+// Does not need to _retest_ ratelimit
+// Does not need to _retest_ logprint
+#define USING_LOGGER_LOCAL
+#else
+#define USING_LOGGER_DEFAULT
+#endif
+#endif
+
// enhanced version of LOG_FAILURE_RETRY to add support for EAGAIN and
// non-syscall libs. Since we are only using this in the emergency of
// a signal to stuff a terminating code into the logs, we will spin rather
@@ -56,7 +79,9 @@
_rc; })
TEST(liblog, __android_log_btwrite) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
+ TEST_PREFIX
+#endif
int intBuf = 0xDEADBEEF;
EXPECT_LT(0, __android_log_btwrite(0,
EVENT_TYPE_INT,
@@ -71,13 +96,10 @@
EVENT_TYPE_STRING,
Buf, sizeof(Buf) - 1));
usleep(1000);
-#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
-#endif
}
-#ifdef __ANDROID__
-std::string popenToString(std::string command) {
+#if (defined(__ANDROID__) && !defined(USING_LOGGER_LOCAL))
+static std::string popenToString(std::string command) {
std::string ret;
FILE* fp = popen(command.c_str(), "r");
@@ -141,11 +163,11 @@
return false;
}
-bool tested__android_log_close;
+static bool tested__android_log_close;
#endif
TEST(liblog, __android_log_btwrite__android_logger_list_read) {
-#ifdef __ANDROID__
+#if (defined(__ANDROID__) || defined(USING_LOGGER_LOCAL))
struct logger_list *logger_list;
pid_t pid = getpid();
@@ -153,9 +175,10 @@
ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
- // Check that we can close and reopen the logger
log_time ts(CLOCK_MONOTONIC);
ASSERT_LT(0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts)));
+#ifndef USING_LOGGER_LOCAL
+ // Check that we can close and reopen the logger
bool pmsgActiveAfter__android_log_btwrite;
bool logdwActiveAfter__android_log_btwrite;
if (getuid() == AID_ROOT) {
@@ -174,15 +197,18 @@
EXPECT_FALSE(pmsgActiveAfter__android_log_close);
EXPECT_FALSE(logdwActiveAfter__android_log_close);
}
+#endif
log_time ts1(CLOCK_MONOTONIC);
ASSERT_LT(0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts1, sizeof(ts1)));
+#ifndef USING_LOGGER_LOCAL
if (getuid() == AID_ROOT) {
pmsgActiveAfter__android_log_btwrite = isPmsgActive();
logdwActiveAfter__android_log_btwrite = isLogdwActive();
EXPECT_TRUE(pmsgActiveAfter__android_log_btwrite);
EXPECT_TRUE(logdwActiveAfter__android_log_btwrite);
}
+#endif
usleep(1000000);
int count = 0;
@@ -225,15 +251,92 @@
#endif
}
-#ifdef __ANDROID__
-static inline int32_t get4LE(const char* src)
-{
+// This test makes little sense standalone, and requires the tests ahead
+// and behind us, to make us whole. We could incorporate a prefix and
+// suffix test to make this standalone, but opted to not complicate this.
+TEST(liblog, android_set_log_frontend) {
+#if (defined(__ANDROID__) || defined(USING_LOGGER_LOCAL))
+#ifdef TEST_PREFIX
+ TEST_PREFIX
+#endif
+
+ int logger = android_get_log_frontend();
+ EXPECT_NE(LOGGER_NULL, logger);
+
+ EXPECT_EQ(LOGGER_NULL, android_set_log_frontend(LOGGER_NULL));
+ EXPECT_EQ(LOGGER_NULL, android_get_log_frontend());
+
+ pid_t pid = getpid();
+
+ struct logger_list *logger_list;
+ ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
+ LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
+
+ log_time ts(CLOCK_MONOTONIC);
+ ASSERT_LT(0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts)));
+
+ usleep(1000000);
+
+ int count = 0;
+
+ for (;;) {
+ log_msg log_msg;
+ if (android_logger_list_read(logger_list, &log_msg) <= 0) {
+ break;
+ }
+
+ ASSERT_EQ(log_msg.entry.pid, pid);
+
+ if ((log_msg.entry.len != sizeof(android_log_event_long_t))
+ || (log_msg.id() != LOG_ID_EVENTS)) {
+ continue;
+ }
+
+ android_log_event_long_t* eventData;
+ eventData = reinterpret_cast<android_log_event_long_t*>(log_msg.msg());
+
+ if (!eventData || (eventData->payload.type != EVENT_TYPE_LONG)) {
+ continue;
+ }
+
+ log_time tx(reinterpret_cast<char*>(&eventData->payload.data));
+ if (ts == tx) {
+ ++count;
+ }
+ }
+
+ android_logger_list_close(logger_list);
+
+ EXPECT_EQ(logger, android_set_log_frontend(logger));
+ EXPECT_EQ(logger, android_get_log_frontend());
+
+ // False negative if liblog.__android_log_btwrite__android_logger_list_read
+ // fails above, so we will likely succeed. But we will have so many
+ // failures elsewhere that it is probably not worthwhile for us to
+ // highlight yet another disappointment.
+ EXPECT_EQ(0, count);
+ // We also expect failures in the following tests if the set does not
+ // react in an appropriate manner internally, yet passes, so we depend
+ // on this test being in the middle of a series of tests performed in
+ // the same process.
+#else
+ GTEST_LOG_(INFO) << "This test does nothing.\n";
+#endif
+}
+
+#ifdef TEST_PREFIX
+static inline uint32_t get4LE(const uint8_t* src) {
return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
}
+
+static inline uint32_t get4LE(const char* src) {
+ return get4LE(reinterpret_cast<const uint8_t*>(src));
+}
#endif
static void bswrite_test(const char *message) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
+ TEST_PREFIX
struct logger_list *logger_list;
pid_t pid = getpid();
@@ -241,7 +344,11 @@
ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
+#ifdef __ANDROID__
log_time ts(android_log_clockid());
+#else
+ log_time ts(CLOCK_REALTIME);
+#endif
ASSERT_LT(0, __android_log_bswrite(0, message));
size_t num_lines = 1, size = 0, length = 0, total = 0;
@@ -307,8 +414,11 @@
&log_msg.entry_v1, &entry, NULL, msgBuf, sizeof(msgBuf));
EXPECT_EQ((length == total) ? 0 : -1, processBinaryLogBuffer);
if (processBinaryLogBuffer == 0) {
+ size_t line_overhead = 20;
+ if (pid > 99999) ++line_overhead;
+ if (pid > 999999) ++line_overhead;
fflush(stderr);
- EXPECT_EQ((int)((20 * num_lines) + size),
+ EXPECT_EQ((int)((line_overhead * num_lines) + size),
android_log_printLogLine(logformat, fileno(stderr), &entry));
}
android_log_format_free(logformat);
@@ -345,7 +455,8 @@
}
static void buf_write_test(const char *message) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
+ TEST_PREFIX
struct logger_list *logger_list;
pid_t pid = getpid();
@@ -354,7 +465,11 @@
LOG_ID_MAIN, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
static const char tag[] = "TEST__android_log_buf_write";
+#ifdef __ANDROID__
log_time ts(android_log_clockid());
+#else
+ log_time ts(CLOCK_REALTIME);
+#endif
EXPECT_LT(0, __android_log_buf_write(LOG_ID_MAIN, ANDROID_LOG_INFO,
tag, message));
@@ -402,8 +517,11 @@
&entry);
EXPECT_EQ(0, processLogBuffer);
if (processLogBuffer == 0) {
+ size_t line_overhead = 11;
+ if (pid > 99999) ++line_overhead;
+ if (pid > 999999) ++line_overhead;
fflush(stderr);
- EXPECT_EQ((int)(((11 + sizeof(tag)) * num_lines) + size),
+ EXPECT_EQ((int)(((line_overhead + sizeof(tag)) * num_lines) + size),
android_log_printLogLine(logformat, fileno(stderr), &entry));
}
android_log_format_free(logformat);
@@ -430,7 +548,8 @@
buf_write_test("\n Hello World \n");
}
-#ifdef __ANDROID__
+#ifndef USING_LOGGER_LOCAL // requires blocking reader functionality
+#ifdef TEST_PREFIX
static unsigned signaled;
static log_time signal_time;
@@ -492,7 +611,8 @@
#endif
TEST(liblog, android_logger_list_read__cpu_signal) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
+ TEST_PREFIX
struct logger_list *logger_list;
unsigned long long v = 0xDEADBEEFA55A0000ULL;
@@ -584,7 +704,7 @@
#endif
}
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
/*
* Strictly, we are not allowed to log messages in a signal context, the
* correct way to handle this is to ensure the messages are constructed in
@@ -618,7 +738,7 @@
return NULL;
}
-int start_thread()
+static int start_thread()
{
sem_init(&thread_trigger, 0, 0);
@@ -650,7 +770,8 @@
#endif
TEST(liblog, android_logger_list_read__cpu_thread) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
+ TEST_PREFIX
struct logger_list *logger_list;
unsigned long long v = 0xDEADBEAFA55A0000ULL;
@@ -742,8 +863,9 @@
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
+#endif // !USING_LOGGER_LOCAL
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
static const char max_payload_tag[] = "TEST_max_payload_and_longish_tag_XXXX";
#define SIZEOF_MAX_PAYLOAD_BUF (LOGGER_ENTRY_MAX_PAYLOAD - \
sizeof(max_payload_tag) - 1)
@@ -880,7 +1002,8 @@
takes his leave.";
TEST(liblog, max_payload) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
+ TEST_PREFIX
pid_t pid = getpid();
char tag[sizeof(max_payload_tag)];
memcpy(tag, max_payload_tag, sizeof(tag));
@@ -944,7 +1067,8 @@
}
TEST(liblog, __android_log_buf_print__maxtag) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
+ TEST_PREFIX
struct logger_list *logger_list;
pid_t pid = getpid();
@@ -952,7 +1076,11 @@
ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
LOG_ID_MAIN, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
+#ifdef __ANDROID__
log_time ts(android_log_clockid());
+#else
+ log_time ts(CLOCK_REALTIME);
+#endif
EXPECT_LT(0, __android_log_buf_print(LOG_ID_MAIN, ANDROID_LOG_INFO,
max_payload_buf, max_payload_buf));
@@ -1004,7 +1132,8 @@
}
TEST(liblog, too_big_payload) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
+ TEST_PREFIX
pid_t pid = getpid();
static const char big_payload_tag[] = "TEST_big_payload_XXXX";
char tag[sizeof(big_payload_tag)];
@@ -1058,6 +1187,12 @@
EXPECT_LE(LOGGER_ENTRY_MAX_PAYLOAD - sizeof(big_payload_tag),
static_cast<size_t>(max_len));
+ // SLOP: Allow the underlying interface to optionally place a
+ // terminating nul at the LOGGER_ENTRY_MAX_PAYLOAD's last byte
+ // or not.
+ if (ret == (max_len + static_cast<ssize_t>(sizeof(big_payload_tag)) - 1)) {
+ --max_len;
+ }
EXPECT_EQ(ret, max_len + static_cast<ssize_t>(sizeof(big_payload_tag)));
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -1065,17 +1200,29 @@
}
TEST(liblog, dual_reader) {
-#ifdef __ANDROID__
- struct logger_list *logger_list1;
+#ifdef TEST_PREFIX
+ TEST_PREFIX
- // >25 messages due to liblog.__android_log_buf_print__concurrentXX above.
+ static const int num = 25;
+
+ for (int i = 25; i > 0; --i) {
+ static const char fmt[] = "dual_reader %02d";
+ char buffer[sizeof(fmt) + 8];
+ snprintf(buffer, sizeof(buffer), fmt, i);
+ LOG_FAILURE_RETRY(__android_log_buf_write(LOG_ID_MAIN,
+ ANDROID_LOG_INFO,
+ "liblog", buffer));
+ }
+ usleep(1000000);
+
+ struct logger_list *logger_list1;
ASSERT_TRUE(NULL != (logger_list1 = android_logger_list_open(
- LOG_ID_MAIN, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 25, 0)));
+ LOG_ID_MAIN, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, num, 0)));
struct logger_list *logger_list2;
if (NULL == (logger_list2 = android_logger_list_open(
- LOG_ID_MAIN, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 15, 0))) {
+ LOG_ID_MAIN, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, num - 10, 0))) {
android_logger_list_close(logger_list1);
ASSERT_TRUE(NULL != logger_list2);
}
@@ -1108,22 +1255,20 @@
android_logger_list_close(logger_list1);
android_logger_list_close(logger_list2);
- EXPECT_EQ(25, count1);
- EXPECT_EQ(15, count2);
+ EXPECT_EQ(num, count1);
+ EXPECT_EQ(num - 10, count2);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
-#ifdef __ANDROID__
+#ifndef USING_LOGGER_LOCAL // Do not retest logprint
static bool checkPriForTag(AndroidLogFormat *p_format, const char *tag, android_LogPriority pri) {
return android_log_shouldPrintLine(p_format, tag, pri)
&& !android_log_shouldPrintLine(p_format, tag, (android_LogPriority)(pri - 1));
}
-#endif
TEST(liblog, filterRule) {
-#ifdef __ANDROID__
static const char tag[] = "random";
AndroidLogFormat *p_format = android_log_format_new();
@@ -1185,11 +1330,10 @@
#endif
android_log_format_free(p_format);
-#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
-#endif
}
+#endif // !USING_LOGGER_LOCAL
+#ifndef USING_LOGGER_LOCAL // Do not retest property handling
TEST(liblog, is_loggable) {
#ifdef __ANDROID__
static const char tag[] = "is_loggable";
@@ -1488,8 +1632,13 @@
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
+#endif // !USING_LOGGER_LOCAL
-#ifdef __ANDROID__
+// Following tests the specific issues surrounding error handling wrt logd.
+// Kills logd and toss all collected data, equivalent to logcat -b all -c,
+// except we also return errors to the logging callers.
+#ifndef USING_LOGGER_LOCAL
+#ifdef TEST_PREFIX
// helper to liblog.enoent to count end-to-end matching logging messages.
static int count_matching_ts(log_time ts) {
usleep(1000000);
@@ -1531,10 +1680,11 @@
testing::AssertionSuccess() :
(testing::AssertionFailure() << message);
}
-#endif
+#endif // TEST_PREFIX
TEST(liblog, enoent) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
+ TEST_PREFIX
log_time ts(CLOCK_MONOTONIC);
EXPECT_LT(0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts)));
EXPECT_EQ(1, count_matching_ts(ts));
@@ -1588,9 +1738,12 @@
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
+#endif // !USING_LOCAL_LOGGER
// Below this point we run risks of setuid(AID_SYSTEM) which may affect others.
+// Do not retest properties, and cannot log into LOG_ID_SECURITY
+#ifndef USING_LOGGER_LOCAL
TEST(liblog, __security) {
#ifdef __ANDROID__
static const char persist_key[] = "persist.logd.security";
@@ -1776,15 +1929,19 @@
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
+#endif // !USING_LOGGER_LOCAL
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
static void android_errorWriteWithInfoLog_helper(int TAG, const char* SUBTAG,
int UID, const char* payload,
int DATA_LEN, int& count) {
+ TEST_PREFIX
struct logger_list *logger_list;
pid_t pid = getpid();
+ count = 0;
+
ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
@@ -1798,8 +1955,6 @@
sleep(2);
- count = 0;
-
for (;;) {
log_msg log_msg;
if (android_logger_list_read(logger_list, &log_msg) <= 0) {
@@ -1839,7 +1994,7 @@
ASSERT_EQ(EVENT_TYPE_STRING, eventData[0]);
eventData++;
- int subtag_len = strlen(SUBTAG);
+ unsigned subtag_len = strlen(SUBTAG);
if (subtag_len > 32) subtag_len = 32;
ASSERT_EQ(subtag_len, get4LE(eventData));
eventData += 4;
@@ -1853,7 +2008,7 @@
ASSERT_EQ(EVENT_TYPE_INT, eventData[0]);
eventData++;
- ASSERT_EQ(UID, get4LE(eventData));
+ ASSERT_EQ(UID, (int)get4LE(eventData));
eventData += 4;
// Element #3: string type for data
@@ -1883,7 +2038,7 @@
#endif
TEST(liblog, android_errorWriteWithInfoLog__android_logger_list_read__typical) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
int count;
android_errorWriteWithInfoLog_helper(
123456781,
@@ -1899,7 +2054,7 @@
}
TEST(liblog, android_errorWriteWithInfoLog__android_logger_list_read__data_too_large) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
int count;
android_errorWriteWithInfoLog_helper(
123456782,
@@ -1915,7 +2070,7 @@
}
TEST(liblog, android_errorWriteWithInfoLog__android_logger_list_read__null_data) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
int count;
android_errorWriteWithInfoLog_helper(
123456783,
@@ -1931,7 +2086,7 @@
}
TEST(liblog, android_errorWriteWithInfoLog__android_logger_list_read__subtag_too_long) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
int count;
android_errorWriteWithInfoLog_helper(
123456784,
@@ -1954,12 +2109,15 @@
buf_write_test(max_payload_buf);
}
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
static void android_errorWriteLog_helper(int TAG, const char *SUBTAG, int& count) {
+ TEST_PREFIX
struct logger_list *logger_list;
pid_t pid = getpid();
+ count = 0;
+
ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
@@ -1972,8 +2130,6 @@
sleep(2);
- count = 0;
-
for (;;) {
log_msg log_msg;
if (android_logger_list_read(logger_list, &log_msg) <= 0) {
@@ -2011,7 +2167,7 @@
ASSERT_EQ(EVENT_TYPE_STRING, eventData[0]);
eventData++;
- ASSERT_EQ((int) strlen(SUBTAG), get4LE(eventData));
+ ASSERT_EQ(strlen(SUBTAG), get4LE(eventData));
eventData +=4;
if (memcmp(SUBTAG, eventData, strlen(SUBTAG))) {
@@ -2025,7 +2181,7 @@
#endif
TEST(liblog, android_errorWriteLog__android_logger_list_read__success) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
int count;
android_errorWriteLog_helper(123456785, "test-subtag", count);
EXPECT_EQ(1, count);
@@ -2035,7 +2191,7 @@
}
TEST(liblog, android_errorWriteLog__android_logger_list_read__null_subtag) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
int count;
android_errorWriteLog_helper(123456786, NULL, count);
EXPECT_EQ(0, count);
@@ -2044,7 +2200,8 @@
#endif
}
-#ifdef __ANDROID__
+// Do not retest logger list handling
+#if (defined(TEST_PREFIX) || !defined(USING_LOGGER_LOCAL))
static int is_real_element(int type) {
return ((type == EVENT_TYPE_INT) ||
(type == EVENT_TYPE_LONG) ||
@@ -2052,8 +2209,8 @@
(type == EVENT_TYPE_FLOAT));
}
-int android_log_buffer_to_string(const char *msg, size_t len,
- char *strOut, size_t strOutLen) {
+static int android_log_buffer_to_string(const char *msg, size_t len,
+ char *strOut, size_t strOutLen) {
android_log_context context = create_android_log_parser(msg, len);
android_log_list_element elem;
bool overflow = false;
@@ -2203,7 +2360,9 @@
return 0;
}
+#endif // TEST_PREFIX || !USING_LOGGER_LOCAL
+#ifdef TEST_PREFIX
static const char *event_test_int32(uint32_t tag, size_t &expected_len) {
android_log_context ctx;
@@ -2459,6 +2618,7 @@
}
static void create_android_logger(const char *(*fn)(uint32_t tag, size_t &expected_len)) {
+ TEST_PREFIX
struct logger_list *logger_list;
pid_t pid = getpid();
@@ -2466,7 +2626,11 @@
ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
+#ifdef __ANDROID__
log_time ts(android_log_clockid());
+#else
+ log_time ts(CLOCK_REALTIME);
+#endif
size_t expected_len;
const char *expected_string = (*fn)(1005, expected_len);
@@ -2507,18 +2671,23 @@
&log_msg.entry_v1, &entry, NULL, msgBuf, sizeof(msgBuf));
EXPECT_EQ(0, processBinaryLogBuffer);
if (processBinaryLogBuffer == 0) {
+ int line_overhead = 20;
+ if (pid > 99999) ++line_overhead;
+ if (pid > 999999) ++line_overhead;
print_barrier();
int printLogLine = android_log_printLogLine(
logformat, fileno(stderr), &entry);
print_barrier();
- EXPECT_EQ(20 + (int)strlen(expected_string), printLogLine);
+ EXPECT_EQ(line_overhead + (int)strlen(expected_string),
+ printLogLine);
}
android_log_format_free(logformat);
// test buffer reading API
int buffer_to_string = -1;
if (eventData) {
- snprintf(msgBuf, sizeof(msgBuf), "I/[%d]", get4LE(eventData));
+ snprintf(msgBuf, sizeof(msgBuf),
+ "I/[%" PRIu32 "]", get4LE(eventData));
print_barrier();
fprintf(stderr, "%-10s(%5u): ", msgBuf, pid);
memset(msgBuf, 0, sizeof(msgBuf));
@@ -2541,7 +2710,7 @@
#endif
TEST(liblog, create_android_logger_int32) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
create_android_logger(event_test_int32);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2549,7 +2718,7 @@
}
TEST(liblog, create_android_logger_int64) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
create_android_logger(event_test_int64);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2557,7 +2726,7 @@
}
TEST(liblog, create_android_logger_list_int64) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
create_android_logger(event_test_list_int64);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2565,7 +2734,7 @@
}
TEST(liblog, create_android_logger_simple_automagic_list) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
create_android_logger(event_test_simple_automagic_list);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2573,7 +2742,7 @@
}
TEST(liblog, create_android_logger_list_empty) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
create_android_logger(event_test_list_empty);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2581,7 +2750,7 @@
}
TEST(liblog, create_android_logger_complex_nested_list) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
create_android_logger(event_test_complex_nested_list);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2589,7 +2758,7 @@
}
TEST(liblog, create_android_logger_7_level_prefix) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
create_android_logger(event_test_7_level_prefix);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2597,7 +2766,7 @@
}
TEST(liblog, create_android_logger_7_level_suffix) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
create_android_logger(event_test_7_level_suffix);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2605,7 +2774,7 @@
}
TEST(liblog, create_android_logger_android_log_error_write) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
create_android_logger(event_test_android_log_error_write);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2613,15 +2782,15 @@
}
TEST(liblog, create_android_logger_android_log_error_write_null) {
-#ifdef __ANDROID__
+#ifdef TEST_PREFIX
create_android_logger(event_test_android_log_error_write_null);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
+#ifndef USING_LOGGER_LOCAL // Do not retest logger list handling
TEST(liblog, create_android_logger_overflow) {
-#ifdef __ANDROID__
android_log_context ctx;
EXPECT_TRUE(NULL != (ctx = create_android_logger(1005)));
@@ -2646,13 +2815,9 @@
EXPECT_GT(0, android_log_write_list_begin(ctx));
EXPECT_LE(0, android_log_destroy(&ctx));
ASSERT_TRUE(NULL == ctx);
-#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
-#endif
}
TEST(liblog, android_log_write_list_buffer) {
-#ifdef __ANDROID__
__android_log_event_list ctx(1005);
ctx << 1005 << "tag_def" << "(tag|1),(name|3),(format|3)";
std::string buffer(ctx);
@@ -2663,11 +2828,10 @@
EXPECT_EQ(android_log_buffer_to_string(buffer.data(), buffer.length(),
msgBuf, sizeof(msgBuf)), 0);
EXPECT_STREQ(msgBuf, "[1005,tag_def,(tag|1),(name|3),(format|3)]");
-#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
-#endif
}
+#endif // !USING_LOGGER_LOCAL
+#ifndef USING_LOGGER_LOCAL // Do not retest pmsg functionality
#ifdef __ANDROID__
static const char __pmsg_file[] =
"/data/william-shakespeare/MuchAdoAboutNothing.txt";
@@ -2730,8 +2894,8 @@
}
#ifdef __ANDROID__
-ssize_t __pmsg_fn(log_id_t logId, char prio, const char *filename,
- const char *buf, size_t len, void *arg) {
+static ssize_t __pmsg_fn(log_id_t logId, char prio, const char *filename,
+ const char *buf, size_t len, void *arg) {
EXPECT_TRUE(NULL == arg);
EXPECT_EQ(LOG_ID_CRASH, logId);
EXPECT_EQ(ANDROID_LOG_VERBOSE, prio);
@@ -2793,7 +2957,9 @@
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
+#endif // !USING_LOGGER_LOCAL
+#ifndef USING_LOGGER_LOCAL // Do not retest event mapping functionality
#ifdef __ANDROID__
// must be: '<needle:> 0 kB'
static bool isZero(const std::string &content, std::string::size_type pos,
@@ -2876,7 +3042,7 @@
EXPECT_TRUE(IsOk(private_ok, content));
EXPECT_TRUE(IsOk(anonymous_ok, content));
}
-#endif
+#endif // __ANDROID__
TEST(liblog, event_log_tags) {
#ifdef __ANDROID__
@@ -2897,7 +3063,9 @@
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
+#endif // !USING_LOGGER_LOCAL
+#ifndef USING_LOGGER_LOCAL // Do not retest ratelimit
TEST(liblog, __android_log_ratelimit) {
time_t state = 0;
@@ -2929,7 +3097,9 @@
}
// Do not test default seconds, to allow liblog to tune freely
}
+#endif // !USING_LOGGER_LOCAL
+#ifndef USING_LOGGER_LOCAL // Do not retest event mapping functionality
TEST(liblog, android_lookupEventTagNum) {
#ifdef __ANDROID__
EventTagMap* map = android_openEventTagMap(NULL);
@@ -2945,3 +3115,4 @@
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
+#endif // !USING_LOGGER_LOCAL
diff --git a/liblog/tests/liblog_test_default.cpp b/liblog/tests/liblog_test_default.cpp
new file mode 100644
index 0000000..079ba07
--- /dev/null
+++ b/liblog/tests/liblog_test_default.cpp
@@ -0,0 +1,5 @@
+#ifdef __ANDROID__
+#include <log/log_frontend.h>
+#define TEST_PREFIX android_set_log_frontend(LOGGER_DEFAULT);
+#endif
+#include "liblog_test.cpp"
diff --git a/liblog/tests/liblog_test_local.cpp b/liblog/tests/liblog_test_local.cpp
new file mode 100644
index 0000000..5f7f645
--- /dev/null
+++ b/liblog/tests/liblog_test_local.cpp
@@ -0,0 +1,4 @@
+#include <log/log_frontend.h>
+#define liblog liblog_local
+#define TEST_PREFIX android_set_log_frontend(LOGGER_LOCAL);
+#include "liblog_test.cpp"
diff --git a/liblog/tests/log_id_test.cpp b/liblog/tests/log_id_test.cpp
index 3241534..b8223f1 100644
--- a/liblog/tests/log_id_test.cpp
+++ b/liblog/tests/log_id_test.cpp
@@ -31,7 +31,6 @@
#endif
TEST(liblog, log_id) {
-#ifdef __ANDROID__
int count = 0;
for(int i = LOG_ID_MIN; i < LOG_ID_MAX; ++i) {
@@ -44,13 +43,9 @@
fprintf(stderr, "log buffer %s\r", name);
}
ASSERT_EQ(LOG_ID_MAX, count);
-#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
-#endif
}
TEST(liblog, __android_log_buf_print) {
-#ifdef __ANDROID__
EXPECT_LT(0, __android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_INFO,
"TEST__android_log_buf_print",
"radio"));
@@ -63,13 +58,9 @@
"TEST__android_log_buf_print",
"main"));
usleep(1000);
-#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
-#endif
}
TEST(liblog, __android_log_buf_write) {
-#ifdef __ANDROID__
EXPECT_LT(0, __android_log_buf_write(LOG_ID_RADIO, ANDROID_LOG_INFO,
"TEST__android_log_buf_write",
"radio"));
@@ -82,26 +73,20 @@
"TEST__android_log_buf_write",
"main"));
usleep(1000);
-#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
-#endif
}
-#ifdef __ANDROID__
static void* ConcurrentPrintFn(void *arg) {
int ret = __android_log_buf_print(LOG_ID_MAIN, ANDROID_LOG_INFO,
"TEST__android_log_print", "Concurrent %" PRIuPTR,
reinterpret_cast<uintptr_t>(arg));
return reinterpret_cast<void*>(ret);
}
-#endif
#define NUM_CONCURRENT 64
#define _concurrent_name(a,n) a##__concurrent##n
#define concurrent_name(a,n) _concurrent_name(a,n)
TEST(liblog, concurrent_name(__android_log_buf_print, NUM_CONCURRENT)) {
-#ifdef __ANDROID__
pthread_t t[NUM_CONCURRENT];
int i;
for (i=0; i < NUM_CONCURRENT; i++) {
@@ -119,7 +104,4 @@
}
}
ASSERT_LT(0, ret);
-#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
-#endif
}
diff --git a/liblog/tests/log_radio_test.cpp b/liblog/tests/log_radio_test.cpp
index 591748a..ecba777 100644
--- a/liblog/tests/log_radio_test.cpp
+++ b/liblog/tests/log_radio_test.cpp
@@ -27,7 +27,6 @@
#include <log/log_radio.h>
TEST(liblog, RLOG) {
-#ifdef __ANDROID__
static const char content[] = "log_radio.h";
static const char content_false[] = "log_radio.h false";
@@ -84,6 +83,7 @@
usleep(100000);
RLOGE_IF(false, content_false);
+#ifdef __ANDROID__
// give time for content to long-path through logger
sleep(1);
@@ -112,6 +112,6 @@
#endif
#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
+ GTEST_LOG_(INFO) << "This test does not test end-to-end.\n";
#endif
}
diff --git a/liblog/tests/log_system_test.cpp b/liblog/tests/log_system_test.cpp
index b62832e..40e3a63 100644
--- a/liblog/tests/log_system_test.cpp
+++ b/liblog/tests/log_system_test.cpp
@@ -27,7 +27,6 @@
#include <log/log_system.h>
TEST(liblog, SLOG) {
-#ifdef __ANDROID__
static const char content[] = "log_system.h";
static const char content_false[] = "log_system.h false";
@@ -84,6 +83,7 @@
usleep(100000);
SLOGE_IF(false, content_false);
+#ifdef __ANDROID__
// give time for content to long-path through logger
sleep(1);
@@ -112,6 +112,6 @@
#endif
#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
+ GTEST_LOG_(INFO) << "This test does not test end-to-end.\n";
#endif
}
diff --git a/liblog/tests/log_time_test.cpp b/liblog/tests/log_time_test.cpp
index f2601b6..59655ba 100644
--- a/liblog/tests/log_time_test.cpp
+++ b/liblog/tests/log_time_test.cpp
@@ -21,8 +21,6 @@
#include <log/log_time.h>
TEST(liblog, log_time) {
-#ifdef __ANDROID__
-
#ifdef _SYSTEM_CORE_INCLUDE_PRIVATE_ANDROID_LOGGER_H_
log_time(CLOCK_MONOTONIC);
@@ -36,8 +34,4 @@
EXPECT_EQ(tl, ts);
EXPECT_GE(tl, ts);
EXPECT_LE(tl, ts);
-
-#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
-#endif
}
diff --git a/libnativeloader/native_loader.cpp b/libnativeloader/native_loader.cpp
index d7b5cb5..2f23c2c 100644
--- a/libnativeloader/native_loader.cpp
+++ b/libnativeloader/native_loader.cpp
@@ -246,7 +246,9 @@
// For now we rely on CTS test to catch things like this but
// it should probably be addressed in the future.
for (const auto& soname : sonames) {
- dlopen(soname.c_str(), RTLD_NOW | RTLD_NODELETE);
+ LOG_ALWAYS_FATAL_IF(dlopen(soname.c_str(), RTLD_NOW | RTLD_NODELETE) == nullptr,
+ "Error preloading public library %s: %s",
+ soname.c_str(), dlerror());
}
public_libraries_ = base::Join(sonames, ':');
diff --git a/libsysutils/src/NetlinkEvent.cpp b/libsysutils/src/NetlinkEvent.cpp
index fef801a..79bc888 100644
--- a/libsysutils/src/NetlinkEvent.cpp
+++ b/libsysutils/src/NetlinkEvent.cpp
@@ -561,10 +561,12 @@
static const char*
has_prefix(const char* str, const char* end, const char* prefix, size_t prefixlen)
{
- if ((end-str) >= (ptrdiff_t)prefixlen && !memcmp(str, prefix, prefixlen))
+ if ((end - str) >= (ptrdiff_t)prefixlen &&
+ (prefixlen == 0 || !memcmp(str, prefix, prefixlen))) {
return str + prefixlen;
- else
+ } else {
return NULL;
+ }
}
/* Same as strlen(x) for constant string literals ONLY */
diff --git a/libutils/tests/Vector_test.cpp b/libutils/tests/Vector_test.cpp
index 671200f..e074a92 100644
--- a/libutils/tests/Vector_test.cpp
+++ b/libutils/tests/Vector_test.cpp
@@ -74,12 +74,9 @@
EXPECT_EQ(other[3], 5);
}
-// TODO: gtest isn't capable of parsing Abort messages formatted by
-// Android (fails differently on host and target), so we always need to
-// use an empty error message for death tests.
TEST_F(VectorTest, SetCapacity_Overflow) {
Vector<int> vector;
- EXPECT_DEATH(vector.setCapacity(SIZE_MAX / sizeof(int) + 1), "");
+ EXPECT_DEATH(vector.setCapacity(SIZE_MAX / sizeof(int) + 1), "Assertion failed");
}
TEST_F(VectorTest, SetCapacity_ShrinkBelowSize) {
@@ -95,20 +92,13 @@
ASSERT_EQ(8U, vector.capacity());
}
-// NOTE: All of the tests below are useless because of the "TODO" above.
-// We have no way of knowing *why* the process crashed. Given that we're
-// inserting a NULL array, we'll fail with a SIGSEGV eventually. We need
-// the ability to make assertions on the abort message to make sure we're
-// failing for the right reasons.
TEST_F(VectorTest, _grow_OverflowSize) {
Vector<int> vector;
vector.add(1);
// Checks that the size calculation (not the capacity calculation) doesn't
// overflow : the size here will be (1 + SIZE_MAX).
- //
- // EXPECT_DEATH(vector.insertArrayAt(NULL, 0, SIZE_MAX), "new_size_overflow");
- EXPECT_DEATH(vector.insertArrayAt(NULL, 0, SIZE_MAX), "");
+ EXPECT_DEATH(vector.insertArrayAt(NULL, 0, SIZE_MAX), "new_size overflow");
}
TEST_F(VectorTest, _grow_OverflowCapacityDoubling) {
@@ -116,18 +106,14 @@
// This should fail because the calculated capacity will overflow even though
// the size of the vector doesn't.
- //
- // EXPECT_DEATH(vector.insertArrayAt(NULL, 0, (SIZE_MAX - 1)), "new_capacity_overflow");
- EXPECT_DEATH(vector.insertArrayAt(NULL, 0, (SIZE_MAX - 1)), "");
+ EXPECT_DEATH(vector.insertArrayAt(NULL, 0, (SIZE_MAX - 1)), "new_capacity overflow");
}
TEST_F(VectorTest, _grow_OverflowBufferAlloc) {
Vector<int> vector;
// This should fail because the capacity * sizeof(int) overflows, even
// though the capacity itself doesn't.
- //
- // EXPECT_DEATH(vector.insertArrayAt(NULL, 0, (SIZE_MAX / 2)), "new_alloc_size overflow");
- EXPECT_DEATH(vector.insertArrayAt(NULL, 0, (SIZE_MAX / 2)), "");
+ EXPECT_DEATH(vector.insertArrayAt(NULL, 0, (SIZE_MAX / 2)), "new_alloc_size overflow");
}
TEST_F(VectorTest, editArray_Shared) {