Android高级——Logger日志系统

自由的羽毛  论坛元老 | 2025-1-3 11:44:19 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 1031|帖子 1031|积分 3093

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）

  1. 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
  1. struct logger_entry {
  2.   uint16_t len;      /* length of the payload */
  3.   uint16_t hdr_size; /* sizeof(struct logger_entry) */
  4.   int32_t pid;       /* generating process's pid */
  5.   uint32_t tid;      /* generating process's tid */
  6.   uint32_t sec;      /* seconds since Epoch */
  7.   uint32_t nsec;     /* nanoseconds */
  8.   uint32_t lid;      /* log id of the payload, bottom 4 bits currently */
  9.   uint32_t uid;      /* generating process's uid */
  10. };
复制代码
log_msg



  • 缓冲区5M
  • 包罗logger_entry
  • 若为C++，则新增函数返回nsec、lid、msg、len
  1. #define LOGGER_ENTRY_MAX_LEN (5 * 1024)
  3. struct log_msg {
  4.   union {
  5.     unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1];
  6.     struct logger_entry entry;
  7.   } __attribute__((aligned(4)));
  8. #ifdef __cplusplus
  9.   uint64_t nsec() const {
  10.     return static_cast<uint64_t>(entry.sec) * NS_PER_SEC + entry.nsec;
  11.   }
  12.   log_id_t id() {
  13.     return static_cast<log_id_t>(entry.lid);
  14.   }
  15.   char* msg() {
  16.     unsigned short hdr_size = entry.hdr_size;
  17.     if (hdr_size >= sizeof(struct log_msg) - sizeof(entry)) {
  18.       return nullptr;
  19.     }
  20.     return reinterpret_cast<char*>(buf) + hdr_size;
  21.   }
  22.   unsigned int len() { return entry.hdr_size + entry.len; }
  23. #endif
  24. };
复制代码
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
  1. int main(int argc, char* argv[]) {
  2.     // We want EPIPE when a reader disconnects, not to terminate logd.
  3.     signal(SIGPIPE, SIG_IGN);
  4.     // logd is written under the assumption that the timezone is UTC.
  5.     // If TZ is not set, persist.sys.timezone is looked up in some time utility
  6.     // libc functions, including mktime. It confuses the logd time handling,
  7.     // so here explicitly set TZ to UTC, which overrides the property.
  8.     setenv("TZ", "UTC", 1);
  9.     // issue reinit command. KISS argument parsing.
  10.     if ((argc > 1) && argv[1] && !strcmp(argv[1], "--reinit")) {
  11.         return issueReinit();
  12.     }
  14.     android::base::InitLogging(
  15.             argv, [](android::base::LogId log_id, android::base::LogSeverity severity,
  16.                      const char* tag, const char* file, unsigned int line, const char* message) {
  17.                 if (tag && strcmp(tag, "logd") != 0) {
  18.                     auto prefixed_message = android::base::StringPrintf("%s: %s", tag, message);
  19.                     android::base::KernelLogger(log_id, severity, "logd", file, line,
  20.                                                 prefixed_message.c_str());
  21.                 } else {
  22.                     android::base::KernelLogger(log_id, severity, "logd", file, line, message);
  23.                 }
  24.             });
  26.     static const char dev_kmsg[] = "/dev/kmsg";
  27.     int fdDmesg = android_get_control_file(dev_kmsg);
  28.     if (fdDmesg < 0) {
  29.         fdDmesg = TEMP_FAILURE_RETRY(open(dev_kmsg, O_WRONLY | O_CLOEXEC));
  30.     }
  32.     int fdPmesg = -1;
  33.     bool klogd = GetBoolPropertyEngSvelteDefault("ro.logd.kernel");
  34.     if (klogd) {
  35.         SetProperty("ro.logd.kernel", "true");
  36.         static const char proc_kmsg[] = "/proc/kmsg";
  37.         fdPmesg = android_get_control_file(proc_kmsg);
  38.         if (fdPmesg < 0) {
  39.             fdPmesg = TEMP_FAILURE_RETRY(
  40.                 open(proc_kmsg, O_RDONLY | O_NDELAY | O_CLOEXEC));
  41.         }
  42.         if (fdPmesg < 0) PLOG(ERROR) << "Failed to open " << proc_kmsg;
  43.     }
  45.     bool auditd = GetBoolProperty("ro.logd.auditd", true);
  46.     DropPrivs(klogd, auditd);
  48.     // A cache of event log tags
  49.     LogTags log_tags;
  51.     // Pruning configuration.
  52.     PruneList prune_list;
  54.     std::string buffer_type = GetProperty("logd.buffer_type", "serialized");
  56.     LogStatistics log_statistics(GetBoolPropertyEngSvelteDefault("logd.statistics"),
  57.                                  buffer_type == "serialized");
  59.     // Serves the purpose of managing the last logs times read on a socket connection, and as a
  60.     // reader lock on a range of log entries.
  61.     LogReaderList reader_list;
  63.     // LogBuffer is the object which is responsible for holding all log entries.
  64.     LogBuffer* log_buffer = nullptr;
  65.     if (buffer_type == "serialized") {
  66.         log_buffer = new SerializedLogBuffer(&reader_list, &log_tags, &log_statistics);
  67.     } else if (buffer_type == "simple") {
  68.         log_buffer = new SimpleLogBuffer(&reader_list, &log_tags, &log_statistics);
  69.     } else {
  70.         LOG(FATAL) << "buffer_type must be one of 'serialized' or 'simple'";
  71.     }
  73.     // LogReader listens on /dev/socket/logdr. When a client
  74.     // connects, log entries in the LogBuffer are written to the client.
  75.     LogReader* reader = new LogReader(log_buffer, &reader_list);
  76.     if (reader->startListener()) {
  77.         return EXIT_FAILURE;
  78.     }
  80.     // LogListener listens on /dev/socket/logdw for client
  81.     // initiated log messages. New log entries are added to LogBuffer
  82.     // and LogReader is notified to send updates to connected clients.
  83.     LogListener* swl = new LogListener(log_buffer);
  84.     if (!swl->StartListener()) {
  85.         return EXIT_FAILURE;
  86.     }
  88.     // Command listener listens on /dev/socket/logd for incoming logd
  89.     // administrative commands.
  90.     CommandListener* cl = new CommandListener(log_buffer, &log_tags, &prune_list, &log_statistics);
  91.     if (cl->startListener()) {
  92.         return EXIT_FAILURE;
  93.     }
  95.     // Notify that others can now interact with logd
  96.     SetProperty("logd.ready", "true");
  98.     // LogAudit listens on NETLINK_AUDIT socket for selinux
  99.     // initiated log messages. New log entries are added to LogBuffer
  100.     // and LogReader is notified to send updates to connected clients.
  101.     LogAudit* al = nullptr;
  102.     if (auditd) {
  103.         int dmesg_fd = GetBoolProperty("ro.logd.auditd.dmesg", true) ? fdDmesg : -1;
  104.         al = new LogAudit(log_buffer, dmesg_fd, &log_statistics);
  105.     }
  107.     LogKlog* kl = nullptr;
  108.     if (klogd) {
  109.         kl = new LogKlog(log_buffer, fdDmesg, fdPmesg, al != nullptr, &log_statistics);
  110.     }
  112.     readDmesg(al, kl);
  114.     // failure is an option ... messages are in dmesg (required by standard)
  115.     if (kl && kl->startListener()) {
  116.         delete kl;
  117.     }
  119.     if (al && al->startListener()) {
  120.         delete al;
  121.     }
  123.     TrustyLog::create(log_buffer);
  125.     TEMP_FAILURE_RETRY(pause());
  126.     return EXIT_SUCCESS;
  127. }
