Logger日志系统

• Logger日志系统是基于内核中的Logger日志驱动程序实现
• 将日志记录保存在内核空间中
• 使用一个环形缓冲区来保存日志，满了之后，新的日志就会覆盖旧的日志

日志类型

• main，记录应用程序级别
• system，记录系统级别
• radio，记录无线设备相关
• events，用于诊断系统问题，开发人员不应使用

日志驱动程序

4种类型的日志通过下面4个设备文件来访问

• /dev/log/main
• /dev/log/system
• /dev/log/radio
• /dev/log/events

运行时库

无论什么类型，最终调用write_to_log写入Logger日志驱动程序

C/C++写入日志

• 宏ALOGV、ALOGD、ALOGI、ALOGW和ALOGE写入main
• 宏SLOGV、SLOGD、SLOGI、SLOGW和SLOGE写入system
• 宏RLOGV、RLOGD、RLOGI、RLOGW和RLOGE写入radio
• 宏LOG_EVENT_INT、LOG_EVENT_LONG、LOG_EVENT_FLOAT和LOG_EVENT_STRING写入events

Java写入日志

• android.util.Log 写入main
• android.util.Slog 写入system
• android.util.Rlog 写入radio
• android.util.EventLog 写入event

整体架构

Logger日志格式

main、system和radio

• priority：优先级，整数，VERBOSE、DEBUG、INFO、WARN、ERROR和FATAL
• tag：标签，字符串
• msg：内容，字符串

events

• tag：标签，整数
• msg：内容，二进制数据，由一个或多个值组成，每个值前面都有一个字段描述它的类型

tag

tag为整数，根据/system/etc/event-log-tags转为字符串

/system/etc/event-log-tags还用来描述events类型的日志内容的格式

• tag number：标签值，范围为0～2147483648
• tag name：标签值对应的字符串描述，字母[A-Z][a-z]、数字[0-9]或者下画线“_”组成
• 第三个字段：日志内容的值

值格式为

• name：名称
• data type：数据类型，int（1）、long（2）、string（3）、list（4）、float（5）
• data unit：数据单位，范围是1～6，分别表示对象数量（number of objects）、字节数（Number of bytes）、毫秒数（Number of milliseconds）、分配额（Number of allocations）、标志（ID）和百分比（Percent）

2722 battery_level (level|1|6),(voltage|1|1),(temperature|1|1)

如上为/system/etc/event-log-tags的内容

• tag number：2722
• tag name：battery_level
• 由三个值组成，level/voltage/temperature，数据类型为1/1/1，数据单位为6/1/1

msg

msg格式为

• 类型
• 值，int（1）、long（2）、string（3）、list（4）、float（5）

Logger日志驱动程序（能力不够暂时分析不了）

基础数据结构

./system/logging/liblog/include/log/log_read.h（Android13）

logger_entry

logger_entry描述一个日志记录，最大长度为4K，其有效负载长度最大等于4K减去结构体logger_entry的大小

• len：实际log的有效负载长度
• hdr_size：logger_entry大小
• pid/itd：进程pid/tid
• sec/nsec：写入时间
• lid：实际log id
• uid：进程uid

struct logger_entry {uint16_t len;      /* length of the payload */uint16_t hdr_size; /* sizeof(struct logger_entry) */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 */
};

log_msg

• 缓冲区5M
• 包含logger_entry
• 若为C++，则新增函数返回nsec、lid、msg、len

#define LOGGER_ENTRY_MAX_LEN (5 * 1024)struct log_msg {union {unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1];struct logger_entry entry;} __attribute__((aligned(4)));
#ifdef __cplusplusuint64_t nsec() const {return static_cast<uint64_t>(entry.sec) * NS_PER_SEC + entry.nsec;}log_id_t id() {return static_cast<log_id_t>(entry.lid);}char* msg() {unsigned short hdr_size = entry.hdr_size;if (hdr_size >= sizeof(struct log_msg) - sizeof(entry)) {return nullptr;}return reinterpret_cast<char*>(buf) + hdr_size;}unsigned int len() { return entry.hdr_size + entry.len; }
#endif
};

main

system/logging/logd/main.cpp，进行初始化操作

• 默认log时区为utc
• 缓冲区类型有SerializedLogBuffer（默认）和SimpleLogBuffer，可通过logd.buffer_type属性修改
• LogReader监听/dev/socket/logdr
• LogListener监听/dev/socket/logdw
• CommandListener监听/dev/socket/logd

int main(int argc, char* argv[]) {// We want EPIPE when a reader disconnects, not to terminate logd.signal(SIGPIPE, SIG_IGN);// logd is written under the assumption that the timezone is UTC.// If TZ is not set, persist.sys.timezone is looked up in some time utility// libc functions, including mktime. It confuses the logd time handling,// so here explicitly set TZ to UTC, which overrides the property.setenv("TZ", "UTC", 1);// issue reinit command. KISS argument parsing.if ((argc > 1) && argv[1] && !strcmp(argv[1], "--reinit")) {return issueReinit();}android::base::InitLogging(argv, [](android::base::LogId log_id, android::base::LogSeverity severity,const char* tag, const char* file, unsigned int line, const char* message) {if (tag && strcmp(tag, "logd") != 0) {auto prefixed_message = android::base::StringPrintf("%s: %s", tag, message);android::base::KernelLogger(log_id, severity, "logd", file, line,prefixed_message.c_str());} else {android::base::KernelLogger(log_id, severity, "logd", file, line, message);}});static const char dev_kmsg[] = "/dev/kmsg";int fdDmesg = android_get_control_file(dev_kmsg);if (fdDmesg < 0) {fdDmesg = TEMP_FAILURE_RETRY(open(dev_kmsg, O_WRONLY | O_CLOEXEC));}int fdPmesg = -1;bool klogd = GetBoolPropertyEngSvelteDefault("ro.logd.kernel");if (klogd) {SetProperty("ro.logd.kernel", "true");static const char proc_kmsg[] = "/proc/kmsg";fdPmesg = android_get_control_file(proc_kmsg);if (fdPmesg < 0) {fdPmesg = TEMP_FAILURE_RETRY(open(proc_kmsg, O_RDONLY | O_NDELAY | O_CLOEXEC));}if (fdPmesg < 0) PLOG(ERROR) << "Failed to open " << proc_kmsg;}bool auditd = GetBoolProperty("ro.logd.auditd", true);DropPrivs(klogd, auditd);// A cache of event log tagsLogTags log_tags;// Pruning configuration.PruneList prune_list;std::string buffer_type = GetProperty("logd.buffer_type", "serialized");LogStatistics log_statistics(GetBoolPropertyEngSvelteDefault("logd.statistics"),buffer_type == "serialized");// Serves the purpose of managing the last logs times read on a socket connection, and as a// reader lock on a range of log entries.LogReaderList reader_list;// LogBuffer is the object which is responsible for holding all log entries.LogBuffer* log_buffer = nullptr;if (buffer_type == "serialized") {log_buffer = new SerializedLogBuffer(&reader_list, &log_tags, &log_statistics);} else if (buffer_type == "simple") {log_buffer = new SimpleLogBuffer(&reader_list, &log_tags, &log_statistics);} else {LOG(FATAL) << "buffer_type must be one of 'serialized' or 'simple'";}// LogReader listens on /dev/socket/logdr. When a client// connects, log entries in the LogBuffer are written to the client.LogReader* reader = new LogReader(log_buffer, &reader_list);if (reader->startListener()) {return EXIT_FAILURE;}// LogListener listens on /dev/socket/logdw for client// initiated log messages. New log entries are added to LogBuffer// and LogReader is notified to send updates to connected clients.LogListener* swl = new LogListener(log_buffer);if (!swl->StartListener()) {return EXIT_FAILURE;}// Command listener listens on /dev/socket/logd for incoming logd// administrative commands.CommandListener* cl = new CommandListener(log_buffer, &log_tags, &prune_list, &log_statistics);if (cl->startListener()) {return EXIT_FAILURE;}// Notify that others can now interact with logdSetProperty("logd.ready", "true");// LogAudit listens on NETLINK_AUDIT socket for selinux// initiated log messages. New log entries are added to LogBuffer// and LogReader is notified to send updates to connected clients.LogAudit* al = nullptr;if (auditd) {int dmesg_fd = GetBoolProperty("ro.logd.auditd.dmesg", true) ? fdDmesg : -1;al = new LogAudit(log_buffer, dmesg_fd, &log_statistics);}LogKlog* kl = nullptr;if (klogd) {kl = new LogKlog(log_buffer, fdDmesg, fdPmesg, al != nullptr, &log_statistics);}readDmesg(al, kl);// failure is an option ... messages are in dmesg (required by standard)if (kl && kl->startListener()) {delete kl;}if (al && al->startListener()) {delete al;}TrustyLog::create(log_buffer);TEMP_FAILURE_RETRY(pause());return EXIT_SUCCESS;
}

