android log机制——输出log【转】

转自：http://blog.csdn.net/tdstds/article/details/19084327

目录(?)[-]

在android Java code中输出log

Logprintln_native方法

本地层代码Log输出

转自： http://my.oschina.net/wolfcs/blog/164624

Android log系统。

在android Java code中输出log

android系统有4种类型、6个优先级的log，有一些常量用于标识这些信息，相关的定义在frameworks/base/core/Java/android/util/Log.java中可以看到：

01 /**

`02`	`* Priority constant for the println method; use Log.v.`

03 */

`04`	`public` `static` `final` `int` `VERBOSE =` `2;`

05

06 /**

`07`	`* Priority constant for the println method; use Log.d.`

08 */

`09`	`public` `static` `final` `int` `DEBUG =` `3;`

10

11 /**

`12`	`* Priority constant for the println method; use Log.i.`

13 */

`14`	`public` `static` `final` `int` `INFO =` `4;`

15

16 /**

`17`	`* Priority constant for the println method; use Log.w.`

18 */

`19`	`public` `static` `final` `int` `WARN =` `5;`

20

21 /**

`22`	`* Priority constant for the println method; use Log.e.`

23 */

`24`	`public` `static` `final` `int` `ERROR =` `6;`

25

26 /**

`27`	`* Priority constant for the println method.`

28 */

`29`	`public` `static` `final` `int` `ASSERT =` `7;`

30

`31`	`/** @hide */` `public` `static` `final` `int` `LOG_ID_MAIN =` `0;`

`32`	`/** @hide */` `public` `static` `final` `int` `LOG_ID_RADIO =` `1;`

`33`	`/** @hide */` `public` `static` `final` `int` `LOG_ID_EVENTS =` `2;`

`34`	`/** @hide */` `public` `static` `final` `int` `LOG_ID_SYSTEM =` `3;`

Java层可以通过三个class来输出其中三种类型的log，三种类型分别为MAIN、RADIO和SYSTEM，三个class分别为Log、Rlog和Slog，其package则分别为android.util、android.telephony和 android.util。这些用于打印log的classes，其构造函数都为private，因而都不能创建其对象，但它们都提供了静态方法来给用户打印log。各个log打印class的实现都大同小异，可以看一下Log这个class中的一些：

`01`	`public` `static` `int` `v(String tag, String msg, Throwable tr) {`

`02`	`return` `println_native(LOG_ID_MAIN, VERBOSE, tag, msg +` `'\n'` `+ getStackTraceString(tr));`

03 }

04

05 /**

`06`	`* Send a {@link #DEBUG} log message.`

`07`	`* @param tag Used to identify the source of a log message. It usually identifies`

`08`	`* the class or activity where the log call occurs.`

`09`	`* @param msg The message you would like logged.`

10 */

`11`	`public` `static` `int` `d(String tag, String msg) {`

`12`	`return` `println_native(LOG_ID_MAIN, DEBUG, tag, msg);`

13 }

最终都会是调用Log.println_native()静态native方法来打印log，各个类中各个方法的不同之处也仅在于参数的差异。

Log.println_native()方法

这个方法的code在/frameworks/base/core/jni/android_util_Log.cpp，为：

`01`	`static` `jint android_util_Log_println_native(JNIEnv* env, jobject clazz,`

`02`	`jint bufID, jint priority, jstring tagObj, jstring msgObj)`

03 {

`04`	`const` `char* tag = NULL;`

`05`	`const` `char* msg = NULL;`

06

`07`	`if` `(msgObj == NULL) {`

`08`	`jniThrowNullPointerException(env,` `"println needs a message");`

`09`	`return` `-1;`

10 }

11

`12`	`if` `(bufID < 0 \|\| bufID >= LOG_ID_MAX) {`

`13`	`jniThrowNullPointerException(env,` `"bad bufID");`

`14`	`return` `-1;`

15 }

16

`17`	`if` `(tagObj != NULL)`