复制代码
SerializedLogBuffer



  • Log将日志封装成SerializedLogEntry、LogStatisticsElement添加到stats_
  1. SerializedLogBuffer::SerializedLogBuffer(LogReaderList* reader_list, LogTags* tags,
  2.                                          LogStatistics* stats)
  3.     : reader_list_(reader_list), tags_(tags), stats_(stats) {
  4.     Init();
  5. }
  7. void SerializedLogBuffer::Init() {
  8.     log_id_for_each(i) {
  9.         if (!SetSize(i, GetBufferSizeFromProperties(i))) {
  10.             SetSize(i, kLogBufferMinSize);
  11.         }
  12.     }
  14.     // Release any sleeping reader threads to dump their current content.
  15.     auto lock = std::lock_guard{logd_lock};
  16.     for (const auto& reader_thread : reader_list_->running_reader_threads()) {
  17.         reader_thread->TriggerReader();
  18.     }
  19. }
  21. int SerializedLogBuffer::Log(log_id_t log_id, log_time realtime, uid_t uid, pid_t pid, pid_t tid,
  22.                              const char* msg, uint16_t len) {
  23.     if (log_id >= LOG_ID_MAX || len == 0) {
  24.         return -EINVAL;
  25.     }
  27.     if (len > LOGGER_ENTRY_MAX_PAYLOAD) {
  28.         len = LOGGER_ENTRY_MAX_PAYLOAD;
  29.     }
  31.     if (!ShouldLog(log_id, msg, len)) {
  32.         stats_->AddTotal(log_id, len);
  33.         return -EACCES;
  34.     }
  36.     auto sequence = sequence_.fetch_add(1, std::memory_order_relaxed);
  38.     auto lock = std::lock_guard{logd_lock};
  39.     auto entry = LogToLogBuffer(logs_[log_id], max_size_[log_id], sequence, realtime, uid, pid, tid,
  40.                                 msg, len);
  41.     stats_->Add(entry->ToLogStatisticsElement(log_id));
  43.     MaybePrune(log_id);
  45.     reader_list_->NotifyNewLog(1 << log_id);
  46.     return len;
  47. }
  49. static SerializedLogEntry* LogToLogBuffer(std::list<SerializedLogChunk>& log_buffer,
  50.                                           size_t max_size, uint64_t sequence, log_time realtime,
  51.                                           uid_t uid, pid_t pid, pid_t tid, const char* msg,
  52.                                           uint16_t len) {
  53.     if (log_buffer.empty()) {
  54.         log_buffer.push_back(SerializedLogChunk(max_size / SerializedLogBuffer::kChunkSizeDivisor));
  55.     }
  57.     auto total_len = sizeof(SerializedLogEntry) + len;
  58.     if (!log_buffer.back().CanLog(total_len)) {
  59.         log_buffer.back().FinishWriting();
  60.         log_buffer.push_back(SerializedLogChunk(max_size / SerializedLogBuffer::kChunkSizeDivisor));
  61.     }
  63.     return log_buffer.back().Log(sequence, realtime, uid, pid, tid, msg, len);
  64. }
复制代码
LogReader

LogListener

StartListener开启线程LogListener，循环调用HandleData，通过LogBuffer的Log方法写入日志
  1. LogListener::LogListener(LogBuffer* buf) : socket_(GetLogSocket()), logbuf_(buf) {}
  3. bool LogListener::StartListener() {
  4.     if (socket_ <= 0) {
  5.         return false;
  6.     }
  7.     auto thread = std::thread(&LogListener::ThreadFunction, this);
  8.     thread.detach();
  9.     return true;
  10. }
  12. void LogListener::ThreadFunction() {
  13.     prctl(PR_SET_NAME, "logd.writer");
  15.     while (true) {
  16.         HandleData();
  17.     }
  18. }
  20. void LogListener::HandleData() {
  21.     // + 1 to ensure null terminator if MAX_PAYLOAD buffer is received
  22.     __attribute__((uninitialized)) char
  23.             buffer[sizeof(android_log_header_t) + LOGGER_ENTRY_MAX_PAYLOAD + 1];
  24.     struct iovec iov = {buffer, sizeof(buffer) - 1};
  26.     alignas(4) char control[CMSG_SPACE(sizeof(struct ucred))];
  27.     struct msghdr hdr = {
  28.         nullptr, 0, &iov, 1, control, sizeof(control), 0,
  29.     };
  31.     ssize_t n = recvmsg(socket_, &hdr, 0);
  32.     if (n <= (ssize_t)(sizeof(android_log_header_t))) {
  33.         return;
  34.     }
  36.     // To clear the entire buffer would be safe, but this contributes to 1.68%
  37.     // overhead under logging load. We are safe because we check counts, but
  38.     // still need to clear null terminator
  39.     buffer[n] = 0;
  41.     struct ucred* cred = nullptr;
  43.     struct cmsghdr* cmsg = CMSG_FIRSTHDR(&hdr);
  44.     while (cmsg != nullptr) {
  45.         if (cmsg->cmsg_level == SOL_SOCKET &&
  46.             cmsg->cmsg_type == SCM_CREDENTIALS) {
  47.             cred = (struct ucred*)CMSG_DATA(cmsg);
  48.             break;
  49.         }
  50.         cmsg = CMSG_NXTHDR(&hdr, cmsg);
  51.     }
  53.     if (cred == nullptr) {
  54.         return;
  55.     }
  57.     if (cred->uid == AID_LOGD) {
  58.         // ignore log messages we send to ourself.
  59.         // Such log messages are often generated by libraries we depend on
  60.         // which use standard Android logging.
  61.         return;
  62.     }
  64.     android_log_header_t* header =
  65.         reinterpret_cast<android_log_header_t*>(buffer);
  66.     log_id_t logId = static_cast<log_id_t>(header->id);
  67.     if (/* logId < LOG_ID_MIN || */ logId >= LOG_ID_MAX ||
  68.         logId == LOG_ID_KERNEL) {
  69.         return;
  70.     }
  72.     if (logId == LOG_ID_SECURITY) {
  73.         if (!__android_log_security()) {
  74.             return;
  75.         }
  76.         if (!clientCanWriteSecurityLog(cred->uid, cred->gid, cred->pid)) {
  77.             return;
  78.         }
  79.     }
  81.     char* msg = ((char*)buffer) + sizeof(android_log_header_t);
  82.     n -= sizeof(android_log_header_t);
  84.     // NB: hdr.msg_flags & MSG_TRUNC is not tested, silently passing a
  85.     // truncated message to the logs.
  87.     logbuf_->Log(logId, header->realtime, cred->uid, cred->pid, header->tid, msg,
  88.                  ((size_t)n <= UINT16_MAX) ? (uint16_t)n : UINT16_MAX);
  89. }
  91. int LogListener::GetLogSocket() {
  92.     static const char socketName[] = "logdw";
  93.     int sock = android_get_control_socket(socketName);
  95.     if (sock < 0) {  // logd started up in init.sh
  96.         sock = socket_local_server(
  97.             socketName, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_DGRAM);
  99.         int on = 1;
  100.         if (setsockopt(sock, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on))) {
  101.             return -1;
  102.         }
  103.     }
  104.     return sock;
  105. }
复制代码
CommandListener

运行时库

write_to_log

system/logging/liblog/logger_write.cpp
调用LogdWrite
  1. #ifdef __ANDROID__
  2. static int write_to_log(log_id_t log_id, struct iovec* vec, size_t nr) {
  3.   int ret;
  4.   struct timespec ts;
  6.   if (log_id == LOG_ID_KERNEL) {
  7.     return -EINVAL;
  8.   }
  10.   clock_gettime(CLOCK_REALTIME, &ts);
  12.   if (log_id == LOG_ID_SECURITY) {
  13.     if (vec[0].iov_len < 4) {
  14.       return -EINVAL;
  15.     }
  17.     ret = check_log_uid_permissions();
  18.     if (ret < 0) {
  19.       return ret;
  20.     }
  21.     if (!__android_log_security()) {
  22.       /* If only we could reset downstream logd counter */
  23.       return -EPERM;
  24.     }
  25.   } else if (log_id == LOG_ID_EVENTS || log_id == LOG_ID_STATS) {
  26.     if (vec[0].iov_len < 4) {
  27.       return -EINVAL;
  28.     }
  29.   }
  31.   ret = LogdWrite(log_id, &ts, vec, nr);
  32.   PmsgWrite(log_id, &ts, vec, nr);
  34.   return ret;
  35. }
  36. #else
  37. static int write_to_log(log_id_t, struct iovec*, size_t) {
  38.   // Non-Android text logs should go to __android_log_stderr_logger, not here.
  39.   // Non-Android binary logs are always dropped.
  40.   return 1;
  41. }
  42. #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需要重新毗连再次写入
  1. int LogdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr) {
  2.   ssize_t ret;
  3.   static const unsigned headerLength = 1;
  4.   struct iovec newVec[nr + headerLength];
  5.   android_log_header_t header;
  6.   size_t i, payloadSize;
  7.   static atomic_int dropped;
  9.   LogdSocket& logd_socket =
  10.       logId == LOG_ID_SECURITY ? LogdSocket::BlockingSocket() : LogdSocket::NonBlockingSocket();
  12.   if (logd_socket.sock() < 0) {
  13.     return -EBADF;
  14.   }
  16.   /* logd, after initialization and priv drop */
  17.   if (getuid() == AID_LOGD) {
  18.     /*
  19.      * ignore log messages we send to ourself (logd).
  20.      * Such log messages are often generated by libraries we depend on
  21.      * which use standard Android logging.
  22.      */
  23.     return 0;
  24.   }
  26.   header.tid = gettid();
  27.   header.realtime.tv_sec = ts->tv_sec;
  28.   header.realtime.tv_nsec = ts->tv_nsec;
  30.   newVec[0].iov_base = (unsigned char*)&header;
  31.   newVec[0].iov_len = sizeof(header);
  33.   int32_t snapshot = atomic_exchange_explicit(&dropped, 0, memory_order_relaxed);
  34.   if (snapshot && __android_log_is_loggable_len(ANDROID_LOG_INFO, "liblog", strlen("liblog"),
  35.                                                 ANDROID_LOG_VERBOSE)) {
  36.     android_log_event_int_t buffer;
  38.     header.id = LOG_ID_EVENTS;
  39.     buffer.header.tag = LIBLOG_LOG_TAG;
  40.     buffer.payload.type = EVENT_TYPE_INT;
  41.     buffer.payload.data = snapshot;
  43.     newVec[headerLength].iov_base = &buffer;
  44.     newVec[headerLength].iov_len = sizeof(buffer);
  46.     ret = TEMP_FAILURE_RETRY(writev(logd_socket.sock(), newVec, 2));
  47.     if (ret != (ssize_t)(sizeof(header) + sizeof(buffer))) {
  48.       atomic_fetch_add_explicit(&dropped, snapshot, memory_order_relaxed);
  49.     }
  50.   }
  52.   header.id = logId;
  54.   for (payloadSize = 0, i = headerLength; i < nr + headerLength; i++) {
  55.     newVec[i].iov_base = vec[i - headerLength].iov_base;
  56.     payloadSize += newVec[i].iov_len = vec[i - headerLength].iov_len;
  58.     if (payloadSize > LOGGER_ENTRY_MAX_PAYLOAD) {
  59.       newVec[i].iov_len -= payloadSize - LOGGER_ENTRY_MAX_PAYLOAD;
  60.       if (newVec[i].iov_len) {
  61.         ++i;
  62.       }
  63.       break;
  64.     }
  65.   }
  67.   // EAGAIN occurs if logd is overloaded, other errors indicate that something went wrong with
  68.   // the connection, so we reset it and try again.
  69.   ret = TEMP_FAILURE_RETRY(writev(logd_socket.sock(), newVec, i));
  70.   if (ret < 0 && errno != EAGAIN) {
  71.     logd_socket.Reconnect();
  73.     ret = TEMP_FAILURE_RETRY(writev(logd_socket.sock(), newVec, i));
  74.   }
  76.   if (ret < 0) {
  77.     ret = -errno;
  78.   }
  80.   if (ret > (ssize_t)sizeof(header)) {
  81.     ret -= sizeof(header);
  82.   } else if (ret < 0) {
  83.     atomic_fetch_add_explicit(&dropped, 1, memory_order_relaxed);
  84.   }
  86.   return ret;
  87. }