SerializedLogBuffer

• Log将日志封装成SerializedLogEntry、LogStatisticsElement添加到stats_

SerializedLogBuffer::SerializedLogBuffer(LogReaderList* reader_list, LogTags* tags,LogStatistics* stats): reader_list_(reader_list), tags_(tags), stats_(stats) {Init();
}void SerializedLogBuffer::Init() {log_id_for_each(i) {if (!SetSize(i, GetBufferSizeFromProperties(i))) {SetSize(i, kLogBufferMinSize);}}// Release any sleeping reader threads to dump their current content.auto lock = std::lock_guard{logd_lock};for (const auto& reader_thread : reader_list_->running_reader_threads()) {reader_thread->TriggerReader();}
}int SerializedLogBuffer::Log(log_id_t log_id, log_time realtime, uid_t uid, pid_t pid, pid_t tid,const char* msg, uint16_t len) {if (log_id >= LOG_ID_MAX || len == 0) {return -EINVAL;}if (len > LOGGER_ENTRY_MAX_PAYLOAD) {len = LOGGER_ENTRY_MAX_PAYLOAD;}if (!ShouldLog(log_id, msg, len)) {stats_->AddTotal(log_id, len);return -EACCES;}auto sequence = sequence_.fetch_add(1, std::memory_order_relaxed);auto lock = std::lock_guard{logd_lock};auto entry = LogToLogBuffer(logs_[log_id], max_size_[log_id], sequence, realtime, uid, pid, tid,msg, len);stats_->Add(entry->ToLogStatisticsElement(log_id));MaybePrune(log_id);reader_list_->NotifyNewLog(1 << log_id);return len;
}static SerializedLogEntry* LogToLogBuffer(std::list<SerializedLogChunk>& log_buffer,size_t max_size, uint64_t sequence, log_time realtime,uid_t uid, pid_t pid, pid_t tid, const char* msg,uint16_t len) {if (log_buffer.empty()) {log_buffer.push_back(SerializedLogChunk(max_size / SerializedLogBuffer::kChunkSizeDivisor));}auto total_len = sizeof(SerializedLogEntry) + len;if (!log_buffer.back().CanLog(total_len)) {log_buffer.back().FinishWriting();log_buffer.push_back(SerializedLogChunk(max_size / SerializedLogBuffer::kChunkSizeDivisor));}return log_buffer.back().Log(sequence, realtime, uid, pid, tid, msg, len);
}

LogReader

LogListener

StartListener开启线程LogListener，循环调用HandleData，通过LogBuffer的Log方法写入日志

LogListener::LogListener(LogBuffer* buf) : socket_(GetLogSocket()), logbuf_(buf) {}bool LogListener::StartListener() {if (socket_ <= 0) {return false;}auto thread = std::thread(&LogListener::ThreadFunction, this);thread.detach();return true;
}void LogListener::ThreadFunction() {prctl(PR_SET_NAME, "logd.writer");while (true) {HandleData();}
}void LogListener::HandleData() {// + 1 to ensure null terminator if MAX_PAYLOAD buffer is received__attribute__((uninitialized)) charbuffer[sizeof(android_log_header_t) + LOGGER_ENTRY_MAX_PAYLOAD + 1];struct iovec iov = {buffer, sizeof(buffer) - 1};alignas(4) char control[CMSG_SPACE(sizeof(struct ucred))];struct msghdr hdr = {nullptr, 0, &iov, 1, control, sizeof(control), 0,};ssize_t n = recvmsg(socket_, &hdr, 0);if (n <= (ssize_t)(sizeof(android_log_header_t))) {return;}// To clear the entire buffer would be safe, but this contributes to 1.68%// overhead under logging load. We are safe because we check counts, but// still need to clear null terminatorbuffer[n] = 0;struct ucred* cred = nullptr;struct cmsghdr* cmsg = CMSG_FIRSTHDR(&hdr);while (cmsg != nullptr) {if (cmsg->cmsg_level == SOL_SOCKET &&cmsg->cmsg_type == SCM_CREDENTIALS) {cred = (struct ucred*)CMSG_DATA(cmsg);break;}cmsg = CMSG_NXTHDR(&hdr, cmsg);}if (cred == nullptr) {return;}if (cred->uid == AID_LOGD) {// ignore log messages we send to ourself.// Such log messages are often generated by libraries we depend on// which use standard Android logging.return;}android_log_header_t* header =reinterpret_cast<android_log_header_t*>(buffer);log_id_t logId = static_cast<log_id_t>(header->id);if (/* logId < LOG_ID_MIN || */ logId >= LOG_ID_MAX ||logId == LOG_ID_KERNEL) {return;}if (logId == LOG_ID_SECURITY) {if (!__android_log_security()) {return;}if (!clientCanWriteSecurityLog(cred->uid, cred->gid, cred->pid)) {return;}}char* msg = ((char*)buffer) + sizeof(android_log_header_t);n -= sizeof(android_log_header_t);// NB: hdr.msg_flags & MSG_TRUNC is not tested, silently passing a// truncated message to the logs.logbuf_->Log(logId, header->realtime, cred->uid, cred->pid, header->tid, msg,((size_t)n <= UINT16_MAX) ? (uint16_t)n : UINT16_MAX);
}int LogListener::GetLogSocket() {static const char socketName[] = "logdw";int sock = android_get_control_socket(socketName);if (sock < 0) {  // logd started up in init.shsock = socket_local_server(socketName, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_DGRAM);int on = 1;if (setsockopt(sock, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on))) {return -1;}}return sock;
}

CommandListener

运行时库

write_to_log

system/logging/liblog/logger_write.cpp

调用LogdWrite

#ifdef __ANDROID__
static int write_to_log(log_id_t log_id, struct iovec* vec, size_t nr) {int ret;struct timespec ts;if (log_id == LOG_ID_KERNEL) {return -EINVAL;}clock_gettime(CLOCK_REALTIME, &ts);if (log_id == LOG_ID_SECURITY) {if (vec[0].iov_len < 4) {return -EINVAL;}ret = check_log_uid_permissions();if (ret < 0) {return ret;}if (!__android_log_security()) {/* If only we could reset downstream logd counter */return -EPERM;}} else if (log_id == LOG_ID_EVENTS || log_id == LOG_ID_STATS) {if (vec[0].iov_len < 4) {return -EINVAL;}}ret = LogdWrite(log_id, &ts, vec, nr);PmsgWrite(log_id, &ts, vec, nr);return ret;
}
#else
static int write_to_log(log_id_t, struct iovec*, size_t) {// Non-Android text logs should go to __android_log_stderr_logger, not here.// Non-Android binary logs are always dropped.return 1;
}
#endif

LogdWrite

system/logging/liblog/logd_writer.cpp

• 若logId == LOG_ID_SECURITY，获取LogdSocket::BlockingSocket()，否则获取LogdSocket::NonBlockingSocket()
• 调用sock打开设备/dev/socket/logdw，通过writev写入struct iovec，
• 返回值小于0且错误码不等于EAGAIN需要重新连接再次写入

int LogdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr) {ssize_t ret;static const unsigned headerLength = 1;struct iovec newVec[nr + headerLength];android_log_header_t header;size_t i, payloadSize;static atomic_int dropped;LogdSocket& logd_socket =logId == LOG_ID_SECURITY ? LogdSocket::BlockingSocket() : LogdSocket::NonBlockingSocket();if (logd_socket.sock() < 0) {return -EBADF;}/* logd, after initialization and priv drop */if (getuid() == AID_LOGD) {/** ignore log messages we send to ourself (logd).* Such log messages are often generated by libraries we depend on* which use standard Android logging.*/return 0;}header.tid = gettid();header.realtime.tv_sec = ts->tv_sec;header.realtime.tv_nsec = ts->tv_nsec;newVec[0].iov_base = (unsigned char*)&header;newVec[0].iov_len = sizeof(header);int32_t snapshot = atomic_exchange_explicit(&dropped, 0, memory_order_relaxed);if (snapshot && __android_log_is_loggable_len(ANDROID_LOG_INFO, "liblog", strlen("liblog"),ANDROID_LOG_VERBOSE)) {android_log_event_int_t buffer;header.id = LOG_ID_EVENTS;buffer.header.tag = LIBLOG_LOG_TAG;buffer.payload.type = EVENT_TYPE_INT;buffer.payload.data = snapshot;newVec[headerLength].iov_base = &buffer;newVec[headerLength].iov_len = sizeof(buffer);ret = TEMP_FAILURE_RETRY(writev(logd_socket.sock(), newVec, 2));if (ret != (ssize_t)(sizeof(header) + sizeof(buffer))) {atomic_fetch_add_explicit(&dropped, snapshot, memory_order_relaxed);}}header.id = logId;for (payloadSize = 0, i = headerLength; i < nr + headerLength; i++) {newVec[i].iov_base = vec[i - headerLength].iov_base;payloadSize += newVec[i].iov_len = vec[i - headerLength].iov_len;if (payloadSize > LOGGER_ENTRY_MAX_PAYLOAD) {newVec[i].iov_len -= payloadSize - LOGGER_ENTRY_MAX_PAYLOAD;if (newVec[i].iov_len) {++i;}break;}}// EAGAIN occurs if logd is overloaded, other errors indicate that something went wrong with// the connection, so we reset it and try again.ret = TEMP_FAILURE_RETRY(writev(logd_socket.sock(), newVec, i));if (ret < 0 && errno != EAGAIN) {logd_socket.Reconnect();ret = TEMP_FAILURE_RETRY(writev(logd_socket.sock(), newVec, i));}if (ret < 0) {ret = -errno;}if (ret > (ssize_t)sizeof(header)) {ret -= sizeof(header);} else if (ret < 0) {atomic_fetch_add_explicit(&dropped, 1, memory_order_relaxed);}return ret;
}

