From aeaaf81c2cc8366ac4f66eb3d2fc85f9b8194982 Mon Sep 17 00:00:00 2001 From: Mark Salyzyn Date: Fri, 30 Sep 2016 13:30:33 -0700 Subject: [PATCH] liblog: logd: logcat: Split out log/logger.h into public and private. log/logger.h pieces moved into log/log.h. Correct for some minor Android Coding standards. Test: gTests liblog-unit-tests, logd-unit-tests and logcat-unit-tests Bug: 19235719 Bug: 26552300 Bug: 31289077 Bug: 31456426 Change-Id: I0a19fd8788eec20a582e72e4c62c04534bdb1b9a --- include/log/log.h | 566 +++++++++++++++++++++++++++++++ include/log/logger.h | 461 ------------------------- include/log/logprint.h | 52 ++- include/private/android_logger.h | 21 +- liblog/README | 4 +- liblog/log_time.cpp | 2 +- liblog/logger.h | 3 +- liblog/logger_name.c | 3 +- liblog/logprint.c | 3 +- logcat/logcat.cpp | 3 +- logcat/tests/logcat_test.cpp | 3 +- logd/FlushCommand.h | 2 +- logd/LogBufferElement.h | 3 +- logd/LogKlog.cpp | 2 +- logd/LogKlog.h | 2 +- logd/LogReader.cpp | 1 + logd/LogStatistics.cpp | 2 +- logd/LogTimes.h | 2 +- logd/LogUtils.h | 2 +- logd/tests/logd_test.cpp | 3 +- 20 files changed, 614 insertions(+), 526 deletions(-) diff --git a/include/log/log.h b/include/log/log.h index 4777ae5ee..a44aba898 100644 --- a/include/log/log.h +++ b/include/log/log.h @@ -29,6 +29,12 @@ #include /* helper to define iovec for portability */ +#if (defined(__cplusplus) && defined(_USING_LIBCXX)) +extern "C++" { +#include +} +#endif + #include #ifdef __cplusplus @@ -326,6 +332,448 @@ typedef enum log_id { /* --------------------------------------------------------------------- */ +/* + * Native log reading interface section. See logcat for sample code. + * + * The preferred API is an exec of logcat. Likely uses of this interface + * are if native code suffers from exec or filtration being too costly, + * access to raw information, or parsing is an issue. + */ + +/* + * The userspace structure for version 1 of the logger_entry ABI. + */ +#ifndef __struct_logger_entry_defined +#define __struct_logger_entry_defined +struct logger_entry { + uint16_t len; /* length of the payload */ + uint16_t __pad; /* no matter what, we get 2 bytes of padding */ + int32_t pid; /* generating process's pid */ + int32_t tid; /* generating process's tid */ + int32_t sec; /* seconds since Epoch */ + int32_t nsec; /* nanoseconds */ +#ifndef __cplusplus + char msg[0]; /* the entry's payload */ +#endif +}; +#endif + +/* + * The userspace structure for version 2 of the logger_entry ABI. + */ +#ifndef __struct_logger_entry_v2_defined +#define __struct_logger_entry_v2_defined +struct logger_entry_v2 { + uint16_t len; /* length of the payload */ + uint16_t hdr_size; /* sizeof(struct logger_entry_v2) */ + int32_t pid; /* generating process's pid */ + int32_t tid; /* generating process's tid */ + int32_t sec; /* seconds since Epoch */ + int32_t nsec; /* nanoseconds */ + uint32_t euid; /* effective UID of logger */ +#ifndef __cplusplus + char msg[0]; /* the entry's payload */ +#endif +} __attribute__((__packed__)); +#endif + +/* + * The userspace structure for version 3 of the logger_entry ABI. + */ +#ifndef __struct_logger_entry_v3_defined +#define __struct_logger_entry_v3_defined +struct logger_entry_v3 { + uint16_t len; /* length of the payload */ + uint16_t hdr_size; /* sizeof(struct logger_entry_v3) */ + int32_t pid; /* generating process's pid */ + int32_t tid; /* generating process's tid */ + int32_t sec; /* seconds since Epoch */ + int32_t nsec; /* nanoseconds */ + uint32_t lid; /* log id of the payload */ +#ifndef __cplusplus + char msg[0]; /* the entry's payload */ +#endif +} __attribute__((__packed__)); +#endif + +/* + * The userspace structure for version 4 of the logger_entry ABI. + */ +#ifndef __struct_logger_entry_v4_defined +#define __struct_logger_entry_v4_defined +struct logger_entry_v4 { + uint16_t len; /* length of the payload */ + uint16_t hdr_size; /* sizeof(struct logger_entry_v4) */ + int32_t pid; /* generating process's pid */ + uint32_t tid; /* generating process's tid */ + uint32_t sec; /* seconds since Epoch */ + uint32_t nsec; /* nanoseconds */ + uint32_t lid; /* log id of the payload, bottom 4 bits currently */ + uint32_t uid; /* generating process's uid */ +#ifndef __cplusplus + char msg[0]; /* the entry's payload */ +#endif +}; +#endif + +/* struct log_time is a wire-format variant of struct timespec */ +#define NS_PER_SEC 1000000000ULL + +#ifndef __struct_log_time_defined +#define __struct_log_time_defined +#ifdef __cplusplus + +/* + * NB: we did NOT define a copy constructor. This will result in structure + * no longer being compatible with pass-by-value which is desired + * efficient behavior. Also, pass-by-reference breaks C/C++ ABI. + */ +struct log_time { +public: + uint32_t tv_sec; /* good to Feb 5 2106 */ + uint32_t tv_nsec; + + static const uint32_t tv_sec_max = 0xFFFFFFFFUL; + static const uint32_t tv_nsec_max = 999999999UL; + + log_time(const timespec& T) + { + tv_sec = static_cast(T.tv_sec); + tv_nsec = static_cast(T.tv_nsec); + } + log_time(uint32_t sec, uint32_t nsec) + { + tv_sec = sec; + tv_nsec = nsec; + } +#ifdef _SYSTEM_CORE_INCLUDE_PRIVATE_ANDROID_LOGGER_H_ +#define __struct_log_time_private_defined + static const timespec EPOCH; +#endif + log_time() + { + } +#ifdef __linux__ + log_time(clockid_t id) + { + timespec T; + clock_gettime(id, &T); + tv_sec = static_cast(T.tv_sec); + tv_nsec = static_cast(T.tv_nsec); + } +#endif + log_time(const char* T) + { + const uint8_t* c = reinterpret_cast(T); + tv_sec = c[0] | + (static_cast(c[1]) << 8) | + (static_cast(c[2]) << 16) | + (static_cast(c[3]) << 24); + tv_nsec = c[4] | + (static_cast(c[5]) << 8) | + (static_cast(c[6]) << 16) | + (static_cast(c[7]) << 24); + } + + /* timespec */ + bool operator== (const timespec& T) const + { + return (tv_sec == static_cast(T.tv_sec)) + && (tv_nsec == static_cast(T.tv_nsec)); + } + bool operator!= (const timespec& T) const + { + return !(*this == T); + } + bool operator< (const timespec& T) const + { + return (tv_sec < static_cast(T.tv_sec)) + || ((tv_sec == static_cast(T.tv_sec)) + && (tv_nsec < static_cast(T.tv_nsec))); + } + bool operator>= (const timespec& T) const + { + return !(*this < T); + } + bool operator> (const timespec& T) const + { + return (tv_sec > static_cast(T.tv_sec)) + || ((tv_sec == static_cast(T.tv_sec)) + && (tv_nsec > static_cast(T.tv_nsec))); + } + bool operator<= (const timespec& T) const + { + return !(*this > T); + } + +#ifdef _SYSTEM_CORE_INCLUDE_PRIVATE_ANDROID_LOGGER_H_ + log_time operator-= (const timespec& T); + log_time operator- (const timespec& T) const + { + log_time local(*this); + return local -= T; + } + log_time operator+= (const timespec& T); + log_time operator+ (const timespec& T) const + { + log_time local(*this); + return local += T; + } +#endif + + /* log_time */ + bool operator== (const log_time& T) const + { + return (tv_sec == T.tv_sec) && (tv_nsec == T.tv_nsec); + } + bool operator!= (const log_time& T) const + { + return !(*this == T); + } + bool operator< (const log_time& T) const + { + return (tv_sec < T.tv_sec) + || ((tv_sec == T.tv_sec) && (tv_nsec < T.tv_nsec)); + } + bool operator>= (const log_time& T) const + { + return !(*this < T); + } + bool operator> (const log_time& T) const + { + return (tv_sec > T.tv_sec) + || ((tv_sec == T.tv_sec) && (tv_nsec > T.tv_nsec)); + } + bool operator<= (const log_time& T) const + { + return !(*this > T); + } + +#ifdef _SYSTEM_CORE_INCLUDE_PRIVATE_ANDROID_LOGGER_H_ + log_time operator-= (const log_time& T); + log_time operator- (const log_time& T) const + { + log_time local(*this); + return local -= T; + } + log_time operator+= (const log_time& T); + log_time operator+ (const log_time& T) const + { + log_time local(*this); + return local += T; + } +#endif + + uint64_t nsec() const + { + return static_cast(tv_sec) * NS_PER_SEC + tv_nsec; + } + +#ifdef _SYSTEM_CORE_INCLUDE_PRIVATE_ANDROID_LOGGER_H_ + static const char default_format[]; + + /* Add %#q for the fraction of a second to the standard library functions */ + char* strptime(const char* s, const char* format = default_format); +#endif +} __attribute__((__packed__)); + +#else + +typedef struct log_time { + uint32_t tv_sec; + uint32_t tv_nsec; +} __attribute__((__packed__)) log_time; + +#endif +#endif + +/* + * The maximum size of the log entry payload that can be + * written to the logger. An attempt to write more than + * this amount will result in a truncated log entry. + */ +#define LOGGER_ENTRY_MAX_PAYLOAD 4068 + +/* + * The maximum size of a log entry which can be read from the + * kernel logger driver. An attempt to read less than this amount + * may result in read() returning EINVAL. + */ +#define LOGGER_ENTRY_MAX_LEN (5*1024) + +#ifndef __struct_log_msg_defined +#define __struct_log_msg_defined +struct log_msg { + union { + unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1]; + struct logger_entry_v4 entry; + struct logger_entry_v4 entry_v4; + struct logger_entry_v3 entry_v3; + struct logger_entry_v2 entry_v2; + struct logger_entry entry_v1; + } __attribute__((aligned(4))); +#ifdef __cplusplus + /* Matching log_time operators */ + bool operator== (const log_msg& T) const + { + return (entry.sec == T.entry.sec) && (entry.nsec == T.entry.nsec); + } + bool operator!= (const log_msg& T) const + { + return !(*this == T); + } + bool operator< (const log_msg& T) const + { + return (entry.sec < T.entry.sec) + || ((entry.sec == T.entry.sec) + && (entry.nsec < T.entry.nsec)); + } + bool operator>= (const log_msg& T) const + { + return !(*this < T); + } + bool operator> (const log_msg& T) const + { + return (entry.sec > T.entry.sec) + || ((entry.sec == T.entry.sec) + && (entry.nsec > T.entry.nsec)); + } + bool operator<= (const log_msg& T) const + { + return !(*this > T); + } + uint64_t nsec() const + { + return static_cast(entry.sec) * NS_PER_SEC + entry.nsec; + } + + /* packet methods */ + log_id_t id() + { + return static_cast(entry.lid); + } + char* msg() + { + unsigned short hdr_size = entry.hdr_size; + if (!hdr_size) { + hdr_size = sizeof(entry_v1); + } + if ((hdr_size < sizeof(entry_v1)) || (hdr_size > sizeof(entry))) { + return NULL; + } + return reinterpret_cast(buf) + hdr_size; + } + unsigned int len() + { + return (entry.hdr_size ? + entry.hdr_size : + static_cast(sizeof(entry_v1))) + + entry.len; + } +#endif +}; +#endif + +#ifndef __ANDROID_USE_LIBLOG_READER_INTERFACE +#ifndef __ANDROID_API__ +#define __ANDROID_USE_LIBLOG_READER_INTERFACE 3 +#elif __ANDROID_API__ > 23 /* > Marshmallow */ +#define __ANDROID_USE_LIBLOG_READER_INTERFACE 3 +#elif __ANDROID_API__ > 22 /* > Lollipop */ +#define __ANDROID_USE_LIBLOG_READER_INTERFACE 2 +#elif __ANDROID_API__ > 19 /* > KitKat */ +#define __ANDROID_USE_LIBLOG_READER_INTERFACE 1 +#else +#define __ANDROID_USE_LIBLOG_READER_INTERFACE 0 +#endif +#endif + +#if __ANDROID_USE_LIBLOG_READER_INTERFACE + +struct logger; + +log_id_t android_logger_get_id(struct logger* logger); + +int android_logger_clear(struct logger* logger); +long android_logger_get_log_size(struct logger* logger); +int android_logger_set_log_size(struct logger* logger, unsigned long size); +long android_logger_get_log_readable_size(struct logger* logger); +int android_logger_get_log_version(struct logger* logger); + +struct logger_list; + +#if __ANDROID_USE_LIBLOG_READER_INTERFACE > 1 +ssize_t android_logger_get_statistics(struct logger_list* logger_list, + char* buf, size_t len); +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, + char* buf, size_t len); +#endif + +#define ANDROID_LOG_RDONLY O_RDONLY +#define ANDROID_LOG_WRONLY O_WRONLY +#define ANDROID_LOG_RDWR O_RDWR +#define ANDROID_LOG_ACCMODE O_ACCMODE +#define ANDROID_LOG_NONBLOCK O_NONBLOCK +#if __ANDROID_USE_LIBLOG_READER_INTERFACE > 2 +#define ANDROID_LOG_WRAP 0x40000000 /* Block until buffer about to wrap */ +#define ANDROID_LOG_WRAP_DEFAULT_TIMEOUT 7200 /* 2 hour default */ +#endif +#if __ANDROID_USE_LIBLOG_READER_INTERFACE > 1 +#define ANDROID_LOG_PSTORE 0x80000000 +#endif + +struct logger_list* android_logger_list_alloc(int mode, + unsigned int tail, + pid_t pid); +struct logger_list* android_logger_list_alloc_time(int mode, + log_time start, + pid_t pid); +void android_logger_list_free(struct logger_list* logger_list); +/* In the purest sense, the following two are orthogonal interfaces */ +int android_logger_list_read(struct logger_list* logger_list, + struct log_msg* log_msg); + +/* Multiple log_id_t opens */ +struct logger* android_logger_open(struct logger_list* logger_list, + log_id_t id); +#define android_logger_close android_logger_free +/* Single log_id_t open */ +struct logger_list* android_logger_list_open(log_id_t id, + int mode, + unsigned int tail, + pid_t pid); +#define android_logger_list_close android_logger_list_free + +#endif /* __ANDROID_USE_LIBLOG_READER_INTERFACE */ + +#ifdef __linux__ + +#ifndef __ANDROID_USE_LIBLOG_CLOCK_INTERFACE +#ifndef __ANDROID_API__ +#define __ANDROID_USE_LIBLOG_CLOCK_INTERFACE 1 +#elif __ANDROID_API__ > 22 /* > Lollipop */ +#define __ANDROID_USE_LIBLOG_CLOCK_INTERFACE 1 +#else +#define __ANDROID_USE_LIBLOG_CLOCK_INTERFACE 0 +#endif +#endif + +#if __ANDROID_USE_LIBLOG_CLOCK_INTERFACE +clockid_t android_log_clockid(); +#endif + +#endif /* __linux__ */ + +/* + * log_id_t helpers + */ +log_id_t android_name_to_log_id(const char* logName); +const char* android_log_id_to_name(log_id_t log_id); + +/* --------------------------------------------------------------------- */ + #ifndef __ANDROID_USE_LIBLOG_EVENT_INTERFACE #ifndef __ANDROID_API__ #define __ANDROID_USE_LIBLOG_EVENT_INTERFACE 1 @@ -405,6 +853,124 @@ android_log_list_element android_log_peek_next(android_log_context ctx); /* Finished with reader or writer context */ int android_log_destroy(android_log_context* ctx); +#ifdef __cplusplus +#ifndef __class_android_log_event_context +#define __class_android_log_event_context +/* android_log_context C++ helpers */ +extern "C++" { +class android_log_event_context { + android_log_context ctx; + int ret; + + android_log_event_context(const android_log_event_context&) = delete; + void operator =(const android_log_event_context&) = delete; + +public: + explicit android_log_event_context(int tag) : ret(0) { + ctx = create_android_logger(static_cast(tag)); + } + explicit android_log_event_context(log_msg& log_msg) : ret(0) { + ctx = create_android_log_parser(log_msg.msg() + sizeof(uint32_t), + log_msg.entry.len - sizeof(uint32_t)); + } + ~android_log_event_context() { android_log_destroy(&ctx); } + + int close() { + int retval = android_log_destroy(&ctx); + if (retval < 0) ret = retval; + return retval; + } + + /* To allow above C calls to use this class as parameter */ + operator android_log_context() const { return ctx; } + + int status() const { return ret; } + + int begin() { + int retval = android_log_write_list_begin(ctx); + if (retval < 0) ret = retval; + return ret; + } + int end() { + int retval = android_log_write_list_end(ctx); + if (retval < 0) ret = retval; + return ret; + } + + android_log_event_context& operator <<(int32_t value) { + int retval = android_log_write_int32(ctx, value); + if (retval < 0) ret = retval; + return *this; + } + android_log_event_context& operator <<(uint32_t value) { + int retval = android_log_write_int32(ctx, static_cast(value)); + if (retval < 0) ret = retval; + return *this; + } + android_log_event_context& operator <<(int64_t value) { + int retval = android_log_write_int64(ctx, value); + if (retval < 0) ret = retval; + return *this; + } + android_log_event_context& operator <<(uint64_t value) { + int retval = android_log_write_int64(ctx, static_cast(value)); + if (retval < 0) ret = retval; + return *this; + } + android_log_event_context& operator <<(const char* value) { + int retval = android_log_write_string8(ctx, value); + if (retval < 0) ret = retval; + return *this; + } +#if defined(_USING_LIBCXX) + android_log_event_context& operator <<(const std::string& value) { + int retval = android_log_write_string8_len(ctx, + value.data(), + value.length()); + if (retval < 0) ret = retval; + return *this; + } +#endif + android_log_event_context& operator <<(float value) { + int retval = android_log_write_float32(ctx, value); + if (retval < 0) ret = retval; + return *this; + } + + int write(log_id_t id = LOG_ID_EVENTS) { + int retval = android_log_write_list(ctx, id); + if (retval < 0) ret = retval; + return ret; + } + + int operator <<(log_id_t id) { + int retval = android_log_write_list(ctx, id); + if (retval < 0) ret = retval; + android_log_destroy(&ctx); + return ret; + } + + /* + * Append should be a lesser-used interface, but adds + * access to string with length. So we offer all types. + */ + template + bool Append(Tvalue value) { *this << value; return ret >= 0; } + + bool Append(const char* value, size_t len) { + int retval = android_log_write_string8_len(ctx, value, len); + if (retval < 0) ret = retval; + return ret >= 0; + } + + android_log_list_element read() { return android_log_read_next(ctx); } + android_log_list_element peek() { return android_log_peek_next(ctx); } + +}; +} +#endif +#endif + #endif /* __ANDROID_USE_LIBLOG_EVENT_INTERFACE */ /* --------------------------------------------------------------------- */ diff --git a/include/log/logger.h b/include/log/logger.h index 65b38de8d..0e0248e50 100644 --- a/include/log/logger.h +++ b/include/log/logger.h @@ -1,462 +1 @@ -/* -** -** Copyright 2007-2014, The Android Open Source Project -** -** This file is dual licensed. It may be redistributed and/or modified -** under the terms of the Apache 2.0 License OR version 2 of the GNU -** General Public License. -*/ - -#ifndef _LIBS_LOG_LOGGER_H -#define _LIBS_LOG_LOGGER_H - -#include -#include - -#ifdef __cplusplus -#include -#endif - #include - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * The userspace structure for version 1 of the logger_entry ABI. - * This structure is returned to userspace by the kernel logger - * driver unless an upgrade to a newer ABI version is requested. - */ -struct logger_entry { - uint16_t len; /* length of the payload */ - uint16_t __pad; /* no matter what, we get 2 bytes of padding */ - int32_t pid; /* generating process's pid */ - int32_t tid; /* generating process's tid */ - int32_t sec; /* seconds since Epoch */ - int32_t nsec; /* nanoseconds */ - char msg[0]; /* the entry's payload */ -} __attribute__((__packed__)); - -/* - * The userspace structure for version 2 of the logger_entry ABI. - * This structure is returned to userspace if ioctl(LOGGER_SET_VERSION) - * is called with version==2; or used with the user space log daemon. - */ -struct logger_entry_v2 { - uint16_t len; /* length of the payload */ - uint16_t hdr_size; /* sizeof(struct logger_entry_v2) */ - int32_t pid; /* generating process's pid */ - int32_t tid; /* generating process's tid */ - int32_t sec; /* seconds since Epoch */ - int32_t nsec; /* nanoseconds */ - uint32_t euid; /* effective UID of logger */ - char msg[0]; /* the entry's payload */ -} __attribute__((__packed__)); - -struct logger_entry_v3 { - uint16_t len; /* length of the payload */ - uint16_t hdr_size; /* sizeof(struct logger_entry_v3) */ - int32_t pid; /* generating process's pid */ - int32_t tid; /* generating process's tid */ - int32_t sec; /* seconds since Epoch */ - int32_t nsec; /* nanoseconds */ - uint32_t lid; /* log id of the payload */ - char msg[0]; /* the entry's payload */ -} __attribute__((__packed__)); - -struct logger_entry_v4 { - uint16_t len; /* length of the payload */ - uint16_t hdr_size; /* sizeof(struct logger_entry_v4) */ - int32_t pid; /* generating process's pid */ - uint32_t tid; /* generating process's tid */ - uint32_t sec; /* seconds since Epoch */ - uint32_t nsec; /* nanoseconds */ - uint32_t lid; /* log id of the payload, bottom 4 bits currently */ - uint32_t uid; /* generating process's uid */ - char msg[0]; /* the entry's payload */ -} __attribute__((__packed__)); - -/* struct log_time is a wire-format variant of struct timespec */ -#define NS_PER_SEC 1000000000ULL - -#ifdef __cplusplus - -// NB: do NOT define a copy constructor. This will result in structure -// no longer being compatible with pass-by-value which is desired -// efficient behavior. Also, pass-by-reference breaks C/C++ ABI. -struct log_time { -public: - uint32_t tv_sec; // good to Feb 5 2106 - uint32_t tv_nsec; - - static const uint32_t tv_sec_max = 0xFFFFFFFFUL; - static const uint32_t tv_nsec_max = 999999999UL; - - log_time(const timespec &T) - { - tv_sec = T.tv_sec; - tv_nsec = T.tv_nsec; - } - log_time(uint32_t sec, uint32_t nsec) - { - tv_sec = sec; - tv_nsec = nsec; - } - static const timespec EPOCH; - log_time() - { - } -#ifdef __linux__ - log_time(clockid_t id) - { - timespec T; - clock_gettime(id, &T); - tv_sec = T.tv_sec; - tv_nsec = T.tv_nsec; - } -#endif - log_time(const char *T) - { - const uint8_t *c = (const uint8_t *) T; - tv_sec = c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24); - tv_nsec = c[4] | (c[5] << 8) | (c[6] << 16) | (c[7] << 24); - } - - // timespec - bool operator== (const timespec &T) const - { - return (tv_sec == static_cast(T.tv_sec)) - && (tv_nsec == static_cast(T.tv_nsec)); - } - bool operator!= (const timespec &T) const - { - return !(*this == T); - } - bool operator< (const timespec &T) const - { - return (tv_sec < static_cast(T.tv_sec)) - || ((tv_sec == static_cast(T.tv_sec)) - && (tv_nsec < static_cast(T.tv_nsec))); - } - bool operator>= (const timespec &T) const - { - return !(*this < T); - } - bool operator> (const timespec &T) const - { - return (tv_sec > static_cast(T.tv_sec)) - || ((tv_sec == static_cast(T.tv_sec)) - && (tv_nsec > static_cast(T.tv_nsec))); - } - bool operator<= (const timespec &T) const - { - return !(*this > T); - } - log_time operator-= (const timespec &T); - log_time operator- (const timespec &T) const - { - log_time local(*this); - return local -= T; - } - log_time operator+= (const timespec &T); - log_time operator+ (const timespec &T) const - { - log_time local(*this); - return local += T; - } - - // log_time - bool operator== (const log_time &T) const - { - return (tv_sec == T.tv_sec) && (tv_nsec == T.tv_nsec); - } - bool operator!= (const log_time &T) const - { - return !(*this == T); - } - bool operator< (const log_time &T) const - { - return (tv_sec < T.tv_sec) - || ((tv_sec == T.tv_sec) && (tv_nsec < T.tv_nsec)); - } - bool operator>= (const log_time &T) const - { - return !(*this < T); - } - bool operator> (const log_time &T) const - { - return (tv_sec > T.tv_sec) - || ((tv_sec == T.tv_sec) && (tv_nsec > T.tv_nsec)); - } - bool operator<= (const log_time &T) const - { - return !(*this > T); - } - log_time operator-= (const log_time &T); - log_time operator- (const log_time &T) const - { - log_time local(*this); - return local -= T; - } - log_time operator+= (const log_time &T); - log_time operator+ (const log_time &T) const - { - log_time local(*this); - return local += T; - } - - uint64_t nsec() const - { - return static_cast(tv_sec) * NS_PER_SEC + tv_nsec; - } - - static const char default_format[]; - - // Add %#q for the fraction of a second to the standard library functions - char *strptime(const char *s, const char *format = default_format); -} __attribute__((__packed__)); - -#else - -typedef struct log_time { - uint32_t tv_sec; - uint32_t tv_nsec; -} __attribute__((__packed__)) log_time; - -#endif - -/* - * The maximum size of the log entry payload that can be - * written to the logger. An attempt to write more than - * this amount will result in a truncated log entry. - */ -#define LOGGER_ENTRY_MAX_PAYLOAD 4068 - -/* - * The maximum size of a log entry which can be read from the - * kernel logger driver. An attempt to read less than this amount - * may result in read() returning EINVAL. - */ -#define LOGGER_ENTRY_MAX_LEN (5*1024) - -struct log_msg { - union { - unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1]; - struct logger_entry_v4 entry; - struct logger_entry_v4 entry_v4; - struct logger_entry_v3 entry_v3; - struct logger_entry_v2 entry_v2; - struct logger_entry entry_v1; - } __attribute__((aligned(4))); -#ifdef __cplusplus - /* Matching log_time operators */ - bool operator== (const log_msg &T) const - { - return (entry.sec == T.entry.sec) && (entry.nsec == T.entry.nsec); - } - bool operator!= (const log_msg &T) const - { - return !(*this == T); - } - bool operator< (const log_msg &T) const - { - return (entry.sec < T.entry.sec) - || ((entry.sec == T.entry.sec) - && (entry.nsec < T.entry.nsec)); - } - bool operator>= (const log_msg &T) const - { - return !(*this < T); - } - bool operator> (const log_msg &T) const - { - return (entry.sec > T.entry.sec) - || ((entry.sec == T.entry.sec) - && (entry.nsec > T.entry.nsec)); - } - bool operator<= (const log_msg &T) const - { - return !(*this > T); - } - uint64_t nsec() const - { - return static_cast(entry.sec) * NS_PER_SEC + entry.nsec; - } - - /* packet methods */ - log_id_t id() - { - return (log_id_t) entry.lid; - } - char *msg() - { - unsigned short hdr_size = entry.hdr_size; - if (!hdr_size) { - hdr_size = sizeof(entry_v1); - } - if ((hdr_size < sizeof(entry_v1)) || (hdr_size > sizeof(entry))) { - return NULL; - } - return (char *) buf + hdr_size; - } - unsigned int len() - { - return (entry.hdr_size ? entry.hdr_size : sizeof(entry_v1)) + entry.len; - } -#endif -}; - -struct logger; - -log_id_t android_logger_get_id(struct logger *logger); - -int android_logger_clear(struct logger *logger); -long android_logger_get_log_size(struct logger *logger); -int android_logger_set_log_size(struct logger *logger, unsigned long size); -long android_logger_get_log_readable_size(struct logger *logger); -int android_logger_get_log_version(struct logger *logger); - -struct logger_list; - -ssize_t android_logger_get_statistics(struct logger_list *logger_list, - char *buf, size_t len); -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, - 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 -#define ANDROID_LOG_NONBLOCK O_NONBLOCK -#define ANDROID_LOG_WRAP 0x40000000 /* Block until buffer about to wrap */ -#define ANDROID_LOG_WRAP_DEFAULT_TIMEOUT 7200 /* 2 hour default */ -#define ANDROID_LOG_PSTORE 0x80000000 - -struct logger_list *android_logger_list_alloc(int mode, - unsigned int tail, - pid_t pid); -struct logger_list *android_logger_list_alloc_time(int mode, - log_time start, - pid_t pid); -void android_logger_list_free(struct logger_list *logger_list); -/* In the purest sense, the following two are orthogonal interfaces */ -int android_logger_list_read(struct logger_list *logger_list, - struct log_msg *log_msg); - -/* Multiple log_id_t opens */ -struct logger *android_logger_open(struct logger_list *logger_list, - log_id_t id); -#define android_logger_close android_logger_free -/* Single log_id_t open */ -struct logger_list *android_logger_list_open(log_id_t id, - int mode, - unsigned int tail, - pid_t pid); -#define android_logger_list_close android_logger_list_free - -#ifdef __linux__ -clockid_t android_log_clockid(); -#endif - -/* - * log_id_t helpers - */ -log_id_t android_name_to_log_id(const char *logName); -const char *android_log_id_to_name(log_id_t log_id); - -#ifdef __cplusplus -// android_log_context C++ helpers -class android_log_event_context { - android_log_context ctx; - int ret; - -public: - explicit android_log_event_context(int tag) : ret(0) { - ctx = create_android_logger(tag); - } - explicit android_log_event_context(log_msg& log_msg) : ret(0) { - ctx = create_android_log_parser(log_msg.msg() + sizeof(uint32_t), - log_msg.entry.len - sizeof(uint32_t)); - } - ~android_log_event_context() { android_log_destroy(&ctx); } - - int close() { - int retval = android_log_destroy(&ctx); - if (retval < 0) ret = retval; - return retval; - } - - // To allow above C calls to use this class as parameter - operator android_log_context() const { return ctx; }; - - int error() const { return ret; } - - int begin() { - int retval = android_log_write_list_begin(ctx); - if (retval < 0) ret = retval; - return ret; - } - int end() { - int retval = android_log_write_list_end(ctx); - if (retval < 0) ret = retval; - return ret; - } - - android_log_event_context& operator <<(int32_t value) { - int retval = android_log_write_int32(ctx, value); - if (retval < 0) ret = retval; - return *this; - } - android_log_event_context& operator <<(uint32_t value) { - int retval = android_log_write_int32(ctx, value); - if (retval < 0) ret = retval; - return *this; - } - android_log_event_context& operator <<(int64_t value) { - int retval = android_log_write_int64(ctx, value); - if (retval < 0) ret = retval; - return *this; - } - android_log_event_context& operator <<(uint64_t value) { - int retval = android_log_write_int64(ctx, value); - if (retval < 0) ret = retval; - return *this; - } - android_log_event_context& operator <<(const char* value) { - int retval = android_log_write_string8(ctx, value); - if (retval < 0) ret = retval; - return *this; - } - android_log_event_context& operator <<(std::string& value) { - int retval = android_log_write_string8_len(ctx, - value.data(), - value.length()); - if (retval < 0) ret = retval; - return *this; - } - android_log_event_context& operator <<(float value) { - int retval = android_log_write_float32(ctx, value); - if (retval < 0) ret = retval; - return *this; - } - - int write(log_id_t id) { - int retval = android_log_write_list(ctx, id); - if (retval < 0) ret = retval; - return ret; - } - - android_log_list_element read() { return android_log_read_next(ctx); } - android_log_list_element peak() { return android_log_peek_next(ctx); } - -}; -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* _LIBS_LOG_LOGGER_H */ diff --git a/include/log/logprint.h b/include/log/logprint.h index e5cd1de7a..493f9f856 100644 --- a/include/log/logprint.h +++ b/include/log/logprint.h @@ -21,7 +21,6 @@ #include #include -#include /* struct logger_entry */ #ifdef __cplusplus extern "C" { @@ -58,24 +57,24 @@ typedef struct AndroidLogEntry_t { int32_t uid; int32_t pid; int32_t tid; - const char * tag; + const char* tag; size_t tagLen; size_t messageLen; - const char * message; + const char* message; } AndroidLogEntry; -AndroidLogFormat *android_log_format_new(); +AndroidLogFormat* android_log_format_new(); -void android_log_format_free(AndroidLogFormat *p_format); +void android_log_format_free(AndroidLogFormat* p_format); /* currently returns 0 if format is a modifier, 1 if not */ -int android_log_setPrintFormat(AndroidLogFormat *p_format, +int android_log_setPrintFormat(AndroidLogFormat* p_format, AndroidLogPrintFormat format); /** * Returns FORMAT_OFF on invalid string */ -AndroidLogPrintFormat android_log_formatFromString(const char *s); +AndroidLogPrintFormat android_log_formatFromString(const char* s); /** * filterExpression: a single filter expression @@ -87,9 +86,8 @@ AndroidLogPrintFormat android_log_formatFromString(const char *s); * */ -int android_log_addFilterRule(AndroidLogFormat *p_format, - const char *filterExpression); - +int android_log_addFilterRule(AndroidLogFormat* p_format, + const char* filterExpression); /** * filterString: a whitespace-separated set of filter expressions @@ -101,17 +99,15 @@ int android_log_addFilterRule(AndroidLogFormat *p_format, * */ -int android_log_addFilterString(AndroidLogFormat *p_format, - const char *filterString); - +int android_log_addFilterString(AndroidLogFormat* p_format, + const char* filterString); /** * returns 1 if this log line should be printed based on its priority * and tag, and 0 if it should not */ int android_log_shouldPrintLine ( - AndroidLogFormat *p_format, const char *tag, android_LogPriority pri); - + AndroidLogFormat* p_format, const char* tag, android_LogPriority pri); /** * Splits a wire-format buffer into an AndroidLogEntry @@ -120,8 +116,8 @@ int android_log_shouldPrintLine ( * Returns 0 on success and -1 on invalid wire format (entry will be * in unspecified state) */ -int android_log_processLogBuffer(struct logger_entry *buf, - AndroidLogEntry *entry); +int android_log_processLogBuffer(struct logger_entry* buf, + AndroidLogEntry* entry); /** * Like android_log_processLogBuffer, but for binary logs. @@ -129,11 +125,10 @@ int android_log_processLogBuffer(struct logger_entry *buf, * If "map" is non-NULL, it will be used to convert the log tag number * into a string. */ -int android_log_processBinaryLogBuffer(struct logger_entry *buf, - AndroidLogEntry *entry, const EventTagMap* map, char* messageBuf, +int android_log_processBinaryLogBuffer(struct logger_entry* buf, + AndroidLogEntry* entry, const EventTagMap* map, char* messageBuf, int messageBufLen); - /** * Formats a log message into a buffer * @@ -142,13 +137,12 @@ int android_log_processBinaryLogBuffer(struct logger_entry *buf, * Returns NULL on malloc error */ -char *android_log_formatLogLine ( - AndroidLogFormat *p_format, - char *defaultBuffer, +char* android_log_formatLogLine ( + AndroidLogFormat* p_format, + char* defaultBuffer, size_t defaultBufferSize, - const AndroidLogEntry *p_line, - size_t *p_outLength); - + const AndroidLogEntry* p_line, + size_t* p_outLength); /** * Either print or do not print log line, based on filter @@ -157,14 +151,12 @@ char *android_log_formatLogLine ( * */ int android_log_printLogLine( - AndroidLogFormat *p_format, + AndroidLogFormat* p_format, int fd, - const AndroidLogEntry *entry); - + const AndroidLogEntry* entry); #ifdef __cplusplus } #endif - #endif /*_LOGPRINT_H*/ diff --git a/include/private/android_logger.h b/include/private/android_logger.h index 02764d3d3..f3c6cf72d 100644 --- a/include/private/android_logger.h +++ b/include/private/android_logger.h @@ -25,8 +25,7 @@ #include #include -#include -#include /* log_time */ +#include #define LOGGER_MAGIC 'l' @@ -110,8 +109,8 @@ typedef struct __attribute__((__packed__)) { ssize_t __android_log_pmsg_file_write( log_id_t logId, char prio, - const char *filename, - const char *buf, size_t len); + const char* filename, + const char* buf, size_t len); #define LOG_ID_ANY ((log_id_t)-1) #define ANDROID_LOG_ANY ANDROID_LOG_UNKNOWN @@ -120,15 +119,15 @@ ssize_t __android_log_pmsg_file_write( typedef ssize_t (*__android_log_pmsg_file_read_fn)( log_id_t logId, char prio, - const char *filename, - const char *buf, size_t len, void *arg); + const char* filename, + const char* buf, size_t len, void* arg); ssize_t __android_log_pmsg_file_read( - log_id_t logId, char prio, const char *prefix, - __android_log_pmsg_file_read_fn fn, void *arg); + log_id_t logId, char prio, const char* prefix, + __android_log_pmsg_file_read_fn fn, void* arg); -int __android_log_security_bwrite(int32_t tag, const void *payload, size_t len); -int __android_log_security_bswrite(int32_t tag, const char *payload); +int __android_log_security_bwrite(int32_t tag, const void* payload, size_t len); +int __android_log_security_bswrite(int32_t tag, const char* payload); int __android_log_security(); /* Device Owner is present */ int __android_log_is_debuggable(); @@ -139,7 +138,7 @@ int __android_log_is_debuggable(); #define BOOL_DEFAULT_FLAG_PERSIST 0x2 /* , persist., ro. */ #define BOOL_DEFAULT_FLAG_ENG 0x4 /* off for user */ #define BOOL_DEFAULT_FLAG_SVELTE 0x8 /* off for low_ram */ -bool __android_logger_property_get_bool(const char *key, int flag); +bool __android_logger_property_get_bool(const char* key, int flag); #define LOG_BUFFER_SIZE (256 * 1024) /* Tuned with ro.logd.size per-platform */ #define LOG_BUFFER_MIN_SIZE (64 * 1024UL) diff --git a/liblog/README b/liblog/README index dd378325a..610338c2f 100644 --- a/liblog/README +++ b/liblog/README @@ -62,9 +62,7 @@ SYNOPSIS LOG_EVENT_INT(tag, value) LOG_EVENT_LONG(tag, value) - Link with -llog - - #include + clockid_t android_log_clockid() log_id_t android_logger_get_id(struct logger *logger) int android_logger_clear(struct logger *logger) diff --git a/liblog/log_time.cpp b/liblog/log_time.cpp index c8bd27d2d..dfd2d443a 100644 --- a/liblog/log_time.cpp +++ b/liblog/log_time.cpp @@ -19,7 +19,7 @@ #include #include -#include +#include #include "log_portability.h" diff --git a/liblog/logger.h b/liblog/logger.h index fb477868d..50d1cb441 100644 --- a/liblog/logger.h +++ b/liblog/logger.h @@ -20,9 +20,8 @@ #include #include -#include #include -#include +#include #include #include "log_portability.h" diff --git a/liblog/logger_name.c b/liblog/logger_name.c index 12e263a04..5c4feaf32 100644 --- a/liblog/logger_name.c +++ b/liblog/logger_name.c @@ -16,8 +16,7 @@ #include -#include -#include +#include #include "log_portability.h" diff --git a/liblog/logprint.c b/liblog/logprint.c index f9b14bd6e..1ff71363c 100644 --- a/liblog/logprint.c +++ b/liblog/logprint.c @@ -31,9 +31,8 @@ #include #include -#include #include -#include +#include #include #include "log_portability.h" diff --git a/logcat/logcat.cpp b/logcat/logcat.cpp index d1a23ae31..51d1a3afa 100644 --- a/logcat/logcat.cpp +++ b/logcat/logcat.cpp @@ -25,15 +25,14 @@ #include #include -#include #include #include #include #include #include #include -#include #include +#include #include #include diff --git a/logcat/tests/logcat_test.cpp b/logcat/tests/logcat_test.cpp index 66800b15e..1baaf11cc 100644 --- a/logcat/tests/logcat_test.cpp +++ b/logcat/tests/logcat_test.cpp @@ -26,9 +26,8 @@ #include -#include #include -#include +#include #define BIG_BUFFER (5 * 1024) diff --git a/logd/FlushCommand.h b/logd/FlushCommand.h index a6cdf9dc2..1e7818a97 100644 --- a/logd/FlushCommand.h +++ b/logd/FlushCommand.h @@ -16,7 +16,7 @@ #ifndef _FLUSH_COMMAND_H #define _FLUSH_COMMAND_H -#include +#include #include class LogBufferElement; diff --git a/logd/LogBufferElement.h b/logd/LogBufferElement.h index f08955093..2c7fd448d 100644 --- a/logd/LogBufferElement.h +++ b/logd/LogBufferElement.h @@ -21,9 +21,8 @@ #include #include -#include +#include #include -#include class LogBuffer; diff --git a/logd/LogKlog.cpp b/logd/LogKlog.cpp index ef6c1ae2c..fe0884600 100644 --- a/logd/LogKlog.cpp +++ b/logd/LogKlog.cpp @@ -25,7 +25,7 @@ #include #include -#include +#include #include #include "LogBuffer.h" diff --git a/logd/LogKlog.h b/logd/LogKlog.h index 6e150e72a..d81243688 100644 --- a/logd/LogKlog.h +++ b/logd/LogKlog.h @@ -17,7 +17,7 @@ #ifndef _LOGD_LOG_KLOG_H__ #define _LOGD_LOG_KLOG_H__ -#include +#include #include char *log_strntok_r(char *s, size_t *len, char **saveptr, size_t *sublen); diff --git a/logd/LogReader.cpp b/logd/LogReader.cpp index 2c07984ce..61d4c49f3 100644 --- a/logd/LogReader.cpp +++ b/logd/LogReader.cpp @@ -21,6 +21,7 @@ #include #include +#include #include "FlushCommand.h" #include "LogBuffer.h" diff --git a/logd/LogStatistics.cpp b/logd/LogStatistics.cpp index f69bc5046..d68bfee99 100644 --- a/logd/LogStatistics.cpp +++ b/logd/LogStatistics.cpp @@ -23,7 +23,7 @@ #include -#include +#include #include "LogStatistics.h" diff --git a/logd/LogTimes.h b/logd/LogTimes.h index 84019533d..12df994af 100644 --- a/logd/LogTimes.h +++ b/logd/LogTimes.h @@ -23,7 +23,7 @@ #include -#include +#include #include class LogReader; diff --git a/logd/LogUtils.h b/logd/LogUtils.h index d6b3dc695..44ac742f0 100644 --- a/logd/LogUtils.h +++ b/logd/LogUtils.h @@ -20,8 +20,8 @@ #include #include +#include #include -#include // Hijack this header as a common include file used by most all sources // to report some utilities defined here and there. diff --git a/logd/tests/logd_test.cpp b/logd/tests/logd_test.cpp index cac8bce93..e0a4cc34b 100644 --- a/logd/tests/logd_test.cpp +++ b/logd/tests/logd_test.cpp @@ -23,11 +23,10 @@ #include -#include #include #include #include -#include +#include #include "../LogReader.h" // pickup LOGD_SNDTIMEO