Android 让adb logcat打印内核调试信息

Android让adb logcat打印内核调试信息

在默认情况下，adb logcat只能显示应用程序的调试信息，我把logcat.cpp修改了一下，让它同时可以打印内核调试信息：

修改的文件：system/core/logcat/logcat.cpp

1、首先先加入头文件
#include <sys/klog.h> //add by 

2、定义所使用的TAG
#define KERNEL_TAG "Kernel"

3、替换readLogLines函数

 static void readLogLines(log_device_t* devices)
 {
     log_device_t* dev;
     int max = 0;
     int ret;
     int queued_lines = 0;
     bool sleep = true;
     char buffer[256] = {0}; //add by zhaofei


     int result;
     fd_set readset;


     for (dev=devices; dev; dev = dev->next) {
         if (dev->fd > max) {
             max = dev->fd;
         }
     }


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


         if (result >= 0) {
             for (dev=devices; dev; dev = dev->next) {
                 if (FD_ISSET(dev->fd, &readset)) {
                     queued_entry_t* entry = new queued_entry_t();
                     /* NOTE: driver guarantees we read exactly one full entry */
                     ret = read(dev->fd, entry->buf, LOGGER_ENTRY_MAX_LEN);
                     if (ret < 0) {
                         if (errno == EINTR) {
                             delete entry;
                             goto next;
                         }
                         if (errno == EAGAIN) {
                             delete entry;
                             break;
                         }
                         perror("logcat read");
                         exit(EXIT_FAILURE);
                     }
                     else if (!ret) {
                         fprintf(stderr, "read: Unexpected EOF!\n");
                         exit(EXIT_FAILURE);
                     }


                     entry->entry.msg[entry->entry.len] = '\0';


                     dev->enqueue(entry);
                     ++queued_lines;


 #if 1 //read kernel log
                     if((ret = klogctl(9, buffer, sizeof(buffer))) > 0) {
                         if((ret = klogctl(2, buffer, sizeof(buffer))) > 0) {
                             entry->entry.tid = 0;
                             entry->entry.pid = getpid();
                             /*priority*/
                             entry->entry.msg[0] = ANDROID_LOG_INFO;
                             /*tag*/
                             strcpy(entry->entry.msg+1, KERNEL_TAG);
                             /*message*/
                             strncpy(entry->entry.msg+1+sizeof(KERNEL_TAG), buffer, ret);
                             entry->entry.len = 1 + sizeof(KERNEL_TAG) + ret + 1;
                             entry->entry.msg[entry->entry.len] = '/0';
                             /*
                             if (g_printBinary) {
                                 printBinary(dev, entry->entry);
                             } else {
                                 (void) processBuffer(dev, entry->entry);
                             }
                             */
                         printNextEntry(dev);
                         }
                     }
 #endif
                 }
             }


             if (result == 0) {
                 // we did our short timeout trick and there's nothing new
                 // print everything we have and wait for more data
                 sleep = true;
                 while (true) {
                     chooseFirst(devices, &dev);
                     if (dev == NULL) {
                         break;
                     }
                     if (g_tail_lines == 0 || queued_lines <= g_tail_lines) {
                         printNextEntry(dev);
                     } else {
                         skipNextEntry(dev);
                     }
                     --queued_lines;
                 }


                 // the caller requested to just dump the log and exit
                 if (g_nonblock) {
                     exit(0);
                 }
             } else {
                 // print all that aren't the last in their list
                 sleep = false;
                 while (g_tail_lines == 0 || queued_lines > g_tail_lines) {
                     chooseFirst(devices, &dev);
                     if (dev == NULL || dev->queue->next == NULL) {
                         break;
                     }
                     if (g_tail_lines == 0) {
                         printNextEntry(dev);
                     } else {
                         skipNextEntry(dev);
                     }
                     --queued_lines;
                 }
             }
         }
 next:
         ;
     }
 }

这里没有把内核调试信息的级别转换成Androind的LOG级别，entry->entry.msg[0] = ANDROID_LOG_INFO;使用了ANDROID_LOG_INFO级别，进程ID用了当前的进程ID。


然后就可以使用logcat来抓取kernel的log了！

Have Fun!