LogdSocket

sock、GetSocket、LogdConnect打开设备/dev/socket/logdw

class LogdSocket {public:static LogdSocket& BlockingSocket() {static LogdSocket logd_socket(true);return logd_socket;}static LogdSocket& NonBlockingSocket() {static LogdSocket logd_socket(false);return logd_socket;}void Reconnect() { LogdConnect(sock_); }// Zygote uses this to clean up open FD's after fork() and before specialization.  It is single// threaded at this point and therefore this function is explicitly not thread safe.  It sets// sock_ to kUninitialized, so future logs will be safely initialized whenever they happen.void Close() {if (sock_ != kUninitialized) {close(sock_);}sock_ = kUninitialized;}int sock() {GetSocket();return sock_;}private:LogdSocket(bool blocking) : blocking_(blocking) {}// Note that it is safe to call connect() multiple times on DGRAM Unix domain sockets, so this// function is used to reconnect to logd without requiring a new socket.static void LogdConnect(int sock) {sockaddr_un un = {};un.sun_family = AF_UNIX;strcpy(un.sun_path, "/dev/socket/logdw");TEMP_FAILURE_RETRY(connect(sock, reinterpret_cast<sockaddr*>(&un), sizeof(sockaddr_un)));}// sock_ should only be opened once.  If we see that sock_ is uninitialized, we// create a new socket and attempt to exchange it into the atomic sock_.  If the// compare/exchange was successful, then that will be the socket used for the duration of the// program, otherwise a different thread has already opened and written the socket to the atomic,// so close the new socket and return.void GetSocket() {if (sock_ != kUninitialized) {return;}int flags = SOCK_DGRAM | SOCK_CLOEXEC;if (!blocking_) {flags |= SOCK_NONBLOCK;}int new_socket = TEMP_FAILURE_RETRY(socket(PF_UNIX, flags, 0));if (new_socket < 0) {return;}LogdConnect(new_socket);int uninitialized_value = kUninitialized;if (!sock_.compare_exchange_strong(uninitialized_value, new_socket)) {close(new_socket);return;}}static const int kUninitialized = -1;atomic_int sock_ = kUninitialized;bool blocking_;
};

__android_log_print

system/logging/liblog/logger_write.cpp

int __android_log_print(int prio, const char* tag, const char* fmt, ...) {ErrnoRestorer errno_restorer;if (!__android_log_is_loggable(prio, tag, ANDROID_LOG_VERBOSE)) {return -EPERM;}va_list ap;__attribute__((uninitialized)) char buf[LOG_BUF_SIZE];va_start(ap, fmt);vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);va_end(ap);__android_log_message log_message = {sizeof(__android_log_message), LOG_ID_MAIN, prio, tag, nullptr, 0, buf};__android_log_write_log_message(&log_message);return 1;
}

__android_log_write_log_message

void __android_log_write_log_message(__android_log_message* log_message) {ErrnoRestorer errno_restorer;if (log_message->buffer_id != LOG_ID_DEFAULT && log_message->buffer_id != LOG_ID_MAIN &&log_message->buffer_id != LOG_ID_SYSTEM && log_message->buffer_id != LOG_ID_RADIO &&log_message->buffer_id != LOG_ID_CRASH) {return;}if (log_message->tag == nullptr) {log_message->tag = GetDefaultTag().c_str();}#if __BIONIC__if (log_message->priority == ANDROID_LOG_FATAL) {android_set_abort_message(log_message->message);}
#endifget_logger_function()(log_message);
}

调用get_logger_function，get_file_logger_path判断是否有定义ro.log.file_logger.path指定log文件路径，如果没有则调用__android_log_logd_logger

