#define KERN_EMERG "<0>"   /* system is unusable          */

#define KERN_ALERT "<1>"   /* action must be taken immediately */

#define KERN_CRIT  "<2>"   /* critical conditions         */

#deinfe KERN_ERR   "<3>"   /* error conditions         */

#deinfe KERN_WARNING   "<4>"   /* warning conditions          */

#deinfe KERN_NOTICE "<5>"  /* normal but significant condition */

#deinfe KERN_INFO  "<6>"   /* informational            */

#deinfe KERN_DEBUG "<7>"   /* debug-level messages        */

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

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

/*

* Android log priority values, in ascending priority order.

*/

typedefenum android_LogPriority{

ANDROID_LOG_UNKNOWN =0,

ANDROID_LOG_DEFAULT,   /* only for SetMinPriority() */

ANDROID_LOG_VERBOSE,

ANDROID_LOG_DEBUG,

ANDROID_LOG_INFO,

ANDROID_LOG_WARN,

ANDROID_LOG_ERROR,

ANDROID_LOG_FATAL,

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

} android_LogPriority;

/*

* This is the local tag used for the following simplified

* logging macros. You can change this preprocessor definition

* before using the other macros to change the tag.

*/

#ifndef LOG_TAG

#define LOG_TAG NULL

#endif

/*

* Simplified macro to send a verbose log message using the current LOG_TAG.

*/

#ifndef LOGV

#if LOG_NDEBUG

#define LOGV(...)  ((void)0)

#else

#define LOGV(...)  ((void)LOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))

#endif

#endif

/*

* Basic log message macro.

*

* Example:

* LOG(LOG_WARN, NULL, "Failed with error %d", errno);

*

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

*/

#ifndef LOG

#define LOG(priority, tag, ...) \

LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)

#endif

/*

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

*/

#ifndef LOG_PRI

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

android_printLog(priority, tag, __VA_ARGS__)

#endif

/*

* ================================================================

*

* The stuff in the rest of this file should not be used directly.

*/

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

__android_log_print(prio, tag, fmt)

................................................

publicfinalclass Log{

................................................

/**

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

*/

publicstaticfinalint VERBOSE=2;

/**

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

*/

publicstaticfinalint DEBUG=3;

/**

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

*/

publicstaticfinalint INFO=4;

/**

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

*/

publicstaticfinalint WARN=5;

/**

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

*/

publicstaticfinalint ERROR=6;

/**

* Priority constant for the println method.

*/

publicstaticfinalint ASSERT=7;

.....................................................

publicstaticint v(String tag, String msg){

return println_native(LOG_ID_MAIN, VERBOSE, tag, msg);

}

publicstaticint v(String tag, String msg, Throwable tr){

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

}

publicstaticint d(String tag, String msg){

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

}

publicstaticint d(String tag, String msg, Throwable tr){

return println_native(LOG_ID_MAIN, DEBUG, tag, msg +'\n'+ getStackTraceString(tr));

}

publicstaticint i(String tag, String msg){

return println_native(LOG_ID_MAIN, INFO, tag, msg);

}

publicstaticint i(String tag, String msg, Throwable tr){

return println_native(LOG_ID_MAIN, INFO, tag, msg +'\n'+ getStackTraceString(tr));

}

publicstaticint w(String tag, String msg){

return println_native(LOG_ID_MAIN, WARN, tag, msg);

}

publicstaticint w(String tag, String msg, Throwable tr){

return println_native(LOG_ID_MAIN, WARN, tag, msg +'\n'+ getStackTraceString(tr));

}

publicstaticint w(String tag, Throwable tr){

return println_native(LOG_ID_MAIN, WARN, tag, getStackTraceString(tr));

}

publicstaticint e(String tag, String msg){

return println_native(LOG_ID_MAIN, ERROR, tag, msg);

}

publicstaticint e(String tag, String msg, Throwable tr){

return println_native(LOG_ID_MAIN, ERROR, tag, msg +'\n'+ getStackTraceString(tr));

}

..................................................................

/**@hide */publicstaticnativeint println_native(int bufID,

int priority, String tag, String msg);

}

#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 process's pid */

__s32       tid;   /* generating process's tid */

__s32       sec;   /* seconds since Epoch */

__s32       nsec;  /* nanoseconds */

char       msg[0];/* the entry's 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))

/*

* 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 {

unsignedchar*    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 log's 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 don't 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_log's 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))

/*

* 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)

staticstruct 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,

};

staticint __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);

staticint __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'!\n", log->misc.name);

return ret;

}

printk(KERN_INFO"logger: created %luK log '%s'\n",

(unsignedlong) log->size>>10, log->misc.name);

return0;

}

/**

*     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_read - our log's 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 log's open() file operation

*

* Note how near a no-op this is in the write-only case. Keep it that way!

*/

staticint 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;

return0;

}

/*

* 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){

case1:

memcpy(&val, log->buffer+ off,1);

memcpy(((char*)&val)+1, log->buffer,1);

break;

default:

memcpy(&val, log->buffer+ off,2);

}

returnsizeof(struct logger_entry)+ val;

}

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_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,conststruct iovec*iov,

unsignedlong 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))

return0;

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 segment's 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;

}

/*

* do_write_log - writes 'len' bytes from 'buf' to 'log'

*

* The caller needs to hold log->mutex.

*/

staticvoid do_write_log(struct logger_log *log,constvoid*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(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 segment's 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,

constvoid __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.

*/

staticvoid 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)

return1;

}else{

if(a< c&& b>= c)

return1;

}

return0;

}