Android 早期版本使用的是一个 log 驱动,后来逐渐使用 logd 进程替代(具体哪个版本我就没有去探究了,至少在 Android 8.0 里,log 驱动已经被移除)。原有 log 驱动负责的功能,都由 logd 完成。此外,logd 还可以读取 Linux 内核 printk、selinux 的 log。

logd 的启动

logd 是由 init 进程启动的:

1
2
3
4
5
6
7
8
9
10
11
12
# system/core/rootdir/init.rc
on post-fs
# Load properties from
# /system/build.prop,
# /odm/build.prop,
# /vendor/build.prop and
# /factory/factory.prop
load_system_props
# start essential services
start logd
start servicemanager
# ...

logd 的参数在 logd.rc 中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# system/core/logd/logd.rc
service logd /system/bin/logd
socket logd stream 0666 logd logd
socket logdr seqpacket 0666 logd logd
socket logdw dgram 0222 logd logd
file /proc/kmsg r
file /dev/kmsg w
user logd
group logd system readproc
writepid /dev/cpuset/system-background/tasks

service logd-reinit /system/bin/logd --reinit
oneshot
disabled
user logd
group logd
writepid /dev/cpuset/system-background/tasks

on fs
write /dev/event-log-tags "# content owned by logd
"
chown logd logd /dev/event-log-tags
chmod 0644 /dev/event-log-tags
restorecon /dev/event-log-tags

可以看到,init 进程会帮 logd 创建 3 个 Unix 域 socket,分别为 /dev/socket/logd, /dev/socket/logdr, /dev/socket/logdw

创建 socket 系统调用原型如下:

1
2
3
4
#include <sys/types.h>
#include <sys/socket.h>

int socket(int domain, int type, int protocol);

init.rc 中的 stream, seqpacket, dgram 用于设置 socket 函数的第二个参数 type,分别对应 SOCK_STREAM, SOCK_SEQPACKET, SOCK_DGRAM

SOCK_STREAM 提供的是可靠的流数据(类比于 TCP),SOCK_SEQPACKET 则提供可靠的基于包的数据(可靠的UDP),SOCK_DGRAM 可以用 UDP 来类比,不可靠的包传输。详细信息可以查看 man page 了解。

当然,domain 参数是 PF_UNIX(估计写着代码的程序员比较老派,新的程序建议使用 AF_LOCAL,两者没有区别)。

这三个 socket 的功能如下:

  1. socket logd 用于外接受控制命令
  2. 客户端通过 logdr 读取 log 数据。使用 seqpacket,可以让用户在可靠地读取数据的同时,一次读取一条 log
  3. 客户端通过 logdw 写入 log 数据。由于类型是 dgram,在非常繁忙的时候,log 可能会丢失。但是,这可以避免客户端阻塞在写 log 的调用上

logd 的初始化

init 进程启动 logd 后,和其他程序一样,首先执行的是 main 函数。main 函数的主要工作如下:

  1. 读取系统属性,判断是否需要读内核的 log (klog 和 selinux 的log)
  2. 初始化一些信号量,启动 reinit 线程
  3. 启动各个子服务,监听上面我们提到的几个 socket
  4. 如果需要读内核 log,也监听对应的 log
  5. 阻塞等待(main 函数不能退出,否则进程直接会退出,即便还有线程在运行)

下面我们一起看看他的 main 函数:

1
2
3
4
5
6
7
8
9
// system/core/logd/main.cpp
int main(int argc, char* argv[]) {
// issue reinit command. KISS argument parsing.
if ((argc > 1) && argv[1] && !strcmp(argv[1], "--reinit")) {
return issueReinit();
}

// ...
}

在上面 init.rc 中,我们看到,正常启动 logd 是不带参数的,所以这里的 if 不会执行。当重新启动时,带 --reinit 参数。这里我们就假定是正常启动。

1
2
3
4
# system/core/logd/logd.rc
service logd /system/bin/logd

service logd-reinit /system/bin/logd --reinit

接下来获取 /dev/kmsg 的描述符。这个文件用于跟内核的 log 系统通信。正常情况下,init 进程会帮我们打开。如果没有,我们自己打开它。

1
2
3
4
5
6
7
8
9
10
11
12
// system/core/logd/main.cpp
int main(int argc, char* argv[]) {
// ...

static const char dev_kmsg[] = "/dev/kmsg";
fdDmesg = android_get_control_file(dev_kmsg);
if (fdDmesg < 0) {
fdDmesg = TEMP_FAILURE_RETRY(open(dev_kmsg, O_WRONLY | O_CLOEXEC));
}

// ...
}

