devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android10.0 日志系统分析(三)-logd、logcat读写日志源码分析-[Android取经之路]_android logd代码移植

作者：小丑西瓜9 | 2024-05-25 07:48:14

赞

踩

android logd代码移植

摘要：本节主要来讲解Android10.0 logd、logcat读写日志源码内容

阅读本文大约需要花费20分钟。

文章首发微信公众号：IngresGe

专注于Android系统级源码分析，Android的平台设计，欢迎关注我，谢谢！

欢迎关注我的公众号！

[Android取经之路] 的源码都基于Android-Q（10.0） 进行分析

[Android取经之路]系列文章：

《系统启动篇》

  1. Android系统架构
  2. Android是怎么启动的
  3. Android 10.0系统启动之init进程
  4. Android10.0系统启动之Zygote进程
  5. Android 10.0 系统启动之SystemServer进程
  6. Android 10.0 系统服务之ActivityMnagerService
  7. Android10.0系统启动之Launcher(桌面)启动流程
  8. Android10.0应用进程创建过程以及Zygote的fork流程
  9. Android 10.0 PackageManagerService（一）工作原理及启动流程
  10. Android 10.0 PackageManagerService（二）权限扫描
  11. Android 10.0 PackageManagerService（三）APK扫描
  12. Android 10.0 PackageManagerService（四）APK安装流程

《日志系统篇》

  1. Android10.0 日志系统分析(一)-logd、logcat 指令说明、分类和属性
  2. Android10.0 日志系统分析(二)-logd、logcat架构分析及日志系统初始化
  3. Android10.0 日志系统分析(三)-logd、logcat读写日志源码分析
  4. Android10.0 日志系统分析(四)-selinux、kernel日志在logd中的实现​

《Binder通信原理》

  1. Android10.0 Binder通信原理(一)Binder、HwBinder、VndBinder概要
  2. Android10.0 Binder通信原理(二)-Binder入门篇
  3. Android10.0 Binder通信原理(三)-ServiceManager篇
  4. Android10.0 Binder通信原理(四)-Native-C\C++实例分析
  5. Android10.0 Binder通信原理(五)-Binder驱动分析
  6. Android10.0 Binder通信原理(六)-Binder数据如何完成定向打击
  7. Android10.0 Binder通信原理(七)-Framework binder示例
  8. Android10.0 Binder通信原理(八)-Framework层分析
  9. Android10.0 Binder通信原理(九)-AIDL Binder示例
  10. Android10.0 Binder通信原理(十)-AIDL原理分析-Proxy-Stub设计模式
  11. Android10.0 Binder通信原理(十一)-Binder总结

  《HwBinder通信原理》

  1. HwBinder入门篇-Android10.0 HwBinder通信原理(一)
  2.  HIDL详解-Android10.0 HwBinder通信原理(二)
  3. HIDL示例-C++服务创建Client验证-Android10.0 HwBinder通信原理(三)
  4. HIDL示例-JAVA服务创建-Client验证-Android10.0 HwBinder通信原理(四)
  5. HwServiceManager篇-Android10.0 HwBinder通信原理(五)
  6. Native层HIDL服务的注册原理-Android10.0 HwBinder通信原理(六)
  7. Native层HIDL服务的获取原理-Android10.0 HwBinder通信原理(七)
  8. JAVA层HIDL服务的注册原理-Android10.0 HwBinder通信原理(八)
  9. JAVA层HIDL服务的获取原理-Android10.0 HwBinder通信原理（九）
  10. HwBinder驱动篇-Android10.0 HwBinder通信原理(十)
  11. HwBinder原理总结-Android10.0 HwBinder通信原理(十一)

《编译原理》

  1. 编译系统入门篇-Android10.0编译系统（一）
  2. 编译环境初始化-Android10.0编译系统（二）
  3. make编译过程-Android10.0编译系统（三）
  4. Image打包流程-Android10.0编译系统（四）
  5. Kati详解-Android10.0编译系统（五）

上一节我们看了Android日志系统的架构分析以及logd、logcat的初始化操作，这一节我们来看看日志系统的读写操作

7.3 写日志

    写日志的过程，主要是通过liblog，把日志写入到/dev/socket/logdw, 守护进程logd监控logdw的写入信息，一旦发现有日志写入后，会把日志存入到LogListener的LogBuffer中。

日志写入调用栈如下：

7.3.1  [logger_write.cpp] __android_log_buf_write()

说明：JAVA层通过jni最终调用到liblog的 __android_log_buf_write()，组装结构体iovec，调用write_to_log()进行日志写入

源码：

 

  1. int __android_log_buf_write(int bufID, int prio, const char* tag, const char* msg) {
  2.   if (!tag) tag = "";
  3.  ...
  4.  //组装结构体，包括tag、msg
  5.   struct iovec vec[3];
  6.   vec[0].iov_base = (unsigned char*)&prio;
  7.   vec[0].iov_len = 1;
  8.   vec[1].iov_base = (void*)tag;
  9.  vec[1].iov_len = strlen(tag) + 1;
  10.   vec[2].iov_base = (void*)msg;
  11.   vec[2].iov_len = strlen(msg) + 1;
  12.  //进一步调用，进行日志的写入
  13.   return write_to_log(static_cast<log_id_t>(bufID), vec, 3);
  14. }

7.3.2 [logger_write.cpp] write_to_log()

write_to_log为一个函数指针，默认指向__write_to_log_init()

static int (*write_to_log)(log_id_t, struct iovec* vec, size_t nr) = __write_to_log_init;

7.3.3 [logger_write.cpp] __write_to_log_init()

说明：write_to_log 开始指向__write_to_log_init()，首先调用__write_to_log_initialize()进行日志配置初始化，再把write_to_log 指向__write_to_log_daemon()，调用__write_to_log_daemon()进行日志写入。

源码：

  1.  
  2. static int __write_to_log_init(log_id_t log_id, struct iovec* vec, size_t nr) {
  3.   int ret, save_errno = errno;
  4.  
  5.   __android_log_lock();
  6.  
  7.   //第一次调用时，write_to_log 指向__write_to_log_init()，此条件满足
  8.   if (write_to_log == __write_to_log_init) {
  9.     //日志配置初始化，最终调用到logdLoggerWrite来进行日志的配置
  10.     ret = __write_to_log_initialize();
  11.     if (ret < 0) {
  12.       __android_log_unlock();  //解锁log写入进程，避免死锁
  13.       if (!list_empty(&__android_log_persist_write)) {
  14.         __write_to_log_daemon(log_id, vec, nr);
  15.       }
  16.       errno = save_errno;
  17.       return ret;
  18.     }
  19.  
  20.    //write_to_log  指向__write_to_log_daemon
  21.     write_to_log = __write_to_log_daemon;
  22.   }
  23.  
  24.   __android_log_unlock();
  25.   //通过__write_to_log_daemon进行日志写入
  26.   ret = write_to_log(log_id, vec, nr);
  27.   errno = save_errno;
  28.   return ret;
  29. }

 