复制代码
LogdSocket

sock、GetSocket、LogdConnect打开装备/dev/socket/logdw
  1. class LogdSocket {
  2. public:
  3.   static LogdSocket& BlockingSocket() {
  4.     static LogdSocket logd_socket(true);
  5.     return logd_socket;
  6.   }
  7.   static LogdSocket& NonBlockingSocket() {
  8.     static LogdSocket logd_socket(false);
  9.     return logd_socket;
  10.   }
  12.   void Reconnect() { LogdConnect(sock_); }
  14.   // Zygote uses this to clean up open FD's after fork() and before specialization.  It is single
  15.   // threaded at this point and therefore this function is explicitly not thread safe.  It sets
  16.   // sock_ to kUninitialized, so future logs will be safely initialized whenever they happen.
  17.   void Close() {
  18.     if (sock_ != kUninitialized) {
  19.       close(sock_);
  20.     }
  21.     sock_ = kUninitialized;
  22.   }
  24.   int sock() {
  25.     GetSocket();
  26.     return sock_;
  27.   }
  29. private:
  30.   LogdSocket(bool blocking) : blocking_(blocking) {}
  32.   // Note that it is safe to call connect() multiple times on DGRAM Unix domain sockets, so this
  33.   // function is used to reconnect to logd without requiring a new socket.
  34.   static void LogdConnect(int sock) {
  35.     sockaddr_un un = {};
  36.     un.sun_family = AF_UNIX;
  37.     strcpy(un.sun_path, "/dev/socket/logdw");
  38.     TEMP_FAILURE_RETRY(connect(sock, reinterpret_cast<sockaddr*>(&un), sizeof(sockaddr_un)));
  39.   }
  41.   // sock_ should only be opened once.  If we see that sock_ is uninitialized, we
  42.   // create a new socket and attempt to exchange it into the atomic sock_.  If the
  43.   // compare/exchange was successful, then that will be the socket used for the duration of the
  44.   // program, otherwise a different thread has already opened and written the socket to the atomic,
  45.   // so close the new socket and return.
  46.   void GetSocket() {
  47.     if (sock_ != kUninitialized) {
  48.       return;
  49.     }
  51.     int flags = SOCK_DGRAM | SOCK_CLOEXEC;
  52.     if (!blocking_) {
  53.       flags |= SOCK_NONBLOCK;
  54.     }
  55.     int new_socket = TEMP_FAILURE_RETRY(socket(PF_UNIX, flags, 0));
  56.     if (new_socket < 0) {
  57.       return;
  58.     }
  60.     LogdConnect(new_socket);
  62.     int uninitialized_value = kUninitialized;
  63.     if (!sock_.compare_exchange_strong(uninitialized_value, new_socket)) {
  64.       close(new_socket);
  65.       return;
  66.     }
  67.   }
  69.   static const int kUninitialized = -1;
  70.   atomic_int sock_ = kUninitialized;
  71.   bool blocking_;
  72. };
复制代码
__android_log_print

system/logging/liblog/logger_write.cpp
  1. int __android_log_print(int prio, const char* tag, const char* fmt, ...) {
  2.   ErrnoRestorer errno_restorer;
  4.   if (!__android_log_is_loggable(prio, tag, ANDROID_LOG_VERBOSE)) {
  5.     return -EPERM;
  6.   }
  8.   va_list ap;
  9.   __attribute__((uninitialized)) char buf[LOG_BUF_SIZE];
  11.   va_start(ap, fmt);
  12.   vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);
  13.   va_end(ap);
  15.   __android_log_message log_message = {
  16.       sizeof(__android_log_message), LOG_ID_MAIN, prio, tag, nullptr, 0, buf};
  17.   __android_log_write_log_message(&log_message);
  18.   return 1;
  19. }
复制代码
__android_log_write_log_message

  1. void __android_log_write_log_message(__android_log_message* log_message) {
  2.   ErrnoRestorer errno_restorer;
  4.   if (log_message->buffer_id != LOG_ID_DEFAULT && log_message->buffer_id != LOG_ID_MAIN &&
  5.       log_message->buffer_id != LOG_ID_SYSTEM && log_message->buffer_id != LOG_ID_RADIO &&
  6.       log_message->buffer_id != LOG_ID_CRASH) {
  7.     return;
  8.   }
  10.   if (log_message->tag == nullptr) {
  11.     log_message->tag = GetDefaultTag().c_str();
  12.   }
  14. #if __BIONIC__
  15.   if (log_message->priority == ANDROID_LOG_FATAL) {
  16.     android_set_abort_message(log_message->message);
  17.   }
  18. #endif
  20.   get_logger_function()(log_message);
  21. }
复制代码
调用get_logger_function，get_file_logger_path判定是否有界说ro.log.file_logger.path指定log文件路径，如果没有则调用__android_log_logd_logger
  1. static __android_logger_function get_logger_function() {
  2.   if (user_set_logger_function != nullptr) {
  3.     return user_set_logger_function;
  4.   }
  5.   static __android_logger_function default_logger_function = []() {
  6. #if __ANDROID__
  7.     if (get_file_logger_path() != nullptr) {
  8.       return file_logger;
  9.     } else {
  10.       return __android_log_logd_logger;
  11.     }
  12. #else
  13.     return file_logger;
  14. #endif
  15.   }();
  16.   return default_logger_function;
  17. }
  19. #ifdef __ANDROID__
  20. static const char* get_file_logger_path() {
  21.   static const char* file_logger_path = []() {
  22.     static char path[PROP_VALUE_MAX] = {};
  23.     if (__system_property_get("ro.log.file_logger.path", path) > 0) {
  24.       return path;
  25.     }
  26.     return (char*)nullptr;  // means file_logger should not be used
  27.   }();
  28.   return file_logger_path;
  29. }
  30. #endif
复制代码
__android_log_logd_logger将优先级、标签、内容存在数字元素vec[0]、vec[1]和vec[2]，最后调用write_to_log
+1是因为标签和内容后面跟着’\0’，用来区分息争析
  1. void __android_log_logd_logger(const struct __android_log_message* log_message) {
  2.   int buffer_id = log_message->buffer_id == LOG_ID_DEFAULT ? LOG_ID_MAIN : log_message->buffer_id;
  4.   struct iovec vec[3];
  5.   vec[0].iov_base =
  6.       const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(&log_message->priority));
  7.   vec[0].iov_len = 1;
  8.   vec[1].iov_base = const_cast<void*>(static_cast<const void*>(log_message->tag));
  9.   vec[1].iov_len = strlen(log_message->tag) + 1;
  10.   vec[2].iov_base = const_cast<void*>(static_cast<const void*>(log_message->message));
  11.   vec[2].iov_len = strlen(log_message->message) + 1;
  13.   write_to_log(static_cast<log_id_t>(buffer_id), vec, 3);
  14. }
复制代码
__android_log_buf_print

也是调用__android_log_write_log_message，同上
  1. int __android_log_buf_print(int bufID, int prio, const char* tag, const char* fmt, ...) {
  2.   ErrnoRestorer errno_restorer;
  4.   if (!__android_log_is_loggable(prio, tag, ANDROID_LOG_VERBOSE)) {
  5.     return -EPERM;
  6.   }
  8.   va_list ap;
  9.   __attribute__((uninitialized)) char buf[LOG_BUF_SIZE];
  11.   va_start(ap, fmt);
  12.   vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);
  13.   va_end(ap);
  15.   __android_log_message log_message = {
  16.       sizeof(__android_log_message), bufID, prio, tag, nullptr, 0, buf};
  17.   __android_log_write_log_message(&log_message);
  18.   return 1;
  19. }