static __android_logger_function get_logger_function() {if (user_set_logger_function != nullptr) {return user_set_logger_function;}static __android_logger_function default_logger_function = []() {
#if __ANDROID__if (get_file_logger_path() != nullptr) {return file_logger;} else {return __android_log_logd_logger;}
#elsereturn file_logger;
#endif}();return default_logger_function;
}#ifdef __ANDROID__
static const char* get_file_logger_path() {static const char* file_logger_path = []() {static char path[PROP_VALUE_MAX] = {};if (__system_property_get("ro.log.file_logger.path", path) > 0) {return path;}return (char*)nullptr;  // means file_logger should not be used}();return file_logger_path;
}
#endif

__android_log_logd_logger将优先级、标签、内容存在数字元素vec[0]、vec[1]和vec[2]，最后调用write_to_log

+1是因为标签和内容后面跟着’\0’，用来区分和解析

void __android_log_logd_logger(const struct __android_log_message* log_message) {int buffer_id = log_message->buffer_id == LOG_ID_DEFAULT ? LOG_ID_MAIN : log_message->buffer_id;struct iovec vec[3];vec[0].iov_base =const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(&log_message->priority));vec[0].iov_len = 1;vec[1].iov_base = const_cast<void*>(static_cast<const void*>(log_message->tag));vec[1].iov_len = strlen(log_message->tag) + 1;vec[2].iov_base = const_cast<void*>(static_cast<const void*>(log_message->message));vec[2].iov_len = strlen(log_message->message) + 1;write_to_log(static_cast<log_id_t>(buffer_id), vec, 3);
}

__android_log_buf_print

也是调用__android_log_write_log_message，同上

int __android_log_buf_print(int bufID, int prio, const char* tag, const char* fmt, ...) {ErrnoRestorer errno_restorer;if (!__android_log_is_loggable(prio, tag, ANDROID_LOG_VERBOSE)) {return -EPERM;}va_list ap;__attribute__((uninitialized)) char buf[LOG_BUF_SIZE];va_start(ap, fmt);vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);va_end(ap);__android_log_message log_message = {sizeof(__android_log_message), bufID, prio, tag, nullptr, 0, buf};__android_log_write_log_message(&log_message);return 1;
}

__android_log_bwrite/__android_log_btwrite/__android_log_bswrite

• __android_log_bwrite 的内容可由多个值组成
• __android_log_btwrite 的内容只有一个值，类型为参数type
• __android_log_btwrite 的内容为字符串

int __android_log_bwrite(int32_t tag, const void* payload, size_t len) {ErrnoRestorer errno_restorer;struct iovec vec[2];vec[0].iov_base = &tag;vec[0].iov_len = sizeof(tag);vec[1].iov_base = (void*)payload;vec[1].iov_len = len;return write_to_log(LOG_ID_EVENTS, vec, 2);
}int __android_log_btwrite(int32_t tag, char type, const void* payload, size_t len) {ErrnoRestorer errno_restorer;struct iovec vec[3];vec[0].iov_base = &tag;vec[0].iov_len = sizeof(tag);vec[1].iov_base = &type;vec[1].iov_len = sizeof(type);vec[2].iov_base = (void*)payload;vec[2].iov_len = len;return write_to_log(LOG_ID_EVENTS, vec, 3);
}int __android_log_bswrite(int32_t tag, const char* payload) {ErrnoRestorer errno_restorer;struct iovec vec[4];char type = EVENT_TYPE_STRING;uint32_t len = strlen(payload);vec[0].iov_base = &tag;vec[0].iov_len = sizeof(tag);vec[1].iov_base = &type;vec[1].iov_len = sizeof(type);vec[2].iov_base = &len;vec[2].iov_len = sizeof(len);vec[3].iov_base = (void*)payload;vec[3].iov_len = len;return write_to_log(LOG_ID_EVENTS, vec, 4);
}

# C/C++写入日志

system/logging/liblog/include/log/log.h(Android13)

属性LOG_NDEBUG限制Log的输出（为0时相关函数定义为空）

#ifndef LOG_NDEBUG
#ifdef NDEBUG
#define LOG_NDEBUG 1
#else
#define LOG_NDEBUG 0
#endif
#endif

属性LOG_TAG定义了当前编译单元的日志TAG，默认为空

#ifndef LOG_TAG
#define LOG_TAG NULL
#endif

ALOGV 、ALOGD 、ALOGI 、ALOGW 和ALOGE

/system/logging/liblog/include/log/log_main.h，ALOGV只有当LOG_NDEBUG为0时才有效

#ifndef ALOGV
#define __ALOGV(...) ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
#if LOG_NDEBUG
#define ALOGV(...)                   \do {                               \__FAKE_USE_VA_ARGS(__VA_ARGS__); \if (false) {                     \__ALOGV(__VA_ARGS__);          \}                                \} while (false)
#else
#define ALOGV(...) __ALOGV(__VA_ARGS__)
#endif
#endif#ifndef ALOGD
#define ALOGD(...) ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__))
#endif#ifndef ALOGI
#define ALOGI(...) ((void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__))
#endif#ifndef ALOGW
#define ALOGW(...) ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__))
#endif#ifndef ALOGE
#define ALOGE(...) ((void)ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__))
#endif

调用ALOG、LOG_PRI、android_printLog，最后调用运行时库的__android_log_print

#ifndef ALOG
#define ALOG(priority, tag, ...) LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)
#endif#ifndef LOG_PRI
#define LOG_PRI(priority, tag, ...) android_printLog(priority, tag, __VA_ARGS__)
#endif#define android_printLog(prio, tag, ...) \__android_log_print(prio, tag, __VA_ARGS__)

RLOGV、RLOGD、RLOGI、RLOGW和RLOGE

/system/logging/liblog/include/log/log_radio.h

同理，RLOGV只有在LOG_NDEBUG为0才有效，最后调用运行时库的__android_log_buf_print，传入LOG_ID_RADIO

#ifndef RLOGV
#define __RLOGV(...)                                                         \((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_VERBOSE, LOG_TAG, \__VA_ARGS__))
#if LOG_NDEBUG
#define RLOGV(...)          \do {                      \if (0) {                \__RLOGV(__VA_ARGS__); \}                       \} while (0)
#else
#define RLOGV(...) __RLOGV(__VA_ARGS__)
#endif
#endif#ifndef RLOGD
#define RLOGD(...)                                                         \((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_DEBUG, LOG_TAG, \__VA_ARGS__))
#endif#ifndef RLOGI
#define RLOGI(...)                                                        \((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_INFO, LOG_TAG, \__VA_ARGS__))
#endif#ifndef RLOGW
#define RLOGW(...)                                                        \((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_WARN, LOG_TAG, \__VA_ARGS__))
#endif#ifndef RLOGE
#define RLOGE(...)                                                         \((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_ERROR, LOG_TAG, \__VA_ARGS__))
#endif

SLOGV、SLOGD、SLOGI、SLOGW和SLOGE

/system/logging/liblog/include/log/log_system.h

同理，SLOGV只有在LOG_NDEBUG为0才有效，最后调用运行时库的__android_log_buf_print，传入LOG_ID_SYSTEM

#ifndef SLOGV
#define __SLOGV(...)                                                          \((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_VERBOSE, LOG_TAG, \__VA_ARGS__))
#if LOG_NDEBUG
#define SLOGV(...)          \do {                      \if (0) {                \__SLOGV(__VA_ARGS__); \}                       \} while (0)
#else
#define SLOGV(...) __SLOGV(__VA_ARGS__)
#endif
#endif#ifndef SLOGD
#define SLOGD(...)                                                          \((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_DEBUG, LOG_TAG, \__VA_ARGS__))
#endif#ifndef SLOGI
#define SLOGI(...)                                                         \((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_INFO, LOG_TAG, \__VA_ARGS__))
#endif#ifndef SLOGW
#define SLOGW(...)                                                         \((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_WARN, LOG_TAG, \__VA_ARGS__))
#endif#ifndef SLOGE
#define SLOGE(...)                                                          \((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_ERROR, LOG_TAG, \__VA_ARGS__))
#endif

LOG_EVENT_INT、LOG_EVENT_LONG、LOG_EVENT_FLOAT和LOG_EVENT_STRING

system/logging/liblog/include/log/log.h

• LOG_EVENT_INT、LOG_EVENT_LONG和LOG_EVENT_LONG调用android_btWriteLog，最后调用运行时库的__android_log_btwrite
• LOG_EVENT_STRING调用运行时库的__android_log_bswrite

