|
|
我們知道，在Android系統(tǒng)中，提供了一個輕量級的日志系統(tǒng)，這個日志系統(tǒng)是以驅(qū)動程序的形式實現(xiàn)在內(nèi)核空間的，而在用戶空間分別提供了Java接口和C/C++接口來使用這個日志系統(tǒng)，取決于你編寫的是Android應(yīng)用程序還是系統(tǒng)組件。在前面的文章淺談Android系統(tǒng)開發(fā)中LOG的使用中，已經(jīng)簡要地介紹了在Android應(yīng)用程序開發(fā)中Log的使用方法，在這一篇文章中，我們將更進(jìn)一步地分析Logger驅(qū)動程序的源代碼，使得我們對Android日志系統(tǒng)有一個深刻的認(rèn)識。
既然Android 日志系統(tǒng)是以驅(qū)動程序的形式實現(xiàn)在內(nèi)核空間的，我們就需要獲取Android內(nèi)核源代碼來分析了，請參照前面在Ubuntu上下載、編譯和安裝Android最新源代碼和在Ubuntu上下載、編譯和安裝Android最新內(nèi)核源代碼（Linux Kernel）兩篇文章，下載好Android源代碼工程。Logger驅(qū)動程序主要由兩個文件構(gòu)成，分別是：
kernel/common/drivers/staging/android/logger.h
kernel/common/drivers/staging/android/logger.c
接下來，我們將分別介紹Logger驅(qū)動程序的相關(guān)數(shù)據(jù)結(jié)構(gòu)，然后對Logger驅(qū)動程序源代碼進(jìn)行情景分析，分別日志系統(tǒng)初始化情景、日志讀取情景和日志寫入情景。
一. Logger驅(qū)動程序的相關(guān)數(shù)據(jù)結(jié)構(gòu)。
我們首先來看logger.h頭文件的內(nèi)容： - #ifndef _LINUX_LOGGER_H
#define _LINUX_LOGGER_H
#include <linux/types.h>
#include <linux/ioctl.h>
struct logger_entry {
__u16 len; /* length of the payload */
__u16 __pad; /* no matter what, we get 2 bytes of padding */
__s32 pid; /* generating processs pid */
__s32 tid; /* generating processs tid */
__s32 sec; /* seconds since Epoch */
__s32 nsec; /* nanoseconds */
char msg[0]; /* the entrys payload */
};
#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 */
#define LOGGER_ENTRY_MAX_LEN (4*1024)
#define LOGGER_ENTRY_MAX_PAYLOAD
(LOGGER_ENTRY_MAX_LEN - sizeof(struct logger_entry))
#define __LOGGERIO 0xAE
#define LOGGER_GET_LOG_BUF_SIZE _IO(__LOGGERIO, 1) /* size of log */
#define LOGGER_GET_LOG_LEN _IO(__LOGGERIO, 2) /* used log len */
#define LOGGER_GET_NEXT_ENTRY_LEN _IO(__LOGGERIO, 3) /* next entry len */
#define LOGGER_FLUSH_LOG _IO(__LOGGERIO, 4) /* flush log */
#endif /* _LINUX_LOGGER_H */
接著定義兩個宏：
#define LOGGER_ENTRY_MAX_LEN (4*1024)
#define LOGGER_ENTRY_MAX_PAYLOAD
(LOGGER_ENTRY_MAX_LEN - sizeof(struct logger_entry))
從這兩個宏可以看出，每條日志記錄的有效負(fù)載長度加上結(jié)構(gòu)體logger_entry的長度不能超過4K個字節(jié)。
logger.h文件中還定義了其它宏，讀者可以自己分析，在下面的分析中，碰到時，我們也會詳細(xì)解釋。
再來看logger.c文件中，其它相關(guān)數(shù)據(jù)結(jié)構(gòu)的定義： - /*
* struct logger_log - represents a specific log, such as main or radio
*
* This structure lives from module insertion until module removal, so it does
* not need additional reference counting. The structure is protected by the
* mutex mutex.
*/
struct logger_log {
unsigned char * buffer; /* the ring buffer itself */
struct miscdevice misc; /* misc device representing the log */
wait_queue_head_t wq; /* wait queue for readers */
struct list_head readers; /* this logs readers */
struct mutex mutex; /* mutex protecting buffer */
size_t w_off; /* current write head offset */
size_t head; /* new readers start here */
size_t size; /* size of the log */
};
/*
* struct logger_reader - a logging device open for reading
*
* This object lives from open to release, so we dont need additional
* reference counting. The structure is protected by log->mutex.
*/
struct logger_reader {
struct logger_log * log; /* associated log */
struct list_head list; /* entry in logger_logs list */
size_t r_off; /* current read head offset */
};
/* logger_offset - returns index n into the log via (optimized) modulus */
#define logger_offset(n) ((n) & (log->size - 1))
結(jié)構(gòu)體struct logger_reader用來表示一個讀取日志的進(jìn)程，log成員變量指向要讀取的日志緩沖區(qū)。list成員變量用來連接其它讀者進(jìn)程。r_off成員變量表示當(dāng)前要讀取的日志在緩沖區(qū)中的位置。
struct logger_log結(jié)構(gòu)體中用于保存日志信息的內(nèi)存緩沖區(qū)buffer是一個循環(huán)使用的環(huán)形緩沖區(qū)，緩沖區(qū)中保存的內(nèi)容是以struct logger_entry為單位的，每個單位的組成為：
struct logger_entry | priority | tag | msg
由于是內(nèi)存緩沖區(qū)buffer是一個循環(huán)使用的環(huán)形緩沖區(qū)，給定一個偏移值，它在buffer中的位置由下logger_offset來確定：
#define logger_offset(n) ((n) & (log->size - 1))
二. Logger驅(qū)動程序模塊的初始化過程分析。
繼續(xù)看logger.c文件，定義了三個日志設(shè)備： - /*
* Defines a log structure with name NAME and a size of SIZE bytes, which
* must be a power of two, greater than LOGGER_ENTRY_MAX_LEN, and less than
* LONG_MAX minus LOGGER_ENTRY_MAX_LEN.
*/
#define DEFINE_LOGGER_DEVICE(VAR, NAME, SIZE)
static unsigned char _buf_ ## VAR[SIZE];
static struct logger_log VAR = {
.buffer = _buf_ ## VAR,
.misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = NAME,
.fops = &logger_fops,
.parent = NULL,
},
.wq = __WAIT_QUEUE_HEAD_INITIALIZER(VAR .wq),
.readers = LIST_HEAD_INIT(VAR .readers),
.mutex = __MUTEX_INITIALIZER(VAR .mutex),
.w_off = 0,
.head = 0,
.size = SIZE,
};
DEFINE_LOGGER_DEVICE(log_main, LOGGER_LOG_MAIN, 64*1024)
DEFINE_LOGGER_DEVICE(log_events, LOGGER_LOG_EVENTS, 256*1024)
DEFINE_LOGGER_DEVICE(log_radio, LOGGER_LOG_RADIO, 64*1024)
#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 */
注釋說明了這三個日志設(shè)備的用途。注冊的日志設(shè)備文件操作方法為logger_fops： - static struct file_operations logger_fops = {
.owner = THIS_MODULE,
.read = logger_read,
.aio_write = logger_aio_write,
.poll = logger_poll,
.unlocked_ioctl = logger_ioctl,
.compat_ioctl = logger_ioctl,
.open = logger_open,
.release = logger_release,
};
- static int __init logger_init(void)
{
int ret;
ret = init_log(&log_main);
if (unlikely(ret))
goto out;
ret = init_log(&log_events);
if (unlikely(ret))
goto out;
ret = init_log(&log_radio);
if (unlikely(ret))
goto out;
out:
return ret;
}
device_initcall(logger_init);
- static int __init init_log(struct logger_log *log)
{
int ret;
ret = misc_register(&log->misc);
if (unlikely(ret)) {
printk(KERN_ERR "logger: failed to register misc "
"device for log %s! - ", log->misc.name);
return ret;
}
printk(KERN_INFO "logger: created %luK log %s - ",
(unsigned long) log->size >> 10, log->misc.name);
return 0;
}
view plain - /**
* misc_register - register a miscellaneous device
* @misc: device structure
*
* Register a miscellaneous device with the kernel. If the minor
* number is set to %MISC_DYNAMIC_MINOR a minor number is assigned
* and placed in the minor field of the structure. For other cases
* the minor number requested is used.
*
* The structure passed is linked into the kernel and may not be
* destroyed until it has been unregistered.
*
* A zero is returned on success and a negative errno code for
* failure.
*/
int misc_register(struct miscdevice * misc)
{
struct miscdevice *c;
dev_t dev;
int err = 0;
INIT_LIST_HEAD(&misc->list);
mutex_lock(&misc_mtx);
list_for_each_entry(c, &misc_list, list) {
if (c->minor == misc->minor) {
mutex_unlock(&misc_mtx);
return -EBUSY;
}
}
if (misc->minor == MISC_DYNAMIC_MINOR) {
int i = DYNAMIC_MINORS;
while (--i >= 0)
if ( (misc_minors[i>>3] & (1 << (i&7))) == 0)
break;
if (i<0) {
mutex_unlock(&misc_mtx);
return -EBUSY;
}
misc->minor = i;
}
if (misc->minor < DYNAMIC_MINORS)
misc_minors[misc->minor >> 3] |= 1 << (misc->minor & 7);
dev = MKDEV(MISC_MAJOR, misc->minor);
misc->this_device = device_create(misc_class, misc->parent, dev, NULL,
"%s", misc->name);
if (IS_ERR(misc->this_device)) {
err = PTR_ERR(misc->this_device);
goto out;
}
/*
* Add it to the front, so that later devices can "override"
* earlier defaults
*/
list_add(&misc->list, &misc_list);
out:
mutex_unlock(&misc_mtx);
return err;
}
三. Logger驅(qū)動程序的日志記錄讀取過程分析。
繼續(xù)看logger.c 文件，注冊的讀取日志設(shè)備文件的方法為logger_read： - /*
* logger_read - our logs read() method
*
* Behavior:
*
* - O_NONBLOCK works
* - If there are no log entries to read, blocks until log is written to
* - Atomically reads exactly one log entry
*
* Optimal read size is LOGGER_ENTRY_MAX_LEN. Will set errno to EINVAL if read
* buffer is insufficient to hold next entry.
*/
static ssize_t logger_read(struct file *file, char __user *buf,
size_t count, loff_t *pos)
{
struct logger_reader *reader = file->private_data;
struct logger_log *log = reader->log;
ssize_t ret;
DEFINE_WAIT(wait);
start:
while (1) {
prepare_to_wait(&log->wq, &wait, TASK_INTERRUPTIBLE);
mutex_lock(&log->mutex);
ret = (log->w_off == reader->r_off);
mutex_unlock(&log->mutex);
if (!ret)
break;
if (file->f_flags & O_NONBLOCK) {
ret = -EAGAIN;
break;
}
if (signal_pending(current)) {
ret = -EINTR;
break;
}
schedule();
}
finish_wait(&log->wq, &wait);
if (ret)
return ret;
mutex_lock(&log->mutex);
/* is there still something to read or did we race? */
if (unlikely(log->w_off == reader->r_off)) {
mutex_unlock(&log->mutex);
goto start;
}
/* get the size of the next entry */
ret = get_entry_len(log, reader->r_off);
if (count < ret) {
ret = -EINVAL;
goto out;
}
/* get exactly one entry from the log */
ret = do_read_log_to_user(log, reader, buf, ret);
out:
mutex_unlock(&log->mutex);
return ret;
}
- /*
* logger_open - the logs open() file operation
*
* Note how near a no-op this is in the write-only case. Keep it that way!
*/
static int logger_open(struct inode *inode, struct file *file)
{
struct logger_log *log;
int ret;
ret = nonseekable_open(inode, file);
if (ret)
return ret;
log = get_log_from_minor(MINOR(inode->i_rdev));
if (!log)
return -ENODEV;
if (file->f_mode & FMODE_READ) {
struct logger_reader *reader;
reader = kmalloc(sizeof(struct logger_reader), GFP_KERNEL);
if (!reader)
return -ENOMEM;
reader->log = log;
INIT_LIST_HEAD(&reader->list);
mutex_lock(&log->mutex);
reader->r_off = log->head;
list_add_tail(&reader->list, &log->readers);
mutex_unlock(&log->mutex);
file->private_data = reader;
} else
file->private_data = log;
return 0;
}
start標(biāo)號處的while循環(huán)是在等待日志可讀，如果已經(jīng)沒有新的日志可讀了，那么就要讀進(jìn)程就要進(jìn)入休眠狀態(tài)，等待新的日志寫入后再喚醒，這是通過prepare_wait和schedule兩個調(diào)用來實現(xiàn)的。如果沒有新的日志可讀，并且設(shè)備文件不是以非阻塞O_NONBLOCK的方式打開或者這時有信號要處理（signal_pending(current)），那么就直接返回，不再等待新的日志寫入。判斷當(dāng)前是否有新的日志可讀的方法是：
ret = (log->w_off == reader->r_off);
即判斷當(dāng)前緩沖區(qū)的寫入位置和當(dāng)前讀進(jìn)程的讀取位置是否相等，如果不相等，則說明有新的日志可讀。
繼續(xù)向下看，如果有新的日志可讀，那么就，首先通過get_entry_len來獲取下一條可讀的日志記錄的長度，從這里可以看出，日志讀取進(jìn)程是以日志記錄為單位進(jìn)行讀取的，一次只讀取一條記錄。get_entry_len的函數(shù)實現(xiàn)如下： - /*
* get_entry_len - Grabs the length of the payload of the next entry starting
* from off.
*
* Caller needs to hold log->mutex.
*/
static __u32 get_entry_len(struct logger_log *log, size_t off)
{
__u16 val;
switch (log->size - off) {
case 1:
memcpy(&val, log->buffer + off, 1);
memcpy(((char *) &val) + 1, log->buffer, 1);
break;
default:
memcpy(&val, log->buffer + off, 2);
}
return sizeof(struct logger_entry) + val;
}
接著往下看，得到了要讀取的記錄的長度，就調(diào)用do_read_log_to_user函數(shù)來執(zhí)行真正的讀取動作： - static ssize_t do_read_log_to_user(struct logger_log *log,
struct logger_reader *reader,
char __user *buf,
size_t count)
{
size_t len;
/*
* We read from the log in two disjoint operations. First, we read from
* the current read head offset up to count bytes or to the end of
* the log, whichever comes first.
*/
len = min(count, log->size - reader->r_off);
if (copy_to_user(buf, log->buffer + reader->r_off, len))
return -EFAULT;
/*
* Second, we read any remaining bytes, starting back at the head of
* the log.
*/
if (count != len)
if (copy_to_user(buf + len, log->buffer, count - len))
return -EFAULT;
reader->r_off = logger_offset(reader->r_off + count);
return count;
}
四. Logger驅(qū)動程序的日志記錄寫入過程分析。
繼續(xù)看logger.c 文件，注冊的寫入日志設(shè)備文件的方法為logger_aio_write： - /*
* logger_aio_write - our write method, implementing support for write(),
* writev(), and aio_write(). Writes are our fast path, and we try to optimize
* them above all else.
*/
ssize_t logger_aio_write(struct kiocb *iocb, const struct iovec *iov,
unsigned long nr_segs, loff_t ppos)
{
struct logger_log *log = file_get_log(iocb->ki_filp);
size_t orig = log->w_off;
struct logger_entry header;
struct timespec now;
ssize_t ret = 0;
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);
/* null writes succeed, return zero */
if (unlikely(!header.len))
return 0;
mutex_lock(&log->mutex);
/*
* Fix up any readers, pulling them forward to the first readable
* entry after (what will be) the new write offset. We do this now
* because if we partially fail, we can end up with clobbered log
* entries that encroach on readable buffer.
*/
fix_up_readers(log, sizeof(struct logger_entry) + header.len);
do_write_log(log, &header, sizeof(struct logger_entry));
while (nr_segs-- > 0) {
size_t len;
ssize_t nr;
/* figure out how much of this vector we can keep */
len = min_t(size_t, iov->iov_len, header.len - ret);
/* write out this segments payload */
nr = do_write_log_from_user(log, iov->iov_base, len);
if (unlikely(nr < 0)) {
log->w_off = orig;
mutex_unlock(&log->mutex);
return nr;
}
iov++;
ret += nr;
}
mutex_unlock(&log->mutex);
/* wake up any blocked readers */
wake_up_interruptible(&log->wq);
return ret;
}
struct logger_entry | priority | tag | msg
其中， priority、tag和msg這三個段的內(nèi)容是由iov參數(shù)從用戶空間傳遞下來的，分別對應(yīng)iov里面的三個元素。而logger_entry是由內(nèi)核空間來構(gòu)造的：
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);
然后調(diào)用do_write_log首先把logger_entry結(jié)構(gòu)體寫入到日志緩沖區(qū)中： - /*
* do_write_log - writes len bytes from buf to log
*
* The caller needs to hold log->mutex.
*/
static void do_write_log(struct logger_log *log, const void *buf, size_t count)
{
size_t len;
len = min(count, log->size - log->w_off);
memcpy(log->buffer + log->w_off, buf, len);
if (count != len)
memcpy(log->buffer, buf + len, count - len);
log->w_off = logger_offset(log->w_off + count);
}
接著，通過一個while循環(huán)把iov的內(nèi)容寫入到日志緩沖區(qū)中，也就是日志的優(yōu)先級別priority、日志Tag和日志主體Msg： - while (nr_segs-- > 0) {
size_t len;
ssize_t nr;
/* figure out how much of this vector we can keep */
len = min_t(size_t, iov->iov_len, header.len - ret);
/* write out this segments payload */
nr = do_write_log_from_user(log, iov->iov_base, len);
if (unlikely(nr < 0)) {
log->w_off = orig;
mutex_unlock(&log->mutex);
return nr;
}
iov++;
ret += nr;
}
- static ssize_t do_write_log_from_user(struct logger_log *log,
const void __user *buf, size_t count)
{
size_t len;
len = min(count, log->size - log->w_off);
if (len && copy_from_user(log->buffer + log->w_off, buf, len))
return -EFAULT;
if (count != len)
if (copy_from_user(log->buffer, buf + len, count - len))
return -EFAULT;
log->w_off = logger_offset(log->w_off + count);
return count;
}
- /*
* Fix up any readers, pulling them forward to the first readable
* entry after (what will be) the new write offset. We do this now
* because if we partially fail, we can end up with clobbered log
* entries that encroach on readable buffer.
*/
fix_up_readers(log, sizeof(struct logger_entry) + header.len);
- /*
* fix_up_readers - walk the list of all readers and "fix up" any who were
* lapped by the writer; also do the same for the default "start head".
* We do this by "pulling forward" the readers and start head to the first
* entry after the new write head.
*
* The caller needs to hold log->mutex.
*/
static void fix_up_readers(struct logger_log *log, size_t len)
{
size_t old = log->w_off;
size_t new = logger_offset(old + len);
struct logger_reader *reader;
if (clock_interval(old, new, log->head))
log->head = get_next_entry(log, log->head, len);
list_for_each_entry(reader, &log->readers, list)
if (clock_interval(old, new, reader->r_off))
reader->r_off = get_next_entry(log, reader->r_off, len);
}
- /*
* get_next_entry - return the offset of the first valid entry at least len
* bytes after off.
*
* Caller must hold log->mutex.
*/
static size_t get_next_entry(struct logger_log *log, size_t off, size_t len)
{
size_t count = 0;
do {
size_t nr = get_entry_len(log, off);
off = logger_offset(off + nr);
count += nr;
} while (count < len);
return off;
}
- /*
* clock_interval - is a < c < b in mod-space? Put another way, does the line
* from a to b cross c?
*/
static inline int clock_interval(size_t a, size_t b, size_t c)
{
if (b < a) {
if (a < c || b >= c)
return 1;
} else {
if (a < c && b >= c)
return 1;
}
return 0;
}
/* wake up any blocked readers */
wake_up_interruptible(&log->wq);
至此， Logger驅(qū)動程序的主要邏輯就分析完成了，還有其它的一些接口，如logger_poll、 logger_ioctl和logger_release函數(shù)，比較簡單，讀取可以自行分析。這里還需要提到的一點是，由于Logger驅(qū)動程序模塊在退出系統(tǒng)時，是不會卸載的，所以這個模塊沒有module_exit函數(shù)，而對于模塊里面定義的對象，也沒有用對引用計數(shù)技術(shù)。
這篇文章著重介紹了Android日志系統(tǒng)在內(nèi)核空間的實現(xiàn)，在下一篇文章中，我們將接著介紹在用戶空間中，提供給Android應(yīng)用程序使用的Java和C/C++ LOG調(diào)用接口的實現(xiàn)過程，敬請關(guān)注 |
上一篇： Android開發(fā)筆記第二篇（Android 手機概念）下一篇： 在Ubuntu上為Android系統(tǒng)內(nèi)置Java應(yīng)用程序測試Application Frameworks
|
網(wǎng)站導(dǎo)航
發(fā)表于 2013-8-28 16:30
收藏
淘帖
頂一個
踩
提升卡
置頂卡
變色卡
千斤頂
znds.com 