android log

Android log的重要性不言而喻，是我们分析问题的依据，理解代码的好助手。
本文从以下两方面对log做一些简单总结：
1. Log分类
2. Log打印控制

---

1. Log分类

Android 打印的log分以下几类：

1. main log
2. sytem log
3. radio log
4. event log
5. kernel log
6. crash log
7. security log
   这些log都是system/core/liblog/Logger_write.c去打印的; 分类在Log_id.h中是定义好了的：

typedef enum log_id {
  LOG_ID_MIN = 0,

  LOG_ID_MAIN = 0,
  LOG_ID_RADIO = 1,
  LOG_ID_EVENTS = 2,
  LOG_ID_SYSTEM = 3,
  LOG_ID_CRASH = 4,
  LOG_ID_SECURITY = 5,
  LOG_ID_KERNEL = 6, /* place last, third-parties can not use it */

  LOG_ID_MAX
} log_id_t;
#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14

对我AP侧的研发来说， 经常要打印的log也就是前4种; 打印log所调用的类是android.util.Log。
android.util.Log.java内对常用的4中log也做了定义：

    /** @hide */ public static final int LOG_ID_MAIN = 0;
    /** @hide */ public static final int LOG_ID_RADIO = 1;
    /** @hide */ public static final int LOG_ID_EVENTS = 2;
    /** @hide */ public static final int LOG_ID_SYSTEM = 3;
    /** @hide */ public static final int LOG_ID_CRASH = 4;
1
2
3
4
5

如果要打印main log，那么直接调用android.util.Log中的方法即可。
如果要打印system log，可以调用android.util.Slog。
如果要打印event log, 可以调用android.utile.Eventlog。
如果要打印radio log，可以调用android.telephony.Rlog。
上面几个类只是为大家写好了要打印的类别，当然实际开发中是经常要包装自定义的工具log类的，以便可以更好的控制打印。

---

2. Log打印控制——可以使用adb 命令设置property的方式来控制log的打印

log的打印是要消耗资源的，而且有些log中包含一些敏感信息，所以有必要控制log的打印。

工作中经常见到如下的log打印控制方式，DBG可能是true或false这种比较简单的控制;也可能是通过property等控制。
这一般是我们自己控制log的方式，没什么好说的。

......
if (DBG) {
    //log打印
}
......
1
2
3
4
5

---

Android源生也提供了log的控制机制，了解这个机制之后我们可以通过使用adb 命令设置property的方式来控制log的打印，下面来说说这个机制。

不管是android.telephonu.Rlog还是android.util.Slog其实都是通过android.util.log的native方法 Log.println_native来打印log的。
对应的jni文件是android_util_Log.cpp。android.util.log还提供了native方法isLoggable(String tag, int level)，这个方法可以用来判断当前level的log是否可以打印。isLoggable方法在android_util_Log.cpp中对应的方法是android_util_Log_isLoggable。