#define android_btWriteLog(tag, type, payload, len) \__android_log_btwrite(tag, type, payload, len)typedef enum {/* Special markers for android_log_list_element type */EVENT_TYPE_LIST_STOP = '\n', /* declare end of list  */EVENT_TYPE_UNKNOWN = '?',    /* protocol error       *//* must match with declaration in java/android/android/util/EventLog.java */EVENT_TYPE_INT = 0,  /* int32_t */EVENT_TYPE_LONG = 1, /* int64_t */EVENT_TYPE_STRING = 2,EVENT_TYPE_LIST = 3,EVENT_TYPE_FLOAT = 4,
} AndroidEventLogType;#ifndef LOG_EVENT_INT
#define LOG_EVENT_INT(_tag, _value)                                          \{                                                                          \int intBuf = _value;                                                     \(void)android_btWriteLog(_tag, EVENT_TYPE_INT, &intBuf, sizeof(intBuf)); \}
#endif#ifndef LOG_EVENT_LONG
#define LOG_EVENT_LONG(_tag, _value)                                            \{                                                                             \long long longBuf = _value;                                                 \(void)android_btWriteLog(_tag, EVENT_TYPE_LONG, &longBuf, sizeof(longBuf)); \}
#endif#ifndef LOG_EVENT_FLOAT
#define LOG_EVENT_FLOAT(_tag, _value)                           \{                                                             \float floatBuf = _value;                                    \(void)android_btWriteLog(_tag, EVENT_TYPE_FLOAT, &floatBuf, \sizeof(floatBuf));                 \}
#endif#ifndef LOG_EVENT_STRING
#define LOG_EVENT_STRING(_tag, _value) \(void)__android_log_bswrite(_tag, _value);
#endif

Java写入日志

android.util.Log

frameworks/base/core/java/android/util/Log.java

public final class Log {....../*** Priority constant for the println method; use Log.v.*/public static final int VERBOSE = 2;/*** Priority constant for the println method; use Log.d.*/public static final int DEBUG = 3;/*** Priority constant for the println method; use Log.i.*/public static final int INFO = 4;/*** Priority constant for the println method; use Log.w.*/public static final int WARN = 5;/*** Priority constant for the println method; use Log.e.*/public static final int ERROR = 6;/*** Priority constant for the println method.*/public static final int ASSERT = 7;......public static int v(@Nullable String tag, @NonNull String msg) {return println_native(LOG_ID_MAIN, VERBOSE, tag, msg);}public static int d(@Nullable String tag, @NonNull String msg) {return println_native(LOG_ID_MAIN, DEBUG, tag, msg);}public static int i(@Nullable String tag, @NonNull String msg) {return println_native(LOG_ID_MAIN, INFO, tag, msg);}public static int w(@Nullable String tag, @NonNull String msg) {return println_native(LOG_ID_MAIN, WARN, tag, msg);}public static int e(@Nullable String tag, @NonNull String msg) {return println_native(LOG_ID_MAIN, ERROR, tag, msg);}....../** @hide */ public static final int LOG_ID_MAIN = 0;/** @hide */ public static final int LOG_ID_RADIO = 1;/** @hide */ public static final int LOG_ID_EVENTS = 2;/** @hide */ public static final int LOG_ID_SYSTEM = 3;/** @hide */ public static final int LOG_ID_CRASH = 4;	......
}

调用println_native，传入LOG_ID_MAIN

println_native

根据frameworks/base/core/jni/android_util_Log.cpp

static const JNINativeMethod gMethods[] = {......{ "println_native",  "(IILjava/lang/String;Ljava/lang/String;)I", (void*) android_util_Log_println_native },......
};

可知对应的调用函数，判断日志内容msgObj 是否为空，判断类型是否在[0, LOG_ID_MAX]，最后调用运行时库的__android_log_buf_write写入log

static jint android_util_Log_println_native(JNIEnv* env, jobject clazz,jint bufID, jint priority, jstring tagObj, jstring msgObj)
{const char* tag = NULL;const char* msg = NULL;if (msgObj == NULL) {jniThrowNullPointerException(env, "println needs a message");return -1;}if (bufID < 0 || bufID >= LOG_ID_MAX) {jniThrowNullPointerException(env, "bad bufID");return -1;}if (tagObj != NULL)tag = env->GetStringUTFChars(tagObj, NULL);msg = env->GetStringUTFChars(msgObj, NULL);int res = __android_log_buf_write(bufID, (android_LogPriority)priority, tag, msg);if (tag != NULL)env->ReleaseStringUTFChars(tagObj, tag);env->ReleaseStringUTFChars(msgObj, msg);return res;
}

android.util.Slog

frameworks/base/core/java/android/util/Slog.java

只可在系统内部使用，同上调用Log中的println_native传入LOG_ID_SYSTEM

public final class Slog {......@UnsupportedAppUsagepublic static int v(@Nullable String tag, @NonNull String msg) {return Log.println_native(Log.LOG_ID_SYSTEM, Log.VERBOSE, tag, msg);}@UnsupportedAppUsagepublic static int d(@Nullable String tag, @NonNull String msg) {return Log.println_native(Log.LOG_ID_SYSTEM, Log.DEBUG, tag, msg);}@UnsupportedAppUsagepublic static int i(@Nullable String tag, @NonNull String msg) {return Log.println_native(Log.LOG_ID_SYSTEM, Log.INFO, tag, msg);}@UnsupportedAppUsagepublic static int w(@Nullable String tag, @NonNull String msg) {return Log.println_native(Log.LOG_ID_SYSTEM, Log.WARN, tag, msg);}@UnsupportedAppUsagepublic static int e(@Nullable String tag, @NonNull String msg) {return Log.println_native(Log.LOG_ID_SYSTEM, Log.ERROR, tag, msg);}
}

android.util.Rlog

frameworks/base/core/java/android/util/Rlog.java

只可在系统内部使用，同上调用Log中的println_native传入LOG_ID_RADIO

public final class Rlog {.....@UnsupportedAppUsagepublic static int v(String tag, String msg) {return Log.println_native(Log.LOG_ID_RADIO, Log.VERBOSE, tag, msg);}@UnsupportedAppUsagepublic static int d(String tag, String msg) {return Log.println_native(Log.LOG_ID_RADIO, Log.DEBUG, tag, msg);}@UnsupportedAppUsagepublic static int i(String tag, String msg) {return Log.println_native(Log.LOG_ID_RADIO, Log.INFO, tag, msg);}@UnsupportedAppUsagepublic static int w(String tag, String msg) {return Log.println_native(Log.LOG_ID_RADIO, Log.WARN, tag, msg);}@UnsupportedAppUsagepublic static int e(String tag, String msg) {return Log.println_native(Log.LOG_ID_RADIO, Log.ERROR, tag, msg);}public static int println(int priority, String tag, String msg) {return Log.println_native(Log.LOG_ID_RADIO, priority, tag, msg);}
}

android.util.EventLog

frameworks/base/core/java/android/util/EventLog.java，重载了5个版本的writeEvent方法，日志内容分别为int、long、float、string、list

public class EventLog {......private static final byte INT_TYPE    = 0;private static final byte LONG_TYPE   = 1;private static final byte STRING_TYPE = 2;private static final byte LIST_TYPE   = 3;private static final byte FLOAT_TYPE = 4;public static native int writeEvent(int tag, int value);public static native int writeEvent(int tag, long value);public static native int writeEvent(int tag, float value);public static native int writeEvent(int tag, String str);public static native int writeEvent(int tag, Object... list);......
}

writeEvent

根据frameworks/base/core/jni/android_util_EventLog.cpp

static const JNINativeMethod gRegisterMethods[] = {/* name, signature, funcPtr */{ "writeEvent", "(II)I", (void*) ELog::writeEventInteger },{ "writeEvent", "(IJ)I", (void*) ELog::writeEventLong },{ "writeEvent", "(IF)I", (void*) ELog::writeEventFloat },{ "writeEvent", "(ILjava/lang/String;)I", (void*) ELog::writeEventString },{ "writeEvent", "(I[Ljava/lang/Object;)I", (void*) ELog::writeEventArray },......
};