7.3.4 日志配置

[logger_write.cpp]  __write_to_log_initialize()

说明：首先进行日志的配置，得到logdLoggerWrite 和pmsgLoggerWrite两个日志节点，包含了open、close、write的函数指针

源码：

  1.  
  2. static int __write_to_log_initialize() {
  3.   struct android_log_transport_write* transport;
  4.   struct listnode* n;
  5.   int i = 0, ret = 0;
  6.   //日志的配置
  7.   __android_log_config_write();
  8.   write_transport_for_each_safe(transport, n, &__android_log_transport_write) {
  9.    //检查节点是否可用
  10.     __android_log_cache_available(transport);
  11.   ...
  12.     ++ret;
  13.   }
  14.   write_transport_for_each_safe(transport, n, &__android_log_persist_write) {
  15.   //检查节点是否可用
  16.     __android_log_cache_available(transport);
  17.   ...
  18.     ++i;
  19.   }
  20.   if (!ret && !i) {
  21.     return -ENODEV;
  22.   }
  23.  
  24.   return ret;
  25. }

[config_write.cpp] __android_log_config_write()

说明：对 "struct android_log_transport_write logdLoggerWrite" 和 "struct android_log_transport_write pmsgLoggerWrite" 的包装.

他们分别在 "/system/core/liblog/logd_writer.c" 和 "/system/core/liblog/pmsg_writer.c" 中实现

源码：

  1.  
  2. void __android_log_config_write() {
  3.   if ((__android_log_transport == LOGGER_DEFAULT) || (__android_log_transport & LOGGER_LOGD)) {
  4. #if (FAKE_LOG_DEVICE == 0)
  5.     extern struct android_log_transport_write logdLoggerWrite;
  6.     extern struct android_log_transport_write pmsgLoggerWrite;
  7.  
  8.     __android_log_add_transport(&__android_log_transport_write, &logdLoggerWrite);
  9.     __android_log_add_transport(&__android_log_persist_write, &pmsgLoggerWrite);
  10. #else
  11.     extern struct android_log_transport_write fakeLoggerWrite;
  12.  
  13.     __android_log_add_transport(&__android_log_transport_write, &fakeLoggerWrite);
  14. #endif
  15.   }
  16.  
  17.   if (__android_log_transport & LOGGER_STDERR) {
  18.     extern struct android_log_transport_write stderrLoggerWrite;
  19.  
  20.     if (list_empty(&__android_log_transport_write)) {
  21.       __android_log_add_transport(&__android_log_transport_write, &stderrLoggerWrite);
  22.     } else {
  23.       struct android_log_transport_write* transp;
  24.       write_transport_for_each(transp, &__android_log_transport_write) {
  25.         if (transp == &stderrLoggerWrite) {
  26.           return;
  27.         }
  28.       }
  29.       __android_log_add_transport(&__android_log_persist_write, &stderrLoggerWrite);
  30.     }
  31.   }
  32. }

[logd_writer.c] logdLoggerWrite

说明：配置logdLoggerWrite的节点，有open、close、write操作，

logdOpen()中连接"/dev/socket/logdw",再通过logdWrite()把日志写入到logdw中

  1. struct android_log_transport_write logdLoggerWrite = {
  2.     .node = {&logdLoggerWrite.node, &logdLoggerWrite.node},
  3.     .context.sock = -EBADF,
  4.     .name = "logd",
  5.     .available = logdAvailable,
  6.     .open = logdOpen,
  7.     .close = logdClose,
  8.     .write = logdWrite,
  9. };

[logd_writer.c] logdOpen()

说明：连接"/dev/socket/logdw" socket,记录socket句柄到 logdLoggerWrite.context.sock

  1. static int logdOpen() {
  2.   int i, ret = 0;
  3.  
  4.   i = atomic_load(&logdLoggerWrite.context.sock);
  5.   if (i < 0) {
  6.     int sock = TEMP_FAILURE_RETRY(socket(PF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0));
  7.     if (sock < 0) {
  8.       ret = -errno;
  9.     } else {
  10.       struct sockaddr_un un;
  11.       memset(&un, 0, sizeof(struct sockaddr_un));
  12.       un.sun_family = AF_UNIX;
  13.       strcpy(un.sun_path, "/dev/socket/logdw");
  14.  
  15.       if (TEMP_FAILURE_RETRY(connect(sock, (struct sockaddr*)&un, sizeof(struct sockaddr_un))) <
  16.           0) {
  17.         ret = -errno;
  18.         switch (ret) {
  19.           case -ENOTCONN:
  20.           case -ECONNREFUSED:
  21.           case -ENOENT:
  22.             i = atomic_exchange(&logdLoggerWrite.context.sock, ret);
  23.             [[fallthrough]];
  24.           default:
  25.             break;
  26.         }
  27.         close(sock);
  28.       } else {
  29.         ret = atomic_exchange(&logdLoggerWrite.context.sock, sock);
  30.         if ((ret >= 0) && (ret != sock)) {
  31.           close(ret);
  32.         }
  33.         ret = 0;
  34.       }
  35.     }
  36.   }
  37.  
  38.   return ret;
  39. }

[logd_writer.c] logdWrite()

