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

Merge changes I8c58d6bd,I0a19fd87 

* changes:
  bootstat: drop event_log_list_builder
  liblog: logd: logcat: Split out log/logger.h into public and private.
This commit is contained in:
Treehugger Robot 2016-10-24 22:49:29 +00:00 committed by Gerrit Code Review
parent 63660add3f 343b76e449
commit 291fd678e5
26 changed files with 616 additions and 834 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bootstat/Android.bp
View File

@ -16,7 +16,6 @@
bootstat_lib_src_files = [
"boot_event_record_store.cpp",
"event_log_list_builder.cpp",
"histogram_logger.cpp",
"uptime_parser.cpp",
]
@ -88,7 +87,6 @@ cc_test {
],
srcs: [
"boot_event_record_store_test.cpp",
"event_log_list_builder_test.cpp",
"testrunner.cpp",
],
}

1
bootstat/bootstat.cpp
View File

@ -35,7 +35,6 @@
#include <cutils/properties.h>
#include "boot_event_record_store.h"
#include "event_log_list_builder.h" /* ToDo: switch to liblog implementation */
#include "histogram_logger.h"
#include "uptime_parser.h"

108
bootstat/event_log_list_builder.cpp
View File

@ -1,108 +0,0 @@
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "event_log_list_builder.h"
#include <cinttypes>
#include <memory>
#include <string>
#include <log/log.h>
#include <android-base/logging.h>
namespace {
const size_t MAX_EVENT_PAYLOAD_SIZE = 512 - 1; // Leave room for final '\n'.
const size_t EVENT_TYPE_SIZE = 1; // Size in bytes of the event type marker.
} // namespace
EventLogListBuilder::EventLogListBuilder()
: payload_count_(0),
payload_size_(0),
payload_(std::make_unique<uint8_t[]>(MAX_EVENT_PAYLOAD_SIZE)) {
memset(payload_.get(), 0, MAX_EVENT_PAYLOAD_SIZE);
// Set up the top-level EventLog data type.
AppendByte(EVENT_TYPE_LIST);
// Skip over the byte prepresenting the number of items in the list. This
// value is set in Release().
payload_size_++;
}
bool EventLogListBuilder::Append(int value) {
DCHECK_NE(static_cast<uint8_t*>(nullptr), payload_.get());
if (!IsSpaceAvailable(sizeof(value) + EVENT_TYPE_SIZE)) {
return false;
}
AppendByte(EVENT_TYPE_INT);
AppendData(&value, sizeof(value));
payload_count_++;
return true;
}
bool EventLogListBuilder::Append(const std::string& value) {
DCHECK_NE(static_cast<uint8_t*>(nullptr), payload_.get());
int len = value.length();
if (!IsSpaceAvailable(sizeof(len) + len)) {
return false;
}
AppendByte(EVENT_TYPE_STRING);
AppendData(&len, sizeof(len));
AppendData(value.c_str(), len);
payload_count_++;
return true;
}
void EventLogListBuilder::Release(std::unique_ptr<uint8_t[]>* log,
size_t* size) {
// Finalize the log payload.
payload_[1] = payload_count_;
// Return the log payload.
*size = payload_size_;
*log = std::move(payload_);
}
void EventLogListBuilder::AppendData(const void* data, size_t size) {
DCHECK_LT(payload_size_ + size, MAX_EVENT_PAYLOAD_SIZE);
memcpy(&payload_[payload_size_], data, size);
payload_size_ += size;
}
void EventLogListBuilder::AppendByte(uint8_t byte) {
DCHECK_LT(payload_size_ + sizeof(byte), MAX_EVENT_PAYLOAD_SIZE);
payload_[payload_size_++] = byte;
}
bool EventLogListBuilder::IsSpaceAvailable(size_t value_size) {
size_t space_needed = value_size + EVENT_TYPE_SIZE;
if (payload_size_ + space_needed > MAX_EVENT_PAYLOAD_SIZE) {
size_t remaining = MAX_EVENT_PAYLOAD_SIZE - payload_size_;
LOG(WARNING) << "Not enough space for value. remain=" <<
remaining << "; needed=" << space_needed;
return false;
}
return true;
}

70
bootstat/event_log_list_builder.h
View File

