Android的log机制

int log_fd;

if (/*(int)log_id >= 0 &&*/ (int)log_id < (int)LOG_ID_MAX) {

log_fd = log_fds[(int)log_id];

} else {

return EBADF;

}

do {

ret = log_writev(log_fd, vec, nr);

} while (ret < 0 && errno == EINTR);

return ret;

}

总结一下，println_native()的操作，就是打开设备文件（如果还没打开），然后写入数据。而具体怎么写入的，要看Log的设备驱动Logger的实现。

（4）LOG设备驱动Logger

Log的驱动是在kernel/drivers/staging/android/Logger.c中实现的。

一、初始化

看一个LINUX驱动，先看它如何初始化的。

static int __init init_log(struct logger_log *log)

{

int ret;

ret = misc_register(&log->misc);

if (unlikely(ret)) {

printk(KERN_ERR "logger: failed to register misc "

“device for log ‘%s’!\n”, log->misc.name);

return ret;

}

printk(KERN_INFO “logger: created %luK log ‘%s’\n”,

(unsigned long) log->size >> 10, log->misc.name);

return 0;

}

static int __init logger_init(void)

{

int ret;

ret = init_log(&log_main);

if (unlikely(ret))

goto out;

ret = init_log(&log_events);

if (unlikely(ret))

goto out;

ret = init_log(&log_radio);

if (unlikely(ret))

goto out;

ret = init_log(&log_system);

if (unlikely(ret))

goto out;

out:

return ret;

}

device_initcall(logger_init);

整个Logger驱动的入口点就是Logger_init()，它用init_log(struct logger_log *log)初始化了log_main, log_events, log_radio和log_system四个logger_log类型的结构，而这四个结构变量分别记录着log的四个存储体。Logger从这四个变量实现了同种设备的四个驱动，而log的驱动是MISC类型的驱动，通过misc_register()向系统注册。四次注册之后，它们对应的MINOR ID将是不同的，Looger也是通过minor来区分是哪一个驱动的。

static struct logger_log *get_log_from_minor(int minor)

{

if (log_main.misc.minor == minor)

return &log_main;

if (log_events.misc.minor == minor)

return &log_events;

if (log_radio.misc.minor == minor)

return &log_radio;

if (log_system.misc.minor == minor)

return &log_system;

return NULL;

}

本文将以log_main来讲解Logger驱动的实现。

二、关键数据结构

上节中，提到了log_main这个结构体变量，现在来看它的定义。

Log_main里保存了Logger操作必须的变量。buffer指向的真是一个静态数组，用来存放用来读写的数据，Logger用它组成了一个逻辑上的循环队列，写者可以往w_off指向的地方写东西，而一旦有内容，会通知等待队列wq里的读者们来读取内容。因为buffer实现的是循环队列，所以buffer的大小size经常用来做除高位的运算，一定要是一个2次幂的数字。mutex用来保护log_main这个关键资源的。Logger是MISC类型的驱动，它保留着一个miscdevice类型的变量misc。misc里面也有最为关键的file_operations结构，这正是应用程序通过文件操作，与驱动打交道的入口。

三、Logger实现的功能

从上面log_main的类型定义就能看出，Logger实现了什么。一句话概括Logger就是实现了读写者，并实现同步操作。不过，Logger的读写者有些特殊，写者写操作不会被阻塞，也不会写满溢出，也就是写时只要有内容可以不停的写，超出Buffer就覆盖旧的[与应用程序具体的写操作结合来看]；读者因为要读的内容为空就会被阻塞挂起，而一旦有内容，所有被挂起的读者都会被唤醒[与应用程序具体的读操作结合来看]。

下面看具体实现的时候，就分别从读者和写者的角度去看。

3.1. 写者的实现

看二小节图中的关键结构logger_fops: file_operations，写者的关键实现就看open、release和write这几个函数的实现了，它们被分别赋值给了logger_open() / logger_release() / logger_aio_write()。

logger_open()为写者做的工作就是，通过minor id获得logger_log的实例，然后赋值给函数参数中传递进来的file的private_data中。

logger_release()不需要为写者做的什么工作。

logger_poll()因为写不需要被阻塞。所以这里检测到是因为非因为读而打开的文件（!(file->f_mode &FMODE_READ)）时，就直接返回POLLOUT | POLLWRNORM。无论怎样都可写。

logger_aio_write()是写数据（也就是log信息）的关键。这里是通过异步IO的方法，应用程序通过write()/writev()和aio_write()时都能调用到这个方法。

记录log信息时，写log用的接口是writev()，写的是vec形式的数据，这边写的过程中来的当然也是vec数据了，另外，写具体之间，还写入了类型为logger_entry的数据，来记录时间等信息。写数据到具体buffer时因为存储的位置可能不是连续的，而写在buffer的结尾和开头位置，所以要做判断，并可能要有两次写的buffer的动作。参数里的数据来自用户空间，不能在内核空间直接使用，要用copy_from_user()。写完之后，用wake_up_interruptible(&log->wq)唤醒所有在挂起等待的读者。