说明：logdWrite() 通过调用writev，把log非阻塞地写入到socket .

  1.  
  2. static int logdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr) {
  3.   ssize_t ret;
  4.   int sock;
  5.   static const unsigned headerLength = 1;
  6.   struct iovec newVec[nr + headerLength];
  7.   android_log_header_t header;
  8.   size_t i, payloadSize;
  9.   static atomic_int dropped;
  10.   static atomic_int droppedSecurity;
  11.  
  12.   //原子操作，load  logdLoggerWrite.context.sock
  13.   sock = atomic_load(&logdLoggerWrite.context.sock);
  14.   if (sock < 0) switch (sock) {
  15.       case -ENOTCONN:
  16.       case -ECONNREFUSED:
  17.       case -ENOENT:
  18.         break;
  19.       default:
  20.         return -EBADF;
  21.     }
  22.  
  23.   /* logd, after initialization and priv drop */
  24.   if (__android_log_uid() == AID_LOGD) {
  25.     return 0;
  26.   }
  27.  
  28.  
  29.   header.tid = gettid();
  30.   header.realtime.tv_sec = ts->tv_sec;
  31.   header.realtime.tv_nsec = ts->tv_nsec;
  32.  
  33.   newVec[0].iov_base = (unsigned char*)&header;
  34.   newVec[0].iov_len = sizeof(header);
  35.  
  36.   if (sock >= 0) {
  37.     int32_t snapshot = atomic_exchange_explicit(&droppedSecurity, 0, memory_order_relaxed);
  38.     if (snapshot) {
  39.       android_log_event_int_t buffer;
  40.  
  41.       header.id = LOG_ID_SECURITY;
  42.       buffer.header.tag = htole32(LIBLOG_LOG_TAG);
  43.       buffer.payload.type = EVENT_TYPE_INT;
  44.       buffer.payload.data = htole32(snapshot);
  45.  
  46.       newVec[headerLength].iov_base = &buffer;
  47.       newVec[headerLength].iov_len = sizeof(buffer);
  48.  
  49.     //调用writev，把日志写入logdw
  50.       ret = TEMP_FAILURE_RETRY(writev(sock, newVec, 2));
  51.       if (ret != (ssize_t)(sizeof(header) + sizeof(buffer))) {
  52.         atomic_fetch_add_explicit(&droppedSecurity, snapshot, memory_order_relaxed);
  53.       }
  54.     }
  55.     snapshot = atomic_exchange_explicit(&dropped, 0, memory_order_relaxed);
  56.     if (snapshot && __android_log_is_loggable_len(ANDROID_LOG_INFO, "liblog", strlen("liblog"),
  57.                                                   ANDROID_LOG_VERBOSE)) {
  58.       android_log_event_int_t buffer;
  59.  
  60.       header.id = LOG_ID_EVENTS;
  61.       buffer.header.tag = htole32(LIBLOG_LOG_TAG);
  62.       buffer.payload.type = EVENT_TYPE_INT;
  63.       buffer.payload.data = htole32(snapshot);
  64.  
  65.       newVec[headerLength].iov_base = &buffer;
  66.       newVec[headerLength].iov_len = sizeof(buffer);
  67.  
  68.       ret = TEMP_FAILURE_RETRY(writev(sock, newVec, 2));
  69.       if (ret != (ssize_t)(sizeof(header) + sizeof(buffer))) {
  70.         atomic_fetch_add_explicit(&dropped, snapshot, memory_order_relaxed);
  71.       }
  72.     }
  73.   }
  74.  
  75.   header.id = logId;
  76.  
  77.   for (payloadSize = 0, i = headerLength; i < nr + headerLength; i++) {
  78.     newVec[i].iov_base = vec[i - headerLength].iov_base;
  79.     payloadSize += newVec[i].iov_len = vec[i - headerLength].iov_len;
  80.  
  81.     if (payloadSize > LOGGER_ENTRY_MAX_PAYLOAD) {
  82.       newVec[i].iov_len -= payloadSize - LOGGER_ENTRY_MAX_PAYLOAD;
  83.       if (newVec[i].iov_len) {
  84.         ++i;
  85.       }
  86.       break;
  87.     }
  88.   }
  89.  
  90.   /*
  91.    * The write below could be lost, but will never block.
  92.    *
  93.    * ENOTCONN occurs if logd has died.
  94.    * ENOENT occurs if logd is not running and socket is missing.
  95.    * ECONNREFUSED occurs if we can not reconnect to logd.
  96.    * EAGAIN occurs if logd is overloaded.
  97.    */
  98.   if (sock < 0) {
  99.     ret = sock;
  100.   } else {
  101.     ret = TEMP_FAILURE_RETRY(writev(sock, newVec, i));
  102.     if (ret < 0) {
  103.       ret = -errno;
  104.     }
  105.   }
  106.   switch (ret) {
  107.     case -ENOTCONN:
  108.     case -ECONNREFUSED:
  109.     case -ENOENT:
  110.       if (__android_log_trylock()) {
  111.         return ret; /* in a signal handler? try again when less stressed */
  112.       }
  113.       __logdClose(ret);
  114.       ret = logdOpen();
  115.       __android_log_unlock();
  116.  
  117.       if (ret < 0) {
  118.         return ret;
  119.       }
  120.  
  121.       ret = TEMP_FAILURE_RETRY(writev(atomic_load(&logdLoggerWrite.context.sock), newVec, i));
  122.       if (ret < 0) {
  123.         ret = -errno;
  124.       }
  125.       [[fallthrough]];
  126.     default:
  127.       break;
  128.   }
  129.  
  130.   if (ret > (ssize_t)sizeof(header)) {
  131.     ret -= sizeof(header);
  132.   } else if (ret == -EAGAIN) {
  133.     atomic_fetch_add_explicit(&dropped, 1, memory_order_relaxed);
  134.     if (logId == LOG_ID_SECURITY) {
  135.       atomic_fetch_add_explicit(&droppedSecurity, 1, memory_order_relaxed);
  136.     }
  137.   }
  138.  
  139.   return ret;
  140. }

[pmsg_writer.c] pmsgLoggerWrite

说明：配置pmsgLoggerWrite的节点，pmsgOpen()打开"/dev/pmsg0"，在通过pmsgWrite()把日志写入到"/dev/pmsg0"中

  1. struct android_log_transport_write pmsgLoggerWrite = {
  2.     .node = {&pmsgLoggerWrite.node, &pmsgLoggerWrite.node},
  3.     .context.fd = -1,
  4.     .name = "pmsg",
  5.     .available = pmsgAvailable,
  6.     .open = pmsgOpen,
  7.     .close = pmsgClose,
  8.     .write = pmsgWrite,
  9. };

[pmsg_writer.c] pmsgOpen()

说明：打开"/dev/pmsg0"

  1. static int pmsgOpen() {
  2.   int fd = atomic_load(&pmsgLoggerWrite.context.fd);
  3.   if (fd < 0) {
  4.     int i;
  5.  
  6.     fd = TEMP_FAILURE_RETRY(open("/dev/pmsg0", O_WRONLY | O_CLOEXEC));
  7.     i = atomic_exchange(&pmsgLoggerWrite.context.fd, fd);
  8.     if ((i >= 0) && (i != fd)) {
  9.       close(i);
  10.     }
  11.   }
  12.  
  13.   return fd;
  14. }

