程序博客网 > 乾隆 知乎

android log系统

来源：互联网 发布：乾隆 知乎 编辑：程序博客网 时间：2024/06/05 10:22

转载自http://blog.csdn.net/Luoshengyang/article/category/838604/3

 

Android系统开发中LOG的使用

在程序开发过程中，LOG是广泛使用的用来记录程序执行过程的机制，它既可以用于程序调试，也可以用于产品运营中的事件记录。在Android系统中，提供了简单、便利的LOG机制，开发人员可以方便地使用。在这一篇文章中，我们简单介绍在Android内核空间和用户空间中LOG的使用和查看方法。

        一. 内核开发时LOG的使用。Android内核是基于Linux Kerne 2.36的，因此，Linux Kernel的LOG机制同样适合于Android内核，它就是有名的printk，与C语言的printf齐名。与printf类似，printk提供格式化输入功能，同时，它也具有所有LOG机制的特点--提供日志级别过虑功能。printk提供了8种日志级别（<linux/kernel.h>）：

[cpp] view plaincopyprint?
  1. #define KERN_EMERG  "<0>"     /* system is unusable           */  
  2. #define KERN_ALERT  "<1>"     /* action must be taken immediately */  
  3. #define KERN_CRIT   "<2>"     /* critical conditions          */  
  4. #deinfe KERN_ERR    "<3>"     /* error conditions         */  
  5. #deinfe KERN_WARNING    "<4>"     /* warning conditions           */  
  6. #deinfe KERN_NOTICE "<5>"     /* normal but significant condition */  
  7. #deinfe KERN_INFO   "<6>"     /* informational            */  
  8. #deinfe KERN_DEBUG  "<7>"     /* debug-level messages         */  

       printk的使用方法：

       printk(KERN_ALERT"This is the log printed by printk in linux kernel space.");

       KERN_ALERT表示日志级别，后面紧跟着要格式化字符串。

       在Android系统中，printk输出的日志信息保存在/proc/kmsg中，要查看/proc/kmsg的内容，参照在Ubuntu上下载、编译和安装Android最新内核源代码（Linux Kernel）一文，在后台中运行模拟器：

       USER-NAME@MACHINE-NAME:~/Android$ emulator &

       启动adb shell工具：

       USER-NAME@MACHINE-NAME:~/Android$ adb shell

       查看/proc/kmsg文件：

       root@android:/ # cat  /proc/kmsg

       二. 用户空间程序开发时LOG的使用。Android系统在用户空间中提供了轻量级的logger日志系统，它是在内核中实现的一种设备驱动，与用户空间的logcat工具配合使用能够方便地跟踪调试程序。在Android系统中，分别为C/C++ 和Java语言提供两种不同的logger访问接口。C/C++日志接口一般是在编写硬件抽象层模块或者编写JNI方法时使用，而Java接口一般是在应用层编写APP时使用。

       Android系统中的C/C++日志接口是通过宏来使用的。在system/core/include/android/log.h定义了日志的级别：

[cpp] view plaincopyprint?
  1. /* 
  2.  * Android log priority values, in ascending priority order. 
  3.  */  
  4. typedef enum android_LogPriority {  
  5.     ANDROID_LOG_UNKNOWN = 0,  
  6.     ANDROID_LOG_DEFAULT,    /* only for SetMinPriority() */  
  7.     ANDROID_LOG_VERBOSE,  
  8.     ANDROID_LOG_DEBUG,  
  9.     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;  

       在system/core/include/cutils/log.h中，定义了对应的宏，如对应于ANDROID_LOG_VERBOSE的宏LOGV：

[cpp] view plaincopyprint?
  1. /* 
  2.  * This is the local tag used for the following simplified 
  3.  * logging macros. You can change this preprocessor definition 
  4.  * before using the other macros to change the tag. 
  5.  */  
  6. #ifndef LOG_TAG   
  7. #define LOG_TAG NULL   
  8. #endif   
  9.   
  10. /* 
  11.  * Simplified macro to send a verbose log message using the current LOG_TAG. 
  12.  */  
  13. #ifndef LOGV   
  14. #if LOG_NDEBUG   
  15. #define LOGV(...)   ((void)0)  
  16. #else   
  17. #define LOGV(...)   ((void)LOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))  
  18. #endif   
  19. #endif   
  20.   
  21. /* 
  22.  * Basic log message macro. 
  23.  * 
  24.  * Example: 
  25.  *  LOG(LOG_WARN, NULL, "Failed with error %d", errno); 
  26.  * 
  27.  * The second argument may be NULL or "" to indicate the "global" tag. 
  28.  */  
  29. #ifndef LOG   
  30. #define LOG(priority, tag, ...) \   
  31.      LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)  
  32. #endif   
  33.   
  34. /* 
  35.  * Log macro that allows you to specify a number for priority. 
  36.  */  
  37. #ifndef LOG_PRI   
  38. #define LOG_PRI(priority, tag, ...) \  
  39.      android_printLog(priority, tag, __VA_ARGS__)  
  40. #endif   
  41.   
  42. /* 
  43.  * ================================================================ 
  44.  * 
  45.  * The stuff in the rest of this file should not be used directly. 
  46.  */  
  47. #define android_printLog(prio, tag, fmt...) \  
  48.      __android_log_print(prio, tag, fmt)  

         因此，如果要使用C/C++日志接口，只要定义自己的LOG_TAG宏和包含头文件system/core/include/cutils/log.h就可以了：

         #define LOG_TAG "MY LOG TAG"

         #include <cutils/log.h>

         就可以了，例如使用LOGV：

         LOGV("This is the log printed by LOGV in android user space.");

         再来看Android系统中的Java日志接口。Android系统在Frameworks层中定义了Log接口（frameworks/base/core/java/android/util/Log.java）：

[java] view plaincopyprint?
  1. ................................................  
  2.   
  3. public final class Log {  
  4.   
  5. ................................................  
  6.   
  7.     /** 
  8.      * Priority constant for the println method; use Log.v. 
  9.          */  
  10.     public static final int VERBOSE = 2;  
  11.   
  12.     /** 
  13.      * Priority constant for the println method; use Log.d. 
  14.          */  
  15.     public static final int DEBUG = 3;  
  16.   
  17.     /** 
  18.      * Priority constant for the println method; use Log.i. 
  19.          */  
  20.     public static final int INFO = 4;  
  21.   
  22.     /** 
  23.      * Priority constant for the println method; use Log.w. 
  24.          */  
  25.     public static final int WARN = 5;  
  26.   
  27.     /** 
  28.      * Priority constant for the println method; use Log.e. 
  29.          */  
  30.     public static final int ERROR = 6;  
  31.   
  32.     /** 
  33.      * Priority constant for the println method. 
  34.          */  
  35.     public static final int ASSERT = 7;  
  36.   
  37. .....................................................  
  38.   
  39.     public static int v(String tag, String msg) {  
  40.         return println_native(LOG_ID_MAIN, VERBOSE, tag, msg);  
  41.     }  
  42.   
  43.     public static int v(String tag, String msg, Throwable tr) {  
  44.         return println_native(LOG_ID_MAIN, VERBOSE, tag, msg + '\n' + getStackTraceString(tr));  
  45.     }  
  46.   
  47.     public static int d(String tag, String msg) {  
  48.         return println_native(LOG_ID_MAIN, DEBUG, tag, msg);  
  49.     }  
  50.   
  51.     public static int d(String tag, String msg, Throwable tr) {  
  52.         return println_native(LOG_ID_MAIN, DEBUG, tag, msg + '\n' + getStackTraceString(tr));  
  53.     }  
  54.   
  55.     public static int i(String tag, String msg) {  
  56.         return println_native(LOG_ID_MAIN, INFO, tag, msg);  
  57.     }  
  58.   
  59.     public static int i(String tag, String msg, Throwable tr) {  
  60.         return println_native(LOG_ID_MAIN, INFO, tag, msg + '\n' + getStackTraceString(tr));  
  61.     }  
  62.   
  63.     public static int w(String tag, String msg) {  
  64.         return println_native(LOG_ID_MAIN, WARN, tag, msg);  
  65.     }  
  66.   
  67.     public static int w(String tag, String msg, Throwable tr) {  
  68.         return println_native(LOG_ID_MAIN, WARN, tag, msg + '\n' + getStackTraceString(tr));  
  69.     }  
  70.   
  71.     public static int w(String tag, Throwable tr) {  
  72.         return println_native(LOG_ID_MAIN, WARN, tag, getStackTraceString(tr));  
  73.     }  
  74.       
  75.     public static int e(String tag, String msg) {  
  76.         return println_native(LOG_ID_MAIN, ERROR, tag, msg);  
  77.     }  
  78.   
  79.     public static int e(String tag, String msg, Throwable tr) {  
  80.         return println_native(LOG_ID_MAIN, ERROR, tag, msg + '\n' + getStackTraceString(tr));  
  81.     }  
  82.   
  83. ..................................................................  
  84.   
  85.     /**@hide */ public static native int println_native(int bufID,  
  86.         int priority, String tag, String msg);  
  87. }  

        因此，如果要使用Java日志接口，只要在类中定义的LOG_TAG常量和引用android.util.Log就可以了：

        private static final String LOG_TAG = "MY_LOG_TAG";

        Log.i(LOG_TAG, "This is the log printed by Log.i in android user space.");

        要查看这些LOG的输出，可以配合logcat工具。如果是在Eclipse环境下运行模拟器，并且安装了Android插件，那么，很简单，直接在Eclipse就可以查看了：

        

        如果是在自己编译的Android源代码工程中使用，则在后台中运行模拟器：

       USER-NAME@MACHINE-NAME:~/Android$ emulator &

       启动adb shell工具：

       USER-NAME@MACHINE-NAME:~/Android$ adb shell

       使用logcat命令查看日志：

       root@android:/ # logcat

       这样就可以看到输出的日志了

Android日志系统驱动程序Logger源代码分析

我们知道，在Android系统中，提供了一个轻量级的日志系统，这个日志系统是以驱动程序的形式实现在内核空间的，而在用户空间分别提供了Java接口和C/C++接口来使用这个日志系统，取决于你编写的是Android应用程序还是系统组件。在前面的文章浅谈Android系统开发中LOG的使用中，已经简要地介绍了在Android应用程序开发中Log的使用方法，在这一篇文章中，我们将更进一步地分析Logger驱动程序的源代码，使得我们对Android日志系统有一个深刻的认识。

        既然Android 日志系统是以驱动程序的形式实现在内核空间的，我们就需要获取Android内核源代码来分析了，请参照前面在Ubuntu上下载、编译和安装Android最新源代码和在Ubuntu上下载、编译和安装Android最新内核源代码（Linux Kernel）两篇文章，下载好Android源代码工程。Logger驱动程序主要由两个文件构成，分别是：

       kernel/common/drivers/staging/android/logger.h

       kernel/common/drivers/staging/android/logger.c

       接下来，我们将分别介绍Logger驱动程序的相关数据结构，然后对Logger驱动程序源代码进行情景分析，分别日志系统初始化情景、日志读取情景和日志写入情景。

       一. Logger驱动程序的相关数据结构。

      我们首先来看logger.h头文件的内容：

