liblog: simplify logd 'command' functions and struct logger
There are a set of functions, such as android_logger_get_log_size()
and android_logger_get_prune_list() that talk to the logd command
socket to perform their activities. There's a transport abstraction
layer that handles these symbols to optionally route them to other
transports, originally designed for pstore or local logger; however
these functions fundamentally only make sense for logd.
Ideally, these functions would be removed and new functions would be
added that do not depend on struct logger_list or struct logger and
more clearly indicate that they only work with logd. For example:
android_logger_get_size(struct logger*) could be
logd_get_buffer_size(log_id_t log_id). We would remove the need to
'open' the struct logger and make it clear that it only operates on
logd.
Since liblog is an llndk library however, we cannot change or remove
these symbols. Since these symbols are not frequently used, it seems
acceptable to keep them as is and not introduce improved versions.
We, however, do want to simplify the code that handles them and this
change removes the transport abstraction layer that handles them.
They retain the behavior that unless the struct logger_list was opened
for logd, that the functions return -EINVAL.
The one exception to this is android_logger_clear(). If the struct
logger provided to this function was opened from a struct logger_list
that used pstore for its mode argument, this function will clear the
entire pstore log. This function does not respect the 'logId'
parameter of the struct logger, since that would not be possible.
This change removes this android_logger_clear() behavior and makes it
strictly for logd, for symmetry with the rest of the functions and due
to the lack of clarity regarding the 'logId' parameter of its input.
The only caller of this function, logcat, will clear pstore directly.
struct logger was built to encapsulate the information needed to
connect to a logger device from the old kernel logger. Now that we
only support reading from pstore and from logd, there is much less
information needed to be captured. Specifically, we only need to know
the log_id and whether or not it was opened as part of a pstore or
logd 'list'.
Test: liblog-unit-test
Test: logcat -c/-g/-G/-p/-P/-S work
Test: logcat -c works with -L
Test: logcat -g/-G/-p/-P/-S continue to fail with -L
Change-Id: I2c549b6f8539de94510e223949ab209ecc40e2d0
diff --git a/liblog/logd_reader.cpp b/liblog/logd_reader.cpp
index eaa157a..4e2dc66 100644
--- a/liblog/logd_reader.cpp
+++ b/liblog/logd_reader.cpp
@@ -40,39 +40,16 @@
#include "logger.h"
static int LogdAvailable(log_id_t LogId);
-static int LogdVersion(struct logger* logger, struct android_log_transport_context* transp);
static int LogdRead(struct logger_list* logger_list, struct android_log_transport_context* transp,
struct log_msg* log_msg);
-static int LogdPoll(struct logger_list* logger_list, struct android_log_transport_context* transp);
static void LogdClose(struct logger_list* logger_list,
struct android_log_transport_context* transp);
-static int LogdClear(struct logger* logger, struct android_log_transport_context* transp);
-static ssize_t LogdSetSize(struct logger* logger, struct android_log_transport_context* transp,
- size_t size);
-static ssize_t LogdGetSize(struct logger* logger, struct android_log_transport_context* transp);
-static ssize_t LogdGetReadableSize(struct logger* logger,
- struct android_log_transport_context* transp);
-static ssize_t LogdGetPrune(struct logger_list* logger,
- struct android_log_transport_context* transp, char* buf, size_t len);
-static ssize_t LogdSetPrune(struct logger_list* logger,
- struct android_log_transport_context* transp, char* buf, size_t len);
-static ssize_t LogdGetStats(struct logger_list* logger,
- struct android_log_transport_context* transp, char* buf, size_t len);
struct android_log_transport_read logdLoggerRead = {
.name = "logd",
.available = LogdAvailable,
- .version = LogdVersion,
.close = LogdClose,
.read = LogdRead,
- .poll = LogdPoll,
- .clear = LogdClear,
- .setSize = LogdSetSize,
- .getSize = LogdGetSize,
- .getReadableSize = LogdGetReadableSize,
- .getPrune = LogdGetPrune,
- .setPrune = LogdSetPrune,
- .getStats = LogdGetStats,
};
static int LogdAvailable(log_id_t logId) {
@@ -116,7 +93,7 @@
}
/* worker for sending the command to the logger */
-static ssize_t send_log_msg(struct logger* logger, const char* msg, char* buf, size_t buf_size) {
+ssize_t SendLogdControlMessage(char* buf, size_t buf_size) {
ssize_t ret;
size_t len;
char* cp;
@@ -126,10 +103,6 @@
return sock;
}
- if (msg) {
- snprintf(buf, buf_size, msg, logger ? logger->logId : (unsigned)-1);
- }
-
len = strlen(buf) + 1;
ret = TEMP_FAILURE_RETRY(write(sock, buf, len));
if (ret <= 0) {
@@ -180,10 +153,6 @@
return ret;
}
-ssize_t __send_log_msg(char* buf, size_t buf_size) {
- return send_log_msg(NULL, NULL, buf, buf_size);
-}
-
static int check_log_success(char* buf, ssize_t ret) {
if (ret < 0) {
return ret;
@@ -197,17 +166,28 @@
return 0;
}
-static int LogdClear(struct logger* logger, struct android_log_transport_context*) {
+int android_logger_clear(struct logger* logger) {
+ if (!android_logger_is_logd(logger)) {
+ return -EINVAL;
+ }
+ uint32_t log_id = android_logger_get_id(logger);
char buf[512];
+ snprintf(buf, sizeof(buf), "clear %" PRIu32, log_id);
- return check_log_success(buf, send_log_msg(logger, "clear %d", buf, sizeof(buf)));
+ return check_log_success(buf, SendLogdControlMessage(buf, sizeof(buf)));
}
/* returns the total size of the log's ring buffer */
-static ssize_t LogdGetSize(struct logger* logger, struct android_log_transport_context*) {
- char buf[512];
+long android_logger_get_log_size(struct logger* logger) {
+ if (!android_logger_is_logd(logger)) {
+ return -EINVAL;
+ }
- ssize_t ret = send_log_msg(logger, "getLogSize %d", buf, sizeof(buf));
+ uint32_t log_id = android_logger_get_id(logger);
+ char buf[512];
+ snprintf(buf, sizeof(buf), "getLogSize %" PRIu32, log_id);
+
+ ssize_t ret = SendLogdControlMessage(buf, sizeof(buf));
if (ret < 0) {
return ret;
}
@@ -219,23 +199,32 @@
return atol(buf);
}
-static ssize_t LogdSetSize(struct logger* logger, struct android_log_transport_context*,
- size_t size) {
+int android_logger_set_log_size(struct logger* logger, unsigned long size) {
+ if (!android_logger_is_logd(logger)) {
+ return -EINVAL;
+ }
+
+ uint32_t log_id = android_logger_get_id(logger);
char buf[512];
+ snprintf(buf, sizeof(buf), "setLogSize %" PRIu32 " %lu", log_id, size);
- snprintf(buf, sizeof(buf), "setLogSize %d %zu", logger->logId, size);
-
- return check_log_success(buf, send_log_msg(NULL, NULL, buf, sizeof(buf)));
+ return check_log_success(buf, SendLogdControlMessage(buf, sizeof(buf)));
}
/*
* returns the readable size of the log's ring buffer (that is, amount of the
* log consumed)
*/
-static ssize_t LogdGetReadableSize(struct logger* logger, struct android_log_transport_context*) {
- char buf[512];
+long android_logger_get_log_readable_size(struct logger* logger) {
+ if (!android_logger_is_logd(logger)) {
+ return -EINVAL;
+ }
- ssize_t ret = send_log_msg(logger, "getLogSizeUsed %d", buf, sizeof(buf));
+ uint32_t log_id = android_logger_get_id(logger);
+ char buf[512];
+ snprintf(buf, sizeof(buf), "getLogSizeUsed %" PRIu32, log_id);
+
+ ssize_t ret = SendLogdControlMessage(buf, sizeof(buf));
if (ret < 0) {
return ret;
}
@@ -247,20 +236,15 @@
return atol(buf);
}
-/*
- * returns the logger version
- */
-static int LogdVersion(struct logger*, struct android_log_transport_context*) {
- uid_t uid = __android_log_uid();
- return ((uid != AID_ROOT) && (uid != AID_LOG) && (uid != AID_SYSTEM)) ? 3 : 4;
+int android_logger_get_log_version(struct logger*) {
+ return 4;
}
-/*
- * returns statistics
- */
-static ssize_t LogdGetStats(struct logger_list* logger_list, struct android_log_transport_context*,
- char* buf, size_t len) {
- struct logger* logger;
+ssize_t android_logger_get_statistics(struct logger_list* logger_list, char* buf, size_t len) {
+ if (logger_list->mode & ANDROID_LOG_PSTORE) {
+ return -EINVAL;
+ }
+
char* cp = buf;
size_t remaining = len;
size_t n;
@@ -270,27 +254,35 @@
remaining -= n;
cp += n;
- logger_for_each(logger, logger_list) {
- n = snprintf(cp, remaining, " %d", logger->logId);
- n = MIN(n, remaining);
- remaining -= n;
- cp += n;
+ for (size_t log_id = 0; log_id < LOG_ID_MAX; ++log_id) {
+ if ((1 << log_id) & logger_list->log_mask) {
+ n = snprintf(cp, remaining, " %zu", log_id);
+ n = MIN(n, remaining);
+ remaining -= n;
+ cp += n;
+ }
}
if (logger_list->pid) {
snprintf(cp, remaining, " pid=%u", logger_list->pid);
}
- return send_log_msg(NULL, NULL, buf, len);
+ return SendLogdControlMessage(buf, len);
+}
+ssize_t android_logger_get_prune_list(struct logger_list* logger_list, char* buf, size_t len) {
+ if (logger_list->mode & ANDROID_LOG_PSTORE) {
+ return -EINVAL;
+ }
+
+ snprintf(buf, len, "getPruneList");
+ return SendLogdControlMessage(buf, len);
}
-static ssize_t LogdGetPrune(struct logger_list*, struct android_log_transport_context*, char* buf,
- size_t len) {
- return send_log_msg(NULL, "getPruneList", buf, len);
-}
+int android_logger_set_prune_list(struct logger_list* logger_list, char* buf, size_t len) {
+ if (logger_list->mode & ANDROID_LOG_PSTORE) {
+ return -EINVAL;
+ }
-static ssize_t LogdSetPrune(struct logger_list*, struct android_log_transport_context*, char* buf,
- size_t len) {
const char cmd[] = "setPruneList ";
const size_t cmdlen = sizeof(cmd) - 1;
@@ -301,11 +293,10 @@
buf[len - 1] = '\0';
memcpy(buf, cmd, cmdlen);
- return check_log_success(buf, send_log_msg(NULL, NULL, buf, len));
+ return check_log_success(buf, SendLogdControlMessage(buf, len));
}
static int logdOpen(struct logger_list* logger_list, struct android_log_transport_context* transp) {
- struct logger* logger;
char buffer[256], *cp, c;
int ret, remaining, sock;
@@ -333,12 +324,15 @@
cp += 5;
c = '=';
remaining = sizeof(buffer) - (cp - buffer);
- logger_for_each(logger, logger_list) {
- ret = snprintf(cp, remaining, "%c%u", c, logger->logId);
- ret = MIN(ret, remaining);
- remaining -= ret;
- cp += ret;
- c = ',';
+
+ for (size_t log_id = 0; log_id < LOG_ID_MAX; ++log_id) {
+ if ((1 << log_id) & logger_list->log_mask) {
+ ret = snprintf(cp, remaining, "%c%zu", c, log_id);
+ ret = MIN(ret, remaining);
+ remaining -= ret;
+ cp += ret;
+ c = ',';
+ }
}
if (logger_list->tail) {
@@ -412,27 +406,6 @@
return ret;
}
-static int LogdPoll(struct logger_list* logger_list, struct android_log_transport_context* transp) {
- struct pollfd p;
-
- int ret = logdOpen(logger_list, transp);
- if (ret < 0) {
- return ret;
- }
-
- memset(&p, 0, sizeof(p));
- p.fd = ret;
- p.events = POLLIN;
- ret = poll(&p, 1, 20);
- if ((ret > 0) && !(p.revents & POLLIN)) {
- ret = 0;
- }
- if ((ret == -1) && errno) {
- return -errno;
- }
- return ret;
-}
-
/* Close all the logs */
static void LogdClose(struct logger_list*, struct android_log_transport_context* transp) {
int sock = atomic_exchange(&transp->context.sock, -1);