复制代码
__android_log_bwrite/__android_log_btwrite/__android_log_bswrite



  • __android_log_bwrite 的内容可由多个值组成
  • __android_log_btwrite 的内容只有一个值，类型为参数type
  • __android_log_btwrite 的内容为字符串
  1. int __android_log_bwrite(int32_t tag, const void* payload, size_t len) {
  2.   ErrnoRestorer errno_restorer;
  4.   struct iovec vec[2];
  6.   vec[0].iov_base = &tag;
  7.   vec[0].iov_len = sizeof(tag);
  8.   vec[1].iov_base = (void*)payload;
  9.   vec[1].iov_len = len;
  11.   return write_to_log(LOG_ID_EVENTS, vec, 2);
  12. }
  14. int __android_log_btwrite(int32_t tag, char type, const void* payload, size_t len) {
  15.   ErrnoRestorer errno_restorer;
  17.   struct iovec vec[3];
  19.   vec[0].iov_base = &tag;
  20.   vec[0].iov_len = sizeof(tag);
  21.   vec[1].iov_base = &type;
  22.   vec[1].iov_len = sizeof(type);
  23.   vec[2].iov_base = (void*)payload;
  24.   vec[2].iov_len = len;
  26.   return write_to_log(LOG_ID_EVENTS, vec, 3);
  27. }
  29. int __android_log_bswrite(int32_t tag, const char* payload) {
  30.   ErrnoRestorer errno_restorer;
  32.   struct iovec vec[4];
  33.   char type = EVENT_TYPE_STRING;
  34.   uint32_t len = strlen(payload);
  36.   vec[0].iov_base = &tag;
  37.   vec[0].iov_len = sizeof(tag);
  38.   vec[1].iov_base = &type;
  39.   vec[1].iov_len = sizeof(type);
  40.   vec[2].iov_base = &len;
  41.   vec[2].iov_len = sizeof(len);
  42.   vec[3].iov_base = (void*)payload;
  43.   vec[3].iov_len = len;
  45.   return write_to_log(LOG_ID_EVENTS, vec, 4);
  46. }
复制代码
# C/C++写入日志

system/logging/liblog/include/log/log.h(Android13)
属性LOG_NDEBUG限定Log的输出（为0时相关函数界说为空）
  1. #ifndef LOG_NDEBUG
  2. #ifdef NDEBUG
  3. #define LOG_NDEBUG 1
  4. #else
  5. #define LOG_NDEBUG 0
  6. #endif
  7. #endif
复制代码
属性LOG_TAG界说了当前编译单位的日志TAG，默认为空
  1. #ifndef LOG_TAG
  2. #define LOG_TAG NULL
  3. #endif
复制代码
ALOGV 、ALOGD 、ALOGI 、ALOGW 和ALOGE

/system/logging/liblog/include/log/log_main.h，ALOGV只有当LOG_NDEBUG为0时才有效
  1. #ifndef ALOGV
  2. #define __ALOGV(...) ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
  3. #if LOG_NDEBUG
  4. #define ALOGV(...)                   \
  5.   do {                               \
  6.     __FAKE_USE_VA_ARGS(__VA_ARGS__); \
  7.     if (false) {                     \
  8.       __ALOGV(__VA_ARGS__);          \
  9.     }                                \
  10.   } while (false)
  11. #else
  12. #define ALOGV(...) __ALOGV(__VA_ARGS__)
  13. #endif
  14. #endif
  16. #ifndef ALOGD
  17. #define ALOGD(...) ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__))
  18. #endif
  20. #ifndef ALOGI
  21. #define ALOGI(...) ((void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__))
  22. #endif
  24. #ifndef ALOGW
  25. #define ALOGW(...) ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__))
  26. #endif
  28. #ifndef ALOGE
  29. #define ALOGE(...) ((void)ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__))
  30. #endif
复制代码
调用ALOG、LOG_PRI、android_printLog，最后调用运行时库的__android_log_print
  1. #ifndef ALOG
  2. #define ALOG(priority, tag, ...) LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)
  3. #endif
  5. #ifndef LOG_PRI
  6. #define LOG_PRI(priority, tag, ...) android_printLog(priority, tag, __VA_ARGS__)
  7. #endif
  9. #define android_printLog(prio, tag, ...) \
  10.   __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
  1. #ifndef RLOGV
  2. #define __RLOGV(...)                                                         \
  3.   ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_VERBOSE, LOG_TAG, \
  4.                                  __VA_ARGS__))
  5. #if LOG_NDEBUG
  6. #define RLOGV(...)          \
  7.   do {                      \
  8.     if (0) {                \
  9.       __RLOGV(__VA_ARGS__); \
  10.     }                       \
  11.   } while (0)
  12. #else
  13. #define RLOGV(...) __RLOGV(__VA_ARGS__)
  14. #endif
  15. #endif
  17. #ifndef RLOGD
  18. #define RLOGD(...)                                                         \
  19.   ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_DEBUG, LOG_TAG, \
  20.                                  __VA_ARGS__))
  21. #endif
  23. #ifndef RLOGI
  24. #define RLOGI(...)                                                        \
  25.   ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_INFO, LOG_TAG, \
  26.                                  __VA_ARGS__))
  27. #endif
  29. #ifndef RLOGW
  30. #define RLOGW(...)                                                        \
  31.   ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_WARN, LOG_TAG, \
  32.                                  __VA_ARGS__))
  33. #endif
  35. #ifndef RLOGE
  36. #define RLOGE(...)                                                         \
  37.   ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_ERROR, LOG_TAG, \
  38.                                  __VA_ARGS__))
  39. #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
  1. #ifndef SLOGV
  2. #define __SLOGV(...)                                                          \
  3.   ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_VERBOSE, LOG_TAG, \
  4.                                  __VA_ARGS__))
  5. #if LOG_NDEBUG
  6. #define SLOGV(...)          \
  7.   do {                      \
  8.     if (0) {                \
  9.       __SLOGV(__VA_ARGS__); \
  10.     }                       \
  11.   } while (0)
  12. #else
  13. #define SLOGV(...) __SLOGV(__VA_ARGS__)
  14. #endif
  15. #endif
  17. #ifndef SLOGD
  18. #define SLOGD(...)                                                          \
  19.   ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_DEBUG, LOG_TAG, \
  20.                                  __VA_ARGS__))
  21. #endif
  23. #ifndef SLOGI
  24. #define SLOGI(...)                                                         \
  25.   ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_INFO, LOG_TAG, \
  26.                                  __VA_ARGS__))
  27. #endif
  29. #ifndef SLOGW
  30. #define SLOGW(...)                                                         \
  31.   ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_WARN, LOG_TAG, \
  32.                                  __VA_ARGS__))
  33. #endif
  35. #ifndef SLOGE
  36. #define SLOGE(...)                                                          \
  37.   ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_ERROR, LOG_TAG, \
  38.                                  __VA_ARGS__))
  39. #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
  1. #define android_btWriteLog(tag, type, payload, len) \
  2.   __android_log_btwrite(tag, type, payload, len)
  4. typedef enum {
  5.   /* Special markers for android_log_list_element type */
  6.   EVENT_TYPE_LIST_STOP = '\n', /* declare end of list  */
  7.   EVENT_TYPE_UNKNOWN = '?',    /* protocol error       */
  9.   /* must match with declaration in java/android/android/util/EventLog.java */
  10.   EVENT_TYPE_INT = 0,  /* int32_t */
  11.   EVENT_TYPE_LONG = 1, /* int64_t */
  12.   EVENT_TYPE_STRING = 2,
  13.   EVENT_TYPE_LIST = 3,
  14.   EVENT_TYPE_FLOAT = 4,
  15. } AndroidEventLogType;
  17. #ifndef LOG_EVENT_INT
  18. #define LOG_EVENT_INT(_tag, _value)                                          \
  19.   {                                                                          \
  20.     int intBuf = _value;                                                     \
  21.     (void)android_btWriteLog(_tag, EVENT_TYPE_INT, &intBuf, sizeof(intBuf)); \
  22.   }
  23. #endif
  25. #ifndef LOG_EVENT_LONG
  26. #define LOG_EVENT_LONG(_tag, _value)                                            \
  27.   {                                                                             \
  28.     long long longBuf = _value;                                                 \
  29.     (void)android_btWriteLog(_tag, EVENT_TYPE_LONG, &longBuf, sizeof(longBuf)); \
  30.   }
  31. #endif
  33. #ifndef LOG_EVENT_FLOAT
  34. #define LOG_EVENT_FLOAT(_tag, _value)                           \
  35.   {                                                             \
  36.     float floatBuf = _value;                                    \
  37.     (void)android_btWriteLog(_tag, EVENT_TYPE_FLOAT, &floatBuf, \
  38.                              sizeof(floatBuf));                 \
  39.   }
  40. #endif
  42. #ifndef LOG_EVENT_STRING
  43. #define LOG_EVENT_STRING(_tag, _value) \
  44.   (void)__android_log_bswrite(_tag, _value);
  45. #endif
