diff --git a/debuggerd/libdebuggerd/tombstone.cpp b/debuggerd/libdebuggerd/tombstone.cpp index b3f059c1c..bb3c2609f 100644 --- a/debuggerd/libdebuggerd/tombstone.cpp +++ b/debuggerd/libdebuggerd/tombstone.cpp @@ -457,8 +457,8 @@ static void dump_log_file(log_t* log, pid_t pid, const char* filename, unsigned return; } - logger_list = android_logger_list_open( - android_name_to_log_id(filename), ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, tail, pid); + logger_list = + android_logger_list_open(android_name_to_log_id(filename), ANDROID_LOG_NONBLOCK, tail, pid); if (!logger_list) { ALOGE("Unable to open %s: %s\n", filename, strerror(errno)); diff --git a/liblog/README.md b/liblog/README.md index 871399a57..f64f37624 100644 --- a/liblog/README.md +++ b/liblog/README.md @@ -118,10 +118,9 @@ at a time in time sorted order, optionally limited to a specific pid and tail of finally a call closing the logs. A single log can be opened with `android_logger_list_open()`; or multiple logs can be opened with `android_logger_list_alloc()`, calling in turn the `android_logger_open()` for each log id. Each entry can be retrieved with -`android_logger_list_read()`. The log(s) can be closed with `android_logger_list_free()`. The logs -should be opened with an `ANDROID_LOG_RDONLY` mode. `ANDROID_LOG_NONBLOCK` mode will report when -the log reading is done with an `EAGAIN` error return code, otherwise the -`android_logger_list_read()` call will block for new entries. +`android_logger_list_read()`. The log(s) can be closed with `android_logger_list_free()`. +`ANDROID_LOG_NONBLOCK` mode will report when the log reading is done with an `EAGAIN` error return +code, otherwise the `android_logger_list_read()` call will block for new entries. The `ANDROID_LOG_WRAP` mode flag to the `android_logger_list_alloc_time()` signals logd to quiesce the reader until the buffer is about to prune at the start time then proceed to dumping content. @@ -130,14 +129,12 @@ The `ANDROID_LOG_PSTORE` mode flag to the `android_logger_open()` is used to swi logs to the persistent logs from before the last reboot. The value returned by `android_logger_open()` can be used as a parameter to the -`android_logger_clear()` function to empty the sub-log. It is recommended to only open log -`ANDROID_LOG_WRONLY` in that case. +`android_logger_clear()` function to empty the sub-log. The value returned by `android_logger_open()` can be used as a parameter to the `android_logger_get_log_(size|readable_size|version)` to retrieve the sub-log maximum size, readable size and log buffer format protocol version respectively. `android_logger_get_id()` returns the id -that was used when opening the sub-log. It is recommended to open the log `ANDROID_LOG_RDONLY` in -these cases. +that was used when opening the sub-log. Errors ------ diff --git a/liblog/include/log/log_read.h b/liblog/include/log/log_read.h index 18c1c33e9..05ad25f5e 100644 --- a/liblog/include/log/log_read.h +++ b/liblog/include/log/log_read.h @@ -141,10 +141,6 @@ ssize_t android_logger_get_prune_list(struct logger_list* logger_list, char* buf, size_t len); int android_logger_set_prune_list(struct logger_list* logger_list, const char* buf, size_t len); -#define ANDROID_LOG_RDONLY O_RDONLY -#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 diff --git a/liblog/pmsg_reader.cpp b/liblog/pmsg_reader.cpp index 64a92b7ce..129d76721 100644 --- a/liblog/pmsg_reader.cpp +++ b/liblog/pmsg_reader.cpp @@ -185,7 +185,7 @@ ssize_t __android_log_pmsg_file_read(log_id_t logId, char prio, const char* pref /* Add just enough clues in logger_list and transp to make API function */ memset(&logger_list, 0, sizeof(logger_list)); - logger_list.mode = ANDROID_LOG_PSTORE | ANDROID_LOG_NONBLOCK | ANDROID_LOG_RDONLY; + logger_list.mode = ANDROID_LOG_PSTORE | ANDROID_LOG_NONBLOCK; logger_list.log_mask = (unsigned)-1; if (logId != LOG_ID_ANY) { logger_list.log_mask = (1 << logId); diff --git a/liblog/tests/liblog_benchmark.cpp b/liblog/tests/liblog_benchmark.cpp index 4366f3d3b..3a6ed90d4 100644 --- a/liblog/tests/liblog_benchmark.cpp +++ b/liblog/tests/liblog_benchmark.cpp @@ -648,8 +648,7 @@ static const int alarm_time = 3; static void BM_log_latency(benchmark::State& state) { pid_t pid = getpid(); - struct logger_list* logger_list = - android_logger_list_open(LOG_ID_EVENTS, ANDROID_LOG_RDONLY, 0, pid); + struct logger_list* logger_list = android_logger_list_open(LOG_ID_EVENTS, 0, 0, pid); if (!logger_list) { fprintf(stderr, "Unable to open events log: %s\n", strerror(errno)); @@ -723,8 +722,7 @@ static void caught_delay(int /*signum*/) { static void BM_log_delay(benchmark::State& state) { pid_t pid = getpid(); - struct logger_list* logger_list = - android_logger_list_open(LOG_ID_EVENTS, ANDROID_LOG_RDONLY, 0, pid); + struct logger_list* logger_list = android_logger_list_open(LOG_ID_EVENTS, 0, 0, pid); if (!logger_list) { fprintf(stderr, "Unable to open events log: %s\n", strerror(errno)); diff --git a/liblog/tests/liblog_test.cpp b/liblog/tests/liblog_test.cpp index 773bac2f0..a031531cb 100644 --- a/liblog/tests/liblog_test.cpp +++ b/liblog/tests/liblog_test.cpp @@ -82,7 +82,7 @@ static void RunLogTests(log_id_t log_buffer, FWrite write_messages, FCheck check pid_t pid = getpid(); auto logger_list = std::unique_ptr{ - android_logger_list_open(log_buffer, ANDROID_LOG_RDONLY, 1000, pid)}; + android_logger_list_open(log_buffer, 0, 1000, pid)}; ASSERT_TRUE(logger_list); write_messages(); @@ -106,7 +106,7 @@ static void RunLogTests(log_id_t log_buffer, FWrite write_messages, FCheck check } auto logger_list_non_block = std::unique_ptr{ - android_logger_list_open(log_buffer, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)}; + android_logger_list_open(log_buffer, ANDROID_LOG_NONBLOCK, 1000, pid)}; ASSERT_TRUE(logger_list_non_block); size_t count = 0; @@ -572,8 +572,7 @@ TEST(liblog, android_logger_list_read__cpu_signal) { v += pid & 0xFFFF; - ASSERT_TRUE(NULL != (logger_list = android_logger_list_open( - LOG_ID_EVENTS, ANDROID_LOG_RDONLY, 1000, pid))); + ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(LOG_ID_EVENTS, 0, 1000, pid))); int count = 0; @@ -728,8 +727,7 @@ TEST(liblog, android_logger_list_read__cpu_thread) { v += pid & 0xFFFF; - ASSERT_TRUE(NULL != (logger_list = android_logger_list_open( - LOG_ID_EVENTS, ANDROID_LOG_RDONLY, 1000, pid))); + ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(LOG_ID_EVENTS, 0, 1000, pid))); int count = 0; @@ -1093,11 +1091,11 @@ TEST(liblog, dual_reader) { pid_t pid = getpid(); auto logger_list1 = std::unique_ptr{ - android_logger_list_open(LOG_ID_MAIN, ANDROID_LOG_RDONLY, expected_count1, pid)}; + android_logger_list_open(LOG_ID_MAIN, 0, expected_count1, pid)}; ASSERT_TRUE(logger_list1); auto logger_list2 = std::unique_ptr{ - android_logger_list_open(LOG_ID_MAIN, ANDROID_LOG_RDONLY, expected_count2, pid)}; + android_logger_list_open(LOG_ID_MAIN, 0, expected_count2, pid)}; ASSERT_TRUE(logger_list2); for (int i = 25; i > 0; --i) { @@ -1128,14 +1126,12 @@ TEST(liblog, dual_reader) { } // Test again with the nonblocking reader. - auto logger_list_non_block1 = - std::unique_ptr{android_logger_list_open( - LOG_ID_MAIN, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, expected_count1, pid)}; + auto logger_list_non_block1 = std::unique_ptr{ + android_logger_list_open(LOG_ID_MAIN, ANDROID_LOG_NONBLOCK, expected_count1, pid)}; ASSERT_TRUE(logger_list_non_block1); - auto logger_list_non_block2 = - std::unique_ptr{android_logger_list_open( - LOG_ID_MAIN, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, expected_count2, pid)}; + auto logger_list_non_block2 = std::unique_ptr{ + android_logger_list_open(LOG_ID_MAIN, ANDROID_LOG_NONBLOCK, expected_count2, pid)}; ASSERT_TRUE(logger_list_non_block2); count1 = 0; count2 = 0; @@ -1542,8 +1538,8 @@ static int count_matching_ts(log_time ts) { pid_t pid = getpid(); - struct logger_list* logger_list = android_logger_list_open( - LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid); + struct logger_list* logger_list = + android_logger_list_open(LOG_ID_EVENTS, ANDROID_LOG_NONBLOCK, 1000, pid); int count = 0; if (logger_list == NULL) return count; @@ -1832,10 +1828,8 @@ TEST(liblog, __security_buffer) { gid = getgid(); pid_t pid = getpid(); - ASSERT_TRUE(NULL != - (logger_list = android_logger_list_open( - LOG_ID_SECURITY, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, - 1000, pid))); + ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(LOG_ID_SECURITY, ANDROID_LOG_NONBLOCK, + 1000, pid))); log_time ts(CLOCK_MONOTONIC); diff --git a/liblog/tests/log_read_test.cpp b/liblog/tests/log_read_test.cpp index 1be99aa80..3e0961749 100644 --- a/liblog/tests/log_read_test.cpp +++ b/liblog/tests/log_read_test.cpp @@ -34,8 +34,7 @@ TEST(liblog, android_logger_get_) { // This test assumes the log buffers are filled with noise from // normal operations. It will fail if done immediately after a // logcat -c. - struct logger_list* logger_list = - android_logger_list_alloc(ANDROID_LOG_WRONLY, 0, 0); + struct logger_list* logger_list = android_logger_list_alloc(0, 0, 0); for (int i = LOG_ID_MIN; i < LOG_ID_MAX; ++i) { log_id_t id = static_cast(i); diff --git a/liblog/tests/log_wrap_test.cpp b/liblog/tests/log_wrap_test.cpp index e06964f72..755898a41 100644 --- a/liblog/tests/log_wrap_test.cpp +++ b/liblog/tests/log_wrap_test.cpp @@ -32,7 +32,7 @@ static void read_with_wrap() { // Read the last line in the log to get a starting timestamp. We're assuming // the log is not empty. - const int mode = ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK; + const int mode = ANDROID_LOG_NONBLOCK; struct logger_list* logger_list = android_logger_list_open(LOG_ID_MAIN, mode, 1000, 0); diff --git a/logcat/logcat.cpp b/logcat/logcat.cpp index 76a970f2a..b065855c5 100644 --- a/logcat/logcat.cpp +++ b/logcat/logcat.cpp @@ -513,7 +513,7 @@ int Logcat::Run(int argc, char** argv) { unsigned long setLogSize = 0; const char* setPruneList = nullptr; const char* setId = nullptr; - int mode = ANDROID_LOG_RDONLY; + int mode = 0; std::string forceFilters; size_t tail_lines = 0; log_time tail_time(log_time::EPOCH); @@ -591,8 +591,7 @@ int Logcat::Run(int argc, char** argv) { break; } if (long_options[option_index].name == wrap_str) { - mode |= ANDROID_LOG_WRAP | ANDROID_LOG_RDONLY | - ANDROID_LOG_NONBLOCK; + mode |= ANDROID_LOG_WRAP | ANDROID_LOG_NONBLOCK; // ToDo: implement API that supports setting a wrap timeout size_t dummy = ANDROID_LOG_WRAP_DEFAULT_TIMEOUT; if (optarg && (!ParseUint(optarg, &dummy) || dummy < 1)) { @@ -626,21 +625,19 @@ int Logcat::Run(int argc, char** argv) { case 'c': clearLog = true; - mode |= ANDROID_LOG_WRONLY; break; case 'L': - mode |= ANDROID_LOG_RDONLY | ANDROID_LOG_PSTORE | - ANDROID_LOG_NONBLOCK; + mode |= ANDROID_LOG_PSTORE | ANDROID_LOG_NONBLOCK; break; case 'd': - mode |= ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK; + mode |= ANDROID_LOG_NONBLOCK; break; case 't': got_t = true; - mode |= ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK; + mode |= ANDROID_LOG_NONBLOCK; FALLTHROUGH_INTENDED; case 'T': if (strspn(optarg, "0123456789") != strlen(optarg)) { diff --git a/logd/LogTags.cpp b/logd/LogTags.cpp index 0cc7886ea..8299e667a 100644 --- a/logd/LogTags.cpp +++ b/logd/LogTags.cpp @@ -289,9 +289,8 @@ static inline uint32_t get4LE(const char* msg) { // special pmsg event for log tags, and build up our internal // database with any found. void LogTags::ReadPersistEventLogTags() { - struct logger_list* logger_list = android_logger_list_alloc( - ANDROID_LOG_RDONLY | ANDROID_LOG_PSTORE | ANDROID_LOG_NONBLOCK, 0, - (pid_t)0); + struct logger_list* logger_list = + android_logger_list_alloc(ANDROID_LOG_PSTORE | ANDROID_LOG_NONBLOCK, 0, (pid_t)0); if (!logger_list) return; struct logger* e = android_logger_open(logger_list, LOG_ID_EVENTS); diff --git a/logd/tests/logd_test.cpp b/logd/tests/logd_test.cpp index f47bee1c0..c7f348069 100644 --- a/logd/tests/logd_test.cpp +++ b/logd/tests/logd_test.cpp @@ -870,10 +870,8 @@ void __android_log_btwrite_multiple__helper(int count) { ASSERT_EQ(0, info.si_status); struct logger_list* logger_list; - ASSERT_TRUE(nullptr != - (logger_list = android_logger_list_open( - LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, - 0, pid))); + ASSERT_TRUE(nullptr != (logger_list = android_logger_list_open(LOG_ID_EVENTS, + ANDROID_LOG_NONBLOCK, 0, pid))); int expected_count = (count < 2) ? count : 2; int expected_chatty_count = (count <= 2) ? 0 : 1;