2 * drivers/misc/logger.c
6 * Copyright (C) 2007-2008 Google, Inc.
8 * Robert Love <rlove@google.com>
10 * This software is licensed under the terms of the GNU General Public
11 * License version 2, as published by the Free Software Foundation, and
12 * may be copied, distributed, and modified under those terms.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
20 #define pr_fmt(fmt) "logger: " fmt
22 #include <linux/sched.h>
23 #include <linux/module.h>
25 #include <linux/miscdevice.h>
26 #include <linux/uaccess.h>
27 #include <linux/poll.h>
28 #include <linux/slab.h>
29 #include <linux/time.h>
30 #include <linux/vmalloc.h>
33 #include <asm/ioctls.h>
36 * struct logger_log - represents a specific log, such as 'main' or 'radio'
37 * @buffer: The actual ring buffer
38 * @misc: The "misc" device representing the log
39 * @wq: The wait queue for @readers
40 * @readers: This log's readers
41 * @mutex: The mutex that protects the @buffer
42 * @w_off: The current write head offset
43 * @head: The head, or location that readers start reading at.
44 * @size: The size of the log
45 * @logs: The list of log channels
47 * This structure lives from module insertion until module removal, so it does
48 * not need additional reference counting. The structure is protected by the
52 unsigned char *buffer
;
53 struct miscdevice misc
;
55 struct list_head readers
;
60 struct list_head logs
;
63 static LIST_HEAD(log_list
);
67 * struct logger_reader - a logging device open for reading
68 * @log: The associated log
69 * @list: The associated entry in @logger_log's list
70 * @r_off: The current read head offset.
72 * This object lives from open to release, so we don't need additional
73 * reference counting. The structure is protected by log->mutex.
75 struct logger_reader
{
76 struct logger_log
*log
;
77 struct list_head list
;
81 /* logger_offset - returns index 'n' into the log via (optimized) modulus */
82 static size_t logger_offset(struct logger_log
*log
, size_t n
)
84 return n
& (log
->size
- 1);
89 * file_get_log - Given a file structure, return the associated log
91 * This isn't aesthetic. We have several goals:
93 * 1) Need to quickly obtain the associated log during an I/O operation
94 * 2) Readers need to maintain state (logger_reader)
95 * 3) Writers need to be very fast (open() should be a near no-op)
97 * In the reader case, we can trivially go file->logger_reader->logger_log.
98 * For a writer, we don't want to maintain a logger_reader, so we just go
99 * file->logger_log. Thus what file->private_data points at depends on whether
100 * or not the file was opened for reading. This function hides that dirtiness.
102 static inline struct logger_log
*file_get_log(struct file
*file
)
104 if (file
->f_mode
& FMODE_READ
) {
105 struct logger_reader
*reader
= file
->private_data
;
108 return file
->private_data
;
112 * get_entry_len - Grabs the length of the payload of the next entry starting
115 * An entry length is 2 bytes (16 bits) in host endian order.
116 * In the log, the length does not include the size of the log entry structure.
117 * This function returns the size including the log entry structure.
119 * Caller needs to hold log->mutex.
121 static __u32
get_entry_len(struct logger_log
*log
, size_t off
)
125 /* copy 2 bytes from buffer, in memcpy order, */
126 /* handling possible wrap at end of buffer */
128 ((__u8
*)&val
)[0] = log
->buffer
[off
];
129 if (likely(off
+1 < log
->size
))
130 ((__u8
*)&val
)[1] = log
->buffer
[off
+1];
132 ((__u8
*)&val
)[1] = log
->buffer
[0];
134 return sizeof(struct logger_entry
) + val
;
138 * do_read_log_to_user - reads exactly 'count' bytes from 'log' into the
139 * user-space buffer 'buf'. Returns 'count' on success.
141 * Caller must hold log->mutex.
143 static ssize_t
do_read_log_to_user(struct logger_log
*log
,
144 struct logger_reader
*reader
,
151 * We read from the log in two disjoint operations. First, we read from
152 * the current read head offset up to 'count' bytes or to the end of
153 * the log, whichever comes first.
155 len
= min(count
, log
->size
- reader
->r_off
);
156 if (copy_to_user(buf
, log
->buffer
+ reader
->r_off
, len
))
160 * Second, we read any remaining bytes, starting back at the head of
164 if (copy_to_user(buf
+ len
, log
->buffer
, count
- len
))
167 reader
->r_off
= logger_offset(log
, reader
->r_off
+ count
);
173 * logger_read - our log's read() method
178 * - If there are no log entries to read, blocks until log is written to
179 * - Atomically reads exactly one log entry
181 * Optimal read size is LOGGER_ENTRY_MAX_LEN. Will set errno to EINVAL if read
182 * buffer is insufficient to hold next entry.
184 static ssize_t
logger_read(struct file
*file
, char __user
*buf
,
185 size_t count
, loff_t
*pos
)
187 struct logger_reader
*reader
= file
->private_data
;
188 struct logger_log
*log
= reader
->log
;
194 mutex_lock(&log
->mutex
);
196 prepare_to_wait(&log
->wq
, &wait
, TASK_INTERRUPTIBLE
);
198 ret
= (log
->w_off
== reader
->r_off
);
199 mutex_unlock(&log
->mutex
);
203 if (file
->f_flags
& O_NONBLOCK
) {
208 if (signal_pending(current
)) {
216 finish_wait(&log
->wq
, &wait
);
220 mutex_lock(&log
->mutex
);
222 /* is there still something to read or did we race? */
223 if (unlikely(log
->w_off
== reader
->r_off
)) {
224 mutex_unlock(&log
->mutex
);
228 /* get the size of the next entry */
229 ret
= get_entry_len(log
, reader
->r_off
);
235 /* get exactly one entry from the log */
236 ret
= do_read_log_to_user(log
, reader
, buf
, ret
);
239 mutex_unlock(&log
->mutex
);
245 * get_next_entry - return the offset of the first valid entry at least 'len'
248 * Caller must hold log->mutex.
250 static size_t get_next_entry(struct logger_log
*log
, size_t off
, size_t len
)
255 size_t nr
= get_entry_len(log
, off
);
256 off
= logger_offset(log
, off
+ nr
);
258 } while (count
< len
);
264 * is_between - is a < c < b, accounting for wrapping of a, b, and c
265 * positions in the buffer
267 * That is, if a<b, check for c between a and b
268 * and if a>b, check for c outside (not between) a and b
270 * |------- a xxxxxxxx b --------|
273 * |xxxxx b --------- a xxxxxxxxx|
277 static inline int is_between(size_t a
, size_t b
, size_t c
)
280 /* is c between a and b? */
284 /* is c outside of b through a? */
293 * fix_up_readers - walk the list of all readers and "fix up" any who were
294 * lapped by the writer; also do the same for the default "start head".
295 * We do this by "pulling forward" the readers and start head to the first
296 * entry after the new write head.
298 * The caller needs to hold log->mutex.
300 static void fix_up_readers(struct logger_log
*log
, size_t len
)
302 size_t old
= log
->w_off
;
303 size_t new = logger_offset(log
, old
+ len
);
304 struct logger_reader
*reader
;
306 if (is_between(old
, new, log
->head
))
307 log
->head
= get_next_entry(log
, log
->head
, len
);
309 list_for_each_entry(reader
, &log
->readers
, list
)
310 if (is_between(old
, new, reader
->r_off
))
311 reader
->r_off
= get_next_entry(log
, reader
->r_off
, len
);
315 * do_write_log - writes 'len' bytes from 'buf' to 'log'
317 * The caller needs to hold log->mutex.
319 static void do_write_log(struct logger_log
*log
, const void *buf
, size_t count
)
323 len
= min(count
, log
->size
- log
->w_off
);
324 memcpy(log
->buffer
+ log
->w_off
, buf
, len
);
327 memcpy(log
->buffer
, buf
+ len
, count
- len
);
329 log
->w_off
= logger_offset(log
, log
->w_off
+ count
);
334 * do_write_log_user - writes 'len' bytes from the user-space buffer 'buf' to
337 * The caller needs to hold log->mutex.
339 * Returns 'count' on success, negative error code on failure.
341 static ssize_t
do_write_log_from_user(struct logger_log
*log
,
342 const void __user
*buf
, size_t count
)
346 len
= min(count
, log
->size
- log
->w_off
);
347 if (len
&& copy_from_user(log
->buffer
+ log
->w_off
, buf
, len
))
351 if (copy_from_user(log
->buffer
, buf
+ len
, count
- len
))
353 * Note that by not updating w_off, this abandons the
354 * portion of the new entry that *was* successfully
355 * copied, just above. This is intentional to avoid
356 * message corruption from missing fragments.
360 log
->w_off
= logger_offset(log
, log
->w_off
+ count
);
366 * logger_aio_write - our write method, implementing support for write(),
367 * writev(), and aio_write(). Writes are our fast path, and we try to optimize
368 * them above all else.
370 static ssize_t
logger_aio_write(struct kiocb
*iocb
, const struct iovec
*iov
,
371 unsigned long nr_segs
, loff_t ppos
)
373 struct logger_log
*log
= file_get_log(iocb
->ki_filp
);
374 size_t orig
= log
->w_off
;
375 struct logger_entry header
;
379 now
= current_kernel_time();
381 header
.pid
= current
->tgid
;
382 header
.tid
= current
->pid
;
383 header
.sec
= now
.tv_sec
;
384 header
.nsec
= now
.tv_nsec
;
385 header
.len
= min_t(size_t, iocb
->ki_left
, LOGGER_ENTRY_MAX_PAYLOAD
);
387 /* null writes succeed, return zero */
388 if (unlikely(!header
.len
))
391 mutex_lock(&log
->mutex
);
394 * Fix up any readers, pulling them forward to the first readable
395 * entry after (what will be) the new write offset. We do this now
396 * because if we partially fail, we can end up with clobbered log
397 * entries that encroach on readable buffer.
399 fix_up_readers(log
, sizeof(struct logger_entry
) + header
.len
);
401 do_write_log(log
, &header
, sizeof(struct logger_entry
));
403 while (nr_segs
-- > 0) {
407 /* figure out how much of this vector we can keep */
408 len
= min_t(size_t, iov
->iov_len
, header
.len
- ret
);
410 /* write out this segment's payload */
411 nr
= do_write_log_from_user(log
, iov
->iov_base
, len
);
412 if (unlikely(nr
< 0)) {
414 mutex_unlock(&log
->mutex
);
422 mutex_unlock(&log
->mutex
);
424 /* wake up any blocked readers */
425 wake_up_interruptible(&log
->wq
);
430 static struct logger_log
*get_log_from_minor(int minor
)
432 struct logger_log
*log
;
434 list_for_each_entry(log
, &log_list
, logs
)
435 if (log
->misc
.minor
== minor
)
441 * logger_open - the log's open() file operation
443 * Note how near a no-op this is in the write-only case. Keep it that way!
445 static int logger_open(struct inode
*inode
, struct file
*file
)
447 struct logger_log
*log
;
450 ret
= nonseekable_open(inode
, file
);
454 log
= get_log_from_minor(MINOR(inode
->i_rdev
));
458 if (file
->f_mode
& FMODE_READ
) {
459 struct logger_reader
*reader
;
461 reader
= kmalloc(sizeof(struct logger_reader
), GFP_KERNEL
);
466 INIT_LIST_HEAD(&reader
->list
);
468 mutex_lock(&log
->mutex
);
469 reader
->r_off
= log
->head
;
470 list_add_tail(&reader
->list
, &log
->readers
);
471 mutex_unlock(&log
->mutex
);
473 file
->private_data
= reader
;
475 file
->private_data
= log
;
481 * logger_release - the log's release file operation
483 * Note this is a total no-op in the write-only case. Keep it that way!
485 static int logger_release(struct inode
*ignored
, struct file
*file
)
487 if (file
->f_mode
& FMODE_READ
) {
488 struct logger_reader
*reader
= file
->private_data
;
489 struct logger_log
*log
= reader
->log
;
491 mutex_lock(&log
->mutex
);
492 list_del(&reader
->list
);
493 mutex_unlock(&log
->mutex
);
502 * logger_poll - the log's poll file operation, for poll/select/epoll
504 * Note we always return POLLOUT, because you can always write() to the log.
505 * Note also that, strictly speaking, a return value of POLLIN does not
506 * guarantee that the log is readable without blocking, as there is a small
507 * chance that the writer can lap the reader in the interim between poll()
508 * returning and the read() request.
510 static unsigned int logger_poll(struct file
*file
, poll_table
*wait
)
512 struct logger_reader
*reader
;
513 struct logger_log
*log
;
514 unsigned int ret
= POLLOUT
| POLLWRNORM
;
516 if (!(file
->f_mode
& FMODE_READ
))
519 reader
= file
->private_data
;
522 poll_wait(file
, &log
->wq
, wait
);
524 mutex_lock(&log
->mutex
);
525 if (log
->w_off
!= reader
->r_off
)
526 ret
|= POLLIN
| POLLRDNORM
;
527 mutex_unlock(&log
->mutex
);
532 static long logger_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
534 struct logger_log
*log
= file_get_log(file
);
535 struct logger_reader
*reader
;
538 mutex_lock(&log
->mutex
);
541 case LOGGER_GET_LOG_BUF_SIZE
:
544 case LOGGER_GET_LOG_LEN
:
545 if (!(file
->f_mode
& FMODE_READ
)) {
549 reader
= file
->private_data
;
550 if (log
->w_off
>= reader
->r_off
)
551 ret
= log
->w_off
- reader
->r_off
;
553 ret
= (log
->size
- reader
->r_off
) + log
->w_off
;
555 case LOGGER_GET_NEXT_ENTRY_LEN
:
556 if (!(file
->f_mode
& FMODE_READ
)) {
560 reader
= file
->private_data
;
561 if (log
->w_off
!= reader
->r_off
)
562 ret
= get_entry_len(log
, reader
->r_off
);
566 case LOGGER_FLUSH_LOG
:
567 if (!(file
->f_mode
& FMODE_WRITE
)) {
571 list_for_each_entry(reader
, &log
->readers
, list
)
572 reader
->r_off
= log
->w_off
;
573 log
->head
= log
->w_off
;
578 mutex_unlock(&log
->mutex
);
583 static const struct file_operations logger_fops
= {
584 .owner
= THIS_MODULE
,
586 .aio_write
= logger_aio_write
,
588 .unlocked_ioctl
= logger_ioctl
,
589 .compat_ioctl
= logger_ioctl
,
591 .release
= logger_release
,
595 * Log size must be a power of two, greater than LOGGER_ENTRY_MAX_LEN,
596 * and less than LONG_MAX minus LOGGER_ENTRY_MAX_LEN.
598 static int __init
create_log(char *log_name
, int size
)
601 struct logger_log
*log
;
602 unsigned char *buffer
;
604 buffer
= vmalloc(size
);
608 log
= kzalloc(sizeof(struct logger_log
), GFP_KERNEL
);
611 goto out_free_buffer
;
613 log
->buffer
= buffer
;
615 log
->misc
.minor
= MISC_DYNAMIC_MINOR
;
616 log
->misc
.name
= kstrdup(log_name
, GFP_KERNEL
);
617 if (log
->misc
.name
== NULL
) {
622 log
->misc
.fops
= &logger_fops
;
623 log
->misc
.parent
= NULL
;
625 init_waitqueue_head(&log
->wq
);
626 INIT_LIST_HEAD(&log
->readers
);
627 mutex_init(&log
->mutex
);
632 INIT_LIST_HEAD(&log
->logs
);
633 list_add_tail(&log
->logs
, &log_list
);
635 /* finally, initialize the misc device for this log */
636 ret
= misc_register(&log
->misc
);
638 pr_err("failed to register misc device for log '%s'!\n",
643 pr_info("created %luK log '%s'\n",
644 (unsigned long) log
->size
>> 10, log
->misc
.name
);
656 static int __init
logger_init(void)
660 ret
= create_log(LOGGER_LOG_MAIN
, 256*1024);
664 ret
= create_log(LOGGER_LOG_EVENTS
, 256*1024);
668 ret
= create_log(LOGGER_LOG_RADIO
, 256*1024);
672 ret
= create_log(LOGGER_LOG_SYSTEM
, 256*1024);
679 device_initcall(logger_init
);