ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

liblog: only allow one transport for reading

Browse source 
liblog has left over code from local_logger that allows for reading
from multiple sources and merging the contents.  Since we've already
removed local_logger, this change removes the rest of this code.

Test: liblog-unit-tests
Change-Id: I5685ad6c1e7cbcaa0a660ed10f47714784a40791
This commit is contained in:
Tom Cherry 2019-08-23 14:04:12 -07:00
parent a033693a9e
commit f7e1b1ebd4
9 changed files with 84 additions and 339 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
liblog/Android.bp
View file

@ -15,7 +15,6 @@
//
liblog_sources = [
"config_read.cpp",
"config_write.cpp",
"log_event_list.cpp",
"log_event_write.cpp",

77
liblog/config_read.cpp
View file

@ -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 <log/log_transport.h>
#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<log_id_t>(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<log_id_t>(i)) < 0) &&
(!transport->available || ((*transport->available)(static_cast<log_id_t>(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);
}
}

52
liblog/config_read.h
View file

@ -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 <cutils/list.h>
#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

1
liblog/logd_reader.cpp
View file

@ -35,7 +35,6 @@
#include <private/android_filesystem_config.h>
#include <private/android_logger.h>
#include "config_read.h"
#include "log_portability.h"
#include "logd_reader.h"
#include "logger.h"

32
liblog/logger.h
View file

@ -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); \

253
liblog/logger_read.cpp
View file

@ -29,7 +29,6 @@
#include <cutils/list.h>
#include <private/android_filesystem_config.h>
#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<android_log_transport_context*>(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<android_log_logger*>(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<android_log_logger_list*>(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<struct logger*>(logger);
}
}
logger = static_cast<android_log_logger*>(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)) {

2
liblog/logger_write.cpp
View file

@ -29,7 +29,6 @@
#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"
@ -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 */

1
liblog/pmsg_reader.cpp
View file

@ -24,7 +24,6 @@
#include <private/android_filesystem_config.h>
#include <private/android_logger.h>
#include "config_read.h"
#include "logger.h"
static int pmsgAvailable(log_id_t logId);

4
liblog/tests/liblog_test.cpp
View file

@ -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,