[pmsg_writer.c] pmsgWrite()

说明：日志写入到"/dev/pmsg0"

  1.  
  2. static int pmsgWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr) {
  3.   static const unsigned headerLength = 2;
  4.   struct iovec newVec[nr + headerLength];
  5.   android_log_header_t header;
  6.   android_pmsg_log_header_t pmsgHeader;
  7.   size_t i, payloadSize;
  8.   ssize_t ret;
  9.  
  10.   if ((logId == LOG_ID_EVENTS) && !__android_log_is_debuggable()) {
  11.     if (vec[0].iov_len < 4) {
  12.       return -EINVAL;
  13.     }
  14.  
  15.     if (SNET_EVENT_LOG_TAG != get4LE(static_cast<uint8_t*>(vec[0].iov_base))) {
  16.       return -EPERM;
  17.     }
  18.   }
  19.  
  20.   if (atomic_load(&pmsgLoggerWrite.context.fd) < 0) {
  21.     return -EBADF;
  22.   }
  23.  
  24.   pmsgHeader.magic = LOGGER_MAGIC;
  25.   pmsgHeader.len = sizeof(pmsgHeader) + sizeof(header);
  26.   pmsgHeader.uid = __android_log_uid();
  27.   pmsgHeader.pid = getpid();
  28.  
  29.   header.id = logId;
  30.   header.tid = gettid();
  31.   header.realtime.tv_sec = ts->tv_sec;
  32.   header.realtime.tv_nsec = ts->tv_nsec;
  33.  
  34.   newVec[0].iov_base = (unsigned char*)&pmsgHeader;
  35.   newVec[0].iov_len = sizeof(pmsgHeader);
  36.   newVec[1].iov_base = (unsigned char*)&header;
  37.   newVec[1].iov_len = sizeof(header);
  38.  
  39.   for (payloadSize = 0, i = headerLength; i < nr + headerLength; i++) {
  40.     newVec[i].iov_base = vec[i - headerLength].iov_base;
  41.     payloadSize += newVec[i].iov_len = vec[i - headerLength].iov_len;
  42.  
  43.     if (payloadSize > LOGGER_ENTRY_MAX_PAYLOAD) {
  44.       newVec[i].iov_len -= payloadSize - LOGGER_ENTRY_MAX_PAYLOAD;
  45.       if (newVec[i].iov_len) {
  46.         ++i;
  47.       }
  48.       payloadSize = LOGGER_ENTRY_MAX_PAYLOAD;
  49.       break;
  50.     }
  51.   }
  52.   pmsgHeader.len += payloadSize;
  53.  
  54.   ret = TEMP_FAILURE_RETRY(writev(atomic_load(&pmsgLoggerWrite.context.fd), newVec, i));
  55.   if (ret < 0) {
  56.     ret = errno ? -errno : -ENOTCONN;
  57.   }
  58.  
  59.   if (ret > (ssize_t)(sizeof(header) + sizeof(pmsgHeader))) {
  60.     ret -= sizeof(header) - sizeof(pmsgHeader);
  61.   }
  62.  
  63.   return ret;
  64. }

7.3.4 日志写入 /dev/socket/logdw

    在前面，日志配置已经完成，那么接下来调用__write_to_log_daemon()进行日志的真正写入

[logger_write.cpp] __write_to_log_daemon()

说明：最终通过获取logdLoggerWrite 和 pmsgLoggerWrite的write操作，即 调用logdWrite()\pmsgWrite()进行日志的写入