[cpp] view plaincopyprint?
  1. #ifndef _LINUX_LOGGER_H   
  2. #define _LINUX_LOGGER_H   
  3.   
  4. #include <linux/types.h>   
  5. #include <linux/ioctl.h>   
  6.   
  7. struct logger_entry {  
  8.     __u16       len;    /* length of the payload */  
  9.     __u16       __pad;  /* no matter what, we get 2 bytes of padding */  
  10.     __s32       pid;    /* generating process's pid */  
  11.     __s32       tid;    /* generating process's tid */  
  12.     __s32       sec;    /* seconds since Epoch */  
  13.     __s32       nsec;   /* nanoseconds */  
  14.     char        msg[0]; /* the entry's payload */  
  15. };  
  16.   
  17. #define LOGGER_LOG_RADIO    "log_radio" /* radio-related messages */  
  18. #define LOGGER_LOG_EVENTS   "log_events"    /* system/hardware events */  
  19. #define LOGGER_LOG_MAIN     "log_main"  /* everything else */  
  20.   
  21. #define LOGGER_ENTRY_MAX_LEN        (4*1024)  
  22. #define LOGGER_ENTRY_MAX_PAYLOAD    \  
  23.     (LOGGER_ENTRY_MAX_LEN - sizeof(struct logger_entry))  
  24.   
  25. #define __LOGGERIO  0xAE   
  26.   
  27. #define LOGGER_GET_LOG_BUF_SIZE     _IO(__LOGGERIO, 1) /* size of log */  
  28. #define LOGGER_GET_LOG_LEN      _IO(__LOGGERIO, 2) /* used log len */  
  29. #define LOGGER_GET_NEXT_ENTRY_LEN   _IO(__LOGGERIO, 3) /* next entry len */  
  30. #define LOGGER_FLUSH_LOG        _IO(__LOGGERIO, 4) /* flush log */  
  31.   
  32. #endif /* _LINUX_LOGGER_H */  

        struct logger_entry是一个用于描述一条Log记录的结构体。len成员变量记录了这条记录的有效负载的长度，有效负载指定的日志记录本身的长度，但是不包括用于描述这个记录的struct logger_entry结构体。回忆一下我们调用android.util.Log接口来使用日志系统时，会指定日志的优先级别Priority、Tag字符串以及Msg字符串，Priority + Tag + Msg三者内容的长度加起来就是记录的有效负载长度了。__pad成员变量是用来对齐结构体的。pid和tid成员变量分别用来记录是哪条进程写入了这条记录。sec和nsec成员变量记录日志写的时间。msg成员变量记录的就有效负载的内容了，它的大小由len成员变量来确定。

       接着定义两个宏：

       #define LOGGER_ENTRY_MAX_LEN             (4*1024)

       #define LOGGER_ENTRY_MAX_PAYLOAD   \

                         (LOGGER_ENTRY_MAX_LEN - sizeof(struct logger_entry))

      从这两个宏可以看出，每条日志记录的有效负载长度加上结构体logger_entry的长度不能超过4K个字节。

      logger.h文件中还定义了其它宏，读者可以自己分析，在下面的分析中，碰到时，我们也会详细解释。

      再来看logger.c文件中，其它相关数据结构的定义：

[cpp] view plaincopyprint?
  1. /* 
  2.  * struct logger_log - represents a specific log, such as 'main' or 'radio' 
  3.  * 
  4.  * This structure lives from module insertion until module removal, so it does 
  5.  * not need additional reference counting. The structure is protected by the 
  6.  * mutex 'mutex'. 
  7.  */  
  8. struct logger_log {  
  9.     unsigned char *     buffer; /* the ring buffer itself */  
  10.     struct miscdevice   misc;   /* misc device representing the log */  
  11.     wait_queue_head_t   wq; /* wait queue for readers */  
  12.     struct list_head    readers; /* this log's readers */  
  13.     struct mutex        mutex;  /* mutex protecting buffer */  
  14.     size_t          w_off;  /* current write head offset */  
  15.     size_t          head;   /* new readers start here */  
  16.     size_t          size;   /* size of the log */  
  17. };  
  18.   
  19. /* 
  20.  * struct logger_reader - a logging device open for reading 
  21.  * 
  22.  * This object lives from open to release, so we don't need additional 
  23.  * reference counting. The structure is protected by log->mutex. 
  24.  */  
  25. struct logger_reader {  
  26.     struct logger_log * log;    /* associated log */  
  27.     struct list_head    list;   /* entry in logger_log's list */  
  28.     size_t          r_off;  /* current read head offset */  
  29. };  
  30.   
  31. /* logger_offset - returns index 'n' into the log via (optimized) modulus */  
  32. #define logger_offset(n)    ((n) & (log->size - 1))  

        结构体struct logger_log就是真正用来保存日志的地方了。buffer成员变量变是用保存日志信息的内存缓冲区，它的大小由size成员变量确定。从misc成员变量可以看出，logger驱动程序使用的设备属于misc类型的设备，通过在Android模拟器上执行cat /proc/devices命令（可参考在Ubuntu上下载、编译和安装Android最新内核源代码（Linux Kernel）一文），可以看出，misc类型设备的主设备号是10。关于主设备号的相关知识，可以参考Android学习启动篇一文中提到的Linux Driver Development一书。wq成员变量是一个等待队列，用于保存正在等待读取日志的进程。readers成员变量用来保存当前正在读取日志的进程，正在读取日志的进程由结构体logger_reader来描述。mutex成员变量是一个互斥量，用来保护log的并发访问。可以看出，这里的日志系统的读写问题，其实是一个生产者-消费者的问题，因此，需要互斥量来保护log的并发访问。 w_off成员变量用来记录下一条日志应该从哪里开始写。head成员变量用来表示打开日志文件中，应该从哪一个位置开始读取日志。

       结构体struct logger_reader用来表示一个读取日志的进程，log成员变量指向要读取的日志缓冲区。list成员变量用来连接其它读者进程。r_off成员变量表示当前要读取的日志在缓冲区中的位置。

       struct logger_log结构体中用于保存日志信息的内存缓冲区buffer是一个循环使用的环形缓冲区，缓冲区中保存的内容是以struct logger_entry为单位的，每个单位的组成为：

       struct logger_entry | priority | tag | msg

       由于是内存缓冲区buffer是一个循环使用的环形缓冲区，给定一个偏移值，它在buffer中的位置由下logger_offset来确定：

       #define logger_offset(n)          ((n) & (log->size - 1))

       二. Logger驱动程序模块的初始化过程分析。

       继续看logger.c文件，定义了三个日志设备：

[cpp] view plaincopyprint?
  1. /* 
  2.  * Defines a log structure with name 'NAME' and a size of 'SIZE' bytes, which 
  3.  * must be a power of two, greater than LOGGER_ENTRY_MAX_LEN, and less than 
  4.  * LONG_MAX minus LOGGER_ENTRY_MAX_LEN. 
  5.  */  
  6. #define DEFINE_LOGGER_DEVICE(VAR, NAME, SIZE) \  
  7. static unsigned char _buf_ ## VAR[SIZE]; \  
  8. static struct logger_log VAR = { \  
  9.     .buffer = _buf_ ## VAR, \  
  10.     .misc = { \  
  11.         .minor = MISC_DYNAMIC_MINOR, \  
  12.         .name = NAME, \  
  13.         .fops = &logger_fops, \  
  14.         .parent = NULL, \  
  15.     }, \  
  16.     .wq = __WAIT_QUEUE_HEAD_INITIALIZER(VAR .wq), \  
  17.     .readers = LIST_HEAD_INIT(VAR .readers), \  
  18.     .mutex = __MUTEX_INITIALIZER(VAR .mutex), \  
  19.     .w_off = 0, \  
  20.     .head = 0, \  
  21.     .size = SIZE, \  
  22. };  
  23.   
  24. DEFINE_LOGGER_DEVICE(log_main, LOGGER_LOG_MAIN, 64*1024)  
  25. DEFINE_LOGGER_DEVICE(log_events, LOGGER_LOG_EVENTS, 256*1024)  
  26. DEFINE_LOGGER_DEVICE(log_radio, LOGGER_LOG_RADIO, 64*1024)  

       分别是log_main、log_events和log_radio，名称分别LOGGER_LOG_MAIN、LOGGER_LOG_EVENTS和LOGGER_LOG_RADIO，它们的次设备号为MISC_DYNAMIC_MINOR，即为在注册时动态分配。在logger.h文件中，有这三个宏的定义：

       #define LOGGER_LOG_RADIO "log_radio"/* radio-related messages */
       #define LOGGER_LOG_EVENTS "log_events"/* system/hardware events */
       #define LOGGER_LOG_MAIN "log_main"/* everything else */

       注释说明了这三个日志设备的用途。注册的日志设备文件操作方法为logger_fops：

[cpp] view plaincopyprint?
  1. static struct file_operations logger_fops = {  
  2.     .owner = THIS_MODULE,  
  3.     .read = logger_read,  
  4.     .aio_write = logger_aio_write,  
  5.     .poll = logger_poll,  
  6.     .unlocked_ioctl = logger_ioctl,  
  7.     .compat_ioctl = logger_ioctl,  
  8.     .open = logger_open,  
  9.     .release = logger_release,  
  10. };  

       日志驱动程序模块的初始化函数为logger_init：

[cpp] view plaincopyprint?
  1. static int __init logger_init(void)  
  2. {  
  3.     int ret;  
  4.   
  5.     ret = init_log(&log_main);  
  6.     if (unlikely(ret))  
  7.         goto out;  
  8.   
  9.     ret = init_log(&log_events);  
  10.     if (unlikely(ret))  
  11.         goto out;  
  12.   
  13.     ret = init_log(&log_radio);  
  14.     if (unlikely(ret))  
  15.         goto out;  
  16.   
  17. out:  
  18.     return ret;  
  19. }  
  20. device_initcall(logger_init);  

        logger_init函数通过调用init_log函数来初始化了上述提到的三个日志设备：

[cpp] view plaincopyprint?
  1. static int __init init_log(struct logger_log *log)  
  2. {  
  3.     int ret;  
  4.   
  5.     ret = misc_register(&log->misc);  
  6.     if (unlikely(ret)) {  
  7.         printk(KERN_ERR "logger: failed to register misc "  
  8.                "device for log '%s'!\n", log->misc.name);  
  9.         return ret;  
  10.     }  
  11.   
  12.     printk(KERN_INFO "logger: created %luK log '%s'\n",  
  13.            (unsigned long) log->size >> 10, log->misc.name);  
  14.   
  15.     return 0;  
  16. }  

        init_log函数主要调用了misc_register函数来注册misc设备，misc_register函数定义在kernel/common/drivers/char/misc.c文件中：

[cpp] view plaincopyprint?
  1. /** 
  2.  *      misc_register   -       register a miscellaneous device 
  3.  *      @misc: device structure 
  4.  * 
  5.  *      Register a miscellaneous device with the kernel. If the minor 
  6.  *      number is set to %MISC_DYNAMIC_MINOR a minor number is assigned 
  7.  *      and placed in the minor field of the structure. For other cases 
  8.  *      the minor number requested is used. 
  9.  * 
  10.  *      The structure passed is linked into the kernel and may not be 
  11.  *      destroyed until it has been unregistered. 
  12.  * 
  13.  *      A zero is returned on success and a negative errno code for 
  14.  *      failure. 
  15.  */  
  16.   
  17. int misc_register(struct miscdevice * misc)  
  18. {  
  19.         struct miscdevice *c;  
  20.         dev_t dev;  
  21.         int err = 0;  
  22.   
  23.         INIT_LIST_HEAD(&misc->list);  
  24.   
  25.         mutex_lock(&misc_mtx);  
  26.         list_for_each_entry(c, &misc_list, list) {  
  27.                 if (c->minor == misc->minor) {  
  28.                         mutex_unlock(&misc_mtx);  
  29.                         return -EBUSY;  
  30.                 }  
  31.         }  
  32.   
  33.         if (misc->minor == MISC_DYNAMIC_MINOR) {  
  34.                 int i = DYNAMIC_MINORS;  
  35.                 while (--i >= 0)  
  36.                         if ( (misc_minors[i>>3] & (1 << (i&7))) == 0)  
  37.                                 break;  
  38.                 if (i<0) {  
  39.                         mutex_unlock(&misc_mtx);  
  40.                         return -EBUSY;  
  41.                 }  
  42.                 misc->minor = i;  
  43.         }  
  44.   
  45.         if (misc->minor < DYNAMIC_MINORS)  
  46.                 misc_minors[misc->minor >> 3] |= 1 << (misc->minor & 7);  
  47.         dev = MKDEV(MISC_MAJOR, misc->minor);  
  48.   
  49.         misc->this_device = device_create(misc_class, misc->parent, dev, NULL,  
  50.                                           "%s", misc->name);  
  51.         if (IS_ERR(misc->this_device)) {  
  52.                 err = PTR_ERR(misc->this_device);  
  53.                 goto out;  
  54.         }  
  55.   
  56.         /* 
  57.          * Add it to the front, so that later devices can "override" 
  58.          * earlier defaults 
  59.          */  
  60.         list_add(&misc->list, &misc_list);  
  61.  out:  
  62.         mutex_unlock(&misc_mtx);  
  63.         return err;  
  64. }  

        注册完成后，通过device_create创建设备文件节点。这里，将创建/dev/log/main、/dev/log/events和/dev/log/radio三个设备文件，这样，用户空间就可以通过读写这三个文件和驱动程序进行交互。

        三. Logger驱动程序的日志记录读取过程分析。

        继续看logger.c 文件，注册的读取日志设备文件的方法为logger_read：

