openkylin
/
platform_system_core
mirror of https://gitee.com/openkylin/platform_system_core.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

liblog: remove stderr logger 

There are no users of the liblog stderr logger, but 66 users of
android::base::StderrLogger.  We'll prefer that format and work to
merge it into liblog.

Test: liblog-unit-tests
Change-Id: Ifad24b27ac0f51379b925f6644caa1f6f3d9ad81
This commit is contained in:
Tom Cherry 2019-09-30 13:51:09 -07:00
parent 7d045f6b74
commit 2238ce2d7f
9 changed files with 11 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
liblog/Android.bp
View File

@ -23,7 +23,6 @@ liblog_sources = [
"logger_read.cpp",
"logger_write.cpp",
"logprint.cpp",
"stderr_write.cpp",
]
liblog_host_sources = [
"fake_log_device.cpp",

21
liblog/config_write.cpp
View File

@ -66,27 +66,6 @@ void __android_log_config_write() {
__android_log_add_transport(&__android_log_transport_write, &fakeLoggerWrite);
#endif
}
if (__android_log_transport & LOGGER_STDERR) {
extern struct android_log_transport_write stderrLoggerWrite;
/*
* stderr logger should be primary if we can be the only one, or if
* already in the primary list. Otherwise land in the persist list.
* Remember we can be called here if we are already initialized.
*/
if (list_empty(&__android_log_transport_write)) {
__android_log_add_transport(&__android_log_transport_write, &stderrLoggerWrite);
} else {
struct android_log_transport_write* transp;
write_transport_for_each(transp, &__android_log_transport_write) {
if (transp == &stderrLoggerWrite) {
return;
}
}
__android_log_add_transport(&__android_log_persist_write, &stderrLoggerWrite);
}
}
}
void __android_log_config_write_close() {

2
liblog/include/log/log_transport.h
View File

@ -22,7 +22,7 @@ extern "C" {
#define LOGGER_KERNEL 0x02 /* Reserved/Deprecated */
#define LOGGER_NULL 0x04 /* Does not release resources of other selections */
#define LOGGER_RESERVED 0x08 /* Reserved, previously for logging to local memory */
#define LOGGER_STDERR 0x10 /* logs sent to stderr */
#define LOGGER_RESERVED2 0x10 /* Reserved, previously for logs sent to stderr */
/* clang-format on */
/* Both return the selected transport flag mask, or negative errno */

6
liblog/logger_write.cpp
View File

@ -586,9 +586,9 @@ int android_set_log_transport(int transport_flag) {
return retval;
}
__android_log_transport &= LOGGER_LOGD | LOGGER_STDERR;
__android_log_transport &= LOGGER_LOGD;
transport_flag &= LOGGER_LOGD | LOGGER_STDERR;
transport_flag &= LOGGER_LOGD;
if (__android_log_transport != transport_flag) {
__android_log_transport = transport_flag;
@ -614,7 +614,7 @@ int android_get_log_transport() {
if (write_to_log == __write_to_log_null) {
ret = LOGGER_NULL;
} else {
__android_log_transport &= LOGGER_LOGD | LOGGER_STDERR;
__android_log_transport &= LOGGER_LOGD;
ret = __android_log_transport;
if ((write_to_log != __write_to_log_init) && (write_to_log != __write_to_log_daemon)) {
ret = -EINVAL;

209
liblog/stderr_write.cpp
View File

@ -1,209 +0,0 @@
/*
* 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.
*/
/*
* stderr write handler. Output is logcat-like, and responds to
* logcat's environment variables ANDROID_PRINTF_LOG and
* ANDROID_LOG_TAGS to filter output.
*
* This transport only provides a writer, that means that it does not
* provide an End-To-End capability as the logs are effectively _lost_
* to the stderr file stream. The purpose of this transport is to
* supply a means for command line tools to report their logging
* to the stderr stream, in line with all other activities.
*/
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <log/event_tag_map.h>
#include <log/log.h>
#include <log/logprint.h>
#include "log_portability.h"
#include "logger.h"
#include "uio.h"
static int stderrOpen();
static void stderrClose();
static int stderrAvailable(log_id_t logId);
static int stderrWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr);
struct stderrContext {
AndroidLogFormat* logformat;
#if defined(__ANDROID__)
EventTagMap* eventTagMap;
#endif
};
struct android_log_transport_write stderrLoggerWrite = {
.node = {&stderrLoggerWrite.node, &stderrLoggerWrite.node},
.context.priv = NULL,
.name = "stderr",
.available = stderrAvailable,
.open = stderrOpen,
.close = stderrClose,
.write = stderrWrite,
};
static int stderrOpen() {
struct stderrContext* ctx;
const char* envStr;
bool setFormat;
if (!stderr || (fileno(stderr) < 0)) {
return -EBADF;
}
if (stderrLoggerWrite.context.priv) {
return fileno(stderr);
}
ctx = static_cast<stderrContext*>(calloc(1, sizeof(stderrContext)));
if (!ctx) {
return -ENOMEM;
}
ctx->logformat = android_log_format_new();
if (!ctx->logformat) {
free(ctx);
return -ENOMEM;
}
envStr = getenv("ANDROID_PRINTF_LOG");
setFormat = false;
if (envStr) {
char* formats = strdup(envStr);
char* sv = NULL;
char* arg = formats;
while (!!(arg = strtok_r(arg, ",:; \t\n\r\f", &sv))) {
AndroidLogPrintFormat format = android_log_formatFromString(arg);
arg = NULL;
if (format == FORMAT_OFF) {
continue;
}
if (android_log_setPrintFormat(ctx->logformat, format) <= 0) {
continue;
}
setFormat = true;
}
free(formats);
}
if (!setFormat) {
AndroidLogPrintFormat format = android_log_formatFromString("threadtime");
android_log_setPrintFormat(ctx->logformat, format);
}
envStr = getenv("ANDROID_LOG_TAGS");
if (envStr) {
android_log_addFilterString(ctx->logformat, envStr);
}
stderrLoggerWrite.context.priv = ctx;
return fileno(stderr);
}
static void stderrClose() {
stderrContext* ctx = static_cast<stderrContext*>(stderrLoggerWrite.context.priv);
if (ctx) {
stderrLoggerWrite.context.priv = NULL;
if (ctx->logformat) {
android_log_format_free(ctx->logformat);
ctx->logformat = NULL;
}
#if defined(__ANDROID__)
if (ctx->eventTagMap) {
android_closeEventTagMap(ctx->eventTagMap);
ctx->eventTagMap = NULL;
}
#endif
}
}
static int stderrAvailable(log_id_t logId) {
if ((logId >= LOG_ID_MAX) || (logId == LOG_ID_KERNEL)) {
return -EINVAL;
}
return 1;
}
static int stderrWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr) {
struct log_msg log_msg;
AndroidLogEntry entry;
char binaryMsgBuf[1024];
int err;
size_t i;
stderrContext* ctx = static_cast<stderrContext*>(stderrLoggerWrite.context.priv);
if (!ctx) return -EBADF;
if (!vec || !nr) return -EINVAL;
log_msg.entry.len = 0;
log_msg.entry.hdr_size = sizeof(log_msg.entry);
log_msg.entry.pid = getpid();
#ifdef __BIONIC__
log_msg.entry.tid = gettid();
#else
log_msg.entry.tid = getpid();
#endif
log_msg.entry.sec = ts->tv_sec;
log_msg.entry.nsec = ts->tv_nsec;
log_msg.entry.lid = logId;
log_msg.entry.uid = __android_log_uid();
for (i = 0; i < nr; ++i) {
size_t len = vec[i].iov_len;
if ((log_msg.entry.len + len) > LOGGER_ENTRY_MAX_PAYLOAD) {
len = LOGGER_ENTRY_MAX_PAYLOAD - log_msg.entry.len;
}
if (!len) continue;
memcpy(log_msg.entry.msg + log_msg.entry.len, vec[i].iov_base, len);
log_msg.entry.len += len;
}
if ((logId == LOG_ID_EVENTS) || (logId == LOG_ID_SECURITY)) {
#if defined(__ANDROID__)
if (!ctx->eventTagMap) {
ctx->eventTagMap = android_openEventTagMap(NULL);
}
#endif
err = android_log_processBinaryLogBuffer(&log_msg.entry_v1, &entry,
#if defined(__ANDROID__)
ctx->eventTagMap,
#else
NULL,
#endif
binaryMsgBuf, sizeof(binaryMsgBuf));
} else {
err = android_log_processLogBuffer(&log_msg.entry_v1, &entry);
}
/* print known truncated data, in essence logcat --debug */
if ((err < 0) && !entry.message) return -EINVAL;
if (!android_log_shouldPrintLine(ctx->logformat, entry.tag, entry.priority)) {
return log_msg.entry.len;
}
err = android_log_printLogLine(ctx->logformat, fileno(stderr), &entry);
if (err < 0) return errno ? -errno : -EINVAL;
return log_msg.entry.len;
}

3
liblog/tests/Android.bp
View File

@ -54,8 +54,7 @@ cc_defaults {
],
srcs: [
"libc_test.cpp",
"liblog_test_default.cpp",
"liblog_test_stderr.cpp",
"liblog_test.cpp",
"log_id_test.cpp",
"log_radio_test.cpp",
"log_read_test.cpp",

11
liblog/tests/liblog_test.cpp
View File

@ -43,6 +43,11 @@
#include <private/android_filesystem_config.h>
#include <private/android_logger.h>
#ifdef __ANDROID__
#define TEST_LOGGER LOGGER_DEFAULT
#endif
#define USING_LOGGER_DEFAULT
#ifndef TEST_PREFIX
#ifdef TEST_LOGGER
#define TEST_PREFIX android_set_log_transport(TEST_LOGGER);
@ -281,11 +286,7 @@ static void print_transport(const char* prefix, int logger) {
fprintf(stderr, "%sLOGGER_NULL", prefix);
prefix = orstr;
}
if (logger & LOGGER_STDERR) {
fprintf(stderr, "%sLOGGER_STDERR", prefix);
prefix = orstr;
}
logger &= ~(LOGGER_LOGD | LOGGER_KERNEL | LOGGER_NULL | LOGGER_STDERR);
logger &= ~(LOGGER_LOGD | LOGGER_KERNEL | LOGGER_NULL);
if (logger) {
fprintf(stderr, "%s0x%x", prefix, logger);
prefix = orstr;

6
liblog/tests/liblog_test_default.cpp
View File

@ -1,6 +0,0 @@
#ifdef __ANDROID__
#include <log/log_transport.h>
#define TEST_LOGGER LOGGER_DEFAULT
#endif
#define USING_LOGGER_DEFAULT
#include "liblog_test.cpp"

5
liblog/tests/liblog_test_stderr.cpp
View File

@ -1,5 +0,0 @@
#include <log/log_transport.h>
#define liblog liblog_stderr
#define TEST_LOGGER LOGGER_STDERR
#define USING_LOGGER_STDERR
#include "liblog_test.cpp"