`18`	`tag = env->GetStringUTFChars(tagObj, NULL);`

`19`	`msg = env->GetStringUTFChars(msgObj, NULL);`

20

`21`	`int` `res = __android_log_buf_write(bufID, (android_LogPriority)priority, tag, msg);`

22

`23`	`if` `(tag != NULL)`

`24`	`env->ReleaseStringUTFChars(tagObj, tag);`

`25`	`env->ReleaseStringUTFChars(msgObj, msg);`

26

`27`	`return` `res;`

28 }

29

30 /*

`31`	`* JNI registration.`

32 */

`33`	`static` `JNINativeMethod gMethods[] = {`

`34`	`/* name, signature, funcPtr */`

`35`	`{` `"isLoggable",` `"(Ljava/lang/String;I)Z", (void*) android_util_Log_isLoggable },`

`36`	`{` `"println_native",` `"(IILjava/lang/String;Ljava/lang/String;)I", (void*) android_util_Log_println_native },`

37 };

可以看到，干的都是转换参数的事情，最终再call到__android_log_buf_write()函数，这个函数的定义在system/core/liblog/logd_write.c，为：

`01`	`int` `__android_log_buf_write(int` `bufID,` `int` `prio,` `const` `char` `tag,` `const` `char` `msg)`

02 {

`03`	`struct` `iovec vec[3];`

`04`	`char` `tmp_tag[32];`

05

`06`	`if` `(!tag)`

`07`	`tag =` `"";`

08

`09`	`/* XXX: This needs to go! */`

`10`	`if` `((bufID != LOG_ID_RADIO) &&`

`11`	`(!strcmp(tag,` `"HTC_RIL") \|\|`

`12`	`!strncmp(tag,` `"RIL", 3) \|\|` `/* Any log tag with "RIL" as the prefix */`

`13`	`!strncmp(tag,` `"IMS", 3) \|\|` `/* Any log tag with "IMS" as the prefix */`

`14`	`!strcmp(tag,` `"AT") \|\|`

`15`	`!strcmp(tag,` `"GSM") \|\|`

`16`	`!strcmp(tag,` `"STK") \|\|`

`17`	`!strcmp(tag,` `"CDMA") \|\|`

`18`	`!strcmp(tag,` `"PHONE") \|\|`

`19`	`!strcmp(tag,` `"SMS"))) {`

`20`	`bufID = LOG_ID_RADIO;`

`21`	`// Inform third party apps/ril/radio.. to use Rlog or RLOG`

`22`	`snprintf(tmp_tag,` `sizeof(tmp_tag),` `"use-Rlog/RLOG-%s", tag);`

`23`	`tag = tmp_tag;`

24 }

25

`26`	`vec[0].iov_base = (unsigned` `char` `*) &prio;`

`27`	`vec[0].iov_len = 1;`

`28`	`vec[1].iov_base = (void` `*) tag;`

`29`	`vec[1].iov_len =` `strlen(tag) + 1;`

`30`	`vec[2].iov_base = (void` `*) msg;`

`31`	`vec[2].iov_len =` `strlen(msg) + 1;`

32

`33`	`return` `write_to_log(bufID, vec, 3);`

34 }

做了三件事情，一是根据log的tag，转换bufID，二是用传进来的参数构造一个struct iovec数组，三是将前一步构造的数组作为参数调用write_to_log()。write_to_log()是一个函数指针，在开始时，它指向了__write_to_log_init()：

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

__write_to_log_init()的实现如下：

`01`	`static` `int` `__write_to_log_init(log_id_t log_id,` `struct` `iovec *vec,` `size_t` `nr)`

