android log机制——输出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.
【作者】
张昺华
【新浪微博】 张昺华--sky
【twitter】 @sky2030_
【facebook】 张昺华 zhangbinghua
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利.