复制代码
Java写入日志

android.util.Log

frameworks/base/core/java/android/util/Log.java
  1. public final class Log {
  2.    ......
  4.     /**
  5.      * Priority constant for the println method; use Log.v.
  6.      */
  7.     public static final int VERBOSE = 2;
  9.     /**
  10.      * Priority constant for the println method; use Log.d.
  11.      */
  12.     public static final int DEBUG = 3;
  14.     /**
  15.      * Priority constant for the println method; use Log.i.
  16.      */
  17.     public static final int INFO = 4;
  19.     /**
  20.      * Priority constant for the println method; use Log.w.
  21.      */
  22.     public static final int WARN = 5;
  24.     /**
  25.      * Priority constant for the println method; use Log.e.
  26.      */
  27.     public static final int ERROR = 6;
  29.     /**
  30.      * Priority constant for the println method.
  31.      */
  32.     public static final int ASSERT = 7;
  34.         ......
  36.     public static int v(@Nullable String tag, @NonNull String msg) {
  37.         return println_native(LOG_ID_MAIN, VERBOSE, tag, msg);
  38.     }
  40.     public static int d(@Nullable String tag, @NonNull String msg) {
  41.         return println_native(LOG_ID_MAIN, DEBUG, tag, msg);
  42.     }
  44.     public static int i(@Nullable String tag, @NonNull String msg) {
  45.         return println_native(LOG_ID_MAIN, INFO, tag, msg);
  46.     }
  48.     public static int w(@Nullable String tag, @NonNull String msg) {
  49.         return println_native(LOG_ID_MAIN, WARN, tag, msg);
  50.     }
  52.     public static int e(@Nullable String tag, @NonNull String msg) {
  53.         return println_native(LOG_ID_MAIN, ERROR, tag, msg);
  54.     }
  56.         ......
  58.     /** @hide */ public static final int LOG_ID_MAIN = 0;
  59.     /** @hide */ public static final int LOG_ID_RADIO = 1;
  60.     /** @hide */ public static final int LOG_ID_EVENTS = 2;
  61.     /** @hide */ public static final int LOG_ID_SYSTEM = 3;
  62.     /** @hide */ public static final int LOG_ID_CRASH = 4;       
  63.         ......
  64. }
复制代码
调用println_native，传入LOG_ID_MAIN
println_native

根据frameworks/base/core/jni/android_util_Log.cpp
  1. static const JNINativeMethod gMethods[] = {
  2.         ......
  3.     { "println_native",  "(IILjava/lang/String;Ljava/lang/String;)I", (void*) android_util_Log_println_native },
  4.           ......
  5. };
复制代码
可知对应的调用函数，判定日志内容msgObj 是否为空，判定类型是否在[0, LOG_ID_MAX]，最后调用运行时库的__android_log_buf_write写入log
  1. static jint android_util_Log_println_native(JNIEnv* env, jobject clazz,
  2.         jint bufID, jint priority, jstring tagObj, jstring msgObj)
  3. {
  4.     const char* tag = NULL;
  5.     const char* msg = NULL;
  7.     if (msgObj == NULL) {
  8.         jniThrowNullPointerException(env, "println needs a message");
  9.         return -1;
  10.     }
  12.     if (bufID < 0 || bufID >= LOG_ID_MAX) {
  13.         jniThrowNullPointerException(env, "bad bufID");
  14.         return -1;
  15.     }
  17.     if (tagObj != NULL)
  18.         tag = env->GetStringUTFChars(tagObj, NULL);
  19.     msg = env->GetStringUTFChars(msgObj, NULL);
  21.     int res = __android_log_buf_write(bufID, (android_LogPriority)priority, tag, msg);
  23.     if (tag != NULL)
  24.         env->ReleaseStringUTFChars(tagObj, tag);
  25.     env->ReleaseStringUTFChars(msgObj, msg);
  27.     return res;
  28. }
复制代码
android.util.Slog

frameworks/base/core/java/android/util/Slog.java
只可在系统内部使用，同上调用Log中的println_native传入LOG_ID_SYSTEM
  1. public final class Slog {
  2.        
  3.         ......
  4.        
  5.         @UnsupportedAppUsage
  6.     public static int v(@Nullable String tag, @NonNull String msg) {
  7.         return Log.println_native(Log.LOG_ID_SYSTEM, Log.VERBOSE, tag, msg);
  8.     }
  9.        
  10.         @UnsupportedAppUsage
  11.     public static int d(@Nullable String tag, @NonNull String msg) {
  12.         return Log.println_native(Log.LOG_ID_SYSTEM, Log.DEBUG, tag, msg);
  13.     }
  15.     @UnsupportedAppUsage
  16.     public static int i(@Nullable String tag, @NonNull String msg) {
  17.         return Log.println_native(Log.LOG_ID_SYSTEM, Log.INFO, tag, msg);
  18.     }
  20.     @UnsupportedAppUsage
  21.     public static int w(@Nullable String tag, @NonNull String msg) {
  22.         return Log.println_native(Log.LOG_ID_SYSTEM, Log.WARN, tag, msg);
  23.     }
  25.     @UnsupportedAppUsage
  26.     public static int e(@Nullable String tag, @NonNull String msg) {
  27.         return Log.println_native(Log.LOG_ID_SYSTEM, Log.ERROR, tag, msg);
  28.     }
  29. }
复制代码
android.util.Rlog

frameworks/base/core/java/android/util/Rlog.java
只可在系统内部使用，同上调用Log中的println_native传入LOG_ID_RADIO
  1. public final class Rlog {
  2.        
  3.         .....
  5.     @UnsupportedAppUsage
  6.     public static int v(String tag, String msg) {
  7.         return Log.println_native(Log.LOG_ID_RADIO, Log.VERBOSE, tag, msg);
  8.     }
  10.     @UnsupportedAppUsage
  11.     public static int d(String tag, String msg) {
  12.         return Log.println_native(Log.LOG_ID_RADIO, Log.DEBUG, tag, msg);
  13.     }
  15.     @UnsupportedAppUsage
  16.     public static int i(String tag, String msg) {
  17.         return Log.println_native(Log.LOG_ID_RADIO, Log.INFO, tag, msg);
  18.     }
  20.     @UnsupportedAppUsage
  21.     public static int w(String tag, String msg) {
  22.         return Log.println_native(Log.LOG_ID_RADIO, Log.WARN, tag, msg);
  23.     }
  25.     @UnsupportedAppUsage
  26.     public static int e(String tag, String msg) {
  27.         return Log.println_native(Log.LOG_ID_RADIO, Log.ERROR, tag, msg);
  28.     }
  30.     public static int println(int priority, String tag, String msg) {
  31.         return Log.println_native(Log.LOG_ID_RADIO, priority, tag, msg);
  32.     }
  33. }
复制代码
android.util.EventLog

frameworks/base/core/java/android/util/EventLog.java，重载了5个版本的writeEvent方法，日志内容分别为int、long、float、string、list
  1. public class EventLog {
  2.         ......
  3.        
  4.         private static final byte INT_TYPE    = 0;
  5.     private static final byte LONG_TYPE   = 1;
  6.     private static final byte STRING_TYPE = 2;
  7.     private static final byte LIST_TYPE   = 3;
  8.     private static final byte FLOAT_TYPE = 4;
  9.    
  10.     public static native int writeEvent(int tag, int value);
  12.     public static native int writeEvent(int tag, long value);
  14.     public static native int writeEvent(int tag, float value);
  16.     public static native int writeEvent(int tag, String str);
  18.     public static native int writeEvent(int tag, Object... list);
  19.        
  20.         ......
  21. }
复制代码
writeEvent

根据frameworks/base/core/jni/android_util_EventLog.cpp
  1. static const JNINativeMethod gRegisterMethods[] = {
  2.     /* name, signature, funcPtr */
  3.     { "writeEvent", "(II)I", (void*) ELog::writeEventInteger },
  4.     { "writeEvent", "(IJ)I", (void*) ELog::writeEventLong },
  5.     { "writeEvent", "(IF)I", (void*) ELog::writeEventFloat },
  6.     { "writeEvent", "(ILjava/lang/String;)I", (void*) ELog::writeEventString },
  7.     { "writeEvent", "(I[Ljava/lang/Object;)I", (void*) ELog::writeEventArray },
  8.     ......
  9. };