02 {

`03`	`#ifdef HAVE_PTHREADS`

`04`	`pthread_mutex_lock(&log_init_lock);`

05 #endif

06

`07`	`if` `(write_to_log == __write_to_log_init) {`

`08`	`log_fds[LOG_ID_MAIN] = log_open("/dev/"LOGGER_LOG_MAIN, O_WRONLY);`

`09`	`log_fds[LOG_ID_RADIO] = log_open("/dev/"LOGGER_LOG_RADIO, O_WRONLY);`

`10`	`log_fds[LOG_ID_EVENTS] = log_open("/dev/"LOGGER_LOG_EVENTS, O_WRONLY);`

`11`	`log_fds[LOG_ID_SYSTEM] = log_open("/dev/"LOGGER_LOG_SYSTEM, O_WRONLY);`

12

`13`	`write_to_log = __write_to_log_kernel;`

14

`15`	`if` `(log_fds[LOG_ID_MAIN] < 0 \|\| log_fds[LOG_ID_RADIO] < 0 \|\|`

`16`	`log_fds[LOG_ID_EVENTS] < 0) {`

`17`	`log_close(log_fds[LOG_ID_MAIN]);`

`18`	`log_close(log_fds[LOG_ID_RADIO]);`

`19`	`log_close(log_fds[LOG_ID_EVENTS]);`

`20`	`log_fds[LOG_ID_MAIN] = -1;`

`21`	`log_fds[LOG_ID_RADIO] = -1;`

`22`	`log_fds[LOG_ID_EVENTS] = -1;`

`23`	`write_to_log = __write_to_log_null;`

24 }

25

`26`	`if` `(log_fds[LOG_ID_SYSTEM] < 0) {`

`27`	`log_fds[LOG_ID_SYSTEM] = log_fds[LOG_ID_MAIN];`

28 }

29 }

30

`31`	`#ifdef HAVE_PTHREADS`

`32`	`pthread_mutex_unlock(&log_init_lock);`

33 #endif

34

`35`	`return` `write_to_log(log_id, vec, nr);`

36 }

这个地方，会检查write_to_log是否指向了__write_to_log_init，也就是是否是第一次打印log，如果是，则打开几个用于输出log的设备文件，然后使write_to_log函数指针指向__write_to_log_kernel，或者在打开输出log设备文件出现异常时，使write_to_log指向__write_to_log_null，最后再次调用经过了重定向的write_to_log，也就是__write_to_log_kernel或者__write_to_log_null函数。我们可以看一下那几个设备文件究竟是什麽(在system/core/include/cutils/logger.h)：

`1`	`#define LOGGER_LOG_MAIN "log/main"`

`2`	`#define LOGGER_LOG_RADIO "log/radio"`

`3`	`#define LOGGER_LOG_EVENTS "log/events"`

`4`	`#define LOGGER_LOG_SYSTEM "log/system"`

接着继续来看__write_to_log_kernel或者__write_to_log_null函数：

`01`	`static` `int` `__write_to_log_null(log_id_t log_fd,` `struct` `iovec *vec,` `size_t` `nr)`

02 {

`03`	`return` `-1;`

04 }

05

`06`	`static` `int` `__write_to_log_kernel(log_id_t log_id,` `struct` `iovec *vec,` `size_t` `nr)`

07 {

`08`	`ssize_t ret;`

`09`	`int` `log_fd;`

10

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

`12`	`log_fd = log_fds[(int)log_id];`

`13`	`}` `else` `{`

`14`	`return` `EBADF;`

15 }

16

17 do {

`18`	`ret = log_writev(log_fd, vec, nr);`

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

20

`21`	`return` `ret;`

22 }

由log_id获取到对应的log_fd，然后调用log_writev()打印log。可以看一下log_writev()的定义，它是一个宏：

`01`	`#if FAKE_LOG_DEVICE`

`02`	`// This will be defined when building for the host.`

`03`	`#define log_open(pathname, flags) fakeLogOpen(pathname, flags)`

`04`	`#define log_writev(filedes, vector, count) fakeLogWritev(filedes, vector, count)`

`05`	`#define log_close(filedes) fakeLogClose(filedes)`

06 #else

`07`	`#define log_open(pathname, flags) open(pathname, (flags) \| O_CLOEXEC)`

`08`	`#define log_writev(filedes, vector, count) writev(filedes, vector, count)`