3.2. 读者的实现

看二小节图中的关键结构logger_fops: file_operations，写者的关键实现就看open、release和read这几个函数的实现了，它们被分别赋值给了logger_open() / logger_release() / logger_read()。

logger_open() 为读者做的工作就是，通过minor id获得logger_log的实例，然后动态申请一个logger_reader类型的读者，并把它加入到logger_log的读者列表readers的结尾，再赋值给函数参数中传递进来的file的private_data中。

logger_release() 与logger_open()对应，将这个读者从读者列表logger_log.readers中移除，并释放掉这个动态申请的实例。

logger_poll()因为应用读之前会调用poll()/select()查看是否可以写。所以这里会用poll_wait()把参数中的poll_table加入到logger_log.wq中，并且如果有内容可读，才设置可读标志|= POLLIN |POLLRDNORM。

logger_read() 是读数据（也就是log信息）的关键。

读数据之前，要先保证有数据，否则该读者就要被挂起在logger_log的等待队列wq上。从具体buffer读数据到时因为存储的位置可能不是连续的，存储在buffer的结尾和开头位置，所以要做判断，并可能要有两次读去buffer的动作。数据来自内核空间，要通过用户空间的参数里传递出去，需要copy_to_user()。

3.3 循环队列的实现

这个是数据结构里最经典的案例了，这里不再具体解释如何实现，只是列出重要结构，只是希望读者还记得数据结构里逻辑结构和物理结构的说法。

队列大小：log_main.size

写头：log_main.w_off

读头：logger_reader.r_off

队列为空判断：log_main.w_off == logger_reader.r_off

队列为满判断：不需要

3.4 ioctl的实现

Logger提供给应用程序通过ioctl()来获取信息或控制LOGbuffer的功能。Logger是把logger_ioctl通过file_operations注册到文件系统中来实现这一功能的。Logger_ioctl()提供了下列ioctl控制命令：LOGGER_GET_LOG_BUF_SIZE / LOGGER_GET_LOG_LEN/ LOGGER_GET_NEXT_ENTRY_LEN / LOGGER_FLUSH_LOG。实现很简单：

LOGGER_GET_LOG_BUF_SIZE获取Buffer的大小，直接返回logger_log.size即可；

LOGGER_GET_LOG_LEN只对读有效，获取当前LOG的大小，存储连续的话就是log->w_off -reader->r_off，否则就是(log->size -reader->r_off) + log->w_off；

LOGGER_GET_NEXT_ENTRY_LEN获取Entry的长度，只对读有效。

LOGGER_FLUSH_LOG只对写打开有效。所谓FLUSH LOG，直接重置每个reader的r_off，并设置新reader要访问用的head即可。

从前文知道，LOG被写入到了驱动的节点，那如何获取这些LOG信息并呈现出来的呢？ANDROID里是有个叫LogCat的应用程序被用来获取LOG信息。LogCat不仅从设备节点处获取LOG，并且还提供了很多选项供用户来过滤、控制输出格式等。本文只讲解如何获取LOG部分，相关的LogCat的使用方式，可参考Android的Logcat命令详解。

LogCat是在文件system/core/logcat/logcat.cpp中实现的。

（5）获取LOG的应用程序LogCat

从Logger设备驱动的实现知道，Log的读取是阻塞的操作，亦即，有数据可用，读出数据；否则，读操作会被BLOCK，相应的读进程也会被挂起等待。下面看应用程序LogCat中如何实现读的，这可能需要不断回头与写操作和驱动实现结合来看。

看具体实现之前，先看一个logcat中定义的重要的结构体log_device_t。其中的重要的成员在后面用到的时候再具体解释。

一、打开设备节点

Android的Logcat命令详解的命令参数-b 知道，logcat是可以通过参数来指定对哪个buffer(main/radio/event)进行操作的。Logcat的b参数解析的地方，是通过传递进来的参数（main/radio/event）来创建了一个上面的结构变量，而这些结构通过log_device_t.next链接起来。

if (devices) {

dev = devices;

while (dev->next) {

dev = dev->next;

}

dev->next = new log_device_t(buf, binary, optarg[0]);

} else {

devices = new log_device_t(buf, binary, optarg[0]);

}

而创建实例的时候的参数被保留了下来，用于后续操作。

是由LOG_FILE_DIR和optarg（-b参数）组合在一起的（为：“/dev/log/main”，“/dev/log/event”或“/dev/log/radio”），保留在device: char*；

保留在binary: bool；

<optarg[0]>是-b参数的第一个字符，保存在label: char中。

好了，下面就有了打开设备节点时的参数：

dev->fd = open(dev->device, mode);

dev->device根据-b的参数可能为“/dev/log/main”，“/dev/log/event”或“/dev/log/radio”；

mode缺省时为O_RDONLY，读取。只要在运行logcat时，用了-c参数清除log时才以O_WRONLY打开。