复制代码
可知调用
  1. static jint writeEventInteger(JNIEnv* env ATTRIBUTE_UNUSED, jobject clazz ATTRIBUTE_UNUSED,
  2.         jint tag, jint value) {
  3.     android_log_event_list ctx(tag);
  4.     ctx << (int32_t)value;
  5.     return ctx.write(LogID);
  6. }
  8. static jint writeEventLong(JNIEnv* env ATTRIBUTE_UNUSED, jobject clazz ATTRIBUTE_UNUSED,
  9.         jint tag, jlong value) {
  10.     android_log_event_list ctx(tag);
  11.     ctx << (int64_t)value;
  12.     return ctx.write(LogID);
  13. }
  15. static jint writeEventFloat(JNIEnv* env ATTRIBUTE_UNUSED, jobject clazz ATTRIBUTE_UNUSED,
  16.         jint tag, jfloat value) {
  17.     android_log_event_list ctx(tag);
  18.     ctx << (float)value;
  19.     return ctx.write(LogID);
  20. }
  22. static jint writeEventString(JNIEnv* env, jobject clazz ATTRIBUTE_UNUSED, jint tag,
  23.         jstring value) {
  24.     android_log_event_list ctx(tag);
  25.     // Don't throw NPE -- I feel like it's sort of mean for a logging function
  26.     // to be all crashy if you pass in NULL -- but make the NULL value explicit.
  27.     ctx << (value != nullptr ? ScopedUtfChars(env, value).c_str() : "NULL");
  28.     return ctx.write(LogID);
  29. }
  31. static jint writeEventArray(JNIEnv* env, jobject clazz ATTRIBUTE_UNUSED, jint tag,
  32.         jobjectArray value) {
  33.     android_log_event_list ctx(tag);
  34.     if (value == nullptr) {
  35.         ctx << "[NULL]";
  36.         return ctx.write(LogID);
  37.     }
  38.     jsize copied = 0, num = env->GetArrayLength(value);
  39.     for (; copied < num && copied < 255; ++copied) {
  40.         if (ctx.status()) break;
  41.         ScopedLocalRef<jobject> item(env, env->GetObjectArrayElement(value, copied));
  42.         if (item == nullptr) {
  43.             ctx << "NULL";
  44.         } else if (env->IsInstanceOf(item.get(), gStringClass)) {
  45.             ctx << ScopedUtfChars(env, (jstring) item.get()).c_str();
  46.         } else if (env->IsInstanceOf(item.get(), gIntegerClass)) {
  47.             ctx << (int32_t)env->GetIntField(item.get(), gIntegerValueID);
  48.         } else if (env->IsInstanceOf(item.get(), gLongClass)) {
  49.             ctx << (int64_t)env->GetLongField(item.get(), gLongValueID);
  50.         } else if (env->IsInstanceOf(item.get(), gFloatClass)) {
  51.             ctx << (float)env->GetFloatField(item.get(), gFloatValueID);
  52.         } else {
  53.             jniThrowException(env,
  54.                     "java/lang/IllegalArgumentException",
  55.                     "Invalid payload item type");
  56.             return -1;
  57.         }
  58.     }
  59.     return ctx.write(LogID);
  60. }
复制代码
log_event_list

system/logging/liblog/include/log/log_event_list.h
  1. int android_log_write_list(android_log_context ctx, log_id_t id);
  3. class android_log_event_list {
  5.         ......
  6.     int write(log_id_t id = LOG_ID_EVENTS) {
  7.     /* facilitate -EBUSY retry */
  8.     if ((ret == -EBUSY) || (ret > 0)) ret = 0;
  9.     int retval = android_log_write_list(ctx, id);
  10.     /* existing errors trump transmission errors */
  11.     if (!ret) ret = retval;
  12.     return ret;
  13.   }
  14.    ......
  15. }
复制代码
system/logging/liblog/log_event_list.cpp，根据id == LOG_ID_EVENTS调用__android_log_bwrite
  1. int android_log_write_list(android_log_context context, log_id_t id) {
  2.   const char* msg;
  3.   ssize_t len;
  5.   if ((id != LOG_ID_EVENTS) && (id != LOG_ID_SECURITY) && (id != LOG_ID_STATS)) {
  6.     return -EINVAL;
  7.   }
  9.   if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
  10.     return -EBADF;
  11.   }
  12.   if (context->list_nest_depth) {
  13.     return -EIO;
  14.   }
  15.   /* NB: if there was overflow, then log is truncated. Nothing reported */
  16.   context->storage[1] = context->count[0];
  17.   len = context->len = context->pos;
  18.   msg = (const char*)context->storage;
  19.   /* it's not a list */
  20.   if (context->count[0] <= 1) {
  21.     len -= sizeof(uint8_t) + sizeof(uint8_t);
  22.     if (len < 0) {
  23.       len = 0;
  24.     }
  25.     msg += sizeof(uint8_t) + sizeof(uint8_t);
  26.   }
  27.   return (id == LOG_ID_EVENTS)
  28.              ? __android_log_bwrite(context->tag, msg, len)
  29.              : ((id == LOG_ID_STATS) ? __android_log_stats_bwrite(context->tag, msg, len)
  30.                                      : __android_log_security_bwrite(context->tag, msg, len));
  31. }
复制代码
Logcat工具分析

基础数据布局

logcat

system/logging/logcat/logcat.cpp
  1. int main(int argc, char** argv) {
  2.     Logcat logcat;
  3.     return logcat.Run(argc, argv);
  4. }