[cpp] view plaincopyprint?
  1. /* 
  2.  * logger_read - our log's read() method 
  3.  * 
  4.  * Behavior: 
  5.  * 
  6.  *  - O_NONBLOCK works 
  7.  *  - If there are no log entries to read, blocks until log is written to 
  8.  *  - Atomically reads exactly one log entry 
  9.  * 
  10.  * Optimal read size is LOGGER_ENTRY_MAX_LEN. Will set errno to EINVAL if read 
  11.  * buffer is insufficient to hold next entry. 
  12.  */  
  13. static ssize_t logger_read(struct file *file, char __user *buf,  
  14.                size_t count, loff_t *pos)  
  15. {  
  16.     struct logger_reader *reader = file->private_data;  
  17.     struct logger_log *log = reader->log;  
  18.     ssize_t ret;  
  19.     DEFINE_WAIT(wait);  
  20.   
  21. start:  
  22.     while (1) {  
  23.         prepare_to_wait(&log->wq, &wait, TASK_INTERRUPTIBLE);  
  24.   
  25.         mutex_lock(&log->mutex);  
  26.         ret = (log->w_off == reader->r_off);  
  27.         mutex_unlock(&log->mutex);  
  28.         if (!ret)  
  29.             break;  
  30.   
  31.         if (file->f_flags & O_NONBLOCK) {  
  32.             ret = -EAGAIN;  
  33.             break;  
  34.         }  
  35.   
  36.         if (signal_pending(current)) {  
  37.             ret = -EINTR;  
  38.             break;  
  39.         }  
  40.   
  41.         schedule();  
  42.     }  
  43.   
  44.     finish_wait(&log->wq, &wait);  
  45.     if (ret)  
  46.         return ret;  
  47.   
  48.     mutex_lock(&log->mutex);  
  49.   
  50.     /* is there still something to read or did we race? */  
  51.     if (unlikely(log->w_off == reader->r_off)) {  
  52.         mutex_unlock(&log->mutex);  
  53.         goto start;  
  54.     }  
  55.   
  56.     /* get the size of the next entry */  
  57.     ret = get_entry_len(log, reader->r_off);  
  58.     if (count < ret) {  
  59.         ret = -EINVAL;  
  60.         goto out;  
  61.     }  
  62.   
  63.     /* get exactly one entry from the log */  
  64.     ret = do_read_log_to_user(log, reader, buf, ret);  
  65.   
  66. out:  
  67.     mutex_unlock(&log->mutex);  
  68.   
  69.     return ret;  
  70. }  

       注意，在函数开始的地方，表示读取日志上下文的struct logger_reader是保存在文件指针的private_data成员变量里面的，这是在打开设备文件时设置的，设备文件打开方法为logger_open：

[cpp] view plaincopyprint?
  1. /* 
  2.  * logger_open - the log's open() file operation 
  3.  * 
  4.  * Note how near a no-op this is in the write-only case. Keep it that way! 
  5.  */  
  6. static int logger_open(struct inode *inode, struct file *file)  
  7. {  
  8.     struct logger_log *log;  
  9.     int ret;  
  10.   
  11.     ret = nonseekable_open(inode, file);  
  12.     if (ret)  
  13.         return ret;  
  14.   
  15.     log = get_log_from_minor(MINOR(inode->i_rdev));  
  16.     if (!log)  
  17.         return -ENODEV;  
  18.   
  19.     if (file->f_mode & FMODE_READ) {  
  20.         struct logger_reader *reader;  
  21.   
  22.         reader = kmalloc(sizeof(struct logger_reader), GFP_KERNEL);  
  23.         if (!reader)  
  24.             return -ENOMEM;  
  25.   
  26.         reader->log = log;  
  27.         INIT_LIST_HEAD(&reader->list);  
  28.   
  29.         mutex_lock(&log->mutex);  
  30.         reader->r_off = log->head;  
  31.         list_add_tail(&reader->list, &log->readers);  
  32.         mutex_unlock(&log->mutex);  
  33.   
  34.         file->private_data = reader;  
  35.     } else  
  36.         file->private_data = log;  
  37.   
  38.     return 0;  
  39. }  

       新打开日志设备文件时，是从log->head位置开始读取日志的，保存在struct logger_reader的成员变量r_off中。

       start标号处的while循环是在等待日志可读，如果已经没有新的日志可读了，那么就要读进程就要进入休眠状态，等待新的日志写入后再唤醒，这是通过prepare_wait和schedule两个调用来实现的。如果没有新的日志可读，并且设备文件不是以非阻塞O_NONBLOCK的方式打开或者这时有信号要处理（signal_pending(current)），那么就直接返回，不再等待新的日志写入。判断当前是否有新的日志可读的方法是：

       ret = (log->w_off == reader->r_off);

       即判断当前缓冲区的写入位置和当前读进程的读取位置是否相等，如果不相等，则说明有新的日志可读。

       继续向下看，如果有新的日志可读，那么就，首先通过get_entry_len来获取下一条可读的日志记录的长度，从这里可以看出，日志读取进程是以日志记录为单位进行读取的，一次只读取一条记录。get_entry_len的函数实现如下：

[cpp] view plaincopyprint?
  1. /* 
  2.  * get_entry_len - Grabs the length of the payload of the next entry starting 
  3.  * from 'off'. 
  4.  * 
  5.  * Caller needs to hold log->mutex. 
  6.  */  
  7. static __u32 get_entry_len(struct logger_log *log, size_t off)  
  8. {  
  9.     __u16 val;  
  10.   
  11.     switch (log->size - off) {  
  12.     case 1:  
  13.         memcpy(&val, log->buffer + off, 1);  
  14.         memcpy(((char *) &val) + 1, log->buffer, 1);  
  15.         break;  
  16.     default:  
  17.         memcpy(&val, log->buffer + off, 2);  
  18.     }  
  19.   
  20.     return sizeof(struct logger_entry) + val;  
  21. }  

        上面我们提到，每一条日志记录是由两大部分组成的，一个用于描述这条日志记录的结构体struct logger_entry，另一个是记录体本身，即有效负载。结构体struct logger_entry的长度是固定的，只要知道有效负载的长度，就可以知道整条日志记录的长度了。而有效负载的长度是记录在结构体struct logger_entry的成员变量len中，而len成员变量的地址与struct logger_entry的地址相同，因此，只需要读取记录的开始位置的两个字节就可以了。又由于日志记录缓冲区是循环使用的，这两个节字有可能是第一个字节存放在缓冲区最后一个字节，而第二个字节存放在缓冲区的第一个节，除此之外，这两个字节都是连在一起的。因此，分两种情况来考虑，对于前者，分别通过读取缓冲区最后一个字节和第一个字节来得到日志记录的有效负载长度到本地变量val中，对于后者，直接读取连续两个字节的值到本地变量val中。这两种情况是通过判断日志缓冲区的大小和要读取的日志记录在缓冲区中的位置的差值来区别的，如果相差1，就说明是前一种情况了。最后，把有效负载的长度val加上struct logger_entry的长度就得到了要读取的日志记录的总长度了。

       接着往下看，得到了要读取的记录的长度，就调用do_read_log_to_user函数来执行真正的读取动作：

[cpp] view plaincopyprint?
  1. static ssize_t do_read_log_to_user(struct logger_log *log,  
  2.                    struct logger_reader *reader,  
  3.                    char __user *buf,  
  4.                    size_t count)  
  5. {  
  6.     size_t len;  
  7.   
  8.     /* 
  9.      * We read from the log in two disjoint operations. First, we read from 
  10.      * the current read head offset up to 'count' bytes or to the end of 
  11.      * the log, whichever comes first. 
  12.      */  
  13.     len = min(count, log->size - reader->r_off);  
  14.     if (copy_to_user(buf, log->buffer + reader->r_off, len))  
  15.         return -EFAULT;  
  16.   
  17.     /* 
  18.      * Second, we read any remaining bytes, starting back at the head of 
  19.      * the log. 
  20.      */  
  21.     if (count != len)  
  22.         if (copy_to_user(buf + len, log->buffer, count - len))  
  23.             return -EFAULT;  
  24.   
  25.     reader->r_off = logger_offset(reader->r_off + count);  
  26.   
  27.     return count;  
  28. }  

        这个函数简单地调用copy_to_user函数来把位于内核空间的日志缓冲区指定的内容拷贝到用户空间的内存缓冲区就可以了，同时，把当前读取日志进程的上下文信息中的读偏移r_off前进到下一条日志记录的开始的位置上。

        四.  Logger驱动程序的日志记录写入过程分析。

        继续看logger.c 文件，注册的写入日志设备文件的方法为logger_aio_write：

[cpp] view plaincopyprint?
  1. /* 
  2.  * logger_aio_write - our write method, implementing support for write(), 
  3.  * writev(), and aio_write(). Writes are our fast path, and we try to optimize 
  4.  * them above all else. 
  5.  */  
  6. ssize_t logger_aio_write(struct kiocb *iocb, const struct iovec *iov,  
  7.              unsigned long nr_segs, loff_t ppos)  
  8. {  
  9.     struct logger_log *log = file_get_log(iocb->ki_filp);  
  10.     size_t orig = log->w_off;  
  11.     struct logger_entry header;  
  12.     struct timespec now;  
  13.     ssize_t ret = 0;  
  14.   
  15.     now = current_kernel_time();  
  16.   
  17.     header.pid = current->tgid;  
  18.     header.tid = current->pid;  
  19.     header.sec = now.tv_sec;  
  20.     header.nsec = now.tv_nsec;  
  21.     header.len = min_t(size_t, iocb->ki_left, LOGGER_ENTRY_MAX_PAYLOAD);  
  22.   
  23.     /* null writes succeed, return zero */  
  24.     if (unlikely(!header.len))  
  25.         return 0;  
  26.   
  27.     mutex_lock(&log->mutex);  
  28.   
  29.     /* 
  30.      * Fix up any readers, pulling them forward to the first readable 
  31.      * entry after (what will be) the new write offset. We do this now 
  32.      * because if we partially fail, we can end up with clobbered log 
  33.      * entries that encroach on readable buffer. 
  34.      */  
  35.     fix_up_readers(log, sizeof(struct logger_entry) + header.len);  
  36.   
  37.     do_write_log(log, &header, sizeof(struct logger_entry));  
  38.   
  39.     while (nr_segs-- > 0) {  
  40.         size_t len;  
  41.         ssize_t nr;  
  42.   
  43.         /* figure out how much of this vector we can keep */  
  44.         len = min_t(size_t, iov->iov_len, header.len - ret);  
  45.   
  46.         /* write out this segment's payload */  
  47.         nr = do_write_log_from_user(log, iov->iov_base, len);  
  48.         if (unlikely(nr < 0)) {  
  49.             log->w_off = orig;  
  50.             mutex_unlock(&log->mutex);  
  51.             return nr;  
  52.         }  
  53.   
  54.         iov++;  
  55.         ret += nr;  
  56.     }  
  57.   
  58.     mutex_unlock(&log->mutex);  
  59.   
  60.     /* wake up any blocked readers */  
  61.     wake_up_interruptible(&log->wq);  
  62.   
  63.     return ret;  
  64. }  

        输入的参数iocb表示io上下文，iov表示要写入的内容，长度为nr_segs，表示有nr_segs个段的内容要写入。我们知道，每个要写入的日志的结构形式为：

        struct logger_entry | priority | tag | msg

        其中， priority、tag和msg这三个段的内容是由iov参数从用户空间传递下来的，分别对应iov里面的三个元素。而logger_entry是由内核空间来构造的：

        struct logger_entry header;
struct timespec now;

now = current_kernel_time();

header.pid = current->tgid;
header.tid = current->pid;
header.sec = now.tv_sec;
header.nsec = now.tv_nsec;
header.len = min_t(size_t, iocb->ki_left, LOGGER_ENTRY_MAX_PAYLOAD);

        然后调用do_write_log首先把logger_entry结构体写入到日志缓冲区中：

[cpp] view plaincopyprint?
  1. /* 
  2.  * do_write_log - writes 'len' bytes from 'buf' to 'log' 
  3.  * 
  4.  * The caller needs to hold log->mutex. 
  5.  */  
  6. static void do_write_log(struct logger_log *log, const void *buf, size_t count)  
  7. {  
  8.     size_t len;  
  9.   
  10.     len = min(count, log->size - log->w_off);  
  11.     memcpy(log->buffer + log->w_off, buf, len);  
  12.   
  13.     if (count != len)  
  14.         memcpy(log->buffer, buf + len, count - len);  
  15.   
  16.     log->w_off = logger_offset(log->w_off + count);  
  17.   
  18. }  

       由于logger_entry是内核堆栈空间分配的，直接用memcpy拷贝就可以了。

       接着，通过一个while循环把iov的内容写入到日志缓冲区中，也就是日志的优先级别priority、日志Tag和日志主体Msg：