`09`	`#define log_close(filedes) close(filedes)`

10 #endif

这些就都是标准的unix系统调用了。

本地层代码Log输出

以一些比较典型的native代码打印log的case为例。先来看一下，在JNI的code中打印log的方法。在JNI中，比较常见到用ALOGx这一组宏来打印log，比如在frameworks/base/core/jni/android/graphics/TextLayoutCache.cpp这个文件中的dumpCacheStats()函数：

`01`	`void` `TextLayoutCache::dumpCacheStats() {`

`02`	`float` `remainingPercent = 100 * ((mMaxSize - mSize) / ((float)mMaxSize));`

`03`	`float` `timeRunningInSec = (systemTime(SYSTEM_TIME_MONOTONIC) - mCacheStartTime) / 1000000000;`

04

`05`	`size_t` `cacheSize = mCache.size();`

06

`07`	`ALOGD("------------------------------------------------");`

`08`	`ALOGD("Cache stats");`

`09`	`ALOGD("------------------------------------------------");`

`10`	`ALOGD("pid : %d", getpid());`

`11`	`ALOGD("running : %.0f seconds", timeRunningInSec);`

`12`	`ALOGD("entries : %d", cacheSize);`

`13`	`ALOGD("max size : %d bytes", mMaxSize);`

`14`	`ALOGD("used : %d bytes according to mSize", mSize);`

`15`	`ALOGD("remaining : %d bytes or %2.2f percent", mMaxSize - mSize, remainingPercent);`

`16`	`ALOGD("hits : %d", mCacheHitCount);`

`17`	`ALOGD("saved : %0.6f ms", mNanosecondsSaved * 0.000001f);`

`18`	`ALOGD("------------------------------------------------");`

19 }

使用这组宏，需要定义另外一个宏来作为所打印log的tag：

`1`	`#define LOG_TAG "TextLayoutCache"`

此外，还要include头文件<cutils/log.h>。来看一下这些宏中的一些的定义：

01 /*

`02`	`* Simplified macro to send a debug log message using the current LOG_TAG.`

03 */

`04`	`#ifndef ALOGD`

`05`	`#define ALOGD(...) ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__))`

06 #endif

07

08 /*

`09`	`* Simplified macro to send a warning log message using the current LOG_TAG.`

10 */

`11`	`#ifndef ALOGW`

`12`	`#define ALOGW(...) ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__))`

13 #endif

14

15 /*

`16`	`* Basic log message macro.`

17 *

`18`	`* Example:`

`19`	`* ALOG(LOG_WARN, NULL, "Failed with error %d", errno);`

20 *

`21`	`* The second argument may be NULL or "" to indicate the "global" tag.`

22 */

`23`	`#ifndef ALOG`

`24`	`#define ALOG(priority, tag, ...) \`

`25`	`LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)`

26 #endif

27

28 /*

`29`	`* Log macro that allows you to specify a number for the priority.`

30 */

`31`	`#ifndef LOG_PRI`

`32`	`#define LOG_PRI(priority, tag, ...) \`

`33`	`android_printLog(priority, tag, __VA_ARGS__)`

34 #endif

35

`36`	`#define android_printLog(prio, tag, fmt...) \`

`37`	`__android_log_print(prio, tag, fmt)`

先来看一下，在native层中定义的priority(在system/core/include/android/log.h中)：

01 /*

`02`	`* Android log priority values, in ascending priority order.`

03 */

`04`	`typedef` `enum` `android_LogPriority {`

`05`	`ANDROID_LOG_UNKNOWN = 0,`

`06`	`ANDROID_LOG_DEFAULT,` `/* only for SetMinPriority() */`

`07`	`ANDROID_LOG_VERBOSE,`

`08`	`ANDROID_LOG_DEBUG,`

`09`	`ANDROID_LOG_INFO,`

`10`	`ANDROID_LOG_WARN,`

`11`	`ANDROID_LOG_ERROR,`

`12`	`ANDROID_LOG_FATAL,`

