tequilaOS/platform_system_core
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

liblog: logd: logcat: Split out log/logger.h into public and private. am: aeaaf81c2c am: 28fcac705b am: df8ca4c0cf

Browse source 
am: 003248a984

Change-Id: I3b6a45c965c814493b7080415f4b3fc2678df3db
This commit is contained in:
Mark Salyzyn 2016-10-24 23:04:41 +00:00 committed by android-build-merger
commit de3ae8cfc0
20 changed files with 614 additions and 526 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

566
include/log/log.h
View file

@ -29,6 +29,12 @@
#include <log/uio.h> /* helper to define iovec for portability */
#if (defined(__cplusplus) && defined(_USING_LIBCXX))
extern "C++" {
#include <string>
}
#endif
#include <android/log.h>
#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<uint32_t>(T.tv_sec);
tv_nsec = static_cast<uint32_t>(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<uint32_t>(T.tv_sec);
tv_nsec = static_cast<uint32_t>(T.tv_nsec);
}
#endif
log_time(const char* T)
{
const uint8_t* c = reinterpret_cast<const uint8_t*>(T);
tv_sec = c[0] |
(static_cast<uint32_t>(c[1]) << 8) |
(static_cast<uint32_t>(c[2]) << 16) |
(static_cast<uint32_t>(c[3]) << 24);
tv_nsec = c[4] |
(static_cast<uint32_t>(c[5]) << 8) |
(static_cast<uint32_t>(c[6]) << 16) |
(static_cast<uint32_t>(c[7]) << 24);
}
/* timespec */
bool operator== (const timespec& T) const
{
return (tv_sec == static_cast<uint32_t>(T.tv_sec))
&& (tv_nsec == static_cast<uint32_t>(T.tv_nsec));
}
bool operator!= (const timespec& T) const
{
return !(*this == T);
}
bool operator< (const timespec& T) const
{
return (tv_sec < static_cast<uint32_t>(T.tv_sec))
|| ((tv_sec == static_cast<uint32_t>(T.tv_sec))
&& (tv_nsec < static_cast<uint32_t>(T.tv_nsec)));
}
bool operator>= (const timespec& T) const
{
return !(*this < T);
}
bool operator> (const timespec& T) const
{
return (tv_sec > static_cast<uint32_t>(T.tv_sec))
|| ((tv_sec == static_cast<uint32_t>(T.tv_sec))
&& (tv_nsec > static_cast<uint32_t>(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<uint64_t>(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<uint64_t>(entry.sec) * NS_PER_SEC + entry.nsec;
}
/* packet methods */
log_id_t id()
{
return static_cast<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 reinterpret_cast<char*>(buf) + hdr_size;
}
unsigned int len()
{
return (entry.hdr_size ?
entry.hdr_size :
static_cast<uint16_t>(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<uint32_t>(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<int32_t>(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<int64_t>(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 <typename Tvalue>
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 */
/* --------------------------------------------------------------------- */

461
include/log/logger.h
View file

@ -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 <stdint.h>
#include <time.h>
#ifdef __cplusplus
#include <string>
#endif
#include <log/log.h>
#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<uint32_t>(T.tv_sec))
&& (tv_nsec == static_cast<uint32_t>(T.tv_nsec));
}
bool operator!= (const timespec &T) const
{
return !(*this == T);
}
bool operator< (const timespec &T) const
{
return (tv_sec < static_cast<uint32_t>(T.tv_sec))
|| ((tv_sec == static_cast<uint32_t>(T.tv_sec))
&& (tv_nsec < static_cast<uint32_t>(T.tv_nsec)));
}
bool operator>= (const timespec &T) const
{
return !(*this < T);
}
bool operator> (const timespec &T) const
{
return (tv_sec > static_cast<uint32_t>(T.tv_sec))
|| ((tv_sec == static_cast<uint32_t>(T.tv_sec))
&& (tv_nsec > static_cast<uint32_t>(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<uint64_t>(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<uint64_t>(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 */

52
include/log/logprint.h
View file

@ -21,7 +21,6 @@
#include <android/log.h>
#include <log/event_tag_map.h>
#include <log/logger.h> /* 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*/

21
include/private/android_logger.h
View file

@ -25,8 +25,7 @@
#include <stdint.h>
#include <sys/types.h>
#include <android/log.h>
#include <log/logger.h> /* log_time */
#include <log/log.h>
#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 /* <key>, persist.<key>, ro.<key> */
#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)

4
liblog/README
View file

@ -62,9 +62,7 @@ SYNOPSIS
LOG_EVENT_INT(tag, value)
LOG_EVENT_LONG(tag, value)
Link with -llog
#include <log/logger.h>
clockid_t android_log_clockid()
log_id_t android_logger_get_id(struct logger *logger)
int android_logger_clear(struct logger *logger)

2
liblog/log_time.cpp
View file

@ -19,7 +19,7 @@
#include <stdio.h>
#include <string.h>
#include <log/logger.h>
#include <private/android_logger.h>
#include "log_portability.h"

3
liblog/logger.h
View file

@ -20,9 +20,8 @@
#include <stdatomic.h>
#include <stdbool.h>
#include <android/log.h>
#include <cutils/list.h>
#include <log/logger.h>
#include <log/log.h>
#include <log/uio.h>
#include "log_portability.h"

3
liblog/logger_name.c
View file

@ -16,8 +16,7 @@
#include <string.h>
#include <android/log.h>
#include <log/logger.h>
#include <log/log.h>
#include "log_portability.h"

3
liblog/logprint.c
View file

@ -31,9 +31,8 @@
#include <sys/param.h>
#include <sys/types.h>
#include <android/log.h>
#include <cutils/list.h>
#include <log/logger.h>
#include <log/log.h>
#include <log/logprint.h>
#include "log_portability.h"

3
logcat/logcat.cpp
View file

@ -25,15 +25,14 @@
#include <memory>
#include <string>
#include <android/log.h>
#include <android-base/file.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <cutils/sched_policy.h>
#include <cutils/sockets.h>
#include <log/event_tag_map.h>
#include <log/logger.h>
#include <log/logprint.h>
#include <private/android_logger.h>
#include <system/thread_defs.h>
#include <pcrecpp.h>

3
logcat/tests/logcat_test.cpp
View file

@ -26,9 +26,8 @@
#include <memory>
#include <android/log.h>
#include <gtest/gtest.h>
#include <log/logger.h>
#include <log/log.h>
#define BIG_BUFFER (5 * 1024)

2
logd/FlushCommand.h
View file

@ -16,7 +16,7 @@
#ifndef _FLUSH_COMMAND_H
#define _FLUSH_COMMAND_H
#include <log/logger.h>
#include <android/log.h>
#include <sysutils/SocketClientCommand.h>
class LogBufferElement;

3
logd/LogBufferElement.h
View file

@ -21,9 +21,8 @@
#include <stdlib.h>
#include <sys/types.h>
#include <android/log.h>
#include <log/log.h>
#include <sysutils/SocketClient.h>
#include <log/logger.h>
class LogBuffer;

2
logd/LogKlog.cpp
View file

@ -25,7 +25,7 @@
#include <sys/uio.h>
#include <syslog.h>
#include <log/logger.h>
#include <private/android_logger.h>
#include <private/android_filesystem_config.h>
#include "LogBuffer.h"

2
logd/LogKlog.h
View file

@ -17,7 +17,7 @@
#ifndef _LOGD_LOG_KLOG_H__
#define _LOGD_LOG_KLOG_H__
#include <log/logger.h>
#include <private/android_logger.h>
#include <sysutils/SocketListener.h>
char *log_strntok_r(char *s, size_t *len, char **saveptr, size_t *sublen);

1
logd/LogReader.cpp
View file

@ -21,6 +21,7 @@
#include <sys/types.h>
#include <cutils/sockets.h>
#include <private/android_logger.h>
#include "FlushCommand.h"
#include "LogBuffer.h"

2
logd/LogStatistics.cpp
View file

@ -23,7 +23,7 @@
#include <list>
#include <log/logger.h>
#include <android/log.h>
#include "LogStatistics.h"

2
logd/LogTimes.h
View file

@ -23,7 +23,7 @@
#include <list>
#include <android/log.h>
#include <log/log.h>
#include <sysutils/SocketClient.h>
class LogReader;

2
logd/LogUtils.h
View file

@ -20,8 +20,8 @@
#include <sys/cdefs.h>
#include <sys/types.h>
#include <private/android_logger.h>
#include <sysutils/SocketClient.h>
#include <log/log.h>
// Hijack this header as a common include file used by most all sources
// to report some utilities defined here and there.

3
logd/tests/logd_test.cpp
View file

@ -23,11 +23,10 @@
#include <string>
#include <android/log.h>
#include <android-base/stringprintf.h>
#include <cutils/sockets.h>
#include <gtest/gtest.h>
#include <log/logger.h>
#include <log/log.h>
#include "../LogReader.h" // pickup LOGD_SNDTIMEO