[cpp] view plaincopyprint?
  1. while (nr_segs-- > 0) {  
  2.         size_t len;  
  3.         ssize_t nr;  
  4.   
  5.         /* figure out how much of this vector we can keep */  
  6.         len = min_t(size_t, iov->iov_len, header.len - ret);  
  7.   
  8.         /* write out this segment's payload */  
  9.         nr = do_write_log_from_user(log, iov->iov_base, len);  
  10.         if (unlikely(nr < 0)) {  
  11.             log->w_off = orig;  
  12.             mutex_unlock(&log->mutex);  
  13.             return nr;  
  14.         }  
  15.   
  16.         iov++;  
  17.         ret += nr;  
  18. }  

         由于iov的内容是由用户空间传下来的，需要调用do_write_log_from_user来写入：

[cpp] view plaincopyprint?
  1. static ssize_t do_write_log_from_user(struct logger_log *log,  
  2.                       const void __user *buf, size_t count)  
  3. {  
  4.     size_t len;  
  5.   
  6.     len = min(count, log->size - log->w_off);  
  7.     if (len && copy_from_user(log->buffer + log->w_off, buf, len))  
  8.         return -EFAULT;  
  9.   
  10.     if (count != len)  
  11.         if (copy_from_user(log->buffer, buf + len, count - len))  
  12.             return -EFAULT;  
  13.   
  14.     log->w_off = logger_offset(log->w_off + count);  
  15.   
  16.     return count;  
  17. }  

        这里，我们还漏了一个重要的步骤：

[cpp] view plaincopyprint?
  1.  /* 
  2.   * Fix up any readers, pulling them forward to the first readable 
  3.   * entry after (what will be) the new write offset. We do this now 
  4.   * because if we partially fail, we can end up with clobbered log 
  5.   * entries that encroach on readable buffer. 
  6.   */  
  7. fix_up_readers(log, sizeof(struct logger_entry) + header.len);  

        为什么要调用fix_up_reader这个函数呢？这个函数又是作什么用的呢？是这样的，由于日志缓冲区是循环使用的，即旧的日志记录如果没有及时读取，而缓冲区的内容又已经用完时，就需要覆盖旧的记录来容纳新的记录。而这部分将要被覆盖的内容，有可能是某些reader的下一次要读取的日志所在的位置，以及为新的reader准备的日志开始读取位置head所在的位置。因此，需要调整这些位置，使它们能够指向一个新的有效的位置。我们来看一下fix_up_reader函数的实现：

[cpp] view plaincopyprint?
  1. /* 
  2.  * fix_up_readers - walk the list of all readers and "fix up" any who were 
  3.  * lapped by the writer; also do the same for the default "start head". 
  4.  * We do this by "pulling forward" the readers and start head to the first 
  5.  * entry after the new write head. 
  6.  * 
  7.  * The caller needs to hold log->mutex. 
  8.  */  
  9. static void fix_up_readers(struct logger_log *log, size_t len)  
  10. {  
  11.     size_t old = log->w_off;  
  12.     size_t new = logger_offset(old + len);  
  13.     struct logger_reader *reader;  
  14.   
  15.     if (clock_interval(old, new, log->head))  
  16.         log->head = get_next_entry(log, log->head, len);  
  17.   
  18.     list_for_each_entry(reader, &log->readers, list)  
  19.         if (clock_interval(old, new, reader->r_off))  
  20.             reader->r_off = get_next_entry(log, reader->r_off, len);  
  21. }  

        判断log->head和所有读者reader的当前读偏移reader->r_off是否在被覆盖的区域内，如果是，就需要调用get_next_entry来取得下一个有效的记录的起始位置来调整当前位置：

[cpp] view plaincopyprint?
  1. /* 
  2.  * get_next_entry - return the offset of the first valid entry at least 'len' 
  3.  * bytes after 'off'. 
  4.  * 
  5.  * Caller must hold log->mutex. 
  6.  */  
  7. static size_t get_next_entry(struct logger_log *log, size_t off, size_t len)  
  8. {  
  9.     size_t count = 0;  
  10.   
  11.     do {  
  12.         size_t nr = get_entry_len(log, off);  
  13.         off = logger_offset(off + nr);  
  14.         count += nr;  
  15.     } while (count < len);  
  16.   
  17.     return off;  
  18. }  

        而判断log->head和所有读者reader的当前读偏移reader->r_off是否在被覆盖的区域内，是通过clock_interval函数来实现的：

[cpp] view plaincopyprint?
  1. /* 
  2.  * clock_interval - is a < c < b in mod-space? Put another way, does the line 
  3.  * from a to b cross c? 
  4.  */  
  5. static inline int clock_interval(size_t a, size_t b, size_t c)  
  6. {  
  7.     if (b < a) {  
  8.         if (a < c || b >= c)  
  9.             return 1;  
  10.     } else {  
  11.         if (a < c && b >= c)  
  12.             return 1;  
  13.     }  
  14.   
  15.     return 0;  
  16. }  

        最后，日志写入完毕，还需要唤醒正在等待新日志的reader进程:

        /* wake up any blocked readers */
wake_up_interruptible(&log->wq);

        至此， Logger驱动程序的主要逻辑就分析完成了，还有其它的一些接口，如logger_poll、 logger_ioctl和logger_release函数，比较简单，读取可以自行分析。这里还需要提到的一点是，由于Logger驱动程序模块在退出系统时，是不会卸载的，所以这个模块没有module_exit函数，而对于模块里面定义的对象，也没有用对引用计数技术。

      这篇文章着重介绍了Android日志系统在内核空间的实现，在下一篇文章中，我们将接着介绍在用户空间中，提供给Android应用程序使用的Java和C/C++ LOG调用接口的实现过程，敬请关注

 

Android应用程序框架层和系统运行库层日志系统源代码分析

在开发Android应用程序时，少不了使用Log来监控和调试程序的执行。在上一篇文章Android日志系统驱动程序Logger源代码分析中，我们分析了驱动程序Logger的源代码，在前面的文章浅谈Android系统开发中Log的使用一文，我们也简单介绍在应用程序中使Log的方法，在这篇文章中，我们将详细介绍Android应用程序框架层和系统运行库存层日志系统的源代码，使得我们可以更好地理解Android的日志系统的实现。

        我们在Android应用程序，一般是调用应用程序框架层的Java接口（android.util.Log）来使用日志系统，这个Java接口通过JNI方法和系统运行库最终调用内核驱动程序Logger把Log写到内核空间中。按照这个调用过程，我们一步步介绍Android应用程序框架层日志系统的源代码。学习完这个过程之后，我们可以很好地理解Android系统的架构，即应用程序层（Application）的接口是如何一步一步地调用到内核空间的。

        一. 应用程序框架层日志系统Java接口的实现。

        在浅谈Android系统开发中Log的使用一文中，我们曾经介绍过Android应用程序框架层日志系统的源代码接口。这里，为了描述方便和文章的完整性，我们重新贴一下这部份的代码，在frameworks/base/core/java/android/util/Log.java文件中，实现日志系统的Java接口：

[java] view plaincopyprint?
  1. ................................................  
  2.   
  3. public final class Log {  
  4.   
  5. ................................................  
  6.   
  7.     /** 
  8.      * Priority constant for the println method; use Log.v. 
  9.          */  
  10.     public static final int VERBOSE = 2;  
  11.   
  12.     /** 
  13.      * Priority constant for the println method; use Log.d. 
  14.          */  
  15.     public static final int DEBUG = 3;  
  16.   
  17.     /** 
  18.      * Priority constant for the println method; use Log.i. 
  19.          */  
  20.     public static final int INFO = 4;  
  21.   
  22.     /** 
  23.      * Priority constant for the println method; use Log.w. 
  24.          */  
  25.     public static final int WARN = 5;  
  26.   
  27.     /** 
  28.      * Priority constant for the println method; use Log.e. 
  29.          */  
  30.     public static final int ERROR = 6;  
  31.   
  32.     /** 
  33.      * Priority constant for the println method. 
  34.          */  
  35.     public static final int ASSERT = 7;  
  36.   
  37. .....................................................  
  38.   
  39.     public static int v(String tag, String msg) {  
  40.         return println_native(LOG_ID_MAIN, VERBOSE, tag, msg);  
  41.     }  
  42.   
  43.     public static int v(String tag, String msg, Throwable tr) {  
  44.         return println_native(LOG_ID_MAIN, VERBOSE, tag, msg + '\n' + getStackTraceString(tr));  
  45.     }  
  46.   
  47.     public static int d(String tag, String msg) {  
  48.         return println_native(LOG_ID_MAIN, DEBUG, tag, msg);  
  49.     }  
  50.   
  51.     public static int d(String tag, String msg, Throwable tr) {  
  52.         return println_native(LOG_ID_MAIN, DEBUG, tag, msg + '\n' + getStackTraceString(tr));  
  53.     }  
  54.   
  55.     public static int i(String tag, String msg) {  
  56.         return println_native(LOG_ID_MAIN, INFO, tag, msg);  
  57.     }  
  58.   
  59.     public static int i(String tag, String msg, Throwable tr) {  
  60.         return println_native(LOG_ID_MAIN, INFO, tag, msg + '\n' + getStackTraceString(tr));  
  61.     }  
  62.   
  63.     public static int w(String tag, String msg) {  
  64.         return println_native(LOG_ID_MAIN, WARN, tag, msg);  
  65.     }  
  66.   
  67.     public static int w(String tag, String msg, Throwable tr) {  
  68.         return println_native(LOG_ID_MAIN, WARN, tag, msg + '\n' + getStackTraceString(tr));  
  69.     }  
  70.   
  71.     public static int w(String tag, Throwable tr) {  
  72.         return println_native(LOG_ID_MAIN, WARN, tag, getStackTraceString(tr));  
  73.     }  
  74.       
  75.     public static int e(String tag, String msg) {  
  76.         return println_native(LOG_ID_MAIN, ERROR, tag, msg);  
  77.     }  
  78.   
  79.     public static int e(String tag, String msg, Throwable tr) {  
  80.         return println_native(LOG_ID_MAIN, ERROR, tag, msg + '\n' + getStackTraceString(tr));  
  81.     }  
  82.   
  83. ..................................................................  
  84.     /** @hide */ public static native int LOG_ID_MAIN = 0;  
  85.     /** @hide */ public static native int LOG_ID_RADIO = 1;  
  86.     /** @hide */ public static native int LOG_ID_EVENTS = 2;  
  87.     /** @hide */ public static native int LOG_ID_SYSTEM = 3;  
  88.   
  89.     /** @hide */ public static native int println_native(int bufID,  
  90.         int priority, String tag, String msg);  
  91. }  

         定义了2~7一共6个日志优先级别ID和4个日志缓冲区ID。回忆一下Android日志系统驱动程序Logger源代码分析一文，在Logger驱动程序模块中，定义了log_main、log_events和log_radio三个日志缓冲区，分别对应三个设备文件/dev/log/main、/dev/log/events和/dev/log/radio。这里的4个日志缓冲区的前面3个ID就是对应这三个设备文件的文件描述符了，在下面的章节中，我们将看到这三个文件描述符是如何创建的。在下载下来的Android内核源代码中，第4个日志缓冲区LOG_ID_SYSTEM并没有对应的设备文件，在这种情况下，它和LOG_ID_MAIN对应同一个缓冲区ID，在下面的章节中，我们同样可以看到这两个ID是如何对应到同一个设备文件的。

         在整个Log接口中，最关键的地方声明了println_native本地方法，所有的Log接口都是通过调用这个本地方法来实现Log的定入。下面我们就继续分析这个本地方法println_native。

         二. 应用程序框架层日志系统JNI方法的实现。

         在frameworks/base/core/jni/android_util_Log.cpp文件中，实现JNI方法println_native：