源码：

  1.  
  2. static int __write_to_log_daemon(log_id_t log_id, struct iovec* vec, size_t nr) {
  3.   struct android_log_transport_write* node;
  4.   int ret, save_errno;
  5.   struct timespec ts;
  6.   size_t len, i;
  7.  
  8.   for (len = i = 0; i < nr; ++i) {
  9.     len += vec[i].iov_len;
  10.   }
  11.   if (!len) {
  12.     return -EINVAL;
  13.   }
  14.  
  15.   save_errno = errno;
  16. #if defined(__ANDROID__)
  17.   clock_gettime(android_log_clockid(), &ts);
  18.  
  19.   if (log_id == LOG_ID_SECURITY) {
  20.     if (vec[0].iov_len < 4) {
  21.       errno = save_errno;
  22.       return -EINVAL;
  23.     }
  24.  
  25.     ret = check_log_uid_permissions();
  26.     if (ret < 0) {
  27.       errno = save_errno;
  28.       return ret;
  29.     }
  30.     if (!__android_log_security()) {
  31.       /* If only we could reset downstream logd counter */
  32.       errno = save_errno;
  33.       return -EPERM;
  34.     }
  35.   } else if (log_id == LOG_ID_EVENTS || log_id == LOG_ID_STATS) {
  36.     const char* tag;
  37.     size_t len;
  38.     EventTagMap *m, *f;
  39.  
  40.     if (vec[0].iov_len < 4) {
  41.       errno = save_errno;
  42.       return -EINVAL;
  43.     }
  44.  
  45.     tag = NULL;
  46.     len = 0;
  47.     f = NULL;
  48.     m = (EventTagMap*)atomic_load(&tagMap);
  49.  
  50.     if (!m) {
  51.       ret = __android_log_trylock();
  52.       m = (EventTagMap*)atomic_load(&tagMap); /* trylock flush cache */
  53.       if (!m) {
  54.         m = android_openEventTagMap(NULL);
  55.         if (ret) { /* trylock failed, use local copy, mark for close */
  56.           f = m;
  57.         } else {
  58.           if (!m) { /* One chance to open map file */
  59.             m = (EventTagMap*)(uintptr_t)-1LL;
  60.           }
  61.           atomic_store(&tagMap, (uintptr_t)m);
  62.         }
  63.       }
  64.       if (!ret) { /* trylock succeeded, unlock */
  65.         __android_log_unlock();
  66.       }
  67.     }
  68.     if (m && (m != (EventTagMap*)(uintptr_t)-1LL)) {
  69.       tag = android_lookupEventTag_len(m, &len, get4LE(static_cast<uint8_t*>(vec[0].iov_base)));
  70.     }
  71.     ret = __android_log_is_loggable_len(ANDROID_LOG_INFO, tag, len, ANDROID_LOG_VERBOSE);
  72.     if (f) { /* local copy marked for close */
  73.       android_closeEventTagMap(f);
  74.     }
  75.     if (!ret) {
  76.       errno = save_errno;
  77.       return -EPERM;
  78.     }
  79.   } else {
  80.     /* Validate the incoming tag, tag content can not split across iovec */
  81.     char prio = ANDROID_LOG_VERBOSE;
  82.     const char* tag = static_cast<const char*>(vec[0].iov_base);
  83.     size_t len = vec[0].iov_len;
  84.     if (!tag) {
  85.       len = 0;
  86.     }
  87.     if (len > 0) {
  88.       prio = *tag;
  89.       if (len > 1) {
  90.         --len;
  91.         ++tag;
  92.       } else {
  93.         len = vec[1].iov_len;
  94.         tag = ((const char*)vec[1].iov_base);
  95.         if (!tag) {
  96.           len = 0;
  97.         }
  98.       }
  99.     }
  100.     /* tag must be nul terminated */
  101.     if (tag && strnlen(tag, len) >= len) {
  102.       tag = NULL;
  103.     }
  104.  
  105.     if (!__android_log_is_loggable_len(prio, tag, len - 1, ANDROID_LOG_VERBOSE)) {
  106.       errno = save_errno;
  107.       return -EPERM;
  108.     }
  109.   }
  110. #else
  111.   /* simulate clock_gettime(CLOCK_REALTIME, &ts); */
  112.   {
  113.     struct timeval tv;
  114.     gettimeofday(&tv, NULL);
  115.     ts.tv_sec = tv.tv_sec;
  116.     ts.tv_nsec = tv.tv_usec * 1000;
  117.   }
  118. #endif
  119.  
  120.   ret = 0;
  121.   i = 1 << log_id;
  122.   write_transport_for_each(node, &__android_log_transport_write) {
  123.     if (node->logMask & i) {
  124.       ssize_t retval;
  125.       //从logdLoggerWrite中拿到write操作，即logdWrite()进行日志的写入
  126.       retval = (*node->write)(log_id, &ts, vec, nr);
  127.       if (ret >= 0) {
  128.         ret = retval;
  129.       }
  130.     }
  131.   }
  132.  
  133.   write_transport_for_each(node, &__android_log_persist_write) {
  134.     if (node->logMask & i) {
  135.        //从pmsgLoggerWrite中拿到write操作，即pmsgWrite()进行日志的写入
  136.       (void)(*node->write)(log_id, &ts, vec, nr);
  137.     }
  138.   }
  139.  
  140.   errno = save_errno;
  141.   return ret;
  142. }

7.3.5 日志写入LogListener的LogBuffer

在前面logd初始化时，我们能够看到LogListener中会先创建一个LogBuffer，LogBuffer在初始化init()中会初始化各个log的域的大小(如main、crash、system等默认为256k)，接着会启动一个SocketListener，对/dev/socket/logdw进行监听，

  [/system/core/logd/main.cpp]

  1. int main(int argc, char* argv[]) {
  2.   ...
  3.     LogListener* swl = new LogListener(logBuf, reader);
  4.     if (swl->startListener(600)) {
  5.         return EXIT_FAILURE;
  6.     }
  7. ... 
  8.  }

LogListene的对象创建时，会先调用 getLogSocket()，对logdw进行监听。

  1. int LogListener::getLogSocket() {
  2.     static const char socketName[] = "logdw";
  3.     int sock = android_get_control_socket(socketName);
  4.  
  5.     if (sock < 0) {  // logd started up in init.sh
  6.         sock = socket_local_server(
  7.             socketName, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_DGRAM);
  8.  
  9.         int on = 1;
  10.         if (setsockopt(sock, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on))) {
  11.             return -1;
  12.         }
  13.     }
  14.     return sock;
  15. }

在startListener函数中创建线程，线程注册函数为SocketListener::threadStart；

执行runListener函数，如果socket监听到数据，则执行onDataAvailable函数进行处理；

调用logbuf->log（LogBuffer::log），这个函数很重要，新建一个LogBufferElement对象（用于保存log），调用mLogElements.insert将LogBufferElement加入list容器，实现log的保存。

源码：

  1. bool LogListener::onDataAvailable(SocketClient* cli) {
  2.     static bool name_set;
  3.     if (!name_set) {
  4.         prctl(PR_SET_NAME, "logd.writer");
  5.         name_set = true;
  6.     }
  7.  
  8.     // + 1 to ensure null terminator if MAX_PAYLOAD buffer is received
  9.     char buffer[sizeof_log_id_t + sizeof(uint16_t) + sizeof(log_time) +
  10.                 LOGGER_ENTRY_MAX_PAYLOAD + 1];
  11.     struct iovec iov = { buffer, sizeof(buffer) - 1 };
  12.  
  13.   //将日志写入list容器
  14.     int res = logbuf->log(logId, header->realtime, cred->uid, cred->pid, header->tid, msg,
  15.                           ((size_t)n <= UINT16_MAX) ? (uint16_t)n : UINT16_MAX);
  16.     if (res > 0) {
  17.         reader->notifyNewLog(static_cast<log_mask_t>(1 << logId));
  18.     }
  19.  
  20.     return true;
  21. }

7.4 读取日志

    读取日志时，主要通过logcat工具来抓取。

    Logcat是通过liblog 连接 "/dev/socket/logdr" 来获取日志。logcat通过调用liblog 的函数android_logger_list_read()进行日志的读取，最终是连接"/dev/socket/logdr"，并读取其中的日志。

    logdr的日志由 logd的LogReader 进行写入。

    日志读取调用栈如下：

  logcat启动后，会调用android_logcat_run_command()，最终进入__logcat()来解析command，并读取日志，我们就从__logcat()来进行分析

7.4.1 [logcat.cpp] __logcat()

说明：__logcat()首先解析传入的command，然后进行日志的读取，如果出现日志读取失败，则退出logcat进程，否则手动启动的logcat进行一直处于运行状态