可知调用

static jint writeEventInteger(JNIEnv* env ATTRIBUTE_UNUSED, jobject clazz ATTRIBUTE_UNUSED,jint tag, jint value) {android_log_event_list ctx(tag);ctx << (int32_t)value;return ctx.write(LogID);
}static jint writeEventLong(JNIEnv* env ATTRIBUTE_UNUSED, jobject clazz ATTRIBUTE_UNUSED,jint tag, jlong value) {android_log_event_list ctx(tag);ctx << (int64_t)value;return ctx.write(LogID);
}static jint writeEventFloat(JNIEnv* env ATTRIBUTE_UNUSED, jobject clazz ATTRIBUTE_UNUSED,jint tag, jfloat value) {android_log_event_list ctx(tag);ctx << (float)value;return ctx.write(LogID);
}static jint writeEventString(JNIEnv* env, jobject clazz ATTRIBUTE_UNUSED, jint tag,jstring value) {android_log_event_list ctx(tag);// Don't throw NPE -- I feel like it's sort of mean for a logging function// to be all crashy if you pass in NULL -- but make the NULL value explicit.ctx << (value != nullptr ? ScopedUtfChars(env, value).c_str() : "NULL");return ctx.write(LogID);
}static jint writeEventArray(JNIEnv* env, jobject clazz ATTRIBUTE_UNUSED, jint tag,jobjectArray value) {android_log_event_list ctx(tag);if (value == nullptr) {ctx << "[NULL]";return ctx.write(LogID);}jsize copied = 0, num = env->GetArrayLength(value);for (; copied < num && copied < 255; ++copied) {if (ctx.status()) break;ScopedLocalRef<jobject> item(env, env->GetObjectArrayElement(value, copied));if (item == nullptr) {ctx << "NULL";} else if (env->IsInstanceOf(item.get(), gStringClass)) {ctx << ScopedUtfChars(env, (jstring) item.get()).c_str();} else if (env->IsInstanceOf(item.get(), gIntegerClass)) {ctx << (int32_t)env->GetIntField(item.get(), gIntegerValueID);} else if (env->IsInstanceOf(item.get(), gLongClass)) {ctx << (int64_t)env->GetLongField(item.get(), gLongValueID);} else if (env->IsInstanceOf(item.get(), gFloatClass)) {ctx << (float)env->GetFloatField(item.get(), gFloatValueID);} else {jniThrowException(env,"java/lang/IllegalArgumentException","Invalid payload item type");return -1;}}return ctx.write(LogID);
}

log_event_list

system/logging/liblog/include/log/log_event_list.h

int android_log_write_list(android_log_context ctx, log_id_t id);class android_log_event_list {......int write(log_id_t id = LOG_ID_EVENTS) {/* facilitate -EBUSY retry */if ((ret == -EBUSY) || (ret > 0)) ret = 0;int retval = android_log_write_list(ctx, id);/* existing errors trump transmission errors */if (!ret) ret = retval;return ret;}......
}

system/logging/liblog/log_event_list.cpp，根据id == LOG_ID_EVENTS调用__android_log_bwrite

int android_log_write_list(android_log_context context, log_id_t id) {const char* msg;ssize_t len;if ((id != LOG_ID_EVENTS) && (id != LOG_ID_SECURITY) && (id != LOG_ID_STATS)) {return -EINVAL;}if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {return -EBADF;}if (context->list_nest_depth) {return -EIO;}/* NB: if there was overflow, then log is truncated. Nothing reported */context->storage[1] = context->count[0];len = context->len = context->pos;msg = (const char*)context->storage;/* it's not a list */if (context->count[0] <= 1) {len -= sizeof(uint8_t) + sizeof(uint8_t);if (len < 0) {len = 0;}msg += sizeof(uint8_t) + sizeof(uint8_t);}return (id == LOG_ID_EVENTS)? __android_log_bwrite(context->tag, msg, len): ((id == LOG_ID_STATS) ? __android_log_stats_bwrite(context->tag, msg, len): __android_log_security_bwrite(context->tag, msg, len));
}

Logcat工具分析

基础数据结构

logcat

system/logging/logcat/logcat.cpp

int main(int argc, char** argv) {Logcat logcat;return logcat.Run(argc, argv);
}

下面来分析其Run方法

命令参数