而打开文件的文件操作符保存在log_device_t的fd域中，用于后续的操作。

获取Log的操作都是在readLogLines(log_device_t* devices)中实现的。

因为logcat可能会同时操作多个Buffer，而read()会阻塞读取进程，对其他Buffer的读取就不能进行，所以这里用select()来判断可读取的Buffer。

二、select选取可读取的Buffer

Logcat把log_device_t中的所有的buffer的文件操作符dev->fd，都放在readset中[line#7]，做为select()的里的<readfds: fd_set*>读参数，来获取可读取的Buffer。这样当任何一个Buffer上有LOG数据时，select()都会返回。当然等待过程中也忽略掉其他signal的影响。相应的代码如下：

fd_set readset;

do {

timeval timeout = { 0, 5000 /* 5ms */ }; // If we oversleep it’s ok, i.e. ignore EINTR.

FD_ZERO(&readset);

for (dev=devices; dev; dev = dev->next) {

FD_SET(dev->fd, &readset);

}

result = select(max + 1, &readset, NULL, NULL, sleep ? NULL : &timeout);

} while (result == -1 && errno == EINTR);

三、读LOG操作

select()返回之后，通过循环判定dev->fd是否在readset里被设置（FD_ISSET）[line#3]，知道哪个log buffer里已经有数据了。

if (result >= 0) {

for (dev=devices; dev; dev = dev->next) {

if (FD_ISSET(dev->fd, &readset)) {

queued_entry_t* entry = new queued_entry_t();

/* NOTE: driver guarantees we read exactly one full entry */

ret = read(dev->fd, entry->buf, LOGGER_ENTRY_MAX_LEN);

//…

通过read()读取[line#6]已经有数据的LOG Buffer的文件操作符dev->fd就可得到新到来的log了。

应用程序logcat中已经获取了LOG信息，接下来对数据的处理就都可以在这里进行了，可以过滤，写文件，格式化输入等操作。详细的logcat的命令参数可参见Android的Logcat命令详解.

（6）c/c++域使用LOG

c/c++本地库中实现LOG输出

通过前面的文章知道Android的Java中通过android.util.Log输出Log信息，那Android的本地c/c++程序能不能也通过这样的机制来记录Log呢？再回头看Log现有的c/c++的本地实现，答案当然是肯定的，而且是相当简单。Android直接在头文件（system/core/include/cutils/log.h）里定义了一些宏就可以很好的实现了。

因为，LOG分了VERBOSE/DEBUG/INFO/WARN/ERROR/ASSERT等类别，简单起见，以DEBUG为例的实现来说明。

#ifndef LOGD

#define LOGD(…) LOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)

#endif

#ifndef LOGD_IF

#define LOGD_IF(cond, …) \

( (CONDITION(cond)) \

? LOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__) \

: (void)0 )

#endif

#ifndef LOG

#define LOG(priority, tag, …) \

LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)

#endif

#ifndef LOG_PRI

#define LOG_PRI(priority, tag, …)                                     \

({                                                                  \

if (((priority == ANDROID_LOG_VERBOSE) && (LOG_NDEBUG == 0)) ||  \

((priority == ANDROID_LOG_DEBUG) && (LOG_NDDEBUG == 0))  ||  \

((priority == ANDROID_LOG_INFO) && (LOG_NIDEBUG == 0))   ||  \

(priority == ANDROID_LOG_WARN)                          ||  \

(priority == ANDROID_LOG_ERROR)                         ||  \

(priority == ANDROID_LOG_FATAL))                            \

(void)android_printLog(priority, tag, __VA_ARGS__);     \

})

#endif

#define android_printLog(prio, tag, fmt…) \

__android_log_print(prio, tag, fmt)

而这一系列宏，最后还是用到了函数__android_log_print()

int __android_log_print(int prio, const char *tag, const char *fmt, …)

{

va_list ap;

char buf[LOG_BUF_SIZE];

va_start(ap, fmt);

vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);

va_end(ap);

return __android_log_write(prio, tag, buf);

}

这里还是调到了函数__android_log_write()。这个函数应该很熟悉吧，正是前文叙及的c/c++本地函数实现写设备文件的地方。

c/c++程序中记录Log的做法

要在c/c++中记录Log通常的做法是：

定义自己的TAG_LOG宏；包含头文件log.h；然后在需要记录Log的地方直接用LOGV/LOGD/LOGI/LOGW/LOGE即可。

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

中记录Log通常的做法是：

定义自己的TAG_LOG宏；包含头文件log.h；然后在需要记录Log的地方直接用LOGV/LOGD/LOGI/LOGW/LOGE即可。

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-OS4qqoXW-1715147813513)]

[外链图片转存中…(img-I7PyTUqi-1715147813514)]

[外链图片转存中…(img-gCr5gfgU-1715147813514)]

[外链图片转存中…(img-1p7AqxWi-1715147813514)]

[外链图片转存中…(img-awm6E6MJ-1715147813514)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！