static jboolean android_util_Log_isLoggable(JNIEnv* env, jobject clazz, jstring tag, jint level)
{
    if (tag == NULL) {
        return false;
    }

    const char* chars = env->GetStringUTFChars(tag, NULL);
    if (!chars) {
        return false;
    }

    jboolean result = isLoggable(chars, level);

    env->ReleaseStringUTFChars(tag, chars);
    return result;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

android_util_Log_isLoggable调用了函数isLoggable，这个函数很简单：

static jboolean isLoggable(const char* tag, jint level) {
    return __android_log_is_loggable(level, tag, ANDROID_LOG_INFO);
}
1
2
3

__android_log_is_loggable是在properties.c中定义的(函数__android_log_level(const char* tag, size_t len, int default_prio)在Android N上定义在/system/core/liblog/log_is_loggable.c中，Android Q放到了system/core/liblog/properties.cpp 文件中)。

LIBLOG_ABI_PUBLIC int __android_log_is_loggable(int prio, const char* tag,
                                                int default_prio) {
  int logLevel =
      __android_log_level(tag, (tag && *tag) ? strlen(tag) : 0, default_prio);
  return logLevel >= 0 && prio >= logLevel;
}
1
2
3
4
5
6

这个函数通过调用__android_log_level获取tag所设置的level，默认值是ANDROID_LOG_INFO。
下面看看__android_log_level是如何获取指定tag所对应的level的。

static int __android_log_level(const char* tag, size_t len, int default_prio) {
  /* sizeof() is used on this array below */
  static const char log_namespace[] = "persist.log.tag.";//property的前缀，即查找这种形式的property。
  static const size_t base_offset = 8; /* skip "persist." */
  /* calculate the size of our key temporary buffer */
  const size_t taglen = tag ? len : 0;
  /* sizeof(log_namespace) = strlen(log_namespace) + 1 */
  char key[sizeof(log_namespace) + taglen];//根据key的长度，可以猜到会用于存储完整的property，e.x. persist.log.tag.TelecomFramework
  char* kp;
  size_t i;
  char c = 0;
  /*
   * Single layer cache of four properties. Priorities are:
   *    log.tag.<tag>
   *    persist.log.tag.<tag>
   *    log.tag
   *    persist.log.tag
   * Where the missing tag matches all tags and becomes the
   * system global default. We do not support ro.log.tag* .
   */
  static char* last_tag;//静态变量，所以不不会因为函数调用结束而丢失; 用于记录上次查询的tag。
  static size_t last_tag_len;//静态变量;用于记录上次查询tag的长度。
  static uint32_t global_serial;//静态变量; 这个变量应该用于判断property是否发生了改变。
  /* some compilers erroneously see uninitialized use. !not_locked */
  uint32_t current_global_serial = 0;
  static struct cache_char tag_cache[2];//静态变量; 用于记录查找结果。
  static struct cache_char global_cache[2];//静态变量;用于记录查找结果。
  int change_detected;
  int global_change_detected;
  int not_locked;

  strcpy(key, log_namespace);

  global_change_detected = change_detected = not_locked = lock();//成功时返回0，否则返回非0值。
  //下面这段代码用于判断property是否发生了改变。
  if (!not_locked) {//成功lock
    /*
     *  check all known serial numbers to changes.
     */
    for (i = 0; i < (sizeof(tag_cache) / sizeof(tag_cache[0])); ++i) {
      if (check_cache(&tag_cache[i].cache)) {
        change_detected = 1;
      }
    }
    for (i = 0; i < (sizeof(global_cache) / sizeof(global_cache[0])); ++i) {
      if (check_cache(&global_cache[i].cache)) {
        global_change_detected = 1;
      }
    }

    current_global_serial = __system_property_area_serial();
    if (current_global_serial != global_serial) {
      change_detected = 1;
      global_change_detected = 1;
    }
  }
  
  //下面这段代码用于判断本次请求的tag是否和上次记录tag不同，以便决定是否需要重新查找。
  if (taglen) {
    int local_change_detected = change_detected;
    if (!not_locked) {
      if (!last_tag || !last_tag[0] || (last_tag[0] != tag[0]) ||
          strncmp(last_tag + 1, tag + 1, last_tag_len - 1)) {//last_tag为null，说明是初次查找
        /* invalidate log.tag.<tag> cache */
        for (i = 0; i < (sizeof(tag_cache) / sizeof(tag_cache[0])); ++i) {
          tag_cache[i].cache.pinfo = NULL;
          tag_cache[i].c = '\0';
        }
        if (last_tag) last_tag[0] = '\0';//置成空字符，这样下面的if语句块便可以进入执行
        local_change_detected = 1;
      }
      if (!last_tag || !last_tag[0]) {//初次查找或者tag和上次记录tag不同的情况
        if (!last_tag) {
          last_tag = calloc(1, len + 1);
          last_tag_len = 0;
          if (last_tag) last_tag_len = len + 1;
        } else if (len >= last_tag_len) {
          last_tag = realloc(last_tag, len + 1);
          last_tag_len = 0;
          if (last_tag) last_tag_len = len + 1;
        }
        if (last_tag) {
          strncpy(last_tag, tag, len);
          last_tag[len] = '\0';
        }
      }
    }
    strncpy(key + sizeof(log_namespace) - 1, tag, len);//现在key的值是"persist.log.tag.*"
    key[sizeof(log_namespace) - 1 + len] = '\0';
    
    //下面就开始查找和tag具体相关的property："persist.log.tag.*"或者"log.tag.*"
    kp = key;
    for (i = 0; i < (sizeof(tag_cache) / sizeof(tag_cache[0])); ++i) {
      struct cache_char* cache = &tag_cache[i];
      struct cache_char temp_cache;

      if (not_locked) {
        temp_cache.cache.pinfo = NULL;
        temp_cache.c = '\0';
        cache = &temp_cache;
      }
      if (local_change_detected) {
        refresh_cache(cache, kp);
      }

      if (cache->c) {
        c = cache->c;
        break;
      }

      kp = key + base_offset;//
    }
  }

  //下面会在查找"persist.log", 即全局配置。
  switch (toupper(c)) { /* if invalid, resort to global */
    case 'V':
    case 'D':
    case 'I':
    case 'W':
    case 'E':
    case 'F': /* Not officially supported */
    case 'A':
    case 'S':
    case BOOLEAN_FALSE: /* Not officially supported */
      break;
    default:
      /* clear '.' after log.tag */
      key[sizeof(log_namespace) - 2] = '\0';//现在key的值是"persist.log"

      kp = key;
      for (i = 0; i < (sizeof(global_cache) / sizeof(global_cache[0])); ++i) {
        struct cache_char* cache = &global_cache[i];
        struct cache_char temp_cache;

        if (not_locked) {
          temp_cache = *cache;
          if (temp_cache.cache.pinfo != cache->cache.pinfo) { /* check atomic */
            temp_cache.cache.pinfo = NULL;
            temp_cache.c = '\0';
          }
          cache = &temp_cache;
        }
        if (global_change_detected) {
          refresh_cache(cache, kp);
        }

        if (cache->c) {
          c = cache->c;
          break;
        }

        kp = key + base_offset;
      }
      break;
  }

  if (!not_locked) {
    global_serial = current_global_serial;
    unlock();
  }

  //下面的代码跟property的值，返回对应的log level。
  switch (toupper(c)) {
    /* clang-format off */
    case 'V': return ANDROID_LOG_VERBOSE;
    case 'D': return ANDROID_LOG_DEBUG;
    case 'I': return ANDROID_LOG_INFO;
    case 'W': return ANDROID_LOG_WARN;
    case 'E': return ANDROID_LOG_ERROR;
    case 'F': /* FALLTHRU */ /* Not officially supported */
    case 'A': return ANDROID_LOG_FATAL;
    case BOOLEAN_FALSE: /* FALLTHRU */ /* Not Officially supported */
    case 'S': return -1; /* ANDROID_LOG_SUPPRESS */
    /* clang-format on */
  }
  return default_prio;//如果没有查找到对应的property，那么返回默认值。
}
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

上面的函数完成的逻辑，真正执行property查找的是函数refresh_cache(struct cache_char* cache, const char* key)，这个函数就不说了，比较简单。

我们平时在工作中，为了打印一些log，我们常用下面的方式向手机/data目录下push local.prop.

adb root
adb remount
adb push local.prop /data/local.prop
adb shell chmod 644 /data/local.prop
adb shell chown root.root /data/local.prop
adb reboot
1
2
3
4
5
6

local.prop文件内容如下：

log.tag.Telecom=VERBOSE
log.tag.RIL-SIM=VERBOSE
log.tag.SIMRecords=VERBOSE
log.tag.DCT=VERBOSE
1
2
3
4

当手机重启时，init会加载/data/local.prop, 文件中的内容会被加载为property。所以当我们的log语句执行时，__android_log_level可以查到到相应的property，进而获取我们设置的level。
其实push文件有些繁琐，根据上面的分析，我们可以直接用adb 命令在设置property控制log输出(如果不生效，可以重启手机再试试)。
可以使用的property name是:

• log.tag.* (开机会丢失)
• persist.log.tag.*
• persist.log(优先级比前面两个低，所以如果有设置前面两个， 后面这个是不生效的)

[例子1]
输出以Telecom为tag的所有log，可以用下面的方法。
adb shell setprop log.tag.Telecom V 或
adb shell setprop persist.log.tag.Telecom V

[例子2]
下面的命令可以输出所以的log，不过不建议使用，因为log太多可能会给查看带来不便。
adb shell setprop persist.log V