接着,读取系统属性,判断是否需要读内核的 log。如果需要,就打开 /proc/kmsg。这个文件用于读取内核 log。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// system/core/logd/main.cpp
int main(int argc, char* argv[]) {
// ...

int fdPmesg = -1;
bool klogd = __android_logger_property_get_bool(
"logd.kernel", BOOL_DEFAULT_TRUE | BOOL_DEFAULT_FLAG_PERSIST |
BOOL_DEFAULT_FLAG_ENG | BOOL_DEFAULT_FLAG_SVELTE);
if (klogd) {
static const char proc_kmsg[] = "/proc/kmsg";
fdPmesg = android_get_control_file(proc_kmsg);
if (fdPmesg < 0) {
fdPmesg = TEMP_FAILURE_RETRY(
open(proc_kmsg, O_RDONLY | O_NDELAY | O_CLOEXEC));
}
if (fdPmesg < 0) android::prdebug("Failed to open %s\n", proc_kmsg);
}

// ...
}

默认情况下,会读取内核 log。这里我们就直接假设 klogd 为 true。

跟着,启动 reinit 线程:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// system/core/logd/main.cpp

static sem_t uidName;
static uid_t uid;
static char* name;

static sem_t reinit;
static bool reinit_running = false;
static LogBuffer* logBuf = nullptr;

static sem_t sem_name;

int main(int argc, char* argv[]) {
// ...

// Reinit Thread
sem_init(&reinit, 0, 0);
sem_init(&uidName, 0, 0);
sem_init(&sem_name, 0, 1);
pthread_attr_t attr;
if (!pthread_attr_init(&attr)) {
struct sched_param param;

memset(&param, 0, sizeof(param));
pthread_attr_setschedparam(&attr, &param);
pthread_attr_setschedpolicy(&attr, SCHED_BATCH);
if (!pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)) {
pthread_t thread;
reinit_running = true;
if (pthread_create(&thread, &attr, reinit_thread_start, nullptr)) {
reinit_running = false;
}
}
pthread_attr_destroy(&attr);
}

// ...
}

sem_init 用于初始化 POSIX 信号量,它的原型如下:

1
2
include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);

pshared 参数控制是否在多个进程间共享。这里我们只是用于进程内部的通信,所以传入 0。

在读这段代码的时候,有一个值得注意的是,pthread 在成功的时候返回 0,失败则返回一个非 0 的错误码(这一点跟一般的系统调用不同。一般的系统调用,失败的情况下会返回 -1)。

举例来说,中间用于判断 pthread_create 是否成功的 if 语句,只有在线程创建失败的时候才会执行。

1
2
3
if (pthread_create(&thread, &attr, reinit_thread_start, nullptr)) {
reinit_running = false;
}

关于 reinit_thread_start 函数,后面我们遇到了再看它的具体内容。

下面判断是否需要读 selinux 的 log。然后,调用 drop_privs 函数根据是否读取内核 log 设置一些权限。关于 drop_privs 函数,有兴趣的读者可以自行阅读源码,这部分并不会影响 logd 的逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
// system/core/logd/main.cpp
int main(int argc, char* argv[]) {
// ...

bool auditd =
__android_logger_property_get_bool("ro.logd.auditd", BOOL_DEFAULT_TRUE);
if (drop_privs(klogd, auditd) != 0) {
return -1;
}

// ...
}

下面,实例化 LogBuffer 并注册信号处理器。所有的 log 都会写入这个 LogBuffer;当客户端需要读取 log 的时候,也从这个 LogBuffer 读取。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// system/core/logd/main.cpp
int main(int argc, char* argv[]) {
// ...

// Serves the purpose of managing the last logs times read on a
// socket connection, and as a reader lock on a range of log
// entries.

LastLogTimes* times = new LastLogTimes();

// LogBuffer is the object which is responsible for holding all
// log entries.

logBuf = new LogBuffer(times);

signal(SIGHUP, reinit_signal_handler);

if (__android_logger_property_get_bool(
"logd.statistics", BOOL_DEFAULT_TRUE | BOOL_DEFAULT_FLAG_PERSIST |
BOOL_DEFAULT_FLAG_ENG |
BOOL_DEFAULT_FLAG_SVELTE)) {
logBuf->enableStatistics();
}

// ...
}