[cpp] view plaincopyprint?
  1. /* //device/libs/android_runtime/android_util_Log.cpp 
  2. ** 
  3. ** Copyright 2006, The Android Open Source Project 
  4. ** 
  5. ** Licensed under the Apache License, Version 2.0 (the "License");  
  6. ** you may not use this file except in compliance with the License.  
  7. ** You may obtain a copy of the License at  
  8. ** 
  9. **     http://www.apache.org/licenses/LICENSE-2.0  
  10. ** 
  11. ** Unless required by applicable law or agreed to in writing, software  
  12. ** distributed under the License is distributed on an "AS IS" BASIS,  
  13. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
  14. ** See the License for the specific language governing permissions and  
  15. ** limitations under the License. 
  16. */  
  17.   
  18. #define LOG_NAMESPACE "log.tag."   
  19. #define LOG_TAG "Log_println"  
  20.   
  21. #include <assert.h>   
  22. #include <cutils/properties.h>   
  23. #include <utils/Log.h>   
  24. #include <utils/String8.h>   
  25.   
  26. #include "jni.h"   
  27. #include "utils/misc.h"   
  28. #include "android_runtime/AndroidRuntime.h"  
  29.   
  30. #define MIN(a,b) ((a<b)?a:b)   
  31.   
  32. namespace android {  
  33.   
  34. struct levels_t {  
  35.     jint verbose;  
  36.     jint debug;  
  37.     jint info;  
  38.     jint warn;  
  39.     jint error;  
  40.     jint assert;  
  41. };  
  42. static levels_t levels;  
  43.   
  44. static int toLevel(const char* value)   
  45. {  
  46.     switch (value[0]) {  
  47.         case 'V': return levels.verbose;  
  48.         case 'D': return levels.debug;  
  49.         case 'I': return levels.info;  
  50.         case 'W': return levels.warn;  
  51.         case 'E': return levels.error;  
  52.         case 'A': return levels.assert;  
  53.         case 'S': return -1; // SUPPRESS  
  54.     }  
  55.     return levels.info;  
  56. }  
  57.   
  58. static jboolean android_util_Log_isLoggable(JNIEnv* env, jobject clazz, jstring tag, jint level)  
  59. {  
  60. #ifndef HAVE_ANDROID_OS   
  61.     return false;  
  62. #else /* HAVE_ANDROID_OS */   
  63.     int len;  
  64.     char key[PROPERTY_KEY_MAX];  
  65.     char buf[PROPERTY_VALUE_MAX];  
  66.   
  67.     if (tag == NULL) {  
  68.         return false;  
  69.     }  
  70.       
  71.     jboolean result = false;  
  72.       
  73.     const char* chars = env->GetStringUTFChars(tag, NULL);  
  74.   
  75.     if ((strlen(chars)+sizeof(LOG_NAMESPACE)) > PROPERTY_KEY_MAX) {  
  76.         jclass clazz = env->FindClass("java/lang/IllegalArgumentException");  
  77.         char buf2[200];  
  78.         snprintf(buf2, sizeof(buf2), "Log tag \"%s\" exceeds limit of %d characters\n",  
  79.                 chars, PROPERTY_KEY_MAX - sizeof(LOG_NAMESPACE));  
  80.   
  81.         // release the chars!   
  82.         env->ReleaseStringUTFChars(tag, chars);  
  83.   
  84.         env->ThrowNew(clazz, buf2);  
  85.         return false;  
  86.     } else {  
  87.         strncpy(key, LOG_NAMESPACE, sizeof(LOG_NAMESPACE)-1);  
  88.         strcpy(key + sizeof(LOG_NAMESPACE) - 1, chars);  
  89.     }  
  90.       
  91.     env->ReleaseStringUTFChars(tag, chars);  
  92.   
  93.     len = property_get(key, buf, "");  
  94.     int logLevel = toLevel(buf);  
  95.     return (logLevel >= 0 && level >= logLevel) ? true : false;  
  96. #endif /* HAVE_ANDROID_OS */   
  97. }  
  98.   
  99. /* 
  100.  * In class android.util.Log: 
  101.  *  public static native int println_native(int buffer, int priority, String tag, String msg) 
  102.  */  
  103. static jint android_util_Log_println_native(JNIEnv* env, jobject clazz,  
  104.         jint bufID, jint priority, jstring tagObj, jstring msgObj)  
  105. {  
  106.     const char* tag = NULL;  
  107.     const char* msg = NULL;  
  108.   
  109.     if (msgObj == NULL) {  
  110.         jclass npeClazz;  
  111.   
  112.         npeClazz = env->FindClass("java/lang/NullPointerException");  
  113.         assert(npeClazz != NULL);  
  114.   
  115.         env->ThrowNew(npeClazz, "println needs a message");  
  116.         return -1;  
  117.     }  
  118.   
  119.     if (bufID < 0 || bufID >= LOG_ID_MAX) {  
  120.         jclass npeClazz;  
  121.   
  122.         npeClazz = env->FindClass("java/lang/NullPointerException");  
  123.         assert(npeClazz != NULL);  
  124.   
  125.         env->ThrowNew(npeClazz, "bad bufID");  
  126.         return -1;  
  127.     }  
  128.   
  129.     if (tagObj != NULL)  
  130.         tag = env->GetStringUTFChars(tagObj, NULL);  
  131.     msg = env->GetStringUTFChars(msgObj, NULL);  
  132.   
  133.     int res = __android_log_buf_write(bufID, (android_LogPriority)priority, tag, msg);  
  134.   
  135.     if (tag != NULL)  
  136.         env->ReleaseStringUTFChars(tagObj, tag);  
  137.     env->ReleaseStringUTFChars(msgObj, msg);  
  138.   
  139.     return res;  
  140. }  
  141.   
  142. /* 
  143.  * JNI registration. 
  144.  */  
  145. static JNINativeMethod gMethods[] = {  
  146.     /* name, signature, funcPtr */  
  147.     { "isLoggable",      "(Ljava/lang/String;I)Z", (void*) android_util_Log_isLoggable },  
  148.     { "println_native",  "(IILjava/lang/String;Ljava/lang/String;)I", (void*) android_util_Log_println_native },  
  149. };  
  150.   
  151. int register_android_util_Log(JNIEnv* env)  
  152. {  
  153.     jclass clazz = env->FindClass("android/util/Log");  
  154.   
  155.     if (clazz == NULL) {  
  156.         LOGE("Can't find android/util/Log");  
  157.         return -1;  
  158.     }  
  159.       
  160.     levels.verbose = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz, "VERBOSE", "I"));  
  161.     levels.debug = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz, "DEBUG", "I"));  
  162.     levels.info = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz, "INFO", "I"));  
  163.     levels.warn = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz, "WARN", "I"));  
  164.     levels.error = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz, "ERROR", "I"));  
  165.     levels.assert = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz, "ASSERT", "I"));  
  166.                   
  167.     return AndroidRuntime::registerNativeMethods(env, "android/util/Log", gMethods, NELEM(gMethods));  
  168. }  
  169.   
  170. }; // namespace android  

        在gMethods变量中，定义了println_native本地方法对应的函数调用是android_util_Log_println_native。在android_util_Log_println_native函数中，通过了各项参数验证正确后，就调用运行时库函数__android_log_buf_write来实现Log的写入操作。__android_log_buf_write函实实现在liblog库中，它有4个参数，分别缓冲区ID、优先级别ID、Tag字符串和Msg字符串。下面运行时库liblog中的__android_log_buf_write的实现。

       三. 系统运行库层日志系统的实现。

       在系统运行库层liblog库的实现中，内容比较多，这里，我们只关注日志写入操作__android_log_buf_write的相关实现：

[cpp] view plaincopyprint?
  1. int __android_log_buf_write(int bufID, int prio, const char *tag, const char *msg)  
  2. {  
  3.     struct iovec vec[3];  
  4.   
  5.     if (!tag)  
  6.         tag = "";  
  7.   
  8.     /* XXX: This needs to go! */  
  9.     if (!strcmp(tag, "HTC_RIL") ||  
  10.         !strncmp(tag, "RIL", 3) || /* Any log tag with "RIL" as the prefix */  
  11.         !strcmp(tag, "AT") ||  
  12.         !strcmp(tag, "GSM") ||  
  13.         !strcmp(tag, "STK") ||  
  14.         !strcmp(tag, "CDMA") ||  
  15.         !strcmp(tag, "PHONE") ||  
  16.         !strcmp(tag, "SMS"))  
  17.             bufID = LOG_ID_RADIO;  
  18.   
  19.     vec[0].iov_base   = (unsigned char *) &prio;  
  20.     vec[0].iov_len    = 1;  
  21.     vec[1].iov_base   = (void *) tag;  
  22.     vec[1].iov_len    = strlen(tag) + 1;  
  23.     vec[2].iov_base   = (void *) msg;  
  24.     vec[2].iov_len    = strlen(msg) + 1;  
  25.   
  26.     return write_to_log(bufID, vec, 3);  
  27. }  

        函数首先是检查传进来的tag参数是否是为HTC_RIL、RIL、AT、GSM、STK、CDMA、PHONE和SMS中的一个，如果是，就无条件地使用ID为LOG_ID_RADIO的日志缓冲区作为写入缓冲区，接着，把传进来的参数prio、tag和msg分别存放在一个向量数组中，调用write_to_log函数来进入下一步操作。write_to_log是一个函数指针，定义在文件开始的位置上：

[cpp] view plaincopyprint?
  1. static int __write_to_log_init(log_id_t, struct iovec *vec, size_t nr);  
  2. static int (*write_to_log)(log_id_t, struct iovec *vec, size_t nr) = __write_to_log_init;  

        并且初始化为__write_to_log_init函数：