@ -1,70 +0,0 @@
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef EVENT_LOG_LIST_BUILDER_H_
#define EVENT_LOG_LIST_BUILDER_H_
#include <cstdint>
#include <memory>
#include <android-base/macros.h>
// EventLogListBuilder provides a mechanism to build an EventLog list
// consisting of int and string EventLog values.
//
// NOTE: This class does not provide the ability to append an embedded list,
// i.e., a list containing a list.
class EventLogListBuilder {
public:
EventLogListBuilder();
// Append a single value of a specified type.
bool Append(int value);
bool Append(const std::string& value);
// Finalizes construction of the EventLog list and releases the data
// to the caller. Caller takes ownership of the payload. No further calls
// to append* may be made once the payload is acquired by the caller.
void Release(std::unique_ptr<uint8_t[]>* log, size_t* size);
private:
// Appends |data| of the given |size| to the payload.
void AppendData(const void* data, size_t size);
// Appends a single byte to the payload.
void AppendByte(uint8_t byte);
// Returns true iff the remaining capacity in |payload_| is large enough to
// accommodate |value_size| bytes. The space required to log the event type
// is included in the internal calculation so must not be passed in to
// |value_size|.
bool IsSpaceAvailable(size_t value_size);
// The number of items in the EventLog list.
size_t payload_count_;
// The size of the data stored in |payload_|. Used to track where to insert
// new data.
size_t payload_size_;
// The payload constructed by calls to log*. The payload may only contain
// MAX_EVENT_PAYLOAD (512) bytes.
std::unique_ptr<uint8_t[]> payload_;
DISALLOW_COPY_AND_ASSIGN(EventLogListBuilder);
};
#endif // EVENT_LOG_LIST_BUILDER_H_

114
bootstat/event_log_list_builder_test.cpp
View File

@ -1,114 +0,0 @@
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "event_log_list_builder.h"
#include <inttypes.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <log/log.h>
using testing::ElementsAreArray;
TEST(EventLogListBuilder, Empty) {
EventLogListBuilder builder;
const uint8_t EXPECTED_LOG[] = {
EVENT_TYPE_LIST,
0, // Number of items in the list.
};
std::unique_ptr<uint8_t[]> log;
size_t size;
builder.Release(&log, &size);
EXPECT_EQ(2U, size);
uint8_t* log_data = log.get();
EXPECT_THAT(std::vector<uint8_t>(log_data, log_data + size),
ElementsAreArray(EXPECTED_LOG));
}
TEST(EventLogListBuilder, SingleInt) {
EventLogListBuilder builder;
const uint8_t EXPECTED_LOG[] = {
EVENT_TYPE_LIST,
1, // Number of items in the list.
EVENT_TYPE_INT,
42, 0, 0, 0, // 4 byte integer value.
};
builder.Append(42);
std::unique_ptr<uint8_t[]> log;
size_t size;
builder.Release(&log, &size);
EXPECT_EQ(7U, size);
uint8_t* log_data = log.get();
EXPECT_THAT(std::vector<uint8_t>(log_data, log_data + size),
ElementsAreArray(EXPECTED_LOG));
}
TEST(EventLogListBuilder, SingleString) {
EventLogListBuilder builder;
const uint8_t EXPECTED_LOG[] = {
EVENT_TYPE_LIST,
1, // Number of items in the list.
EVENT_TYPE_STRING,
5, 0, 0, 0, // 4 byte length of the string.
'D', 'r', 'o', 'i', 'd',
};
builder.Append("Droid");
std::unique_ptr<uint8_t[]> log;
size_t size;
builder.Release(&log, &size);
EXPECT_EQ(12U, size);
uint8_t* log_data = log.get();
EXPECT_THAT(std::vector<uint8_t>(log_data, log_data + size),
ElementsAreArray(EXPECTED_LOG));
}
TEST(EventLogListBuilder, IntThenString) {
EventLogListBuilder builder;
const uint8_t EXPECTED_LOG[] = {
EVENT_TYPE_LIST,
2, // Number of items in the list.
EVENT_TYPE_INT,
42, 0, 0, 0, // 4 byte integer value.
EVENT_TYPE_STRING,
5, 0, 0, 0, // 4 byte length of the string.
'D', 'r', 'o', 'i', 'd',
};
builder.Append(42);
builder.Append("Droid");
std::unique_ptr<uint8_t[]> log;
size_t size;
builder.Release(&log, &size);
EXPECT_EQ(17U, size);
uint8_t* log_data = log.get();
EXPECT_THAT(std::vector<uint8_t>(log_data, log_data + size),
ElementsAreArray(EXPECTED_LOG));
}

15
bootstat/histogram_logger.cpp
View File

@ -17,27 +17,16 @@
#include "histogram_logger.h"
#include <cstdlib>
#include <memory>
#include <android-base/logging.h>
#include <log/log.h>
#include "event_log_list_builder.h"
namespace bootstat {
void LogHistogram(const std::string& event, int32_t data) {
LOG(INFO) << "Logging histogram: " << event << " " << data;
EventLogListBuilder log_builder;
log_builder.Append(event);
log_builder.Append(data);
std::unique_ptr<uint8_t[]> log;
size_t size;
log_builder.Release(&log, &size);
android_bWriteLog(HISTOGRAM_LOG_TAG, log.get(), size);
android_log_event_context log(HISTOGRAM_LOG_TAG);
log << event << data << LOG_ID_EVENTS;
}
} // namespace bootstat

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