源码：

  1. static int __logcat(android_logcat_context_internal* context) {
  2.   ...
  3.   struct logger_list* logger_list;
  4.   ...
  5.   //logcat command的解析
  6.   while (true) {
  7.         int c = getopt_long(argc, argv, ":cdDhLt:T:gG:sQf:r:n:v:b:BSpP:m:e:", long_options,
  8.                             &option_index);
  9.     switch (c) {
  10.       ...
  11.             case 'g':
  12.                 if (!optarg) {
  13.                     getLogSize = true;
  14.                     break;
  15.                 }
  16.                 FALLTHROUGH_INTENDED;
  17.       case 'b': {
  18.                 std::unique_ptr<char, void (*)(void*)> buffers(strdup(optarg), free);
  19.                 char* arg = buffers.get();
  20.                 unsigned idMask = 0;
  21.                 char* sv = nullptr;  // protect against -ENOMEM above
  22.                 while (!!(arg = strtok_r(arg, delimiters, &sv))) {
  23.                     if (!strcmp(arg, "default")) {
  24.                         idMask |= (1 << LOG_ID_MAIN) | (1 << LOG_ID_SYSTEM) |
  25.                                   (1 << LOG_ID_CRASH);
  26.                     } else if (!strcmp(arg, "all")) {
  27.                         allSelected = true;
  28.                         idMask = (unsigned)-1;
  29.                     } else {
  30.                         log_id_t log_id = android_name_to_log_id(arg);
  31.                         const char* name = android_log_id_to_name(log_id);
  32.  
  33.                         if (!!strcmp(name, arg)) {
  34.                             logcat_panic(context, HELP_TRUE,
  35.                                          "unknown buffer %s\n", arg);
  36.                             goto exit;
  37.                         }
  38.                         if (log_id == LOG_ID_SECURITY) allSelected = false;
  39.                         idMask |= (1 << log_id);
  40.                     }
  41.                     arg = nullptr;
  42.                 }
  43.  
  44.                 for (int i = LOG_ID_MIN; i < LOG_ID_MAX; ++i) {
  45.                     const char* name = android_log_id_to_name((log_id_t)i);
  46.                     log_id_t log_id = android_name_to_log_id(name);
  47.  
  48.                     if (log_id != (log_id_t)i) continue;
  49.                     if (!(idMask & (1 << i))) continue;
  50.  
  51.                     bool found = false;
  52.                     for (dev = context->devices; dev; dev = dev->next) {
  53.                         if (!strcmp(name, dev->device)) {
  54.                             found = true;
  55.                             break;
  56.                         }
  57.                         if (!dev->next) break;
  58.                     }
  59.                     if (found) continue;
  60.  
  61.                     bool binary = !strcmp(name, "events") ||
  62.                                   !strcmp(name, "security") ||
  63.                                   !strcmp(name, "stats");
  64.                     log_device_t* d = new log_device_t(name, binary);
  65.  
  66.                     if (dev) {
  67.                         dev->next = d;
  68.                         dev = d;
  69.                     } else {
  70.                         context->devices = dev = d;
  71.                     }
  72.                     context->devCount++;
  73.                 }
  74.             }
  75.       ...
  76.             case 'h':
  77.                 show_help(context);
  78.                 show_format_help(context);
  79.                 goto exit;
  80.  
  81.             default:
  82.                 logcat_panic(context, HELP_TRUE, "Unrecognized Option %c\n", optopt);
  83.                 goto exit;
  84.     }
  85.   }
  86.   ...
  87.     while (!context->stop &&
  88.            (!context->maxCount || (context->printCount < context->maxCount))) {
  89.         struct log_msg log_msg;
  90.     //调用liblog的接口，读取"/dev/socket/logdr"来读取日志
  91.         int ret = android_logger_list_read(logger_list, &log_msg);
  92.         if (!ret) {
  93.             logcat_panic(context, HELP_FALSE, "read: unexpected EOF!\n");
  94.             break;
  95.         }
  96.     ...
  97.   }
  98. close:
  99.     // Short and sweet. Implemented generic version in android_logcat_destroy.
  100.     while (!!(dev = context->devices)) {
  101.         context->devices = dev->next;
  102.         delete dev;
  103.     }
  104.     android_logger_list_free(logger_list);
  105.  
  106. exit:
  107.     // close write end of pipe to help things along
  108.     if (context->output_fd == context->fds[1]) {
  109.         android::close_output(context);
  110.     }
  111.     if (context->error_fd == context->fds[1]) {
  112.         android::close_error(context);
  113.     }
  114.     if (context->fds[1] >= 0) {
  115.         // NB: should be closed by the above
  116.         int save_errno = errno;
  117.         close(context->fds[1]);
  118.         errno = save_errno;
  119.         context->fds[1] = -1;
  120.     }
  121.     context->thread_stopped = true;
  122.     return context->retval;
  123. }

 

下面进入liblog的android_logger_list_read()来进一步分析：

 

7.4.2 [logger_read.cpp] android_logger_list_read()

说明：先初始化logger_list，获得logdLoggerRead的节点，在进行transport_context的赋值操作，最终调用logdLoggerRead中的logdRead()进行日志读取

源码：

  1. int android_logger_list_read(struct logger_list* logger_list, struct log_msg* log_msg) {
  2.   struct android_log_logger_list* logger_list_internal =
  3.       (struct android_log_logger_list*)logger_list;
  4.  
  5.  //1. 初始化logger_list，把logdLoggerRead 和 pmsgLoggerRead 两个节点按需传给transoprt，我们一般使用 logdLoggerRead
  6.   int ret = init_transport_context(logger_list_internal);
  7.   if (ret < 0) {
  8.     return ret;
  9.   }
  10.  
  11.   //2. transoport的赋值
  12.   android_log_transport_context* transport_context = &logger_list_internal->transport_context;
  13.   //3.通过调用 logger_list中read方法，即logdLoggerRead中的logdRead()进行日志读取
  14.   return android_transport_read(logger_list_internal, transport_context, log_msg);
  15. }

7.4.3 [logger_read.cpp] init_transport_context()

说明：根据logger_list->mode来决定使用哪种日志读取节点，我们大部分情况下使用logdLoggerRead，并进行赋值，主要内容就是得到 logdLoggerRead的节点，为后续日志读取提供服务