[cpp] view plaincopyprint?
  1. static int __write_to_log_init(log_id_t log_id, struct iovec *vec, size_t nr)  
  2. {  
  3. #ifdef HAVE_PTHREADS   
  4.     pthread_mutex_lock(&log_init_lock);  
  5. #endif   
  6.   
  7.     if (write_to_log == __write_to_log_init) {  
  8.         log_fds[LOG_ID_MAIN] = log_open("/dev/"LOGGER_LOG_MAIN, O_WRONLY);  
  9.         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 == __write_to_log_init判断语句就会true，于是执行log_open函数打开设备文件，并把文件描述符保存在log_fds数组中。如果打开/dev/LOGGER_LOG_SYSTEM文件失败，即log_fds[LOG_ID_SYSTEM] < 0，就把log_fds[LOG_ID_SYSTEM]设置为log_fds[LOG_ID_MAIN]，这就是我们上面描述的如果不存在ID为LOG_ID_SYSTEM的日志缓冲区，就把LOG_ID_SYSTEM设置为和LOG_ID_MAIN对应的日志缓冲区了。LOGGER_LOG_MAIN、LOGGER_LOG_RADIO、LOGGER_LOG_EVENTS和LOGGER_LOG_SYSTEM四个宏定义在system/core/include/cutils/logger.h文件中：

[cpp] view plaincopyprint?
  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函数指针指向__write_to_log_kernel函数：

[cpp] view plaincopyprint?
  1. static int __write_to_log_kernel(log_id_t log_id, struct iovec *vec, size_t nr)  
  2. {  
  3.     ssize_t ret;  
  4.     int log_fd;  
  5.   
  6.     if (/*(int)log_id >= 0 &&*/ (int)log_id < (int)LOG_ID_MAX) {  
  7.         log_fd = log_fds[(int)log_id];  
  8.     } else {  
  9.         return EBADF;  
  10.     }  
  11.   
  12.     do {  
  13.         ret = log_writev(log_fd, vec, nr);  
  14.     } while (ret < 0 && errno == EINTR);  
  15.   
  16.     return ret;  
  17. }  

       函数调用log_writev来实现Log的写入，注意，这里通过一个循环来写入Log，直到写入成功为止。这里log_writev是一个宏，在文件开始的地方定义为：

[cpp] view plaincopyprint?
  1. #if FAKE_LOG_DEVICE   
  2. // This will be defined when building for the host.  
  3. #define log_open(pathname, flags) fakeLogOpen(pathname, flags)  
  4. #define log_writev(filedes, vector, count) fakeLogWritev(filedes, vector, count)  
  5. #define log_close(filedes) fakeLogClose(filedes)  
  6. #else   
  7. #define log_open(pathname, flags) open(pathname, flags)  
  8. #define log_writev(filedes, vector, count) writev(filedes, vector, count)  
  9. #define log_close(filedes) close(filedes)  
  10. #endif  

       这里，我们看到，一般情况下，log_writev就是writev了，这是个常见的批量文件写入函数，就不多说了。

       至些，整个调用过程就结束了。总结一下，首先是从应用程序层调用应用程序框架层的Java接口，应用程序框架层的Java接口通过调用本层的JNI方法进入到系统运行库层的C接口，系统运行库层的C接口通过设备文件来访问内核空间层的Logger驱动程序。这是一个典型的调用过程，很好地诠释Android的系统架构，希望读者好好领会

Android日志系统Logcat源代码简要分析

在前面两篇文章Android日志系统驱动程序Logger源代码分析和Android应用程序框架层和系统运行库层日志系统源代码中，介绍了Android内核空间层、系统运行库层和应用程序框架层日志系统相关的源代码，其中，后一篇文章着重介绍了日志的写入操作。为了描述完整性，这篇文章着重介绍日志的读取操作，这就是我们在开发Android应用程序时，经常要用到日志查看工具Logcat了。

        Logcat工具内置在Android系统中，可以在主机上通过adb logcat命令来查看模拟机上日志信息。Logcat工具的用法很丰富，因此，源代码也比较多，本文并不打算完整地介绍整个Logcat工具的源代码，主要是介绍Logcat读取日志的主线，即从打开日志设备文件到读取日志设备文件的日志记录到输出日志记录的主要过程，希望能起到一个抛砖引玉的作用。

        Logcat工具源代码位于system/core/logcat目录下，只有一个源代码文件logcat.cpp，编译后生成的可执行文件位于out/target/product/generic/system/bin目录下，在模拟机中，可以在/system/bin目录下看到logcat工具。下面我们就分段来阅读logcat.cpp源代码文件。

        一.  Logcat工具的相关数据结构。

        这些数据结构是用来保存从日志设备文件读出来的日志记录：

[cpp] view plaincopyprint?
  1. struct queued_entry_t {  
  2.     union {  
  3.         unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1] __attribute__((aligned(4)));  
  4.         struct logger_entry entry __attribute__((aligned(4)));  
  5.     };  
  6.     queued_entry_t* next;  
  7.   
  8.     queued_entry_t() {  
  9.         next = NULL;  
  10.     }  
  11. };  
  12.   
  13. struct log_device_t {  
  14.     char* device;  
  15.     bool binary;  
  16.     int fd;  
  17.     bool printed;  
  18.     char label;  
  19.   
  20.     queued_entry_t* queue;  
  21.     log_device_t* next;  
  22.   
  23.     log_device_t(char* d, bool b, char l) {  
  24.         device = d;  
  25.         binary = b;  
  26.         label = l;  
  27.         queue = NULL;  
  28.         next = NULL;  
  29.         printed = false;  
  30.     }  
  31.   
  32.     void enqueue(queued_entry_t* entry) {  
  33.         if (this->queue == NULL) {  
  34.             this->queue = entry;  
  35.         } else {  
  36.             queued_entry_t** e = &this->queue;  
  37.             while (*e && cmp(entry, *e) >= 0) {  
  38.                 e = &((*e)->next);  
  39.             }  
  40.             entry->next = *e;  
  41.             *e = entry;  
  42.         }  
  43.     }  
  44. };  

        其中，宏LOGGER_ENTRY_MAX_LEN和struct logger_entry定义在system/core/include/cutils/logger.h文件中，在Android应用程序框架层和系统运行库层日志系统源代码分析一文有提到，为了方便描述，这里列出这个宏和结构体的定义：

[cpp] view plaincopyprint?
  1. struct logger_entry {  
  2.     __u16       len;    /* length of the payload */  
  3.     __u16       __pad;  /* no matter what, we get 2 bytes of padding */  
  4.     __s32       pid;    /* generating process's pid */  
  5.     __s32       tid;    /* generating process's tid */  
  6.     __s32       sec;    /* seconds since Epoch */  
  7.     __s32       nsec;   /* nanoseconds */  
  8.     char        msg[0]; /* the entry's payload */  
  9. };  
  10.   
  11. #define LOGGER_ENTRY_MAX_LEN        (4*1024)  

        从结构体struct queued_entry_t和struct log_device_t的定义可以看出，每一个log_device_t都包含有一个queued_entry_t队列，queued_entry_t就是对应从日志设备文件读取出来的一条日志记录了，而log_device_t则是对应一个日志设备文件上下文。在Android日志系统驱动程序Logger源代码分析一文中，我们曾提到，Android日志系统有三个日志设备文件，分别是/dev/log/main、/dev/log/events和/dev/log/radio。

        每个日志设备上下文通过其next成员指针连接起来，每个设备文件上下文的日志记录也是通过next指针连接起来。日志记录队例是按时间戳从小到大排列的，这个log_device_t::enqueue函数可以看出，当要插入一条日志记录的时候，先队列头开始查找，直到找到一个时间戳比当前要插入的日志记录的时间戳大的日志记录的位置，然后插入当前日志记录。比较函数cmp的定义如下：

[cpp] view plaincopyprint?
  1. static int cmp(queued_entry_t* a, queued_entry_t* b) {  
  2.     int n = a->entry.sec - b->entry.sec;  
  3.     if (n != 0) {  
  4.         return n;  
  5.     }  
  6.     return a->entry.nsec - b->entry.nsec;  
  7. }  

        为什么日志记录要按照时间戳从小到大排序呢？原来，Logcat在使用时，可以指定一个参数-t <count>，可以指定只显示最新count条记录，超过count的记录将被丢弃，在这里的实现中，就是要把排在队列前面的多余日记记录丢弃了，因为排在前面的日志记录是最旧的，默认是显示所有的日志记录。在下面的代码中，我们还会继续分析这个过程。
        二. 打开日志设备文件。

        Logcat工具的入口函数main，打开日志设备文件和一些初始化的工作也是在这里进行。main函数的内容也比较多，前面的逻辑都是解析命令行参数。这里假设我们使用logcat工具时，不带任何参数。这不会影响我们分析logcat读取日志的主线，有兴趣的读取可以自行分析解析命令行参数的逻辑。

        分析完命令行参数以后，就开始要创建日志设备文件上下文结构体struct log_device_t了：

[cpp] view plaincopyprint?
  1. if (!devices) {  
  2.     devices = new log_device_t(strdup("/dev/"LOGGER_LOG_MAIN), false, 'm');  
  3.     android::g_devCount = 1;  
  4.     int accessmode =  
  5.               (mode & O_RDONLY) ? R_OK : 0  
  6.             | (mode & O_WRONLY) ? W_OK : 0;  
  7.     // only add this if it's available  
  8.     if (0 == access("/dev/"LOGGER_LOG_SYSTEM, accessmode)) {  
  9.         devices->next = new log_device_t(strdup("/dev/"LOGGER_LOG_SYSTEM), false, 's');  
  10.         android::g_devCount++;  
  11.     }  
  12. }  

        由于我们假设使用logcat时，不带任何命令行参数，这里的devices变量为NULL，因此，就会默认创建/dev/log/main设备上下文结构体，如果存在/dev/log/system设备文件，也会一并创建。宏LOGGER_LOG_MAIN和LOGGER_LOG_SYSTEM也是定义在system/core/include/cutils/logger.h文件中：

[cpp] view plaincopyprint?
  1. #define LOGGER_LOG_MAIN     "log/main"  
  2. #define LOGGER_LOG_SYSTEM   "log/system"  

        我们在Android日志系统驱动程序Logger源代码分析一文中看到，在Android日志系统驱动程序Logger中，默认是不创建/dev/log/system设备文件的。

        往下看，调用setupOutput()函数来初始化输出文件：

[cpp] view plaincopyprint?
  1. android::setupOutput();  

        setupOutput()函数定义如下：

[cpp] view plaincopyprint?
  1. static void setupOutput()  
  2. {  
  3.   
  4.     if (g_outputFileName == NULL) {  
  5.         g_outFD = STDOUT_FILENO;  
  6.   
  7.     } else {  
  8.         struct stat statbuf;  
  9.   
  10.         g_outFD = openLogFile (g_outputFileName);  
  11.   
  12.         if (g_outFD < 0) {  
  13.             perror ("couldn't open output file");  
  14.             exit(-1);  
  15.         }  
  16.   
  17.         fstat(g_outFD, &statbuf);  
  18.   
  19.         g_outByteCount = statbuf.st_size;  
  20.     }  
  21. }  

        如果我们在执行logcat命令时，指定了-f  <filename>选项，日志内容就输出到filename文件中，否则，就输出到标准输出控制台去了。

        再接下来，就是打开日志设备文件了：

[cpp] view plaincopyprint?
  1. dev = devices;  
  2. while (dev) {  
  3.     dev->fd = open(dev->device, mode);  
  4.     if (dev->fd < 0) {  
  5.         fprintf(stderr, "Unable to open log device '%s': %s\n",  
  6.             dev->device, strerror(errno));  
  7.         exit(EXIT_FAILURE);  
  8.     }  
  9.   
  10.     if (clearLog) {  
  11.         int ret;  
  12.         ret = android::clearLog(dev->fd);  
  13.         if (ret) {  
  14.             perror("ioctl");  
  15.             exit(EXIT_FAILURE);  
  16.         }  
  17.     }  
  18.   
  19.     if (getLogSize) {  
  20.         int size, readable;  
  21.   
  22.         size = android::getLogSize(dev->fd);  
  23.         if (size < 0) {  
  24.             perror("ioctl");  
  25.             exit(EXIT_FAILURE);  
  26.         }  
  27.   
  28.         readable = android::getLogReadableSize(dev->fd);  
  29.         if (readable < 0) {  
  30.             perror("ioctl");  
  31.             exit(EXIT_FAILURE);  
  32.         }  
  33.   
  34.         printf("%s: ring buffer is %dKb (%dKb consumed), "  
  35.                "max entry is %db, max payload is %db\n", dev->device,  
  36.                size / 1024, readable / 1024,  
  37.                (int) LOGGER_ENTRY_MAX_LEN, (int) LOGGER_ENTRY_MAX_PAYLOAD);  
  38.     }  
  39.   
  40.     dev = dev->next;  
  41. }  

        如果执行logcat命令的目的是清空日志，即clearLog为true，则调用android::clearLog函数来执行清空日志操作：

[cpp] view plaincopyprint?
  1. static int clearLog(int logfd)  
  2. {  
  3.     return ioctl(logfd, LOGGER_FLUSH_LOG);  
  4. }  

        这里是通过标准的文件函数ioctl函数来执行日志清空操作，具体可以参考logger驱动程序的实现。

        如果执行logcat命令的目的是获取日志内存缓冲区的大小，即getLogSize为true，通过调用android::getLogSize函数实现：

[cpp] view plaincopyprint?
  1. /* returns the total size of the log's ring buffer */  
  2. static int getLogSize(int logfd)  
  3. {  
  4.     return ioctl(logfd, LOGGER_GET_LOG_BUF_SIZE);  
  5. }  

        如果为负数，即size < 0，就表示出错了，退出程序。

        接着验证日志缓冲区可读内容的大小，即调用android::getLogReadableSize函数：

[cpp] view plaincopyprint?
  1. /* returns the readable size of the log's ring buffer (that is, amount of the log consumed) */  
  2. static int getLogReadableSize(int logfd)  
  3. {  
  4.     return ioctl(logfd, LOGGER_GET_LOG_LEN);  
  5. }  

        如果返回负数，即readable < 0，也表示出错了，退出程序。

        接下去的printf语句，就是输出日志缓冲区的大小以及可读日志的大小到控制台去了。

        继续看下看代码，如果执行logcat命令的目的是清空日志或者获取日志的大小信息，则现在就完成使命了，可以退出程序了：

[cpp] view plaincopyprint?
  1. if (getLogSize) {  
  2.     return 0;  
  3. }  
  4. if (clearLog) {  
  5.     return 0;  
  6. }  

        否则，就要开始读取设备文件的日志记录了：

[html] view plaincopyprint?
  1. android::readLogLines(devices);  

       至此日志设备文件就打开并且初始化好了，下面，我们继续分析从日志设备文件读取日志记录的操作，即readLogLines函数。

       三. 读取日志设备文件。

       读取日志设备文件内容的函数是readLogLines函数：

[cpp] view plaincopyprint?
  1. static void readLogLines(log_device_t* devices)  
  2. {  
  3.     log_device_t* dev;  
  4.     int max = 0;  
  5.     int ret;  
  6.     int queued_lines = 0;  
  7.     bool sleep = true;  
  8.   
  9.     int result;  
  10.     fd_set readset;  
  11.   
  12.     for (dev=devices; dev; dev = dev->next) {  
  13.         if (dev->fd > max) {  
  14.             max = dev->fd;  
  15.         }  
  16.     }  
  17.   
  18.     while (1) {  
  19.         do {  
  20.             timeval timeout = { 0, 5000 /* 5ms */ }; // If we oversleep it's ok, i.e. ignore EINTR.  
  21.             FD_ZERO(&readset);  
  22.             for (dev=devices; dev; dev = dev->next) {  
  23.                 FD_SET(dev->fd, &readset);  
  24.             }  
  25.             result = select(max + 1, &readset, NULL, NULL, sleep ? NULL : &timeout);  
  26.         } while (result == -1 && errno == EINTR);  
  27.   
  28.         if (result >= 0) {  
  29.             for (dev=devices; dev; dev = dev->next) {  
  30.                 if (FD_ISSET(dev->fd, &readset)) {  
  31.                     queued_entry_t* entry = new queued_entry_t();  
  32.                     /* NOTE: driver guarantees we read exactly one full entry */  
  33.                     ret = read(dev->fd, entry->buf, LOGGER_ENTRY_MAX_LEN);  
  34.                     if (ret < 0) {  
  35.                         if (errno == EINTR) {  
  36.                             delete entry;  
  37.                             goto next;  
  38.                         }  
  39.                         if (errno == EAGAIN) {  
  40.                             delete entry;  
  41.                             break;  
  42.                         }  
  43.                         perror("logcat read");  
  44.                         exit(EXIT_FAILURE);  
  45.                     }  
  46.                     else if (!ret) {  
  47.                         fprintf(stderr, "read: Unexpected EOF!\n");  
  48.                         exit(EXIT_FAILURE);  
  49.                     }  
  50.   
  51.                     entry->entry.msg[entry->entry.len] = '\0';  
  52.   
  53.                     dev->enqueue(entry);  
  54.                     ++queued_lines;  
  55.                 }  
  56.             }  
  57.   
  58.             if (result == 0) {  
  59.                 // we did our short timeout trick and there's nothing new  
  60.                 // print everything we have and wait for more data  
  61.                 sleep = true;  
  62.                 while (true) {  
  63.                     chooseFirst(devices, &dev);  
  64.                     if (dev == NULL) {  
  65.                         break;  
  66.                     }  
  67.                     if (g_tail_lines == 0 || queued_lines <= g_tail_lines) {  
  68.                         printNextEntry(dev);  
  69.                     } else {  
  70.                         skipNextEntry(dev);  
  71.                     }  
  72.                     --queued_lines;  
  73.                 }  
  74.   
  75.                 // the caller requested to just dump the log and exit  
  76.                 if (g_nonblock) {  
  77.                     exit(0);  
  78.                 }  
  79.             } else {  
  80.                 // print all that aren't the last in their list  
  81.                 sleep = false;  
  82.                 while (g_tail_lines == 0 || queued_lines > g_tail_lines) {  
  83.                     chooseFirst(devices, &dev);  
  84.                     if (dev == NULL || dev->queue->next == NULL) {  
  85.                         break;  
  86.                     }  
  87.                     if (g_tail_lines == 0) {  
  88.                         printNextEntry(dev);  
  89.                     } else {  
  90.                         skipNextEntry(dev);  
  91.                     }  
  92.                     --queued_lines;  
  93.                 }  
  94.             }  
  95.         }  
  96. next:  
  97.         ;  
  98.     }  
  99. }  

        由于可能同时打开了多个日志设备文件，这里使用select函数来同时监控哪个文件当前可读：

[cpp] view plaincopyprint?
  1. do {  
  2.     timeval timeout = { 0, 5000 /* 5ms */ }; // If we oversleep it's ok, i.e. ignore EINTR.  
  3.     FD_ZERO(&readset);  
  4.     for (dev=devices; dev; dev = dev->next) {  
  5.         FD_SET(dev->fd, &readset);  
  6.     }  
  7.     result = select(max + 1, &readset, NULL, NULL, sleep ? NULL : &timeout);  
  8. } while (result == -1 && errno == EINTR);  

       如果result >= 0，就表示有日志设备文件可读或者超时。接着，用一个for语句检查哪个设备文件可读，即FD_ISSET(dev->fd, &readset)是否为true，如果为true，表明可读，就要进一步通过read函数将日志读出，注意，每次只读出一条日志记录：

[cpp] view plaincopyprint?
  1. for (dev=devices; dev; dev = dev->next) {  
  2.            if (FD_ISSET(dev->fd, &readset)) {  
  3.                queued_entry_t* entry = new queued_entry_t();  
  4.                /* NOTE: driver guarantees we read exactly one full entry */  
  5.                ret = read(dev->fd, entry->buf, LOGGER_ENTRY_MAX_LEN);  
  6.                if (ret < 0) {  
  7.                    if (errno == EINTR) {  
  8.                        delete entry;  
  9.                        goto next;  
  10.                    }  
  11.                    if (errno == EAGAIN) {  
  12.                        delete entry;  
  13.                        break;  
  14.                    }  
  15.                    perror("logcat read");  
  16.                    exit(EXIT_FAILURE);  
  17.                }  
  18.                else if (!ret) {  
  19.                    fprintf(stderr, "read: Unexpected EOF!\n");  
  20.                    exit(EXIT_FAILURE);  
  21.                }  
  22.   
  23.                entry->entry.msg[entry->entry.len] = '\0';  
  24.   
  25.                dev->enqueue(entry);  
  26.                ++queued_lines;  
  27.            }  
  28.        }  

        调用read函数之前，先创建一个日志记录项entry，接着调用read函数将日志读到entry->buf中，最后调用dev->enqueue(entry)将日志记录加入到日志队例中去。同时，把当前的日志记录数保存在queued_lines变量中。

        继续进一步处理日志：

[cpp] view plaincopyprint?
  1. if (result == 0) {  
  2.     // we did our short timeout trick and there's nothing new  
  3.     // print everything we have and wait for more data  
  4.     sleep = true;  
  5.     while (true) {  
  6.         chooseFirst(devices, &dev);  
  7.         if (dev == NULL) {  
  8.             break;  
  9.         }  
  10.         if (g_tail_lines == 0 || queued_lines <= g_tail_lines) {  
  11.             printNextEntry(dev);  
  12.         } else {  
  13.             skipNextEntry(dev);  
  14.         }  
  15.         --queued_lines;  
  16.     }  
  17.   
  18.     // the caller requested to just dump the log and exit  
  19.     if (g_nonblock) {  
  20.         exit(0);  
  21.     }  
  22. } else {  
  23.     // print all that aren't the last in their list  
  24.     sleep = false;  
  25.     while (g_tail_lines == 0 || queued_lines > g_tail_lines) {  
  26.         chooseFirst(devices, &dev);  
  27.         if (dev == NULL || dev->queue->next == NULL) {  
  28.             break;  
  29.         }  
  30.         if (g_tail_lines == 0) {  
  31.             printNextEntry(dev);  
  32.         } else {  
  33.             skipNextEntry(dev);  
  34.         }  
  35.         --queued_lines;  
  36.     }  
  37. }  

        如果result == 0，表明是等待超时了，目前没有新的日志可读，这时候就要先处理之前已经读出来的日志。调用chooseFirst选择日志队列不为空，且日志队列中的第一个日志记录的时间戳为最小的设备，即先输出最旧的日志：

[cpp] view plaincopyprint?
  1. static void chooseFirst(log_device_t* dev, log_device_t** firstdev) {  
  2.     for (*firstdev = NULL; dev != NULL; dev = dev->next) {  
  3.         if (dev->queue != NULL && (*firstdev == NULL || cmp(dev->queue, (*firstdev)->queue) < 0)) {  
  4.             *firstdev = dev;  
  5.         }  
  6.     }  
  7. }  

       如果存在这样的日志设备，接着判断日志记录是应该丢弃还是输出。前面我们说过，如果执行logcat命令时，指定了参数-t <count>，那么就会只显示最新的count条记录，其它的旧记录将被丢弃：

[cpp] view plaincopyprint?
  1. if (g_tail_lines == 0 || queued_lines <= g_tail_lines) {  
  2.      printNextEntry(dev);  
  3. } else {  
  4.      skipNextEntry(dev);  
  5. }  

         g_tail_lines表示显示最新记录的条数，如果为0，就表示全部显示。如果g_tail_lines == 0或者queued_lines <= g_tail_lines，就表示这条日志记录应该输出，否则就要丢弃了。每处理完一条日志记录，queued_lines就减1，这样，最新的g_tail_lines就可以输出出来了。

        如果result > 0，表明有新的日志可读，这时候的处理方式与result == 0的情况不同，因为这时候还有新的日志可读，所以就不能先急着处理之前已经读出来的日志。这里，分两种情况考虑，如果能设置了只显示最新的g_tail_lines条记录，并且当前已经读出来的日志记录条数已经超过g_tail_lines，就要丢弃，剩下的先不处理，等到下次再来处理；如果没有设备显示最新的g_tail_lines条记录，即g_tail_lines == 0，这种情况就和result  == 0的情况处理方式一样，先处理所有已经读出的日志记录，再进入下一次循环。希望读者可以好好体会这段代码：

[cpp] view plaincopyprint?
  1. while (g_tail_lines == 0 || queued_lines > g_tail_lines) {  
  2.      chooseFirst(devices, &dev);  
  3.      if (dev == NULL || dev->queue->next == NULL) {  
  4.           break;  
  5.      }  
  6.      if (g_tail_lines == 0) {  
  7.           printNextEntry(dev);  
  8.      } else {  
  9.           skipNextEntry(dev);  
  10.      }  
  11.      --queued_lines;  
  12. }  

        丢弃日志记录的函数skipNextEntry实现如下：

[cpp] view plaincopyprint?
  1. static void skipNextEntry(log_device_t* dev) {  
  2.     maybePrintStart(dev);  
  3.     queued_entry_t* entry = dev->queue;  
  4.     dev->queue = entry->next;  
  5.     delete entry;  
  6. }  

        这里只是简单地跳过日志队列头，这样就把最旧的日志丢弃了。

        printNextEntry函数处理日志输出，下一节中继续分析。

        四. 输出日志设备文件的内容。

        从前面的分析中看出，最终日志设备文件内容的输出是通过printNextEntry函数进行的：

[cpp] view plaincopyprint?
  1. static void printNextEntry(log_device_t* dev) {  
  2.     maybePrintStart(dev);  
  3.     if (g_printBinary) {  
  4.         printBinary(&dev->queue->entry);  
  5.     } else {  
  6.         processBuffer(dev, &dev->queue->entry);  
  7.     }  
  8.     skipNextEntry(dev);  
  9. }  

        g_printBinary为true时，以二进制方式输出日志内容到指定的文件中：

[cpp] view plaincopyprint?
  1. void printBinary(struct logger_entry *buf)  
  2. {  
  3.     size_t size = sizeof(logger_entry) + buf->len;  
  4.     int ret;  
  5.       
  6.     do {  
  7.         ret = write(g_outFD, buf, size);  
  8.     } while (ret < 0 && errno == EINTR);  
  9. }  

       我们关注g_printBinary为false的情况，调用processBuffer进一步处理：

[cpp] view plaincopyprint?
  1. static void processBuffer(log_device_t* dev, struct logger_entry *buf)  
  2. {  
  3.     int bytesWritten = 0;  
  4.     int err;  
  5.     AndroidLogEntry entry;  
  6.     char binaryMsgBuf[1024];  
  7.   
  8.     if (dev->binary) {  
  9.         err = android_log_processBinaryLogBuffer(buf, &entry, g_eventTagMap,  
  10.                 binaryMsgBuf, sizeof(binaryMsgBuf));  
  11.         //printf(">>> pri=%d len=%d msg='%s'\n",  
  12.         //    entry.priority, entry.messageLen, entry.message);  
  13.     } else {  
  14.         err = android_log_processLogBuffer(buf, &entry);  
  15.     }  
  16.     if (err < 0) {  
  17.         goto error;  
  18.     }  
  19.   
  20.     if (android_log_shouldPrintLine(g_logformat, entry.tag, entry.priority)) {  
  21.         if (false && g_devCount > 1) {  
  22.             binaryMsgBuf[0] = dev->label;  
  23.             binaryMsgBuf[1] = ' ';  
  24.             bytesWritten = write(g_outFD, binaryMsgBuf, 2);  
  25.             if (bytesWritten < 0) {  
  26.                 perror("output error");  
  27.                 exit(-1);  
  28.             }  
  29.         }  
  30.   
  31.         bytesWritten = android_log_printLogLine(g_logformat, g_outFD, &entry);  
  32.   
  33.         if (bytesWritten < 0) {  
  34.             perror("output error");  
  35.             exit(-1);  
  36.         }  
  37.     }  
  38.   
  39.     g_outByteCount += bytesWritten;  
  40.   
  41.     if (g_logRotateSizeKBytes > 0   
  42.         && (g_outByteCount / 1024) >= g_logRotateSizeKBytes  
  43.     ) {  
  44.         rotateLogs();  
  45.     }  
  46.   
  47. error:  
  48.     //fprintf (stderr, "Error processing record\n");  
  49.     return;  
  50. }  

        当dev->binary为true，日志记录项是二进制形式，不同于我们在Android日志系统驱动程序Logger源代码分析一文中提到的常规格式：

        struct logger_entry | priority | tag | msg
        这里我们不关注这种情况，有兴趣的读者可以自已分析，android_log_processBinaryLogBuffer函数定义在system/core/liblog/logprint.c文件中，它的作用是将一条二进制形式的日志记录转换为ASCII形式，并保存在entry参数中，它的原型为：

[cpp] view plaincopyprint?
  1. /** 
  2.  * Convert a binary log entry to ASCII form. 
  3.  * 
  4.  * For convenience we mimic the processLogBuffer API.  There is no 
  5.  * pre-defined output length for the binary data, since we're free to format 
  6.  * it however we choose, which means we can't really use a fixed-size buffer 
  7.  * here. 
  8.  */  
  9. int android_log_processBinaryLogBuffer(struct logger_entry *buf,  
  10.     AndroidLogEntry *entry, const EventTagMap* map, char* messageBuf,  
  11.     int messageBufLen);  

        通常情况下，dev->binary为false，调用android_log_processLogBuffer函数将日志记录由logger_entry格式转换为AndroidLogEntry格式。logger_entry格式在在Android日志系统驱动程序Logger源代码分析一文中已经有详细描述，这里不述；AndroidLogEntry结构体定义在system/core/include/cutils/logprint.h中：

[cpp] view plaincopyprint?
  1. typedef struct AndroidLogEntry_t {  
  2.     time_t tv_sec;  
  3.     long tv_nsec;  
  4.     android_LogPriority priority;  
  5.     pid_t pid;  
  6.     pthread_t tid;  
  7.     const char * tag;  
  8.     size_t messageLen;  
  9.     const char * message;  
  10. } AndroidLogEntry;  

        android_LogPriority是一个枚举类型，定义在system/core/include/android/log.h文件中：

[cpp] view plaincopyprint?
  1. /* 
  2.  * Android log priority values, in ascending priority order. 
  3.  */  
  4. typedef enum android_LogPriority {  
  5.     ANDROID_LOG_UNKNOWN = 0,  
  6.     ANDROID_LOG_DEFAULT,    /* only for SetMinPriority() */  
  7.     ANDROID_LOG_VERBOSE,  
  8.     ANDROID_LOG_DEBUG,  
  9.     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;  

        android_log_processLogBuffer定义在system/core/liblog/logprint.c文件中：

[cpp] view plaincopyprint?
  1. /** 
  2.  * Splits a wire-format buffer into an AndroidLogEntry 
  3.  * entry allocated by caller. Pointers will point directly into buf 
  4.  * 
  5.  * Returns 0 on success and -1 on invalid wire format (entry will be 
  6.  * in unspecified state) 
  7.  */  
  8. int android_log_processLogBuffer(struct logger_entry *buf,  
  9.                                  AndroidLogEntry *entry)  
  10. {  
  11.     size_t tag_len;  
  12.   
  13.     entry->tv_sec = buf->sec;  
  14.     entry->tv_nsec = buf->nsec;  
  15.     entry->priority = buf->msg[0];  
  16.     entry->pid = buf->pid;  
  17.     entry->tid = buf->tid;  
  18.     entry->tag = buf->msg + 1;  
  19.     tag_len = strlen(entry->tag);  
  20.     entry->messageLen = buf->len - tag_len - 3;  
  21.     entry->message = entry->tag + tag_len + 1;  
  22.   
  23.     return 0;  
  24. }  

        结合logger_entry结构体中日志项的格式定义（struct logger_entry | priority | tag | msg），这个函数很直观，不再累述。

        调用完android_log_processLogBuffer函数后，日志记录的具体信息就保存在本地变量entry中了，接着调用android_log_shouldPrintLine函数来判断这条日志记录是否应该输出。

        在分析android_log_shouldPrintLine函数之前，我们先了解数据结构AndroidLogFormat，这个结构体定义在system/core/liblog/logprint.c文件中：

[cpp] view plaincopyprint?
  1. struct AndroidLogFormat_t {  
  2.     android_LogPriority global_pri;  
  3.     FilterInfo *filters;  
  4.     AndroidLogPrintFormat format;  
  5. };  

        AndroidLogPrintFormat也是定义在system/core/liblog/logprint.c文件中：

[cpp] view plaincopyprint?
  1. typedef struct FilterInfo_t {  
  2.     char *mTag;  
  3.     android_LogPriority mPri;  
  4.     struct FilterInfo_t *p_next;  
  5. } FilterInfo;  

        因此，可以看出，AndroidLogFormat结构体定义了日志过滤规范。在logcat.c文件中，定义了变量

[cpp] view plaincopyprint?
  1. static AndroidLogFormat * g_logformat;  

       这个变量是在main函数里面进行分配的：

[cpp] view plaincopyprint?
  1. g_logformat = android_log_format_new();  

       在main函数里面，在分析logcat命令行参数时，会将g_logformat进行初始化，有兴趣的读者可以自行分析。

       回到android_log_shouldPrintLine函数中，它定义在system/core/liblog/logprint.c文件中：

[cpp] view plaincopyprint?
  1. /** 
  2.  * returns 1 if this log line should be printed based on its priority 
  3.  * and tag, and 0 if it should not 
  4.  */  
  5. int android_log_shouldPrintLine (  
  6.         AndroidLogFormat *p_format, const char *tag, android_LogPriority pri)  
  7. {  
  8.     return pri >= filterPriForTag(p_format, tag);  
  9. }  

       这个函数判断在p_format中根据tag值，找到对应的pri值，如果返回来的pri值小于等于参数传进来的pri值，那么就表示这条日志记录可以输出。我们来看filterPriForTag函数的实现：

[cpp] view plaincopyprint?
  1. static android_LogPriority filterPriForTag(  
  2.         AndroidLogFormat *p_format, const char *tag)  
  3. {  
  4.     FilterInfo *p_curFilter;  
  5.   
  6.     for (p_curFilter = p_format->filters  
  7.             ; p_curFilter != NULL  
  8.             ; p_curFilter = p_curFilter->p_next  
  9.     ) {  
  10.         if (0 == strcmp(tag, p_curFilter->mTag)) {  
  11.             if (p_curFilter->mPri == ANDROID_LOG_DEFAULT) {  
  12.                 return p_format->global_pri;  
  13.             } else {  
  14.                 return p_curFilter->mPri;  
  15.             }  
  16.         }  
  17.     }  
  18.   
  19.     return p_format->global_pri;  
  20. }  

        如果在p_format中找到与tag值对应的filter，并且该filter的mPri不等于ANDROID_LOG_DEFAULT，那么就返回该filter的成员变量mPri的值；其它情况下，返回p_format->global_pri的值。

        回到processBuffer函数中，如果执行完android_log_shouldPrintLine函数后，表明当前日志记录应当输出，则调用android_log_printLogLine函数来输出日志记录到文件fd中， 这个函数也是定义在system/core/liblog/logprint.c文件中：

[cpp] view plaincopyprint?
  1. int android_log_printLogLine(  
  2.     AndroidLogFormat *p_format,  
  3.     int fd,  
  4.     const AndroidLogEntry *entry)  
  5. {  
  6.     int ret;  
  7.     char defaultBuffer[512];  
  8.     char *outBuffer = NULL;  
  9.     size_t totalLen;  
  10.   
  11.     outBuffer = android_log_formatLogLine(p_format, defaultBuffer,  
  12.             sizeof(defaultBuffer), entry, &totalLen);  
  13.   
  14.     if (!outBuffer)  
  15.         return -1;  
  16.   
  17.     do {  
  18.         ret = write(fd, outBuffer, totalLen);  
  19.     } while (ret < 0 && errno == EINTR);  
  20.   
  21.     if (ret < 0) {  
  22.         fprintf(stderr, "+++ LOG: write failed (errno=%d)\n", errno);  
  23.         ret = 0;  
  24.         goto done;  
  25.     }  
  26.   
  27.     if (((size_t)ret) < totalLen) {  
  28.         fprintf(stderr, "+++ LOG: write partial (%d of %d)\n", ret,  
  29.                 (int)totalLen);  
  30.         goto done;  
  31.     }  
  32.   
  33. done:  
  34.     if (outBuffer != defaultBuffer) {  
  35.         free(outBuffer);  
  36.     }  
  37.   
  38.     return ret;  
  39. }  

        这个函数的作用就是把AndroidLogEntry格式的日志记录按照指定的格式AndroidLogFormat进行输出了，这里，不再进一步分析这个函数。

        processBuffer函数的最后，还有一个rotateLogs的操作：

[cpp] view plaincopyprint?
  1. static void rotateLogs()  
  2. {  
  3.     int err;  
  4.   
  5.     // Can't rotate logs if we're not outputting to a file  
  6.     if (g_outputFileName == NULL) {  
  7.         return;  
  8.     }  
  9.   
  10.     close(g_outFD);  
  11.   
  12.     for (int i = g_maxRotatedLogs ; i > 0 ; i--) {  
  13.         char *file0, *file1;  
  14.   
  15.         asprintf(&file1, "%s.%d", g_outputFileName, i);  
  16.   
  17.         if (i - 1 == 0) {  
  18.             asprintf(&file0, "%s", g_outputFileName);  
  19.         } else {  
  20.             asprintf(&file0, "%s.%d", g_outputFileName, i - 1);  
  21.         }  
  22.   
  23.         err = rename (file0, file1);  
  24.   
  25.         if (err < 0 && errno != ENOENT) {  
  26.             perror("while rotating log files");  
  27.         }  
  28.   
  29.         free(file1);  
  30.         free(file0);  
  31.     }  
  32.   
  33.     g_outFD = openLogFile (g_outputFileName);  
  34.   
  35.     if (g_outFD < 0) {  
  36.         perror ("couldn't open output file");  
  37.         exit(-1);  
  38.     }  
  39.   
  40.     g_outByteCount = 0;  
  41.   
  42. }  

        这个函数只有在执行logcat命令时，指定了-f <filename>参数时，即g_outputFileName不为NULL时才起作用。它的作用是在将日志记录循环输出到一组文件中。例如，指定-f参数为logfile，g_maxRotatedLogs为3，则这组文件分别为：

        logfile，logfile.1，logfile.2，logfile.3

        当当前输入到logfile文件的日志记录大小g_outByteCount大于等于g_logRotateSizeKBytes时，就要将logfile.2的内容移至logfile.3中，同时将logfile.1的内容移至logfile.2中，同时logfle的内容移至logfile.1中，再重新打开logfile文件进入后续输入。这样做的作用是不至于使得日志文件变得越来越来大，以至于占用过多的磁盘空间，而是只在磁盘上保存一定量的最新的日志记录。这样，旧的日志记录就会可能被新的日志记录所覆盖。

        至此，关于Android日志系统源代码，我们就完整地分析完了，其中包括位于内核空间的驱动程序Logger源代码分析，还有位于应用程序框架层和系统运行库层的日志写入操作接口源代码分析和用于日志读取的工具Logcat源代码分析，希望能够帮助读者对Android的日志系统有一个清晰的认识

 

 

 

乾隆 知乎 乾隆 知乎
原创粉丝点击
热门IT博客
在c 中执行sql语句在c 中执行sql语句
设计软件手机版设计软件手机版
nginx视频教程 尚学堂
数据分析模型作用
12306数据库 百度网盘
中国进出口月度数据
路由器mac地址用设置吗
windows 映射
linux上新建weblogic域
化学品分类数据库
网络运营转产品
五十音图 软件
重复犯错歌词 知乎
九阴脸型数据
阿里巴巴旗下所有软件
淘宝宝贝卖点模板
js转化成数字
51单片机和arm单片机
南京市雨花区网络问政
淘宝产品编辑招聘
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 御锦城小区 御锦城售楼电话 御锦城房子怎么样 御锦城电话 御锦城开发商 御锦城样板间 西安车管所 融创御锦装修 重庆融创御锦 常规纺锦纶切片价格 长春融创御湖宸院 郑州融创御湖宸院 沁园春御院二手房 金科中央御院 御阴宝抗菌凝胶 御清 得露清 垂饮清露 美颜膏 还颜膏 花酿洗颜膏 草本净颜祛痘膏 颜庄绿茶粉刺膏 荔枝牌美颜珍珠膏 石家庄御指天骄爽记 萌萌奇欲记御书网 御天记 御食尚小吃培训 冰糖葫芦御食园 北京御食园食品股份有限公司 御鑫宫宾馆 骨松宝 骨得宝 骨宝胶囊 金骨宝胶囊 御魂师 御魂忍 御龙修仙传2在线播放 御龙修仙传2什么时候上映 御龙在天2下载 御龙修仙传2上映时间

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里