diff --git a/liblog/Android.bp b/liblog/Android.bp index 53d3ab304..c38d8cd86 100644 --- a/liblog/Android.bp +++ b/liblog/Android.bp @@ -15,7 +15,6 @@ // liblog_sources = [ - "config_read.cpp", "config_write.cpp", "log_event_list.cpp", "log_event_write.cpp", diff --git a/liblog/config_read.cpp b/liblog/config_read.cpp deleted file mode 100644 index 3139f7828..000000000 --- a/liblog/config_read.cpp +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright (C) 2016 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 - -#include "config_read.h" -#include "logger.h" - -struct listnode __android_log_transport_read = {&__android_log_transport_read, - &__android_log_transport_read}; -struct listnode __android_log_persist_read = {&__android_log_persist_read, - &__android_log_persist_read}; - -static void __android_log_add_transport(struct listnode* list, - struct android_log_transport_read* transport) { - uint32_t i; - - /* Try to keep one functioning transport for each log buffer id */ - for (i = LOG_ID_MIN; i < LOG_ID_MAX; i++) { - struct android_log_transport_read* transp; - - if (list_empty(list)) { - if (!transport->available || ((*transport->available)(static_cast(i)) >= 0)) { - list_add_tail(list, &transport->node); - return; - } - } else { - read_transport_for_each(transp, list) { - if (!transp->available) { - return; - } - if (((*transp->available)(static_cast(i)) < 0) && - (!transport->available || ((*transport->available)(static_cast(i)) >= 0))) { - list_add_tail(list, &transport->node); - return; - } - } - } - } -} - -void __android_log_config_read() { -#if (FAKE_LOG_DEVICE == 0) - if ((__android_log_transport == LOGGER_DEFAULT) || (__android_log_transport & 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 -} - -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 deleted file mode 100644 index 212b8a09f..000000000 --- a/liblog/config_read.h +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright (C) 2016 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. - */ - -#pragma once - -#include - -#include "log_portability.h" - -__BEGIN_DECLS - -extern struct listnode __android_log_transport_read; -extern struct listnode __android_log_persist_read; - -#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)) && \ - ((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)) - -#define read_transport_for_each_safe(transp, n, transports) \ - for ((transp) = node_to_item((transports)->next, \ - 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((n), struct android_log_transport_read, node), \ - (n) = (transp)->node.next) - -void __android_log_config_read(); -void __android_log_config_read_close(); - -__END_DECLS diff --git a/liblog/logd_reader.cpp b/liblog/logd_reader.cpp index b7ba7826d..eba305f8a 100644 --- a/liblog/logd_reader.cpp +++ b/liblog/logd_reader.cpp @@ -35,7 +35,6 @@ #include #include -#include "config_read.h" #include "log_portability.h" #include "logd_reader.h" #include "logger.h" diff --git a/liblog/logger.h b/liblog/logger.h index accb6e7cb..4b4ef5fc3 100644 --- a/liblog/logger.h +++ b/liblog/logger.h @@ -95,9 +95,19 @@ struct android_log_transport_read { size_t len); }; +struct android_log_transport_context { + union android_log_context_union context; /* zero init per-transport context */ + + struct android_log_transport_read* transport; + 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 */ +}; + struct android_log_logger_list { struct listnode logger; - struct listnode transport; + android_log_transport_context transport_context; + bool transport_initialized; int mode; unsigned int tail; log_time start; @@ -111,27 +121,7 @@ struct android_log_logger { log_id_t logId; }; -struct android_log_transport_context { - struct listnode node; - union android_log_context_union context; /* zero init per-transport context */ - struct android_log_logger_list* parent; - - struct android_log_transport_read* transport; - 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 */ -#define transport_context_for_each(transp, logger_list) \ - for ((transp) = node_to_item((logger_list)->transport.next, \ - struct android_log_transport_context, node); \ - ((transp) != node_to_item(&(logger_list)->transport, \ - struct android_log_transport_context, node)) && \ - ((transp)->parent == (logger_list)); \ - (transp) = node_to_item((transp)->node.next, \ - struct android_log_transport_context, node)) - #define logger_for_each(logp, logger_list) \ for ((logp) = node_to_item((logger_list)->logger.next, \ struct android_log_logger, node); \ diff --git a/liblog/logger_read.cpp b/liblog/logger_read.cpp index 4cf0846fb..ff816b768 100644 --- a/liblog/logger_read.cpp +++ b/liblog/logger_read.cpp @@ -29,7 +29,6 @@ #include #include -#include "config_read.h" #include "log_portability.h" #include "logger.h" @@ -55,9 +54,6 @@ log_id_t android_logger_get_id(struct logger* logger) { } static int init_transport_context(struct android_log_logger_list* logger_list) { - struct android_log_transport_read* transport; - struct listnode* node; - if (!logger_list) { return -EINVAL; } @@ -66,77 +62,63 @@ static int init_transport_context(struct android_log_logger_list* logger_list) { return -EINVAL; } - if (!list_empty(&logger_list->transport)) { + if (logger_list->transport_initialized) { return 0; } - __android_log_lock(); - /* mini __write_to_log_initialize() to populate transports */ - if (list_empty(&__android_log_transport_read) && list_empty(&__android_log_persist_read)) { - __android_log_config_read(); - } - __android_log_unlock(); +#if (FAKE_LOG_DEVICE == 0) + extern struct android_log_transport_read logdLoggerRead; + extern struct android_log_transport_read pmsgLoggerRead; - node = (logger_list->mode & ANDROID_LOG_PSTORE) ? &__android_log_persist_read - : &__android_log_transport_read; + struct android_log_transport_read* transport; + transport = (logger_list->mode & ANDROID_LOG_PSTORE) ? &pmsgLoggerRead : &logdLoggerRead; - read_transport_for_each(transport, node) { - struct android_log_transport_context* transp; - struct android_log_logger* logger; - unsigned logMask = 0; + struct android_log_logger* logger; + unsigned logMask = 0; - logger_for_each(logger, logger_list) { - log_id_t logId = logger->logId; + logger_for_each(logger, logger_list) { + log_id_t logId = logger->logId; - if ((logId == LOG_ID_SECURITY) && (__android_log_uid() != AID_SYSTEM)) { - continue; - } - if (transport->read && (!transport->available || (transport->available(logId) >= 0))) { - logMask |= 1 << logId; - } - } - if (!logMask) { + if (logId == LOG_ID_SECURITY && __android_log_uid() != AID_SYSTEM) { continue; } - transp = static_cast(calloc(1, sizeof(*transp))); - if (!transp) { - return -ENOMEM; + if (transport->read && (!transport->available || transport->available(logId) >= 0)) { + logMask |= 1 << logId; } - transp->parent = logger_list; - transp->transport = transport; - transp->logMask = logMask; - transp->ret = 1; - list_add_tail(&logger_list->transport, &transp->node); } - if (list_empty(&logger_list->transport)) { + if (!logMask) { return -ENODEV; } + + logger_list->transport_context.transport = transport; + logger_list->transport_context.logMask = logMask; + logger_list->transport_context.ret = 1; +#endif return 0; } -#define LOGGER_FUNCTION(logger, def, func, args...) \ - ssize_t ret = -EINVAL; \ - struct android_log_transport_context* transp; \ - struct android_log_logger* logger_internal = (struct android_log_logger*)(logger); \ - \ - if (!logger_internal) { \ - return ret; \ - } \ - ret = init_transport_context(logger_internal->parent); \ - if (ret < 0) { \ - return ret; \ - } \ - \ - ret = (def); \ - transport_context_for_each(transp, logger_internal->parent) { \ - if ((transp->logMask & (1 << logger_internal->logId)) && transp->transport && \ - transp->transport->func) { \ - ssize_t retval = (transp->transport->func)(logger_internal, transp, ##args); \ - if ((ret >= 0) || (ret == (def))) { \ - ret = retval; \ - } \ - } \ - } \ +#define LOGGER_FUNCTION(logger, def, func, args...) \ + ssize_t ret = -EINVAL; \ + android_log_logger* logger_internal = reinterpret_cast(logger); \ + \ + if (!logger_internal) { \ + return ret; \ + } \ + ret = init_transport_context(logger_internal->parent); \ + if (ret < 0) { \ + return ret; \ + } \ + \ + ret = (def); \ + android_log_transport_context* transport_context = &logger_internal->parent->transport_context; \ + if (transport_context->logMask & (1 << logger_internal->logId) && \ + transport_context->transport && transport_context->transport->func) { \ + ssize_t retval = \ + (transport_context->transport->func)(logger_internal, transport_context, ##args); \ + if (ret >= 0 || ret == (def)) { \ + ret = retval; \ + } \ + } \ return ret int android_logger_clear(struct logger* logger) { @@ -167,25 +149,24 @@ int android_logger_get_log_version(struct logger* logger) { LOGGER_FUNCTION(logger, 4, version); } -#define LOGGER_LIST_FUNCTION(logger_list, def, func, args...) \ - struct android_log_transport_context* transp; \ - struct android_log_logger_list* logger_list_internal = \ - (struct android_log_logger_list*)(logger_list); \ - \ - ssize_t ret = init_transport_context(logger_list_internal); \ - if (ret < 0) { \ - return ret; \ - } \ - \ - ret = (def); \ - transport_context_for_each(transp, logger_list_internal) { \ - if (transp->transport && (transp->transport->func)) { \ - ssize_t retval = (transp->transport->func)(logger_list_internal, transp, ##args); \ - if ((ret >= 0) || (ret == (def))) { \ - ret = retval; \ - } \ - } \ - } \ +#define LOGGER_LIST_FUNCTION(logger_list, def, func, args...) \ + android_log_logger_list* logger_list_internal = \ + reinterpret_cast(logger_list); \ + \ + ssize_t ret = init_transport_context(logger_list_internal); \ + if (ret < 0) { \ + return ret; \ + } \ + \ + ret = (def); \ + android_log_transport_context* transport_context = &logger_list_internal->transport_context; \ + if (transport_context->transport && transport_context->transport->func) { \ + ssize_t retval = \ + (transport_context->transport->func)(logger_list_internal, transport_context, ##args); \ + if (ret >= 0 || ret == (def)) { \ + ret = retval; \ + } \ + } \ return ret /* @@ -212,7 +193,6 @@ struct logger_list* android_logger_list_alloc(int mode, unsigned int tail, pid_t } list_init(&logger_list->logger); - list_init(&logger_list->transport); logger_list->mode = mode; logger_list->tail = tail; logger_list->pid = pid; @@ -229,7 +209,6 @@ struct logger_list* android_logger_list_alloc_time(int mode, log_time start, pid } list_init(&logger_list->logger); - list_init(&logger_list->transport); logger_list->mode = mode; logger_list->start = start; logger_list->pid = pid; @@ -247,38 +226,27 @@ struct logger* android_logger_open(struct logger_list* logger_list, log_id_t log struct android_log_logger* logger; if (!logger_list_internal || (logId >= LOG_ID_MAX)) { - goto err; + return nullptr; } logger_for_each(logger, logger_list_internal) { if (logger->logId == logId) { - goto ok; + return reinterpret_cast(logger); } } logger = static_cast(calloc(1, sizeof(*logger))); if (!logger) { - goto err; + return nullptr; } logger->logId = logId; list_add_tail(&logger_list_internal->logger, &logger->node); logger->parent = logger_list_internal; - /* Reset known transports to re-evaluate, we just added one */ - while (!list_empty(&logger_list_internal->transport)) { - struct listnode* node = list_head(&logger_list_internal->transport); - struct android_log_transport_context* transp = - node_to_item(node, struct android_log_transport_context, node); + // Reset known transport to re-evaluate, since we added a new logger. + logger_list_internal->transport_initialized = false; - list_remove(&transp->node); - free(transp); - } - goto ok; - -err: - logger = NULL; -ok: return (struct logger*)logger; } @@ -340,7 +308,6 @@ static int android_transport_read(struct android_log_logger_list* logger_list, /* Read from the selected logs */ int android_logger_list_read(struct logger_list* logger_list, struct log_msg* log_msg) { - struct android_log_transport_context* transp; struct android_log_logger_list* logger_list_internal = (struct android_log_logger_list*)logger_list; @@ -349,84 +316,8 @@ int android_logger_list_read(struct logger_list* logger_list, struct log_msg* lo return ret; } - /* at least one transport */ - transp = node_to_item(logger_list_internal->transport.next, struct android_log_transport_context, - node); - - /* more than one transport? */ - if (transp->node.next != &logger_list_internal->transport) { - /* Poll and merge sort the entries if from multiple transports */ - struct android_log_transport_context* oldest = NULL; - int ret; - int polled = 0; - do { - if (polled) { - sched_yield(); - } - ret = -1000; - polled = 0; - do { - int retval = transp->ret; - if ((retval > 0) && !transp->logMsg.entry.len) { - if (!transp->transport->read) { - retval = transp->ret = 0; - } else if ((logger_list_internal->mode & ANDROID_LOG_NONBLOCK) || - !transp->transport->poll) { - retval = android_transport_read(logger_list_internal, transp, &transp->logMsg); - } else { - int pollval = (*transp->transport->poll)(logger_list_internal, transp); - if (pollval <= 0) { - sched_yield(); - pollval = (*transp->transport->poll)(logger_list_internal, transp); - } - polled = 1; - if (pollval < 0) { - if ((pollval == -EINTR) || (pollval == -EAGAIN)) { - return -EAGAIN; - } - retval = transp->ret = pollval; - } else if (pollval > 0) { - retval = android_transport_read(logger_list_internal, transp, &transp->logMsg); - } - } - } - if (ret < retval) { - ret = retval; - } - if ((transp->ret > 0) && transp->logMsg.entry.len && - (!oldest || (oldest->logMsg.entry.sec > transp->logMsg.entry.sec) || - ((oldest->logMsg.entry.sec == transp->logMsg.entry.sec) && - (oldest->logMsg.entry.nsec > transp->logMsg.entry.nsec)))) { - oldest = transp; - } - transp = node_to_item(transp->node.next, struct android_log_transport_context, node); - } while (transp != node_to_item(&logger_list_internal->transport, - struct android_log_transport_context, node)); - if (!oldest && (logger_list_internal->mode & ANDROID_LOG_NONBLOCK)) { - return (ret < 0) ? ret : -EAGAIN; - } - transp = node_to_item(logger_list_internal->transport.next, - struct android_log_transport_context, node); - } while (!oldest && (ret > 0)); - if (!oldest) { - return ret; - } - // ret is a positive value less than sizeof(struct log_msg) - ret = oldest->ret; - if (ret < oldest->logMsg.entry.hdr_size) { - // zero truncated header fields. - memset( - log_msg, 0, - (oldest->logMsg.entry.hdr_size > sizeof(oldest->logMsg) ? sizeof(oldest->logMsg) - : oldest->logMsg.entry.hdr_size)); - } - memcpy(log_msg, &oldest->logMsg, ret); - oldest->logMsg.entry.len = 0; /* Mark it as copied */ - return ret; - } - - /* if only one, no need to copy into transport_context and merge-sort */ - return android_transport_read(logger_list_internal, transp, log_msg); + android_log_transport_context* transport_context = &logger_list_internal->transport_context; + return android_transport_read(logger_list_internal, transport_context, log_msg); } /* Close all the logs */ @@ -438,16 +329,10 @@ void android_logger_list_free(struct logger_list* logger_list) { return; } - while (!list_empty(&logger_list_internal->transport)) { - struct listnode* node = list_head(&logger_list_internal->transport); - struct android_log_transport_context* transp = - node_to_item(node, struct android_log_transport_context, node); + android_log_transport_context* transport_context = &logger_list_internal->transport_context; - if (transp->transport && transp->transport->close) { - (*transp->transport->close)(logger_list_internal, transp); - } - list_remove(&transp->node); - free(transp); + if (transport_context->transport && transport_context->transport->close) { + (*transport_context->transport->close)(logger_list_internal, transport_context); } while (!list_empty(&logger_list_internal->logger)) { diff --git a/liblog/logger_write.cpp b/liblog/logger_write.cpp index a4b3cd7b2..4fbab4b15 100644 --- a/liblog/logger_write.cpp +++ b/liblog/logger_write.cpp @@ -29,7 +29,6 @@ #include #include -#include "config_read.h" /* __android_log_config_read_close() definition */ #include "config_write.h" #include "log_portability.h" #include "logger.h" @@ -624,7 +623,6 @@ int android_set_log_transport(int transport_flag) { if (__android_log_transport != transport_flag) { __android_log_transport = transport_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 */ diff --git a/liblog/pmsg_reader.cpp b/liblog/pmsg_reader.cpp index eaac97f93..81563bc5d 100644 --- a/liblog/pmsg_reader.cpp +++ b/liblog/pmsg_reader.cpp @@ -24,7 +24,6 @@ #include #include -#include "config_read.h" #include "logger.h" static int pmsgAvailable(log_id_t logId); diff --git a/liblog/tests/liblog_test.cpp b/liblog/tests/liblog_test.cpp index d931ed1ef..45a9bc90b 100644 --- a/liblog/tests/liblog_test.cpp +++ b/liblog/tests/liblog_test.cpp @@ -1062,6 +1062,7 @@ for trouble being gone, comfort should remain, but\n\ when you depart from me, sorrow abides and happiness\n\ takes his leave."; +#ifdef USING_LOGGER_DEFAULT TEST(liblog, max_payload) { #ifdef TEST_PREFIX TEST_PREFIX @@ -1130,6 +1131,7 @@ TEST(liblog, max_payload) { GTEST_LOG_(INFO) << "This test does nothing.\n"; #endif } +#endif TEST(liblog, __android_log_buf_print__maxtag) { #ifdef TEST_PREFIX @@ -1271,6 +1273,7 @@ TEST(liblog, too_big_payload) { #endif } +#ifdef USING_LOGGER_DEFAULT TEST(liblog, dual_reader) { #ifdef TEST_PREFIX TEST_PREFIX @@ -1334,6 +1337,7 @@ TEST(liblog, dual_reader) { GTEST_LOG_(INFO) << "This test does nothing.\n"; #endif } +#endif #ifdef USING_LOGGER_DEFAULT // Do not retest logprint static bool checkPriForTag(AndroidLogFormat* p_format, const char* tag,