int Logcat::Run(int argc, char** argv) {......while (true) {......switch (c) {......case 'd':mode |= ANDROID_LOG_NONBLOCK;break;case 't':got_t = true;mode |= ANDROID_LOG_NONBLOCK;FALLTHROUGH_INTENDED;case 'T':if (strspn(optarg, "0123456789") != strlen(optarg)) {char* cp = parseTime(tail_time, optarg);if (!cp) {error(EXIT_FAILURE, 0, "-%c '%s' not in time format.", c, optarg);}if (*cp) {char ch = *cp;*cp = '\0';fprintf(stderr, "WARNING: -%c '%s' '%c%s' time truncated\n", c, optarg, ch,cp + 1);*cp = ch;}} else {if (!ParseUint(optarg, &tail_lines) || tail_lines < 1) {fprintf(stderr, "WARNING: -%c %s invalid, setting to 1\n", c, optarg);tail_lines = 1;}}break;case 'D':print_dividers_ = true;break;case 'e':regex_.reset(new std::regex(optarg));break;case 'm': {if (!ParseUint(optarg, &max_count_) || max_count_ < 1) {error(EXIT_FAILURE, 0, "-%c '%s' isn't an integer greater than zero.", c,optarg);}} break;case 'g':if (!optarg) {getLogSize = true;break;}FALLTHROUGH_INTENDED;case 'G': {if (!ParseByteCount(optarg, &setLogSize) || setLogSize < 1) {error(EXIT_FAILURE, 0, "-G must be specified as <num><multiplier>.");}} break;case 'p':if (!optarg) {getPruneList = true;break;}FALLTHROUGH_INTENDED;case 'P':setPruneList = optarg;break;case 'b':for (const auto& buffer : Split(optarg, delimiters)) {if (buffer == "default") {id_mask |= (1 << LOG_ID_MAIN) | (1 << LOG_ID_SYSTEM) | (1 << LOG_ID_CRASH);} else if (buffer == "all") {id_mask = -1;} else {log_id_t log_id = android_name_to_log_id(buffer.c_str());if (log_id >= LOG_ID_MAX) {error(EXIT_FAILURE, 0, "Unknown buffer '%s' listed for -b.",buffer.c_str());}if (log_id == LOG_ID_SECURITY) {security_buffer_selected = true;}id_mask |= (1 << log_id);}}break;case 'B':print_binary_ = 1;break;case 'f':if ((tail_time == log_time::EPOCH) && !tail_lines) {tail_time = lastLogTime(optarg);}// redirect output to a fileoutput_file_name_ = optarg;break;case 'r':if (!ParseUint(optarg, &log_rotate_size_kb_) || log_rotate_size_kb_ < 1) {error(EXIT_FAILURE, 0, "Invalid parameter '%s' to -r.", optarg);}break;case 'n':if (!ParseUint(optarg, &max_rotated_logs_) || max_rotated_logs_ < 1) {error(EXIT_FAILURE, 0, "Invalid parameter '%s' to -n.", optarg);}break;case 'v':for (const auto& arg : Split(optarg, delimiters)) {int err = SetLogFormat(arg.c_str());if (err < 0) {error(EXIT_FAILURE, 0, "Invalid parameter '%s' to -v.", arg.c_str());}if (err) hasSetLogFormat = true;}break;case 'S':printStatistics = true;break;case ':':error(EXIT_FAILURE, 0, "Option '%s' needs an argument.", argv[optind - 1]);break;case 'h':show_help();return EXIT_SUCCESS;case '?':error(EXIT_FAILURE, 0, "Unknown option '%s'.", argv[optind]);break;default:error(EXIT_FAILURE, 0, "Unknown getopt_long() result '%c'.", c);}}

• d 把 mode设为ANDROID_LOG_NONBLOCK，表示没有日志记录可读时logcat直接退出
• t 将got_t 设为true，表示只输出最新的日志
• b 将参数分割出来，通过id_mask设置读取的设备
• B print_binary_ = 1，表示以二进制输出日志
• f 指定输出文件output_file_name_
• r 指定输出文件的大小log_rotate_size_kb_（默认0无限制）
• n 指定输出文件的个数max_rotated_logs_（默认4），若输出日志时，已超过-r指定大小，则建立新的日志文件，格式为xxx.1/xxx.2/xxx.n
• v 调用SetLogFormat设置日志输出格式，将参数转为AndroidLogPrintFormat并设置到p_format->format

int Logcat::SetLogFormat(const char* format_string) {AndroidLogPrintFormat format = android_log_formatFromString(format_string);// invalid string?if (format == FORMAT_OFF) return -1;return android_log_setPrintFormat(logformat_.get(), format);
}

system/logging/liblog/logprint.cpp

AndroidLogPrintFormat android_log_formatFromString(const char* formatString) {/* clang-format off */if (!strcmp(formatString, "brief")) return FORMAT_BRIEF;if (!strcmp(formatString, "process")) return FORMAT_PROCESS;if (!strcmp(formatString, "tag")) return FORMAT_TAG;if (!strcmp(formatString, "thread")) return FORMAT_THREAD;if (!strcmp(formatString, "raw")) return FORMAT_RAW;if (!strcmp(formatString, "time")) return FORMAT_TIME;if (!strcmp(formatString, "threadtime")) return FORMAT_THREADTIME;if (!strcmp(formatString, "long")) return FORMAT_LONG;if (!strcmp(formatString, "color")) return FORMAT_MODIFIER_COLOR;if (!strcmp(formatString, "colour")) return FORMAT_MODIFIER_COLOR;if (!strcmp(formatString, "usec")) return FORMAT_MODIFIER_TIME_USEC;if (!strcmp(formatString, "nsec")) return FORMAT_MODIFIER_TIME_NSEC;if (!strcmp(formatString, "printable")) return FORMAT_MODIFIER_PRINTABLE;if (!strcmp(formatString, "year")) return FORMAT_MODIFIER_YEAR;if (!strcmp(formatString, "zone")) return FORMAT_MODIFIER_ZONE;if (!strcmp(formatString, "epoch")) return FORMAT_MODIFIER_EPOCH;if (!strcmp(formatString, "monotonic")) return FORMAT_MODIFIER_MONOTONIC;if (!strcmp(formatString, "uid")) return FORMAT_MODIFIER_UID;if (!strcmp(formatString, "descriptive")) return FORMAT_MODIFIER_DESCRIPT;/* clang-format on */#if !defined(__MINGW32__)// Check whether the format string is actually a time zone. If tzname[0]// is the empty string, that's tzset() signalling that it doesn't know// the requested timezone.TzSetter tz(formatString);if (!*tzname[0]) {tz.Reset();} else {// We keep the new time zone as a side effect!return FORMAT_MODIFIER_ZONE;}
#endifreturn FORMAT_OFF;
}int android_log_setPrintFormat(AndroidLogFormat* p_format, AndroidLogPrintFormat format) {switch (format) {case FORMAT_MODIFIER_COLOR:p_format->colored_output = true;return 0;case FORMAT_MODIFIER_TIME_USEC:p_format->usec_time_output = true;return 0;case FORMAT_MODIFIER_TIME_NSEC:p_format->nsec_time_output = true;return 0;case FORMAT_MODIFIER_PRINTABLE:p_format->printable_output = true;return 0;case FORMAT_MODIFIER_YEAR:p_format->year_output = true;return 0;case FORMAT_MODIFIER_ZONE:p_format->zone_output = !p_format->zone_output;return 0;case FORMAT_MODIFIER_EPOCH:p_format->epoch_output = true;return 0;case FORMAT_MODIFIER_MONOTONIC:p_format->monotonic_output = true;return 0;case FORMAT_MODIFIER_UID:p_format->uid_output = true;return 0;case FORMAT_MODIFIER_DESCRIPT:p_format->descriptive_output = true;descriptive_output = true;return 0;default:break;}p_format->format = format;return 1;
}

日志的格式为＜PREFIX＞+MESSAGE+＜SUFFIX＞，不同格式的＜PREFIX＞和＜SUFFIX＞不同

• FORMAT_BRIEF：“＜priority＞/＜tag＞（＜pid＞）：”和“\n”。

• FORMAT_PROCESS：“＜priority＞（＜pid＞）”和“（＜t a g＞）\n”。

• FORMAT_TAG：“＜priority＞/（＜tag＞）：”和“\n”。

• FORMAT_THREAD：“＜priority＞（＜pid＞：＜tid＞）”和“\n”。

• FORMAT_RAW：空值和“\n”。

• FORMAT_TIME：“＜sec＞.＜nsec＞ ＜priority＞/＜tag＞（＜pid＞）：”和“\n”。

• FORMAT_THREADTIME：“＜sec＞.＜nsec＞＜pid＞＜tid＞＜priority＞＜tag＞：”和“\n”。

• FORMAT_LONG：“[＜sec＞.＜nsec＞ ＜pid＞：＜tid＞＜priority＞/＜tag＞]”和“\n\n”

其他

上面解析完参数，继续往后走，未指定选项b时，默认输出MAIN、system、crash、kernel的log

    // If no buffers are specified, default to using these buffers.if (id_mask == 0) {id_mask = (1 << LOG_ID_MAIN) | (1 << LOG_ID_SYSTEM) | (1 << LOG_ID_CRASH) |(1 << LOG_ID_KERNEL);}

未设置选项v时，将环境变量ANDROID_PRINTF_LOG的值设置为当前格式，若无则设置为threadtime

    if (!hasSetLogFormat) {const char* logFormat = getenv("ANDROID_PRINTF_LOG");if (!!logFormat) {for (const auto& arg : Split(logFormat, delimiters)) {int err = SetLogFormat(arg.c_str());// environment should not cause crash of logcatif (err < 0) {fprintf(stderr, "invalid format in ANDROID_PRINTF_LOG '%s'\n", arg.c_str());}if (err > 0) hasSetLogFormat = true;}}if (!hasSetLogFormat) {SetLogFormat("threadtime");}}

• forceFilters.size()不为0，表示通过选项Q让logcat读取/proc/cmdline中的过滤器
• argc == optind表示命令没有其他参数，读取ANDROID_LOG_TAGS的值作为过滤器
• 将命令参数设置为过滤器，格式为 tag:priority，如 *:E

    if (forceFilters.size()) {int err = android_log_addFilterString(logformat_.get(), forceFilters.c_str());if (err < 0) {error(EXIT_FAILURE, 0, "Invalid filter expression in logcat args.");}} else if (argc == optind) {// Add from environment variableconst char* env_tags_orig = getenv("ANDROID_LOG_TAGS");if (!!env_tags_orig) {int err = android_log_addFilterString(logformat_.get(), env_tags_orig);if (err < 0) {error(EXIT_FAILURE, 0, "Invalid filter expression in ANDROID_LOG_TAGS.");}}} else {// Add from commandlinefor (int i = optind ; i < argc ; i++) {int err = android_log_addFilterString(logformat_.get(), argv[i]);if (err < 0) {error(EXIT_FAILURE, 0, "Invalid filter expression '%s'.", argv[i]);}}}

通过android_log_addFilterString设置过滤器，filterString可能以空格、tab或逗号分割

int android_log_addFilterString(AndroidLogFormat* p_format, const char* filterString) {char* filterStringCopy = strdup(filterString);char* p_cur = filterStringCopy;char* p_ret;int err;/* Yes, I'm using strsep */while (NULL != (p_ret = strsep(&p_cur, " \t,"))) {/* ignore whitespace-only entries */if (p_ret[0] != '\0') {err = android_log_addFilterRule(p_format, p_ret);if (err < 0) {goto error;}}}free(filterStringCopy);return 0;
error:free(filterStringCopy);return -1;
}

通过android_log_addFilterRule添加解析过滤器，将冒号后面的字符转为android_LogPriority，通过tagName和pri创建FilterInfo

int android_log_addFilterRule(AndroidLogFormat* p_format, const char* filterExpression) {size_t tagNameLength;android_LogPriority pri = ANDROID_LOG_DEFAULT;tagNameLength = strcspn(filterExpression, ":");if (tagNameLength == 0) {goto error;}if (filterExpression[tagNameLength] == ':') {pri = filterCharToPri(filterExpression[tagNameLength + 1]);if (pri == ANDROID_LOG_UNKNOWN) {goto error;}}if (0 == strncmp("*", filterExpression, tagNameLength)) {/** This filter expression refers to the global filter* The default level for this is DEBUG if the priority* is unspecified*/if (pri == ANDROID_LOG_DEFAULT) {pri = ANDROID_LOG_DEBUG;}p_format->global_pri = pri;} else {/** for filter expressions that don't refer to the global* filter, the default is verbose if the priority is unspecified*/if (pri == ANDROID_LOG_DEFAULT) {pri = ANDROID_LOG_VERBOSE;}char* tagName;/** Presently HAVE_STRNDUP is never defined, so the second case is always taken* Darwin doesn't have strndup, everything else does*/
#ifdef HAVE_STRNDUPtagName = strndup(filterExpression, tagNameLength);
#else/* a few extra bytes copied... */tagName = strdup(filterExpression);tagName[tagNameLength] = '\0';
#endif /*HAVE_STRNDUP*/FilterInfo* p_fi = filterinfo_new(tagName, pri);free(tagName);p_fi->p_next = p_format->filters;p_format->filters = p_fi;}return 0;
error:return -1;
}static android_LogPriority filterCharToPri(char c) {android_LogPriority pri;c = tolower(c);if (c >= '0' && c <= '9') {if (c >= ('0' + ANDROID_LOG_SILENT)) {pri = ANDROID_LOG_VERBOSE;} else {pri = (android_LogPriority)(c - '0');}} else if (c == 'v') {pri = ANDROID_LOG_VERBOSE;} else if (c == 'd') {pri = ANDROID_LOG_DEBUG;} else if (c == 'i') {pri = ANDROID_LOG_INFO;} else if (c == 'w') {pri = ANDROID_LOG_WARN;} else if (c == 'e') {pri = ANDROID_LOG_ERROR;} else if (c == 'f') {pri = ANDROID_LOG_FATAL;} else if (c == 's') {pri = ANDROID_LOG_SILENT;} else if (c == '*') {pri = ANDROID_LOG_DEFAULT;} else {pri = ANDROID_LOG_UNKNOWN;}return pri;
}

若通过选项f指定输出文件，通过max_rotated_logs_设置个数，格式为xxx.1/…/xxx.n

    if (output_file_name_) {if (setLogSize || getLogSize || printStatistics || getPruneList || setPruneList) {error(EXIT_FAILURE, 0, "-f is incompatible with -g/-G, -S, and -p/-P.");}if (clearLog || setId) {int max_rotation_count_digits =max_rotated_logs_ > 0 ? (int)(floor(log10(max_rotated_logs_) + 1)) : 0;for (int i = max_rotated_logs_; i >= 0; --i) {std::string file;if (!i) {file = output_file_name_;} else {file = StringPrintf("%s.%.*d", output_file_name_, max_rotation_count_digits, i);}int err = unlink(file.c_str());if (err < 0 && errno != ENOENT) {fprintf(stderr, "failed to delete log file '%s': %s\n", file.c_str(),strerror(errno));}}}if (clearLog) {return EXIT_SUCCESS;}}

根据id打开log设备

    for (int i = LOG_ID_MIN; i < LOG_ID_MAX; ++i) {if (!(id_mask & (1 << i))) continue;const char* buffer_name = android_log_id_to_name(static_cast<log_id_t>(i));auto logger = android_logger_open(logger_list.get(), static_cast<log_id_t>(i));if (logger == nullptr) {ReportErrorName(buffer_name, security_buffer_selected, &open_device_failures);continue;}......

判断输出是二进制调用WriteFully，否则调用ProcessBuffer

    while (!max_count_ || print_count_ < max_count_) {......if (print_binary_) {WriteFully(&log_msg, log_msg.len());} else {ProcessBuffer(&log_msg);}if (blocking && output_file_ == stdout) fflush(stdout);}return EXIT_SUCCESS;
}

• 若日志类型是Event，调用android_log_processBinaryLogBuffer，否则调用android_log_processLogBuffer，他们都会将buf转为AndroidLogEntry用于输出
• android_log_shouldPrintLine 判断tag和pri是否符合设置的过滤条件
• 当日志超出大小时，调用RotateLogs建立新文件

void Logcat::ProcessBuffer(struct log_msg* buf) {AndroidLogEntry entry;char binaryMsgBuf[1024] __attribute__((__uninitialized__));bool is_binary =buf->id() == LOG_ID_EVENTS || buf->id() == LOG_ID_STATS || buf->id() == LOG_ID_SECURITY;int err;if (is_binary) {if (!event_tag_map_ && !has_opened_event_tag_map_) {event_tag_map_.reset(android_openEventTagMap(nullptr));has_opened_event_tag_map_ = true;}// This causes entry to point to binaryMsgBuf!err = android_log_processBinaryLogBuffer(&buf->entry, &entry, event_tag_map_.get(),binaryMsgBuf, sizeof(binaryMsgBuf));// printf(">>> pri=%d len=%d msg='%s'\n",//    entry.priority, entry.messageLen, entry.message);} else {err = android_log_processLogBuffer(&buf->entry, &entry);}if (err < 0 && !debug_) return;if (android_log_shouldPrintLine(logformat_.get(), std::string(entry.tag, entry.tagLen).c_str(),entry.priority)) {bool match = !regex_ ||std::regex_search(entry.message, entry.message + entry.messageLen, *regex_);print_count_ += match;if (match || print_it_anyway_) {PrintDividers(buf->id(), print_dividers_);out_byte_count_ += android_log_printLogLine(logformat_.get(), output_file_, &entry);}}if (log_rotate_size_kb_ > 0 && (out_byte_count_ / 1024) >= log_rotate_size_kb_) {RotateLogs();}
}

android_log_printLogLine时输出的最后一个步骤，调用android_log_formatLogLine格式化要输出的日志，调用fwrite把日志输出到文件描述符fd所描述的目标文件中

size_t android_log_printLogLine(AndroidLogFormat* p_format, FILE* fp,const AndroidLogEntry* entry) {char buf[4096] __attribute__((__uninitialized__));size_t line_length;char* line = android_log_formatLogLine(p_format, buf, sizeof(buf), entry, &line_length);if (!line) {fprintf(stderr, "android_log_formatLogLine failed\n");exit(1);}size_t bytesWritten = fwrite(line, 1, line_length, fp);if (bytesWritten != line_length) {perror("fwrite failed");exit(1);}if (line != buf) free(line);return bytesWritten;
}