现在,各种准备工作都完成了,启动实际的工作线程:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// system/core/logd/main.cpp
int main(int argc, char* argv[]) {
// ...

// LogReader listens on /dev/socket/logdr. When a client
// connects, log entries in the LogBuffer are written to the client.

LogReader* reader = new LogReader(logBuf);
if (reader->startListener()) {
exit(1);
}

// LogListener listens on /dev/socket/logdw for client
// initiated log messages. New log entries are added to LogBuffer
// and LogReader is notified to send updates to connected clients.

LogListener* swl = new LogListener(logBuf, reader);
// Backlog and /proc/sys/net/unix/max_dgram_qlen set to large value
if (swl->startListener(600)) {
exit(1);
}

// Command listener listens on /dev/socket/logd for incoming logd
// administrative commands.

CommandListener* cl = new CommandListener(logBuf, reader, swl);
if (cl->startListener()) {
exit(1);
}

// LogAudit listens on NETLINK_AUDIT socket for selinux
// initiated log messages. New log entries are added to LogBuffer
// and LogReader is notified to send updates to connected clients.

LogAudit* al = nullptr;
if (auditd) {
al = new LogAudit(logBuf, reader,
__android_logger_property_get_bool(
"ro.logd.auditd.dmesg", BOOL_DEFAULT_TRUE)
? fdDmesg
: -1);
}

LogKlog* kl = nullptr;
if (klogd) {
kl = new LogKlog(logBuf, reader, fdDmesg, fdPmesg, al != nullptr);
}

readDmesg(al, kl);

// failure is an option ... messages are in dmesg (required by standard)

if (kl && kl->startListener()) {
delete kl;
}

if (al && al->startListener()) {
delete al;
}

// ...
}

在 logd 进程启动的时候,内核很可能已经有 log 数据存在,readDmesg() 把已有的 log 读出来放到 logBuffer 中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// system/core/logd/main.cpp
static void readDmesg(LogAudit* al, LogKlog* kl) {
if (!al && !kl) {
return;
}

int rc = klogctl(KLOG_SIZE_BUFFER, nullptr, 0);
if (rc <= 0) {
return;
}

// Margin for additional input race or trailing nul
ssize_t len = rc + 1024;
std::unique_ptr<char[]> buf(new char[len]);

rc = klogctl(KLOG_READ_ALL, buf.get(), len);
if (rc <= 0) {
return;
}

if (rc < len) {
len = rc + 1;
}
buf[--len] = '\0';

if (kl && kl->isMonotonic()) {
kl->synchronize(buf.get(), len);
}

ssize_t sublen;
for (char *ptr = nullptr, *tok = buf.get();
(rc >= 0) && !!(tok = android::log_strntok_r(tok, len, ptr, sublen));
tok = nullptr) {
if ((sublen <= 0) || !*tok) continue;
if (al) {
rc = al->log(tok, sublen);
}
if (kl) {
rc = kl->log(tok, sublen);
}
}
}

klogctl 是 Linux 内核特有的系统调用,用于读取、设置内核 log,原型如下,详情可以查看 man page:

1
2
#include <sys/klog.h>
int klogctl(int type, char *bufp, int len);

第一个 klogctltypeKLOG_SIZE_BUFFER,该调用返回内核 log 缓冲的总长度。

值得注意的是,查看 man page 时,man page 里对应的常量为 KLOG_ACTION_**。这些常量跟 KLOG_** 是一一对应的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// platform/bionic/libc/include/sys/klog.h

/* These correspond to the kernel's SYSLOG_ACTION_whatever constants. */
#define KLOG_CLOSE 0
#define KLOG_OPEN 1
#define KLOG_READ 2
#define KLOG_READ_ALL 3
#define KLOG_READ_CLEAR 4
#define KLOG_CLEAR 5
#define KLOG_CONSOLE_OFF 6
#define KLOG_CONSOLE_ON 7
#define KLOG_CONSOLE_LEVEL 8
#define KLOG_SIZE_UNREAD 9
#define KLOG_SIZE_BUFFER 10

第二个 klogctl 使用 KLOG_READ_ALL 读取所有的 log。随后,使用 LogAudit, LogKlog 讲读取到的 log 写入 LogBuffer

最后,main 函数在 pause() 上永久等待。这是因为,如果 main 函数退出,进程就会退出(即使没有最后那个 exit(0)main 函数返回也会导致进程退出)。

1
2
3
4
5
6
7
8
9
10
// system/core/logd/main.cpp
int main(int argc, char* argv[]) {
// ...

TEMP_FAILURE_RETRY(pause());

exit(0);

// ...
}

logd 的启动到这里就结束了,实际的 log 读写逻辑,后面再一一分析。