源码：

  1. static int init_transport_context(struct android_log_logger_list* logger_list) {
  2.   if (!logger_list) {
  3.     return -EINVAL;
  4.   }
  5.  
  6.   if (list_empty(&logger_list->logger)) {
  7.     return -EINVAL;
  8.   }
  9.  
  10.   if (logger_list->transport_initialized) {
  11.     return 0;
  12.   }
  13.  
  14. #if (FAKE_LOG_DEVICE == 0)
  15.   extern struct android_log_transport_read logdLoggerRead;
  16.   extern struct android_log_transport_read pmsgLoggerRead;
  17.  
  18.   struct android_log_transport_read* transport;
  19.   //根据logger_list->mode来决定使用哪种日志读取节点，我们大部分情况下使用logdLoggerRead
  20.   transport = (logger_list->mode & ANDROID_LOG_PSTORE) ? &pmsgLoggerRead : &logdLoggerRead;
  21.  
  22.   struct android_log_logger* logger;
  23.   unsigned logMask = 0;
  24.  
  25.   //logger的校验
  26.   logger_for_each(logger, logger_list) {
  27.     log_id_t logId = logger->logId;
  28.  
  29.     if (logId == LOG_ID_SECURITY && __android_log_uid() != AID_SYSTEM) {
  30.       continue;
  31.     }
  32.     if (transport->read && (!transport->available || transport->available(logId) >= 0)) {
  33.       logMask |= 1 << logId;
  34.     }
  35.   }
  36.   if (!logMask) {
  37.     return -ENODEV;
  38.   }
  39.  
  40.   //节点赋值
  41.   logger_list->transport_context.transport = transport;
  42.   logger_list->transport_context.logMask = logMask;
  43.   logger_list->transport_context.ret = 1;
  44. #endif
  45.   return 0;
  46. }

logdLoggerRead  中提供了 read、poll、close等操作：

  1. struct android_log_transport_read logdLoggerRead = {
  2.     .node = {&logdLoggerRead.node, &logdLoggerRead.node},
  3.     .name = "logd",
  4.     .available = logdAvailable,
  5.     .version = logdVersion,
  6.     .read = logdRead,
  7.     .poll = logdPoll,
  8.     .close = logdClose,
  9.     .clear = logdClear,
  10.     .getSize = logdGetSize,
  11.     .setSize = logdSetSize,
  12.     .getReadableSize = logdGetReadableSize,
  13.     .getPrune = logdGetPrune,
  14.     .setPrune = logdSetPrune,
  15.     .getStats = logdGetStats,
  16. };

 

7.4.4 [logger_read.cpp] android_transport_read()

说明： 调用的logdRead()来读取日志，并组装日志 msg，供logcat进行展示

源码：

  1. static int android_transport_read(struct android_log_logger_list* logger_list,
  2.                                   struct android_log_transport_context* transp,
  3.                                   struct log_msg* log_msg) {
  4.  // 根据7.4.3 克制最终调用的是logdRead()来读取日志
  5.   int ret = (*transp->transport->read)(logger_list, transp, log_msg);
  6.  
  7.   if (ret > (int)sizeof(*log_msg)) {
  8.     ret = sizeof(*log_msg);
  9.   }
  10.  
  11.   transp->ret = ret;
  12.  
  13.   /* propagate errors, or make sure len & hdr_size members visible */
  14.   if (ret < (int)(sizeof(log_msg->entry.len) + sizeof(log_msg->entry.hdr_size))) {
  15.     if (ret >= (int)sizeof(log_msg->entry.len)) {
  16.       log_msg->entry.len = 0;
  17.     }
  18.     return ret;
  19.   }
  20.  
  21.   /* hdr_size correction (logger_entry -> logger_entry_v2+ conversion) */
  22.   if (log_msg->entry_v2.hdr_size == 0) {
  23.     log_msg->entry_v2.hdr_size = sizeof(struct logger_entry);
  24.   }
  25.   if ((log_msg->entry_v2.hdr_size < sizeof(log_msg->entry_v1)) ||
  26.       (log_msg->entry_v2.hdr_size > sizeof(log_msg->entry))) {
  27.     return -EINVAL;
  28.   }
  29.  
  30.   /* len validation */
  31.   if (ret <= log_msg->entry_v2.hdr_size) {
  32.     log_msg->entry.len = 0;
  33.   } else {
  34.     log_msg->entry.len = ret - log_msg->entry_v2.hdr_size;
  35.   }
  36.  
  37.   return ret;
  38. }

7.4.5 [logd_reader.cpp] logdRead()

说明：连接socket "/dev/socket/lodgr"，读取logdr 的日志

源码：

  1. static int logdRead(struct android_log_logger_list* logger_list,
  2.                     struct android_log_transport_context* transp, struct log_msg* log_msg) {
  3.   int ret, e;
  4.   struct sigaction ignore;
  5.   struct sigaction old_sigaction;
  6.   unsigned int old_alarm = 0;
  7.   //连接socket "/dev/socket/lodgr"
  8.   ret = logdOpen(logger_list, transp);
  9.   if (ret < 0) {
  10.     return ret;
  11.   }
  12.  
  13.   memset(log_msg, 0, sizeof(*log_msg));
  14.  
  15.   unsigned int new_alarm = 0;
  16.   if (logger_list->mode & ANDROID_LOG_NONBLOCK) {
  17.     if ((logger_list->mode & ANDROID_LOG_WRAP) &&
  18.         (logger_list->start.tv_sec || logger_list->start.tv_nsec)) {
  19.       /* b/64143705 */
  20.       new_alarm = (ANDROID_LOG_WRAP_DEFAULT_TIMEOUT * 11) / 10 + 10;
  21.       logger_list->mode &= ~ANDROID_LOG_WRAP;
  22.     } else {
  23.       new_alarm = 30;
  24.     }
  25.  
  26.     memset(&ignore, 0, sizeof(ignore));
  27.     ignore.sa_handler = caught_signal;
  28.     sigemptyset(&ignore.sa_mask);
  29.     /* particularily useful if tombstone is reporting for logd */
  30.     sigaction(SIGALRM, &ignore, &old_sigaction);
  31.     old_alarm = alarm(new_alarm);
  32.   }
  33.  
  34.   //读取logdr 的日志
  35.   ret = recv(ret, log_msg, LOGGER_ENTRY_MAX_LEN, 0);
  36.   e = errno;
  37.  
  38.   if (new_alarm) {
  39.     if ((ret == 0) || (e == EINTR)) {
  40.       e = EAGAIN;
  41.       ret = -1;
  42.     }
  43.     alarm(old_alarm);
  44.     sigaction(SIGALRM, &old_sigaction, NULL);
  45.   }
  46.  
  47.   if ((ret == -1) && e) {
  48.     return -e;
  49.   }
  50.   return ret;
  51. }

  至此，我们知道了logcat读取日志的流程，但是logdr的日志是由谁写入的呢，让我们接下来继续分析。在前面logd的初始化时，我们注意到创建了一个LogReader对象，其中存储了一个LogBuffer.

    

