#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 */ 

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

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

	printk(KERN_INFO "logger: created %luK log '%s'\n",
	 (unsigned long) log->size >> 10, log->misc.name);

	return 0;
}

 * 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! 
 */ 
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; 

/* 
 * 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; 

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, 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 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. 
 */ 
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 (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; 
} 

/* 
 * 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; 
}