`13`	`ANDROID_LOG_SILENT,` `/* only for SetMinPriority(); must be last */`

`14`	`} android_LogPriority;`

另外，这些宏最终都会call到__android_log_print()，也是在system/core/liblog/logd_write.c中：

`01`	`int` `__android_log_print(int` `prio,` `const` `char` `tag,` `const` `char` `fmt, ...)`

02 {

`03`	`va_list` `ap;`

`04`	`char` `buf[LOG_BUF_SIZE];`

05

`06`	`va_start(ap, fmt);`

`07`	`vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);`

`08`	`va_end(ap);`

09

`10`	`return` `__android_log_write(prio, tag, buf);`

11 }

先是格式化参数，然后就是调用__android_log_write()函数。这个函数的code如下：

`01`	`int` `__android_log_write(int` `prio,` `const` `char` `tag,` `const` `char` `msg)`

02 {

`03`	`struct` `iovec vec[3];`

`04`	`log_id_t log_id = LOG_ID_MAIN;`

`05`	`char` `tmp_tag[32];`

06

`07`	`if` `(!tag)`

`08`	`tag =` `"";`

09

`10`	`/* XXX: This needs to go! */`

`11`	`if` `(!strcmp(tag,` `"HTC_RIL") \|\|`

`12`	`!strncmp(tag,` `"RIL", 3) \|\|` `/* Any log tag with "RIL" as the prefix */`

`13`	`!strncmp(tag,` `"IMS", 3) \|\|` `/* Any log tag with "IMS" as the prefix */`

`14`	`!strcmp(tag,` `"AT") \|\|`

`15`	`!strcmp(tag,` `"GSM") \|\|`

`16`	`!strcmp(tag,` `"STK") \|\|`

`17`	`!strcmp(tag,` `"CDMA") \|\|`

`18`	`!strcmp(tag,` `"PHONE") \|\|`

`19`	`!strcmp(tag,` `"SMS")) {`

`20`	`log_id = LOG_ID_RADIO;`

`21`	`// Inform third party apps/ril/radio.. to use Rlog or RLOG`

`22`	`snprintf(tmp_tag,` `sizeof(tmp_tag),` `"use-Rlog/RLOG-%s", tag);`

`23`	`tag = tmp_tag;`

24 }

25

`26`	`vec[0].iov_base = (unsigned` `char` `*) &prio;`

`27`	`vec[0].iov_len = 1;`

`28`	`vec[1].iov_base = (void` `*) tag;`

`29`	`vec[1].iov_len =` `strlen(tag) + 1;`

`30`	`vec[2].iov_base = (void` `*) msg;`

`31`	`vec[2].iov_len =` `strlen(msg) + 1;`

32

`33`	`return` `write_to_log(log_id, vec, 3);`

34 }

这个函数与我们前面看到的__android_log_buf_write()非常相似。所不同的就是这个函数没有log_id参数，因而它默认是输出MAIN log，当log的TAG为某些特殊字串时，则输出RADIO log。最后同样是调用write_to_log这个函数指针来输出log。

我们再来看一个skia里面打log的SkDebugf()函数的实现：

`1`	`#include <android/log.h>`

2

`3`	`void` `SkDebugf(const` `char` `format[], ...) {`

`4`	`va_list` `args;`

`5`	`va_start(args, format);`

`6`	`__android_log_vprint(ANDROID_LOG_DEBUG, LOG_TAG, format, args);`

`7`	`va_end(args);`

8 }

call到了__android_log_vprint()来输出log，__android_log_vprint()的定义也在system/core/liblog/logd_write.c中：

`1`	`int` `__android_log_vprint(int` `prio,` `const` `char` `tag,` `const` `char` `fmt,` `va_list` `ap)`

2 {

`3`	`char` `buf[LOG_BUF_SIZE];`

4

`5`	`vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);`

6

`7`	`return` `__android_log_write(prio, tag, buf);`

8 }

一样是__android_log_write()函数。

Done.