7.4.6 logd  LogReader

LogReader被创建后，会调用getLogSocket()来连接。"/dev/socket/logdr"这个socket。

  1. int LogReader::getLogSocket() {
  2.     static const char socketName[] = "logdr";
  3.     int sock = android_get_control_socket(socketName);
  4.  
  5.     if (sock < 0) {
  6.         sock = socket_local_server(
  7.             socketName, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_SEQPACKET);
  8.     }
  9.  
  10.     return sock;
  11. }

   在 [7.3.5] 中，当有日志写入logdw时，LogListener()的onDataAvailable生效，先把日志写入LogBufer后，再LogReader的notifyNewLog()来通知有新的日志写入。

    当收到一个新的日志条目可用时，通知正在监视此条目的日志id的侦听socket，即我们可以进行读日志了。

  1. void LogReader::notifyNewLog(log_mask_t logMask) {
  2.     // 创建一个FlushCommand 对象，传入LogReader的对象和logmask
  3.     FlushCommand command(*this, logMask);
  4.     //调用socket接口，最终进入 logd的runSocketCommand()
  5.     runOnEachSocket(&command);
  6. }
  7.  
  8. 运行FlushCommand 的runSocketCommand()
  9. void SocketListener::runOnEachSocket(SocketClientCommand *command) {
  10.     SocketClientCollection safeList;
  11.   ...
  12.     while (!safeList.empty()) {
  13.     ...
  14.         command->runSocketCommand(c);
  15.     ...
  16.     }
  17. }

[FlushCommand.cpp] runSocketCommand()

说明：对日志读取器套接字上的每个打开的客户端调用一次runSocketCommand。主要有三个command：LogListener、LogAudit、LogKlog。

对日志reader socket上的每个打开一次客户端就调用一次runSocketCommand。

在这里，我们管理并关联reader-client的跟踪和日志区域，锁定logtimeentry的LastLogTimes列表，并产生一个临时的客户端线程来讲数据归档到socket。

全局LogTimeEntry：：wrlock（）用于保护访问，引用计数用于确保在不受保护时管理单个LogTimeEntry生存期。

源码：

  1. void FlushCommand::runSocketCommand(SocketClient* client) {
  2.     LogTimeEntry* entry = nullptr;
  3.     LastLogTimes& times = mReader.logbuf().mTimes;
  4.  
  5.     LogTimeEntry::wrlock();
  6.     LastLogTimes::iterator it = times.begin();
  7.     while (it != times.end()) {
  8.         entry = it->get();
  9.         if (entry->mClient == client) {
  10.             if (!entry->isWatchingMultiple(mLogMask)) {
  11.                 LogTimeEntry::unlock();
  12.                 return;
  13.             }
  14.             if (entry->mTimeout.tv_sec || entry->mTimeout.tv_nsec) {
  15.                 if (mReader.logbuf().isMonotonic()) {
  16.                     LogTimeEntry::unlock();
  17.                     return;
  18.                 }
  19.                 // If the user changes the time in a gross manner that
  20.                 // invalidates the timeout, fall through and trigger.
  21.                 log_time now(CLOCK_REALTIME);
  22.                 if (((entry->mEnd + entry->mTimeout) > now) &&
  23.                     (now > entry->mEnd)) {
  24.                     LogTimeEntry::unlock();
  25.                     return;
  26.                 }
  27.             }
  28.             entry->triggerReader_Locked();
  29.             LogTimeEntry::unlock();
  30.             return;
  31.         }
  32.         it++;
  33.     }
  34.  
  35.     LogTimeEntry::unlock();
  36. }

如果socket监听到数据，则执行onDataAvailable()，进入LogReader的onDataAvailable()

[LogReader.cpp] onDataAvailable()

说明：相应日志读操作，先读入logdr中传入的客户端参数，然后把之前LogBuffer中的日志通过flushto，最终通过socket的sendDatav()写给client，比如logcat，所以我们可以开启多个logcat来获取日志。

源码：

  1.  
  2. bool LogReader::onDataAvailable(SocketClient* cli) {
  3.     static bool name_set;
  4.     //响应日志读操作
  5.     if (!name_set) {
  6.         prctl(PR_SET_NAME, "logd.reader");
  7.         name_set = true;
  8.     }
  9.  
  10.     char buffer[255];
  11.      //读取客户端传入参数
  12.     int len = read(cli->getSocket(), buffer, sizeof(buffer) - 1);
  13.     if (len <= 0) {
  14.         doSocketDelete(cli);
  15.         return false;
  16.     }
  17.     buffer[len] = '\0';
  18.  
  19.     // Clients are only allowed to send one command, disconnect them if they
  20.     // send another.
  21.     //客户端只允许发送一个命令，如果它们发送另一个命令，则断开它们的连接
  22.     LogTimeEntry::wrlock();
  23.     for (const auto& entry : mLogbuf.mTimes) {
  24.         if (entry->mClient == cli) {
  25.             entry->release_Locked();
  26.             LogTimeEntry::unlock();
  27.             return false;
  28.         }
  29.     }
  30.     LogTimeEntry::unlock();
  31.   ...
  32.     log_time sequence = start;
  33.   ...
  34.     if (nonBlock && (sequence != log_time::EPOCH) && timeout) {
  35.     ..
  36.     //LogBuffer中的日志写入传入的client，即写入logcat
  37.         logbuf().flushTo(cli, sequence, nullptr, FlushCommand::hasReadLogs(cli),
  38.                          FlushCommand::hasSecurityLogs(cli),
  39.                          logFindStart.callback, &logFindStart);
  40.  
  41.         if (!logFindStart.found()) {
  42.             doSocketDelete(cli);
  43.             return false;
  44.         }
  45.     }
  46.   ...
  47.     LogTimeEntry::wrlock();
  48.   ...
  49.     setsockopt(cli->getSocket(), SOL_SOCKET, SO_SNDTIMEO, (const char*)&t,
  50.                sizeof(t));
  51.  
  52.     LogTimeEntry::unlock();
  53.  
  54.     return true;
  55. }

至此日志的读取操作完成。下一节我们一起来看看<logd中如何进行selinux、kernel日志的读写>

微信公众号：IngresGe

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/621169
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号