复制代码
下面来分析其Run方法
命令参数

  1. int Logcat::Run(int argc, char** argv) {
  2.            ......
  3.     while (true) {
  4.     ......
  5.         switch (c) {
  6.                 ......
  7.             case 'd':
  8.                 mode |= ANDROID_LOG_NONBLOCK;
  9.                 break;
  11.             case 't':
  12.                 got_t = true;
  13.                 mode |= ANDROID_LOG_NONBLOCK;
  14.                 FALLTHROUGH_INTENDED;
  15.             case 'T':
  16.                 if (strspn(optarg, "0123456789") != strlen(optarg)) {
  17.                     char* cp = parseTime(tail_time, optarg);
  18.                     if (!cp) {
  19.                         error(EXIT_FAILURE, 0, "-%c '%s' not in time format.", c, optarg);
  20.                     }
  21.                     if (*cp) {
  22.                         char ch = *cp;
  23.                         *cp = '\0';
  24.                         fprintf(stderr, "WARNING: -%c '%s' '%c%s' time truncated\n", c, optarg, ch,
  25.                                 cp + 1);
  26.                         *cp = ch;
  27.                     }
  28.                 } else {
  29.                     if (!ParseUint(optarg, &tail_lines) || tail_lines < 1) {
  30.                         fprintf(stderr, "WARNING: -%c %s invalid, setting to 1\n", c, optarg);
  31.                         tail_lines = 1;
  32.                     }
  33.                 }
  34.                 break;
  36.             case 'D':
  37.                 print_dividers_ = true;
  38.                 break;
  40.             case 'e':
  41.                 regex_.reset(new std::regex(optarg));
  42.                 break;
  44.             case 'm': {
  45.                 if (!ParseUint(optarg, &max_count_) || max_count_ < 1) {
  46.                     error(EXIT_FAILURE, 0, "-%c '%s' isn't an integer greater than zero.", c,
  47.                           optarg);
  48.                 }
  49.             } break;
  51.             case 'g':
  52.                 if (!optarg) {
  53.                     getLogSize = true;
  54.                     break;
  55.                 }
  56.                 FALLTHROUGH_INTENDED;
  58.             case 'G': {
  59.                 if (!ParseByteCount(optarg, &setLogSize) || setLogSize < 1) {
  60.                     error(EXIT_FAILURE, 0, "-G must be specified as <num><multiplier>.");
  61.                 }
  62.             } break;
  64.             case 'p':
  65.                 if (!optarg) {
  66.                     getPruneList = true;
  67.                     break;
  68.                 }
  69.                 FALLTHROUGH_INTENDED;
  71.             case 'P':
  72.                 setPruneList = optarg;
  73.                 break;
  74.             case 'b':
  75.                 for (const auto& buffer : Split(optarg, delimiters)) {
  76.                     if (buffer == "default") {
  77.                         id_mask |= (1 << LOG_ID_MAIN) | (1 << LOG_ID_SYSTEM) | (1 << LOG_ID_CRASH);
  78.                     } else if (buffer == "all") {
  79.                         id_mask = -1;
  80.                     } else {
  81.                         log_id_t log_id = android_name_to_log_id(buffer.c_str());
  82.                         if (log_id >= LOG_ID_MAX) {
  83.                             error(EXIT_FAILURE, 0, "Unknown buffer '%s' listed for -b.",
  84.                                   buffer.c_str());
  85.                         }
  86.                         if (log_id == LOG_ID_SECURITY) {
  87.                             security_buffer_selected = true;
  88.                         }
  89.                         id_mask |= (1 << log_id);
  90.                     }
  91.                 }
  92.                 break;
  94.             case 'B':
  95.                 print_binary_ = 1;
  96.                 break;
  98.             case 'f':
  99.                 if ((tail_time == log_time::EPOCH) && !tail_lines) {
  100.                     tail_time = lastLogTime(optarg);
  101.                 }
  102.                 // redirect output to a file
  103.                 output_file_name_ = optarg;
  104.                 break;
  105.             case 'r':
  106.                 if (!ParseUint(optarg, &log_rotate_size_kb_) || log_rotate_size_kb_ < 1) {
  107.                     error(EXIT_FAILURE, 0, "Invalid parameter '%s' to -r.", optarg);
  108.                 }
  109.                 break;
  111.             case 'n':
  112.                 if (!ParseUint(optarg, &max_rotated_logs_) || max_rotated_logs_ < 1) {
  113.                     error(EXIT_FAILURE, 0, "Invalid parameter '%s' to -n.", optarg);
  114.                 }
  115.                 break;
  117.             case 'v':
  118.                 for (const auto& arg : Split(optarg, delimiters)) {
  119.                     int err = SetLogFormat(arg.c_str());
  120.                     if (err < 0) {
  121.                         error(EXIT_FAILURE, 0, "Invalid parameter '%s' to -v.", arg.c_str());
  122.                     }
  123.                     if (err) hasSetLogFormat = true;
  124.                 }
  125.                 break;
  127.             case 'S':
  128.                 printStatistics = true;
  129.                 break;
  131.             case ':':
  132.                 error(EXIT_FAILURE, 0, "Option '%s' needs an argument.", argv[optind - 1]);
  133.                 break;
  135.             case 'h':
  136.                 show_help();
  137.                 return EXIT_SUCCESS;
  139.             case '?':
  140.                 error(EXIT_FAILURE, 0, "Unknown option '%s'.", argv[optind]);
  141.                 break;
  143.             default:
  144.                 error(EXIT_FAILURE, 0, "Unknown getopt_long() result '%c'.", c);
  145.         }
  146.     }
复制代码


  • 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
  1. int Logcat::SetLogFormat(const char* format_string) {
  2.     AndroidLogPrintFormat format = android_log_formatFromString(format_string);
  4.     // invalid string?
  5.     if (format == FORMAT_OFF) return -1;
  7.     return android_log_setPrintFormat(logformat_.get(), format);
  8. }
复制代码
system/logging/liblog/logprint.cpp
  1. AndroidLogPrintFormat android_log_formatFromString(const char* formatString) {
  2.   /* clang-format off */
  3.   if (!strcmp(formatString, "brief")) return FORMAT_BRIEF;
  4.   if (!strcmp(formatString, "process")) return FORMAT_PROCESS;
  5.   if (!strcmp(formatString, "tag")) return FORMAT_TAG;
  6.   if (!strcmp(formatString, "thread")) return FORMAT_THREAD;
  7.   if (!strcmp(formatString, "raw")) return FORMAT_RAW;
  8.   if (!strcmp(formatString, "time")) return FORMAT_TIME;
  9.   if (!strcmp(formatString, "threadtime")) return FORMAT_THREADTIME;
  10.   if (!strcmp(formatString, "long")) return FORMAT_LONG;
  11.   if (!strcmp(formatString, "color")) return FORMAT_MODIFIER_COLOR;
  12.   if (!strcmp(formatString, "colour")) return FORMAT_MODIFIER_COLOR;
  13.   if (!strcmp(formatString, "usec")) return FORMAT_MODIFIER_TIME_USEC;
  14.   if (!strcmp(formatString, "nsec")) return FORMAT_MODIFIER_TIME_NSEC;
  15.   if (!strcmp(formatString, "printable")) return FORMAT_MODIFIER_PRINTABLE;
  16.   if (!strcmp(formatString, "year")) return FORMAT_MODIFIER_YEAR;
  17.   if (!strcmp(formatString, "zone")) return FORMAT_MODIFIER_ZONE;
  18.   if (!strcmp(formatString, "epoch")) return FORMAT_MODIFIER_EPOCH;
  19.   if (!strcmp(formatString, "monotonic")) return FORMAT_MODIFIER_MONOTONIC;
  20.   if (!strcmp(formatString, "uid")) return FORMAT_MODIFIER_UID;
  21.   if (!strcmp(formatString, "descriptive")) return FORMAT_MODIFIER_DESCRIPT;
  22.     /* clang-format on */
  24. #if !defined(__MINGW32__)
  25.   // Check whether the format string is actually a time zone. If tzname[0]
  26.   // is the empty string, that's tzset() signalling that it doesn't know
  27.   // the requested timezone.
  28.   TzSetter tz(formatString);
  29.   if (!*tzname[0]) {
  30.     tz.Reset();
  31.   } else {
  32.     // We keep the new time zone as a side effect!
  33.     return FORMAT_MODIFIER_ZONE;
  34.   }
  35. #endif
  37.   return FORMAT_OFF;
  38. }
  40. int android_log_setPrintFormat(AndroidLogFormat* p_format, AndroidLogPrintFormat format) {
  41.   switch (format) {
  42.     case FORMAT_MODIFIER_COLOR:
  43.       p_format->colored_output = true;
  44.       return 0;
  45.     case FORMAT_MODIFIER_TIME_USEC:
  46.       p_format->usec_time_output = true;
  47.       return 0;
  48.     case FORMAT_MODIFIER_TIME_NSEC:
  49.       p_format->nsec_time_output = true;
  50.       return 0;
  51.     case FORMAT_MODIFIER_PRINTABLE:
  52.       p_format->printable_output = true;
  53.       return 0;
  54.     case FORMAT_MODIFIER_YEAR:
  55.       p_format->year_output = true;
  56.       return 0;
  57.     case FORMAT_MODIFIER_ZONE:
  58.       p_format->zone_output = !p_format->zone_output;
  59.       return 0;
  60.     case FORMAT_MODIFIER_EPOCH:
  61.       p_format->epoch_output = true;
  62.       return 0;
  63.     case FORMAT_MODIFIER_MONOTONIC:
  64.       p_format->monotonic_output = true;
  65.       return 0;
  66.     case FORMAT_MODIFIER_UID:
  67.       p_format->uid_output = true;
  68.       return 0;
  69.     case FORMAT_MODIFIER_DESCRIPT:
  70.       p_format->descriptive_output = true;
  71.       descriptive_output = true;
  72.       return 0;
  73.     default:
  74.       break;
  75.   }
  76.   p_format->format = format;
  77.   return 1;
  78. }
复制代码
日志的格式为＜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
  1.     // If no buffers are specified, default to using these buffers.
  2.     if (id_mask == 0) {
  3.         id_mask = (1 << LOG_ID_MAIN) | (1 << LOG_ID_SYSTEM) | (1 << LOG_ID_CRASH) |
  4.                   (1 << LOG_ID_KERNEL);
  5.     }
复制代码
未设置选项v时，将情况变量ANDROID_PRINTF_LOG的值设置为当前格式，若无则设置为threadtime
  1.     if (!hasSetLogFormat) {
  2.         const char* logFormat = getenv("ANDROID_PRINTF_LOG");
  4.         if (!!logFormat) {
  5.             for (const auto& arg : Split(logFormat, delimiters)) {
  6.                 int err = SetLogFormat(arg.c_str());
  7.                 // environment should not cause crash of logcat
  8.                 if (err < 0) {
  9.                     fprintf(stderr, "invalid format in ANDROID_PRINTF_LOG '%s'\n", arg.c_str());
  10.                 }
  11.                 if (err > 0) hasSetLogFormat = true;
  12.             }
  13.         }
  14.         if (!hasSetLogFormat) {
  15.             SetLogFormat("threadtime");
  16.         }
  17.     }
复制代码


  • forceFilters.size()不为0，表示通过选项Q让logcat读取/proc/cmdline中的过滤器
  • argc == optind表示命令没有其他参数，读取ANDROID_LOG_TAGS的值作为过滤器
  • 将命令参数设置为过滤器，格式为 tag:priority，如 *:E
  1.     if (forceFilters.size()) {
  2.         int err = android_log_addFilterString(logformat_.get(), forceFilters.c_str());
  3.         if (err < 0) {
  4.             error(EXIT_FAILURE, 0, "Invalid filter expression in logcat args.");
  5.         }
  6.     } else if (argc == optind) {
  7.         // Add from environment variable
  8.         const char* env_tags_orig = getenv("ANDROID_LOG_TAGS");
  10.         if (!!env_tags_orig) {
  11.             int err = android_log_addFilterString(logformat_.get(), env_tags_orig);
  13.             if (err < 0) {
  14.                 error(EXIT_FAILURE, 0, "Invalid filter expression in ANDROID_LOG_TAGS.");
  15.             }
  16.         }
  17.     } else {
  18.         // Add from commandline
  19.         for (int i = optind ; i < argc ; i++) {
  20.             int err = android_log_addFilterString(logformat_.get(), argv[i]);
  21.             if (err < 0) {
  22.                 error(EXIT_FAILURE, 0, "Invalid filter expression '%s'.", argv[i]);
  23.             }
  24.         }
  25.     }
复制代码
通过android_log_addFilterString设置过滤器，filterString大概以空格、tab或逗号分割
  1. int android_log_addFilterString(AndroidLogFormat* p_format, const char* filterString) {
  2.   char* filterStringCopy = strdup(filterString);
  3.   char* p_cur = filterStringCopy;
  4.   char* p_ret;
  5.   int err;
  7.   /* Yes, I'm using strsep */
  8.   while (NULL != (p_ret = strsep(&p_cur, " \t,"))) {
  9.     /* ignore whitespace-only entries */
  10.     if (p_ret[0] != '\0') {
  11.       err = android_log_addFilterRule(p_format, p_ret);
  13.       if (err < 0) {
  14.         goto error;
  15.       }
  16.     }
  17.   }
  19.   free(filterStringCopy);
  20.   return 0;
  21. error:
  22.   free(filterStringCopy);
  23.   return -1;
  24. }
复制代码
通过android_log_addFilterRule添加解析过滤器，将冒号后面的字符转为android_LogPriority，通过tagName和pri创建FilterInfo
  1. int android_log_addFilterRule(AndroidLogFormat* p_format, const char* filterExpression) {
  2.   size_t tagNameLength;
  3.   android_LogPriority pri = ANDROID_LOG_DEFAULT;
  5.   tagNameLength = strcspn(filterExpression, ":");
  7.   if (tagNameLength == 0) {
  8.     goto error;
  9.   }
  11.   if (filterExpression[tagNameLength] == ':') {
  12.     pri = filterCharToPri(filterExpression[tagNameLength + 1]);
  14.     if (pri == ANDROID_LOG_UNKNOWN) {
  15.       goto error;
  16.     }
  17.   }
  19.   if (0 == strncmp("*", filterExpression, tagNameLength)) {
  20.     /*
  21.      * This filter expression refers to the global filter
  22.      * The default level for this is DEBUG if the priority
  23.      * is unspecified
  24.      */
  25.     if (pri == ANDROID_LOG_DEFAULT) {
  26.       pri = ANDROID_LOG_DEBUG;
  27.     }
  29.     p_format->global_pri = pri;
  30.   } else {
  31.     /*
  32.      * for filter expressions that don't refer to the global
  33.      * filter, the default is verbose if the priority is unspecified
  34.      */
  35.     if (pri == ANDROID_LOG_DEFAULT) {
  36.       pri = ANDROID_LOG_VERBOSE;
  37.     }
  39.     char* tagName;
  41. /*
  42. * Presently HAVE_STRNDUP is never defined, so the second case is always taken
  43. * Darwin doesn't have strndup, everything else does
  44. */
  45. #ifdef HAVE_STRNDUP
  46.     tagName = strndup(filterExpression, tagNameLength);
  47. #else
  48.     /* a few extra bytes copied... */
  49.     tagName = strdup(filterExpression);
  50.     tagName[tagNameLength] = '\0';
  51. #endif /*HAVE_STRNDUP*/
  53.     FilterInfo* p_fi = filterinfo_new(tagName, pri);
  54.     free(tagName);
  56.     p_fi->p_next = p_format->filters;
  57.     p_format->filters = p_fi;
  58.   }
  60.   return 0;
  61. error:
  62.   return -1;
  63. }
  65. static android_LogPriority filterCharToPri(char c) {
  66.   android_LogPriority pri;
  68.   c = tolower(c);
  70.   if (c >= '0' && c <= '9') {
  71.     if (c >= ('0' + ANDROID_LOG_SILENT)) {
  72.       pri = ANDROID_LOG_VERBOSE;
  73.     } else {
  74.       pri = (android_LogPriority)(c - '0');
  75.     }
  76.   } else if (c == 'v') {
  77.     pri = ANDROID_LOG_VERBOSE;
  78.   } else if (c == 'd') {
  79.     pri = ANDROID_LOG_DEBUG;
  80.   } else if (c == 'i') {
  81.     pri = ANDROID_LOG_INFO;
  82.   } else if (c == 'w') {
  83.     pri = ANDROID_LOG_WARN;
  84.   } else if (c == 'e') {
  85.     pri = ANDROID_LOG_ERROR;
  86.   } else if (c == 'f') {
  87.     pri = ANDROID_LOG_FATAL;
  88.   } else if (c == 's') {
  89.     pri = ANDROID_LOG_SILENT;
  90.   } else if (c == '*') {
  91.     pri = ANDROID_LOG_DEFAULT;
  92.   } else {
  93.     pri = ANDROID_LOG_UNKNOWN;
  94.   }
  96.   return pri;
  97. }
复制代码
若通过选项f指定输出文件，通过max_rotated_logs_设置个数，格式为xxx.1/…/xxx.n
  1.     if (output_file_name_) {
  2.         if (setLogSize || getLogSize || printStatistics || getPruneList || setPruneList) {
  3.             error(EXIT_FAILURE, 0, "-f is incompatible with -g/-G, -S, and -p/-P.");
  4.         }
  6.         if (clearLog || setId) {
  7.             int max_rotation_count_digits =
  8.                     max_rotated_logs_ > 0 ? (int)(floor(log10(max_rotated_logs_) + 1)) : 0;
  10.             for (int i = max_rotated_logs_; i >= 0; --i) {
  11.                 std::string file;
  13.                 if (!i) {
  14.                     file = output_file_name_;
  15.                 } else {
  16.                     file = StringPrintf("%s.%.*d", output_file_name_, max_rotation_count_digits, i);
  17.                 }
  19.                 int err = unlink(file.c_str());
  21.                 if (err < 0 && errno != ENOENT) {
  22.                     fprintf(stderr, "failed to delete log file '%s': %s\n", file.c_str(),
  23.                             strerror(errno));
  24.                 }
  25.             }
  26.         }
  28.         if (clearLog) {
  29.             return EXIT_SUCCESS;
  30.         }
  31.     }
复制代码
根据id打开log装备
  1.     for (int i = LOG_ID_MIN; i < LOG_ID_MAX; ++i) {
  2.         if (!(id_mask & (1 << i))) continue;
  3.         const char* buffer_name = android_log_id_to_name(static_cast<log_id_t>(i));
  5.         auto logger = android_logger_open(logger_list.get(), static_cast<log_id_t>(i));
  6.         if (logger == nullptr) {
  7.             ReportErrorName(buffer_name, security_buffer_selected, &open_device_failures);
  8.             continue;
  9.         }
  10.         ......
复制代码
判定输出是二进制调用WriteFully，否则调用ProcessBuffer
  1.     while (!max_count_ || print_count_ < max_count_) {
  2.         ......
  3.         if (print_binary_) {
  4.             WriteFully(&log_msg, log_msg.len());
  5.         } else {
  6.             ProcessBuffer(&log_msg);
  7.         }
  8.         if (blocking && output_file_ == stdout) fflush(stdout);
  9.     }
  10.     return EXIT_SUCCESS;
  11. }
复制代码


  • 若日志类型是Event，调用android_log_processBinaryLogBuffer，否则调用android_log_processLogBuffer，他们都会将buf转为AndroidLogEntry用于输出
  • android_log_shouldPrintLine 判定tag和pri是否符合设置的过滤条件
  • 当日志超出大小时，调用RotateLogs建立新文件
  1. void Logcat::ProcessBuffer(struct log_msg* buf) {
  2.     AndroidLogEntry entry;
  3.     char binaryMsgBuf[1024] __attribute__((__uninitialized__));
  5.     bool is_binary =
  6.             buf->id() == LOG_ID_EVENTS || buf->id() == LOG_ID_STATS || buf->id() == LOG_ID_SECURITY;
  7.     int err;
  8.     if (is_binary) {
  9.         if (!event_tag_map_ && !has_opened_event_tag_map_) {
  10.             event_tag_map_.reset(android_openEventTagMap(nullptr));
  11.             has_opened_event_tag_map_ = true;
  12.         }
  13.         // This causes entry to point to binaryMsgBuf!
  14.         err = android_log_processBinaryLogBuffer(&buf->entry, &entry, event_tag_map_.get(),
  15.                                                  binaryMsgBuf, sizeof(binaryMsgBuf));
  17.         // printf(">>> pri=%d len=%d msg='%s'\n",
  18.         //    entry.priority, entry.messageLen, entry.message);
  19.     } else {
  20.         err = android_log_processLogBuffer(&buf->entry, &entry);
  21.     }
  22.     if (err < 0 && !debug_) return;
  24.     if (android_log_shouldPrintLine(logformat_.get(), std::string(entry.tag, entry.tagLen).c_str(),
  25.                                     entry.priority)) {
  26.         bool match = !regex_ ||
  27.                      std::regex_search(entry.message, entry.message + entry.messageLen, *regex_);
  29.         print_count_ += match;
  30.         if (match || print_it_anyway_) {
  31.             PrintDividers(buf->id(), print_dividers_);
  32.             out_byte_count_ += android_log_printLogLine(logformat_.get(), output_file_, &entry);
  33.         }
  34.     }
  36.     if (log_rotate_size_kb_ > 0 && (out_byte_count_ / 1024) >= log_rotate_size_kb_) {
  37.         RotateLogs();
  38.     }
  39. }
复制代码
android_log_printLogLine时输出的最后一个步骤，调用android_log_formatLogLine格式化要输出的日志，调用fwrite把日志输出到文件形貌符fd所形貌的目标文件中
  1. size_t android_log_printLogLine(AndroidLogFormat* p_format, FILE* fp,
  2.                                 const AndroidLogEntry* entry) {
  3.   char buf[4096] __attribute__((__uninitialized__));
  4.   size_t line_length;
  5.   char* line = android_log_formatLogLine(p_format, buf, sizeof(buf), entry, &line_length);
  6.   if (!line) {
  7.     fprintf(stderr, "android_log_formatLogLine failed\n");
  8.     exit(1);
  9.   }
  11.   size_t bytesWritten = fwrite(line, 1, line_length, fp);
  12.   if (bytesWritten != line_length) {
  13.     perror("fwrite failed");
  14.     exit(1);
  15.   }
  17.   if (line != buf) free(line);
  18.   return bytesWritten;
  19. }
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

自由的羽毛

论坛元老
这个人很懒什么都没写!

楼主热帖

标签云

运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表