* [RFC v3 1/9] printk: extract kmsg-related routines from printk.c to kmsg.c
2015-10-19 12:58 [RFC v3 0/9] Additional kmsg devices Paul Osmialowski
@ 2015-10-19 12:58 ` Paul Osmialowski
2015-10-19 13:53 ` kbuild test robot
2015-10-19 13:59 ` kbuild test robot
2015-10-19 12:58 ` [RFC v3 2/9] printk: add one function for storing log in proper format Paul Osmialowski
` (7 subsequent siblings)
8 siblings, 2 replies; 23+ messages in thread
From: Paul Osmialowski @ 2015-10-19 12:58 UTC (permalink / raw)
To: Jonathan Corbet, Arnd Bergmann, Andrew Morton, Petr Mladek,
Greg Kroah-Hartman, Daniel Mack, Kay Sievers, Joe Perches,
Tejun Heo, linux-kernel, linux-doc, linux-api
Cc: Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
Following suggestions regarding printk.c code bloat, I prepared this
patch which moves kmsg-related routines to new file, kmsg.c
This is premilinary step needed for an attempt to extent kmsg interface
with ability to dynamically create (and destroy) kmsg-like devices.
Signed-off-by: Paul Osmialowski <p.osmialowsk@samsung.com>
---
kernel/printk/Makefile | 1 +
kernel/printk/kmsg.c | 574 ++++++++++++++++++++++++++++++++++++++
kernel/printk/printk.c | 736 +------------------------------------------------
kernel/printk/printk.h | 221 +++++++++++++++
4 files changed, 810 insertions(+), 722 deletions(-)
create mode 100644 kernel/printk/kmsg.c
create mode 100644 kernel/printk/printk.h
diff --git a/kernel/printk/Makefile b/kernel/printk/Makefile
index 85405bd..bd6a4ec 100644
--- a/kernel/printk/Makefile
+++ b/kernel/printk/Makefile
@@ -1,2 +1,3 @@
obj-y = printk.o
+obj-$(CONFIG_PRINTK) += kmsg.o
obj-$(CONFIG_A11Y_BRAILLE_CONSOLE) += braille.o
diff --git a/kernel/printk/kmsg.c b/kernel/printk/kmsg.c
new file mode 100644
index 0000000..260b2ee
--- /dev/null
+++ b/kernel/printk/kmsg.c
@@ -0,0 +1,574 @@
+#include <linux/printk.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/fcntl.h>
+#include <linux/fs.h>
+#include <linux/kmsg_dump.h>
+#include <linux/moduleparam.h>
+#include <linux/mutex.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <linux/poll.h>
+#include <linux/rculist.h>
+#include <linux/rcupdate.h>
+#include <linux/stat.h>
+#include <linux/syslog.h>
+#include <linux/uio.h>
+#include <linux/wait.h>
+
+#include <asm/uaccess.h>
+
+#include "printk.h"
+
+/* /dev/kmsg - userspace message inject/listen interface */
+struct devkmsg_user {
+ u64 seq;
+ u32 idx;
+ enum log_flags prev;
+ struct mutex lock;
+ char buf[CONSOLE_EXT_LOG_MAX];
+};
+
+static ssize_t devkmsg_write(struct kiocb *iocb, struct iov_iter *from)
+{
+ char *buf, *line;
+ int i;
+ int level = default_message_loglevel;
+ int facility = 1; /* LOG_USER */
+ size_t len = iov_iter_count(from);
+ ssize_t ret = len;
+
+ if (len > LOG_LINE_MAX)
+ return -EINVAL;
+ buf = kmalloc(len+1, GFP_KERNEL);
+ if (buf == NULL)
+ return -ENOMEM;
+
+ buf[len] = '\0';
+ if (copy_from_iter(buf, len, from) != len) {
+ kfree(buf);
+ return -EFAULT;
+ }
+
+ /*
+ * Extract and skip the syslog prefix <[0-9]*>. Coming from userspace
+ * the decimal value represents 32bit, the lower 3 bit are the log
+ * level, the rest are the log facility.
+ *
+ * If no prefix or no userspace facility is specified, we
+ * enforce LOG_USER, to be able to reliably distinguish
+ * kernel-generated messages from userspace-injected ones.
+ */
+ line = buf;
+ if (line[0] == '<') {
+ char *endp = NULL;
+
+ i = simple_strtoul(line+1, &endp, 10);
+ if (endp && endp[0] == '>') {
+ level = i & 7;
+ if (i >> 3)
+ facility = i >> 3;
+ endp++;
+ len -= endp - line;
+ line = endp;
+ }
+ }
+
+ printk_emit(facility, level, NULL, 0, "%s", line);
+ kfree(buf);
+ return ret;
+}
+
+static ssize_t devkmsg_read(struct file *file, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct devkmsg_user *user = file->private_data;
+ struct printk_log *msg;
+ size_t len;
+ ssize_t ret;
+
+ if (!user)
+ return -EBADF;
+
+ ret = mutex_lock_interruptible(&user->lock);
+ if (ret)
+ return ret;
+ raw_spin_lock_irq(&logbuf_lock);
+ while (user->seq == log_next_seq) {
+ if (file->f_flags & O_NONBLOCK) {
+ ret = -EAGAIN;
+ raw_spin_unlock_irq(&logbuf_lock);
+ goto out;
+ }
+
+ raw_spin_unlock_irq(&logbuf_lock);
+ ret = wait_event_interruptible(log_wait,
+ user->seq != log_next_seq);
+ if (ret)
+ goto out;
+ raw_spin_lock_irq(&logbuf_lock);
+ }
+
+ if (user->seq < log_first_seq) {
+ /* our last seen message is gone, return error and reset */
+ user->idx = log_first_idx;
+ user->seq = log_first_seq;
+ ret = -EPIPE;
+ raw_spin_unlock_irq(&logbuf_lock);
+ goto out;
+ }
+
+ msg = log_from_idx(user->idx);
+ len = msg_print_ext_header(user->buf, sizeof(user->buf),
+ msg, user->seq, user->prev);
+ len += msg_print_ext_body(user->buf + len, sizeof(user->buf) - len,
+ log_dict(msg), msg->dict_len,
+ log_text(msg), msg->text_len);
+
+ user->prev = msg->flags;
+ user->idx = log_next(user->idx);
+ user->seq++;
+ raw_spin_unlock_irq(&logbuf_lock);
+
+ if (len > count) {
+ ret = -EINVAL;
+ goto out;
+ }
+
+ if (copy_to_user(buf, user->buf, len)) {
+ ret = -EFAULT;
+ goto out;
+ }
+ ret = len;
+out:
+ mutex_unlock(&user->lock);
+ return ret;
+}
+
+static loff_t devkmsg_llseek(struct file *file, loff_t offset, int whence)
+{
+ struct devkmsg_user *user = file->private_data;
+ loff_t ret = 0;
+
+ if (!user)
+ return -EBADF;
+ if (offset)
+ return -ESPIPE;
+
+ raw_spin_lock_irq(&logbuf_lock);
+ switch (whence) {
+ case SEEK_SET:
+ /* the first record */
+ user->idx = log_first_idx;
+ user->seq = log_first_seq;
+ break;
+ case SEEK_DATA:
+ /*
+ * The first record after the last SYSLOG_ACTION_CLEAR,
+ * like issued by 'dmesg -c'. Reading /dev/kmsg itself
+ * changes no global state, and does not clear anything.
+ */
+ user->idx = clear_idx;
+ user->seq = clear_seq;
+ break;
+ case SEEK_END:
+ /* after the last record */
+ user->idx = log_next_idx;
+ user->seq = log_next_seq;
+ break;
+ default:
+ ret = -EINVAL;
+ }
+ raw_spin_unlock_irq(&logbuf_lock);
+ return ret;
+}
+
+static unsigned int devkmsg_poll(struct file *file, poll_table *wait)
+{
+ struct devkmsg_user *user = file->private_data;
+ int ret = 0;
+
+ if (!user)
+ return POLLERR|POLLNVAL;
+
+ poll_wait(file, &log_wait, wait);
+
+ raw_spin_lock_irq(&logbuf_lock);
+ if (user->seq < log_next_seq) {
+ /* return error when data has vanished underneath us */
+ if (user->seq < log_first_seq)
+ ret = POLLIN|POLLRDNORM|POLLERR|POLLPRI;
+ else
+ ret = POLLIN|POLLRDNORM;
+ }
+ raw_spin_unlock_irq(&logbuf_lock);
+
+ return ret;
+}
+
+static int devkmsg_open(struct inode *inode, struct file *file)
+{
+ struct devkmsg_user *user;
+ int err;
+
+ /* write-only does not need any file context */
+ if ((file->f_flags & O_ACCMODE) == O_WRONLY)
+ return 0;
+
+ err = check_syslog_permissions(SYSLOG_ACTION_READ_ALL,
+ SYSLOG_FROM_READER);
+ if (err)
+ return err;
+
+ user = kmalloc(sizeof(struct devkmsg_user), GFP_KERNEL);
+ if (!user)
+ return -ENOMEM;
+
+ mutex_init(&user->lock);
+
+ raw_spin_lock_irq(&logbuf_lock);
+ user->idx = log_first_idx;
+ user->seq = log_first_seq;
+ raw_spin_unlock_irq(&logbuf_lock);
+
+ file->private_data = user;
+ return 0;
+}
+
+static int devkmsg_release(struct inode *inode, struct file *file)
+{
+ struct devkmsg_user *user = file->private_data;
+
+ if (!user)
+ return 0;
+
+ mutex_destroy(&user->lock);
+ kfree(user);
+ return 0;
+}
+
+const struct file_operations kmsg_fops = {
+ .open = devkmsg_open,
+ .read = devkmsg_read,
+ .write_iter = devkmsg_write,
+ .llseek = devkmsg_llseek,
+ .poll = devkmsg_poll,
+ .release = devkmsg_release,
+};
+
+static DEFINE_SPINLOCK(dump_list_lock);
+static LIST_HEAD(dump_list);
+
+/**
+ * kmsg_dump_register - register a kernel log dumper.
+ * @dumper: pointer to the kmsg_dumper structure
+ *
+ * Adds a kernel log dumper to the system. The dump callback in the
+ * structure will be called when the kernel oopses or panics and must be
+ * set. Returns zero on success and %-EINVAL or %-EBUSY otherwise.
+ */
+int kmsg_dump_register(struct kmsg_dumper *dumper)
+{
+ unsigned long flags;
+ int err = -EBUSY;
+
+ /* The dump callback needs to be set */
+ if (!dumper->dump)
+ return -EINVAL;
+
+ spin_lock_irqsave(&dump_list_lock, flags);
+ /* Don't allow registering multiple times */
+ if (!dumper->registered) {
+ dumper->registered = 1;
+ list_add_tail_rcu(&dumper->list, &dump_list);
+ err = 0;
+ }
+ spin_unlock_irqrestore(&dump_list_lock, flags);
+
+ return err;
+}
+EXPORT_SYMBOL_GPL(kmsg_dump_register);
+
+/**
+ * kmsg_dump_unregister - unregister a kmsg dumper.
+ * @dumper: pointer to the kmsg_dumper structure
+ *
+ * Removes a dump device from the system. Returns zero on success and
+ * %-EINVAL otherwise.
+ */
+int kmsg_dump_unregister(struct kmsg_dumper *dumper)
+{
+ unsigned long flags;
+ int err = -EINVAL;
+
+ spin_lock_irqsave(&dump_list_lock, flags);
+ if (dumper->registered) {
+ dumper->registered = 0;
+ list_del_rcu(&dumper->list);
+ err = 0;
+ }
+ spin_unlock_irqrestore(&dump_list_lock, flags);
+ synchronize_rcu();
+
+ return err;
+}
+EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
+
+static bool always_kmsg_dump;
+module_param_named(always_kmsg_dump, always_kmsg_dump, bool, S_IRUGO | S_IWUSR);
+
+/**
+ * kmsg_dump - dump kernel log to kernel message dumpers.
+ * @reason: the reason (oops, panic etc) for dumping
+ *
+ * Call each of the registered dumper's dump() callback, which can
+ * retrieve the kmsg records with kmsg_dump_get_line() or
+ * kmsg_dump_get_buffer().
+ */
+void kmsg_dump(enum kmsg_dump_reason reason)
+{
+ struct kmsg_dumper *dumper;
+ unsigned long flags;
+
+ if ((reason > KMSG_DUMP_OOPS) && !always_kmsg_dump)
+ return;
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(dumper, &dump_list, list) {
+ if (dumper->max_reason && reason > dumper->max_reason)
+ continue;
+
+ /* initialize iterator with data about the stored records */
+ dumper->active = true;
+
+ raw_spin_lock_irqsave(&logbuf_lock, flags);
+ dumper->cur_seq = clear_seq;
+ dumper->cur_idx = clear_idx;
+ dumper->next_seq = log_next_seq;
+ dumper->next_idx = log_next_idx;
+ raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+
+ /* invoke dumper which will iterate over records */
+ dumper->dump(dumper, reason);
+
+ /* reset iterator */
+ dumper->active = false;
+ }
+ rcu_read_unlock();
+}
+
+/**
+ * kmsg_dump_get_line_nolock - retrieve one kmsg log line (unlocked version)
+ * @dumper: registered kmsg dumper
+ * @syslog: include the "<4>" prefixes
+ * @line: buffer to copy the line to
+ * @size: maximum size of the buffer
+ * @len: length of line placed into buffer
+ *
+ * Start at the beginning of the kmsg buffer, with the oldest kmsg
+ * record, and copy one record into the provided buffer.
+ *
+ * Consecutive calls will return the next available record moving
+ * towards the end of the buffer with the youngest messages.
+ *
+ * A return value of FALSE indicates that there are no more records to
+ * read.
+ *
+ * The function is similar to kmsg_dump_get_line(), but grabs no locks.
+ */
+bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog,
+ char *line, size_t size, size_t *len)
+{
+ struct printk_log *msg;
+ size_t l = 0;
+ bool ret = false;
+
+ if (!dumper->active)
+ goto out;
+
+ if (dumper->cur_seq < log_first_seq) {
+ /* messages are gone, move to first available one */
+ dumper->cur_seq = log_first_seq;
+ dumper->cur_idx = log_first_idx;
+ }
+
+ /* last entry */
+ if (dumper->cur_seq >= log_next_seq)
+ goto out;
+
+ msg = log_from_idx(dumper->cur_idx);
+ l = msg_print_text(msg, 0, syslog, line, size);
+
+ dumper->cur_idx = log_next(dumper->cur_idx);
+ dumper->cur_seq++;
+ ret = true;
+out:
+ if (len)
+ *len = l;
+ return ret;
+}
+
+/**
+ * kmsg_dump_get_line - retrieve one kmsg log line
+ * @dumper: registered kmsg dumper
+ * @syslog: include the "<4>" prefixes
+ * @line: buffer to copy the line to
+ * @size: maximum size of the buffer
+ * @len: length of line placed into buffer
+ *
+ * Start at the beginning of the kmsg buffer, with the oldest kmsg
+ * record, and copy one record into the provided buffer.
+ *
+ * Consecutive calls will return the next available record moving
+ * towards the end of the buffer with the youngest messages.
+ *
+ * A return value of FALSE indicates that there are no more records to
+ * read.
+ */
+bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog,
+ char *line, size_t size, size_t *len)
+{
+ unsigned long flags;
+ bool ret;
+
+ raw_spin_lock_irqsave(&logbuf_lock, flags);
+ ret = kmsg_dump_get_line_nolock(dumper, syslog, line, size, len);
+ raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(kmsg_dump_get_line);
+
+/**
+ * kmsg_dump_get_buffer - copy kmsg log lines
+ * @dumper: registered kmsg dumper
+ * @syslog: include the "<4>" prefixes
+ * @buf: buffer to copy the line to
+ * @size: maximum size of the buffer
+ * @len: length of line placed into buffer
+ *
+ * Start at the end of the kmsg buffer and fill the provided buffer
+ * with as many of the the *youngest* kmsg records that fit into it.
+ * If the buffer is large enough, all available kmsg records will be
+ * copied with a single call.
+ *
+ * Consecutive calls will fill the buffer with the next block of
+ * available older records, not including the earlier retrieved ones.
+ *
+ * A return value of FALSE indicates that there are no more records to
+ * read.
+ */
+bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
+ char *buf, size_t size, size_t *len)
+{
+ unsigned long flags;
+ u64 seq;
+ u32 idx;
+ u64 next_seq;
+ u32 next_idx;
+ enum log_flags prev;
+ size_t l = 0;
+ bool ret = false;
+
+ if (!dumper->active)
+ goto out;
+
+ raw_spin_lock_irqsave(&logbuf_lock, flags);
+ if (dumper->cur_seq < log_first_seq) {
+ /* messages are gone, move to first available one */
+ dumper->cur_seq = log_first_seq;
+ dumper->cur_idx = log_first_idx;
+ }
+
+ /* last entry */
+ if (dumper->cur_seq >= dumper->next_seq) {
+ raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+ goto out;
+ }
+
+ /* calculate length of entire buffer */
+ seq = dumper->cur_seq;
+ idx = dumper->cur_idx;
+ prev = 0;
+ while (seq < dumper->next_seq) {
+ struct printk_log *msg = log_from_idx(idx);
+
+ l += msg_print_text(msg, prev, true, NULL, 0);
+ idx = log_next(idx);
+ seq++;
+ prev = msg->flags;
+ }
+
+ /* move first record forward until length fits into the buffer */
+ seq = dumper->cur_seq;
+ idx = dumper->cur_idx;
+ prev = 0;
+ while (l > size && seq < dumper->next_seq) {
+ struct printk_log *msg = log_from_idx(idx);
+
+ l -= msg_print_text(msg, prev, true, NULL, 0);
+ idx = log_next(idx);
+ seq++;
+ prev = msg->flags;
+ }
+
+ /* last message in next interation */
+ next_seq = seq;
+ next_idx = idx;
+
+ l = 0;
+ while (seq < dumper->next_seq) {
+ struct printk_log *msg = log_from_idx(idx);
+
+ l += msg_print_text(msg, prev, syslog, buf + l, size - l);
+ idx = log_next(idx);
+ seq++;
+ prev = msg->flags;
+ }
+
+ dumper->next_seq = next_seq;
+ dumper->next_idx = next_idx;
+ ret = true;
+ raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+out:
+ if (len)
+ *len = l;
+ return ret;
+}
+EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
+
+/**
+ * kmsg_dump_rewind_nolock - reset the interator (unlocked version)
+ * @dumper: registered kmsg dumper
+ *
+ * Reset the dumper's iterator so that kmsg_dump_get_line() and
+ * kmsg_dump_get_buffer() can be called again and used multiple
+ * times within the same dumper.dump() callback.
+ *
+ * The function is similar to kmsg_dump_rewind(), but grabs no locks.
+ */
+void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper)
+{
+ dumper->cur_seq = clear_seq;
+ dumper->cur_idx = clear_idx;
+ dumper->next_seq = log_next_seq;
+ dumper->next_idx = log_next_idx;
+}
+
+/**
+ * kmsg_dump_rewind - reset the interator
+ * @dumper: registered kmsg dumper
+ *
+ * Reset the dumper's iterator so that kmsg_dump_get_line() and
+ * kmsg_dump_get_buffer() can be called again and used multiple
+ * times within the same dumper.dump() callback.
+ */
+void kmsg_dump_rewind(struct kmsg_dumper *dumper)
+{
+ unsigned long flags;
+
+ raw_spin_lock_irqsave(&logbuf_lock, flags);
+ kmsg_dump_rewind_nolock(dumper);
+ raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+}
+EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index 8f0324e..50c48c7 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -25,7 +25,6 @@
#include <linux/jiffies.h>
#include <linux/nmi.h>
#include <linux/module.h>
-#include <linux/moduleparam.h>
#include <linux/interrupt.h> /* For in_interrupt() */
#include <linux/delay.h>
#include <linux/smp.h>
@@ -36,22 +35,19 @@
#include <linux/kexec.h>
#include <linux/kdb.h>
#include <linux/ratelimit.h>
-#include <linux/kmsg_dump.h>
#include <linux/syslog.h>
#include <linux/cpu.h>
#include <linux/notifier.h>
-#include <linux/rculist.h>
-#include <linux/poll.h>
#include <linux/irq_work.h>
#include <linux/utsname.h>
#include <linux/ctype.h>
-#include <linux/uio.h>
#include <asm/uaccess.h>
#define CREATE_TRACE_POINTS
#include <trace/events/printk.h>
+#include "printk.h"
#include "console_cmdline.h"
#include "braille.h"
@@ -150,96 +146,7 @@ EXPORT_SYMBOL(console_set_on_cmdline);
/* Flag: console code may call schedule() */
static int console_may_schedule;
-/*
- * The printk log buffer consists of a chain of concatenated variable
- * length records. Every record starts with a record header, containing
- * the overall length of the record.
- *
- * The heads to the first and last entry in the buffer, as well as the
- * sequence numbers of these entries are maintained when messages are
- * stored.
- *
- * If the heads indicate available messages, the length in the header
- * tells the start next message. A length == 0 for the next message
- * indicates a wrap-around to the beginning of the buffer.
- *
- * Every record carries the monotonic timestamp in microseconds, as well as
- * the standard userspace syslog level and syslog facility. The usual
- * kernel messages use LOG_KERN; userspace-injected messages always carry
- * a matching syslog facility, by default LOG_USER. The origin of every
- * message can be reliably determined that way.
- *
- * The human readable log message directly follows the message header. The
- * length of the message text is stored in the header, the stored message
- * is not terminated.
- *
- * Optionally, a message can carry a dictionary of properties (key/value pairs),
- * to provide userspace with a machine-readable message context.
- *
- * Examples for well-defined, commonly used property names are:
- * DEVICE=b12:8 device identifier
- * b12:8 block dev_t
- * c127:3 char dev_t
- * n8 netdev ifindex
- * +sound:card0 subsystem:devname
- * SUBSYSTEM=pci driver-core subsystem name
- *
- * Valid characters in property names are [a-zA-Z0-9.-_]. The plain text value
- * follows directly after a '=' character. Every property is terminated by
- * a '\0' character. The last property is not terminated.
- *
- * Example of a message structure:
- * 0000 ff 8f 00 00 00 00 00 00 monotonic time in nsec
- * 0008 34 00 record is 52 bytes long
- * 000a 0b 00 text is 11 bytes long
- * 000c 1f 00 dictionary is 23 bytes long
- * 000e 03 00 LOG_KERN (facility) LOG_ERR (level)
- * 0010 69 74 27 73 20 61 20 6c "it's a l"
- * 69 6e 65 "ine"
- * 001b 44 45 56 49 43 "DEVIC"
- * 45 3d 62 38 3a 32 00 44 "E=b8:2\0D"
- * 52 49 56 45 52 3d 62 75 "RIVER=bu"
- * 67 "g"
- * 0032 00 00 00 padding to next message header
- *
- * The 'struct printk_log' buffer header must never be directly exported to
- * userspace, it is a kernel-private implementation detail that might
- * need to be changed in the future, when the requirements change.
- *
- * /dev/kmsg exports the structured data in the following line format:
- * "<level>,<sequnum>,<timestamp>,<contflag>[,additional_values, ... ];<message text>\n"
- *
- * Users of the export format should ignore possible additional values
- * separated by ',', and find the message after the ';' character.
- *
- * The optional key/value pairs are attached as continuation lines starting
- * with a space character and terminated by a newline. All possible
- * non-prinatable characters are escaped in the "\xff" notation.
- */
-
-enum log_flags {
- LOG_NOCONS = 1, /* already flushed, do not print to console */
- LOG_NEWLINE = 2, /* text ended with a newline */
- LOG_PREFIX = 4, /* text started with a prefix */
- LOG_CONT = 8, /* text is a fragment of a continuation line */
-};
-
-struct printk_log {
- u64 ts_nsec; /* timestamp in nanoseconds */
- u16 len; /* length of entire record */
- u16 text_len; /* length of text buffer */
- u16 dict_len; /* length of dictionary buffer */
- u8 facility; /* syslog facility */
- u8 flags:5; /* internal record flags */
- u8 level:3; /* syslog level */
-};
-
-/*
- * The logbuf_lock protects kmsg buffer, indices, counters. This can be taken
- * within the scheduler's rq lock. It must be released before calling
- * console_unlock() or anything else that might wake up a process.
- */
-static DEFINE_RAW_SPINLOCK(logbuf_lock);
+DEFINE_RAW_SPINLOCK(logbuf_lock);
#ifdef CONFIG_PRINTK
DECLARE_WAIT_QUEUE_HEAD(log_wait);
@@ -249,25 +156,19 @@ static u32 syslog_idx;
static enum log_flags syslog_prev;
static size_t syslog_partial;
-/* index and sequence number of the first record stored in the buffer */
-static u64 log_first_seq;
-static u32 log_first_idx;
-
-/* index and sequence number of the next record to store in the buffer */
-static u64 log_next_seq;
-static u32 log_next_idx;
-
/* the next printk record to write to the console */
static u64 console_seq;
static u32 console_idx;
static enum log_flags console_prev;
-/* the next printk record to read after the last 'clear' command */
-static u64 clear_seq;
-static u32 clear_idx;
+u64 log_first_seq;
+u32 log_first_idx;
-#define PREFIX_MAX 32
-#define LOG_LINE_MAX (1024 - PREFIX_MAX)
+u64 log_next_seq;
+u32 log_next_idx;
+
+u64 clear_seq;
+u32 clear_idx;
/* record buffer */
#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
@@ -292,50 +193,6 @@ u32 log_buf_len_get(void)
return log_buf_len;
}
-/* human readable text of the record */
-static char *log_text(const struct printk_log *msg)
-{
- return (char *)msg + sizeof(struct printk_log);
-}
-
-/* optional key/value pair dictionary attached to the record */
-static char *log_dict(const struct printk_log *msg)
-{
- return (char *)msg + sizeof(struct printk_log) + msg->text_len;
-}
-
-/* get record by index; idx must point to valid msg */
-static struct printk_log *log_from_idx(u32 idx)
-{
- struct printk_log *msg = (struct printk_log *)(log_buf + idx);
-
- /*
- * A length == 0 record is the end of buffer marker. Wrap around and
- * read the message at the start of the buffer.
- */
- if (!msg->len)
- return (struct printk_log *)log_buf;
- return msg;
-}
-
-/* get next record; idx must point to valid msg */
-static u32 log_next(u32 idx)
-{
- struct printk_log *msg = (struct printk_log *)(log_buf + idx);
-
- /* length == 0 indicates the end of the buffer; wrap */
- /*
- * A length == 0 record is the end of buffer marker. Wrap around and
- * read the message at the start of the buffer as *this* one, and
- * return the one after that.
- */
- if (!msg->len) {
- msg = (struct printk_log *)log_buf;
- return msg->len;
- }
- return idx + msg->len;
-}
-
/*
* Check whether there is enough free space for the given message.
*
@@ -524,8 +381,8 @@ static void append_char(char **pp, char *e, char c)
*(*pp)++ = c;
}
-static ssize_t msg_print_ext_header(char *buf, size_t size,
- struct printk_log *msg, u64 seq,
+ssize_t msg_print_ext_header(char *buf, size_t size,
+ struct printk_log *msg, u64 seq,
enum log_flags prev_flags)
{
u64 ts_usec = msg->ts_nsec;
@@ -551,7 +408,7 @@ static ssize_t msg_print_ext_header(char *buf, size_t size,
(msg->facility << 3) | msg->level, seq, ts_usec, cont);
}
-static ssize_t msg_print_ext_body(char *buf, size_t size,
+ssize_t msg_print_ext_body(char *buf, size_t size,
char *dict, size_t dict_len,
char *text, size_t text_len)
{
@@ -599,242 +456,6 @@ static ssize_t msg_print_ext_body(char *buf, size_t size,
return p - buf;
}
-/* /dev/kmsg - userspace message inject/listen interface */
-struct devkmsg_user {
- u64 seq;
- u32 idx;
- enum log_flags prev;
- struct mutex lock;
- char buf[CONSOLE_EXT_LOG_MAX];
-};
-
-static ssize_t devkmsg_write(struct kiocb *iocb, struct iov_iter *from)
-{
- char *buf, *line;
- int i;
- int level = default_message_loglevel;
- int facility = 1; /* LOG_USER */
- size_t len = iov_iter_count(from);
- ssize_t ret = len;
-
- if (len > LOG_LINE_MAX)
- return -EINVAL;
- buf = kmalloc(len+1, GFP_KERNEL);
- if (buf == NULL)
- return -ENOMEM;
-
- buf[len] = '\0';
- if (copy_from_iter(buf, len, from) != len) {
- kfree(buf);
- return -EFAULT;
- }
-
- /*
- * Extract and skip the syslog prefix <[0-9]*>. Coming from userspace
- * the decimal value represents 32bit, the lower 3 bit are the log
- * level, the rest are the log facility.
- *
- * If no prefix or no userspace facility is specified, we
- * enforce LOG_USER, to be able to reliably distinguish
- * kernel-generated messages from userspace-injected ones.
- */
- line = buf;
- if (line[0] == '<') {
- char *endp = NULL;
-
- i = simple_strtoul(line+1, &endp, 10);
- if (endp && endp[0] == '>') {
- level = i & 7;
- if (i >> 3)
- facility = i >> 3;
- endp++;
- len -= endp - line;
- line = endp;
- }
- }
-
- printk_emit(facility, level, NULL, 0, "%s", line);
- kfree(buf);
- return ret;
-}
-
-static ssize_t devkmsg_read(struct file *file, char __user *buf,
- size_t count, loff_t *ppos)
-{
- struct devkmsg_user *user = file->private_data;
- struct printk_log *msg;
- size_t len;
- ssize_t ret;
-
- if (!user)
- return -EBADF;
-
- ret = mutex_lock_interruptible(&user->lock);
- if (ret)
- return ret;
- raw_spin_lock_irq(&logbuf_lock);
- while (user->seq == log_next_seq) {
- if (file->f_flags & O_NONBLOCK) {
- ret = -EAGAIN;
- raw_spin_unlock_irq(&logbuf_lock);
- goto out;
- }
-
- raw_spin_unlock_irq(&logbuf_lock);
- ret = wait_event_interruptible(log_wait,
- user->seq != log_next_seq);
- if (ret)
- goto out;
- raw_spin_lock_irq(&logbuf_lock);
- }
-
- if (user->seq < log_first_seq) {
- /* our last seen message is gone, return error and reset */
- user->idx = log_first_idx;
- user->seq = log_first_seq;
- ret = -EPIPE;
- raw_spin_unlock_irq(&logbuf_lock);
- goto out;
- }
-
- msg = log_from_idx(user->idx);
- len = msg_print_ext_header(user->buf, sizeof(user->buf),
- msg, user->seq, user->prev);
- len += msg_print_ext_body(user->buf + len, sizeof(user->buf) - len,
- log_dict(msg), msg->dict_len,
- log_text(msg), msg->text_len);
-
- user->prev = msg->flags;
- user->idx = log_next(user->idx);
- user->seq++;
- raw_spin_unlock_irq(&logbuf_lock);
-
- if (len > count) {
- ret = -EINVAL;
- goto out;
- }
-
- if (copy_to_user(buf, user->buf, len)) {
- ret = -EFAULT;
- goto out;
- }
- ret = len;
-out:
- mutex_unlock(&user->lock);
- return ret;
-}
-
-static loff_t devkmsg_llseek(struct file *file, loff_t offset, int whence)
-{
- struct devkmsg_user *user = file->private_data;
- loff_t ret = 0;
-
- if (!user)
- return -EBADF;
- if (offset)
- return -ESPIPE;
-
- raw_spin_lock_irq(&logbuf_lock);
- switch (whence) {
- case SEEK_SET:
- /* the first record */
- user->idx = log_first_idx;
- user->seq = log_first_seq;
- break;
- case SEEK_DATA:
- /*
- * The first record after the last SYSLOG_ACTION_CLEAR,
- * like issued by 'dmesg -c'. Reading /dev/kmsg itself
- * changes no global state, and does not clear anything.
- */
- user->idx = clear_idx;
- user->seq = clear_seq;
- break;
- case SEEK_END:
- /* after the last record */
- user->idx = log_next_idx;
- user->seq = log_next_seq;
- break;
- default:
- ret = -EINVAL;
- }
- raw_spin_unlock_irq(&logbuf_lock);
- return ret;
-}
-
-static unsigned int devkmsg_poll(struct file *file, poll_table *wait)
-{
- struct devkmsg_user *user = file->private_data;
- int ret = 0;
-
- if (!user)
- return POLLERR|POLLNVAL;
-
- poll_wait(file, &log_wait, wait);
-
- raw_spin_lock_irq(&logbuf_lock);
- if (user->seq < log_next_seq) {
- /* return error when data has vanished underneath us */
- if (user->seq < log_first_seq)
- ret = POLLIN|POLLRDNORM|POLLERR|POLLPRI;
- else
- ret = POLLIN|POLLRDNORM;
- }
- raw_spin_unlock_irq(&logbuf_lock);
-
- return ret;
-}
-
-static int devkmsg_open(struct inode *inode, struct file *file)
-{
- struct devkmsg_user *user;
- int err;
-
- /* write-only does not need any file context */
- if ((file->f_flags & O_ACCMODE) == O_WRONLY)
- return 0;
-
- err = check_syslog_permissions(SYSLOG_ACTION_READ_ALL,
- SYSLOG_FROM_READER);
- if (err)
- return err;
-
- user = kmalloc(sizeof(struct devkmsg_user), GFP_KERNEL);
- if (!user)
- return -ENOMEM;
-
- mutex_init(&user->lock);
-
- raw_spin_lock_irq(&logbuf_lock);
- user->idx = log_first_idx;
- user->seq = log_first_seq;
- raw_spin_unlock_irq(&logbuf_lock);
-
- file->private_data = user;
- return 0;
-}
-
-static int devkmsg_release(struct inode *inode, struct file *file)
-{
- struct devkmsg_user *user = file->private_data;
-
- if (!user)
- return 0;
-
- mutex_destroy(&user->lock);
- kfree(user);
- return 0;
-}
-
-const struct file_operations kmsg_fops = {
- .open = devkmsg_open,
- .read = devkmsg_read,
- .write_iter = devkmsg_write,
- .llseek = devkmsg_llseek,
- .poll = devkmsg_poll,
- .release = devkmsg_release,
-};
-
#ifdef CONFIG_KEXEC_CORE
/*
* This appends the listed symbols to /proc/vmcore
@@ -1072,8 +693,8 @@ static size_t print_prefix(const struct printk_log *msg, bool syslog, char *buf)
return len;
}
-static size_t msg_print_text(const struct printk_log *msg, enum log_flags prev,
- bool syslog, char *buf, size_t size)
+size_t msg_print_text(const struct printk_log *msg, enum log_flags prev,
+ bool syslog, char *buf, size_t size)
{
const char *text = log_text(msg);
size_t text_size = msg->text_len;
@@ -1935,21 +1556,9 @@ static struct cont {
u8 level;
bool flushed:1;
} cont;
-static char *log_text(const struct printk_log *msg) { return NULL; }
-static char *log_dict(const struct printk_log *msg) { return NULL; }
-static struct printk_log *log_from_idx(u32 idx) { return NULL; }
-static u32 log_next(u32 idx) { return 0; }
-static ssize_t msg_print_ext_header(char *buf, size_t size,
- struct printk_log *msg, u64 seq,
- enum log_flags prev_flags) { return 0; }
-static ssize_t msg_print_ext_body(char *buf, size_t size,
- char *dict, size_t dict_len,
- char *text, size_t text_len) { return 0; }
static void call_console_drivers(int level,
const char *ext_text, size_t ext_len,
const char *text, size_t len) {}
-static size_t msg_print_text(const struct printk_log *msg, enum log_flags prev,
- bool syslog, char *buf, size_t size) { return 0; }
static size_t cont_print_text(char *text, size_t size) { return 0; }
/* Still needs to be defined for users */
@@ -2759,323 +2368,6 @@ bool printk_timed_ratelimit(unsigned long *caller_jiffies,
}
EXPORT_SYMBOL(printk_timed_ratelimit);
-static DEFINE_SPINLOCK(dump_list_lock);
-static LIST_HEAD(dump_list);
-
-/**
- * kmsg_dump_register - register a kernel log dumper.
- * @dumper: pointer to the kmsg_dumper structure
- *
- * Adds a kernel log dumper to the system. The dump callback in the
- * structure will be called when the kernel oopses or panics and must be
- * set. Returns zero on success and %-EINVAL or %-EBUSY otherwise.
- */
-int kmsg_dump_register(struct kmsg_dumper *dumper)
-{
- unsigned long flags;
- int err = -EBUSY;
-
- /* The dump callback needs to be set */
- if (!dumper->dump)
- return -EINVAL;
-
- spin_lock_irqsave(&dump_list_lock, flags);
- /* Don't allow registering multiple times */
- if (!dumper->registered) {
- dumper->registered = 1;
- list_add_tail_rcu(&dumper->list, &dump_list);
- err = 0;
- }
- spin_unlock_irqrestore(&dump_list_lock, flags);
-
- return err;
-}
-EXPORT_SYMBOL_GPL(kmsg_dump_register);
-
-/**
- * kmsg_dump_unregister - unregister a kmsg dumper.
- * @dumper: pointer to the kmsg_dumper structure
- *
- * Removes a dump device from the system. Returns zero on success and
- * %-EINVAL otherwise.
- */
-int kmsg_dump_unregister(struct kmsg_dumper *dumper)
-{
- unsigned long flags;
- int err = -EINVAL;
-
- spin_lock_irqsave(&dump_list_lock, flags);
- if (dumper->registered) {
- dumper->registered = 0;
- list_del_rcu(&dumper->list);
- err = 0;
- }
- spin_unlock_irqrestore(&dump_list_lock, flags);
- synchronize_rcu();
-
- return err;
-}
-EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
-
-static bool always_kmsg_dump;
-module_param_named(always_kmsg_dump, always_kmsg_dump, bool, S_IRUGO | S_IWUSR);
-
-/**
- * kmsg_dump - dump kernel log to kernel message dumpers.
- * @reason: the reason (oops, panic etc) for dumping
- *
- * Call each of the registered dumper's dump() callback, which can
- * retrieve the kmsg records with kmsg_dump_get_line() or
- * kmsg_dump_get_buffer().
- */
-void kmsg_dump(enum kmsg_dump_reason reason)
-{
- struct kmsg_dumper *dumper;
- unsigned long flags;
-
- if ((reason > KMSG_DUMP_OOPS) && !always_kmsg_dump)
- return;
-
- rcu_read_lock();
- list_for_each_entry_rcu(dumper, &dump_list, list) {
- if (dumper->max_reason && reason > dumper->max_reason)
- continue;
-
- /* initialize iterator with data about the stored records */
- dumper->active = true;
-
- raw_spin_lock_irqsave(&logbuf_lock, flags);
- dumper->cur_seq = clear_seq;
- dumper->cur_idx = clear_idx;
- dumper->next_seq = log_next_seq;
- dumper->next_idx = log_next_idx;
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
-
- /* invoke dumper which will iterate over records */
- dumper->dump(dumper, reason);
-
- /* reset iterator */
- dumper->active = false;
- }
- rcu_read_unlock();
-}
-
-/**
- * kmsg_dump_get_line_nolock - retrieve one kmsg log line (unlocked version)
- * @dumper: registered kmsg dumper
- * @syslog: include the "<4>" prefixes
- * @line: buffer to copy the line to
- * @size: maximum size of the buffer
- * @len: length of line placed into buffer
- *
- * Start at the beginning of the kmsg buffer, with the oldest kmsg
- * record, and copy one record into the provided buffer.
- *
- * Consecutive calls will return the next available record moving
- * towards the end of the buffer with the youngest messages.
- *
- * A return value of FALSE indicates that there are no more records to
- * read.
- *
- * The function is similar to kmsg_dump_get_line(), but grabs no locks.
- */
-bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog,
- char *line, size_t size, size_t *len)
-{
- struct printk_log *msg;
- size_t l = 0;
- bool ret = false;
-
- if (!dumper->active)
- goto out;
-
- if (dumper->cur_seq < log_first_seq) {
- /* messages are gone, move to first available one */
- dumper->cur_seq = log_first_seq;
- dumper->cur_idx = log_first_idx;
- }
-
- /* last entry */
- if (dumper->cur_seq >= log_next_seq)
- goto out;
-
- msg = log_from_idx(dumper->cur_idx);
- l = msg_print_text(msg, 0, syslog, line, size);
-
- dumper->cur_idx = log_next(dumper->cur_idx);
- dumper->cur_seq++;
- ret = true;
-out:
- if (len)
- *len = l;
- return ret;
-}
-
-/**
- * kmsg_dump_get_line - retrieve one kmsg log line
- * @dumper: registered kmsg dumper
- * @syslog: include the "<4>" prefixes
- * @line: buffer to copy the line to
- * @size: maximum size of the buffer
- * @len: length of line placed into buffer
- *
- * Start at the beginning of the kmsg buffer, with the oldest kmsg
- * record, and copy one record into the provided buffer.
- *
- * Consecutive calls will return the next available record moving
- * towards the end of the buffer with the youngest messages.
- *
- * A return value of FALSE indicates that there are no more records to
- * read.
- */
-bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog,
- char *line, size_t size, size_t *len)
-{
- unsigned long flags;
- bool ret;
-
- raw_spin_lock_irqsave(&logbuf_lock, flags);
- ret = kmsg_dump_get_line_nolock(dumper, syslog, line, size, len);
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
-
- return ret;
-}
-EXPORT_SYMBOL_GPL(kmsg_dump_get_line);
-
-/**
- * kmsg_dump_get_buffer - copy kmsg log lines
- * @dumper: registered kmsg dumper
- * @syslog: include the "<4>" prefixes
- * @buf: buffer to copy the line to
- * @size: maximum size of the buffer
- * @len: length of line placed into buffer
- *
- * Start at the end of the kmsg buffer and fill the provided buffer
- * with as many of the the *youngest* kmsg records that fit into it.
- * If the buffer is large enough, all available kmsg records will be
- * copied with a single call.
- *
- * Consecutive calls will fill the buffer with the next block of
- * available older records, not including the earlier retrieved ones.
- *
- * A return value of FALSE indicates that there are no more records to
- * read.
- */
-bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
- char *buf, size_t size, size_t *len)
-{
- unsigned long flags;
- u64 seq;
- u32 idx;
- u64 next_seq;
- u32 next_idx;
- enum log_flags prev;
- size_t l = 0;
- bool ret = false;
-
- if (!dumper->active)
- goto out;
-
- raw_spin_lock_irqsave(&logbuf_lock, flags);
- if (dumper->cur_seq < log_first_seq) {
- /* messages are gone, move to first available one */
- dumper->cur_seq = log_first_seq;
- dumper->cur_idx = log_first_idx;
- }
-
- /* last entry */
- if (dumper->cur_seq >= dumper->next_seq) {
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
- goto out;
- }
-
- /* calculate length of entire buffer */
- seq = dumper->cur_seq;
- idx = dumper->cur_idx;
- prev = 0;
- while (seq < dumper->next_seq) {
- struct printk_log *msg = log_from_idx(idx);
-
- l += msg_print_text(msg, prev, true, NULL, 0);
- idx = log_next(idx);
- seq++;
- prev = msg->flags;
- }
-
- /* move first record forward until length fits into the buffer */
- seq = dumper->cur_seq;
- idx = dumper->cur_idx;
- prev = 0;
- while (l > size && seq < dumper->next_seq) {
- struct printk_log *msg = log_from_idx(idx);
-
- l -= msg_print_text(msg, prev, true, NULL, 0);
- idx = log_next(idx);
- seq++;
- prev = msg->flags;
- }
-
- /* last message in next interation */
- next_seq = seq;
- next_idx = idx;
-
- l = 0;
- while (seq < dumper->next_seq) {
- struct printk_log *msg = log_from_idx(idx);
-
- l += msg_print_text(msg, prev, syslog, buf + l, size - l);
- idx = log_next(idx);
- seq++;
- prev = msg->flags;
- }
-
- dumper->next_seq = next_seq;
- dumper->next_idx = next_idx;
- ret = true;
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
-out:
- if (len)
- *len = l;
- return ret;
-}
-EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
-
-/**
- * kmsg_dump_rewind_nolock - reset the interator (unlocked version)
- * @dumper: registered kmsg dumper
- *
- * Reset the dumper's iterator so that kmsg_dump_get_line() and
- * kmsg_dump_get_buffer() can be called again and used multiple
- * times within the same dumper.dump() callback.
- *
- * The function is similar to kmsg_dump_rewind(), but grabs no locks.
- */
-void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper)
-{
- dumper->cur_seq = clear_seq;
- dumper->cur_idx = clear_idx;
- dumper->next_seq = log_next_seq;
- dumper->next_idx = log_next_idx;
-}
-
-/**
- * kmsg_dump_rewind - reset the interator
- * @dumper: registered kmsg dumper
- *
- * Reset the dumper's iterator so that kmsg_dump_get_line() and
- * kmsg_dump_get_buffer() can be called again and used multiple
- * times within the same dumper.dump() callback.
- */
-void kmsg_dump_rewind(struct kmsg_dumper *dumper)
-{
- unsigned long flags;
-
- raw_spin_lock_irqsave(&logbuf_lock, flags);
- kmsg_dump_rewind_nolock(dumper);
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
-}
-EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
-
static char dump_stack_arch_desc_str[128];
/**
diff --git a/kernel/printk/printk.h b/kernel/printk/printk.h
new file mode 100644
index 0000000..0416793
--- /dev/null
+++ b/kernel/printk/printk.h
@@ -0,0 +1,221 @@
+#ifndef _PRINTK_PRINTK_H
+#define _PRINTK_PRINTK_H
+
+#include <linux/printk.h>
+#include <linux/spinlock_types.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+
+#define PREFIX_MAX 32
+#define LOG_LINE_MAX (1024 - PREFIX_MAX)
+
+/*
+ * The printk log buffer consists of a chain of concatenated variable
+ * length records. Every record starts with a record header, containing
+ * the overall length of the record.
+ *
+ * The heads to the first and last entry in the buffer, as well as the
+ * sequence numbers of these entries are maintained when messages are
+ * stored.
+ *
+ * If the heads indicate available messages, the length in the header
+ * tells the start next message. A length == 0 for the next message
+ * indicates a wrap-around to the beginning of the buffer.
+ *
+ * Every record carries the monotonic timestamp in microseconds, as well as
+ * the standard userspace syslog level and syslog facility. The usual
+ * kernel messages use LOG_KERN; userspace-injected messages always carry
+ * a matching syslog facility, by default LOG_USER. The origin of every
+ * message can be reliably determined that way.
+ *
+ * The human readable log message directly follows the message header. The
+ * length of the message text is stored in the header, the stored message
+ * is not terminated.
+ *
+ * Optionally, a message can carry a dictionary of properties (key/value pairs),
+ * to provide userspace with a machine-readable message context.
+ *
+ * Examples for well-defined, commonly used property names are:
+ * DEVICE=b12:8 device identifier
+ * b12:8 block dev_t
+ * c127:3 char dev_t
+ * n8 netdev ifindex
+ * +sound:card0 subsystem:devname
+ * SUBSYSTEM=pci driver-core subsystem name
+ *
+ * Valid characters in property names are [a-zA-Z0-9.-_]. The plain text value
+ * follows directly after a '=' character. Every property is terminated by
+ * a '\0' character. The last property is not terminated.
+ *
+ * Example of a message structure:
+ * 0000 ff 8f 00 00 00 00 00 00 monotonic time in nsec
+ * 0008 34 00 record is 52 bytes long
+ * 000a 0b 00 text is 11 bytes long
+ * 000c 1f 00 dictionary is 23 bytes long
+ * 000e 03 00 LOG_KERN (facility) LOG_ERR (level)
+ * 0010 69 74 27 73 20 61 20 6c "it's a l"
+ * 69 6e 65 "ine"
+ * 001b 44 45 56 49 43 "DEVIC"
+ * 45 3d 62 38 3a 32 00 44 "E=b8:2\0D"
+ * 52 49 56 45 52 3d 62 75 "RIVER=bu"
+ * 67 "g"
+ * 0032 00 00 00 padding to next message header
+ *
+ * The 'struct printk_log' buffer header must never be directly exported to
+ * userspace, it is a kernel-private implementation detail that might
+ * need to be changed in the future, when the requirements change.
+ *
+ * /dev/kmsg exports the structured data in the following line format:
+ * "<level>,<sequnum>,<tstamp>,<contflag>[,additional_vals, ... ];<msg txt>\n"
+ *
+ * Users of the export format should ignore possible additional values
+ * separated by ',', and find the message after the ';' character.
+ *
+ * The optional key/value pairs are attached as continuation lines starting
+ * with a space character and terminated by a newline. All possible
+ * non-prinatable characters are escaped in the "\xff" notation.
+ */
+
+enum log_flags {
+ LOG_NOCONS = 1, /* already flushed, do not print to console */
+ LOG_NEWLINE = 2, /* text ended with a newline */
+ LOG_PREFIX = 4, /* text started with a prefix */
+ LOG_CONT = 8, /* text is a fragment of a continuation line */
+};
+
+struct printk_log {
+ u64 ts_nsec; /* timestamp in nanoseconds */
+ u16 len; /* length of entire record */
+ u16 text_len; /* length of text buffer */
+ u16 dict_len; /* length of dictionary buffer */
+ u8 facility; /* syslog facility */
+ u8 flags:5; /* internal record flags */
+ u8 level:3; /* syslog level */
+};
+
+/*
+ * The logbuf_lock protects kmsg buffer, indices, counters. This can be taken
+ * within the scheduler's rq lock. It must be released before calling
+ * console_unlock() or anything else that might wake up a process.
+ */
+extern raw_spinlock_t logbuf_lock;
+
+#ifdef CONFIG_PRINTK
+
+extern wait_queue_head_t log_wait;
+
+/* index and sequence number of the first record stored in the buffer */
+extern u64 log_first_seq;
+extern u32 log_first_idx;
+
+/* index and sequence number of the next record to store in the buffer */
+extern u64 log_next_seq;
+extern u32 log_next_idx;
+
+/* the next printk record to read after the last 'clear' command */
+extern u64 clear_seq;
+extern u32 clear_idx;
+
+ssize_t msg_print_ext_header(char *buf, size_t size,
+ struct printk_log *msg, u64 seq,
+ enum log_flags prev_flags);
+
+ssize_t msg_print_ext_body(char *buf, size_t size,
+ char *dict, size_t dict_len,
+ char *text, size_t text_len);
+
+size_t msg_print_text(const struct printk_log *msg, enum log_flags prev,
+ bool syslog, char *buf, size_t size);
+
+/* get next record; idx must point to valid msg */
+static inline u32 log_next(u32 idx)
+{
+ char *log_buf = log_buf_addr_get();
+ struct printk_log *msg = (struct printk_log *)(log_buf + idx);
+
+ /* length == 0 indicates the end of the buffer; wrap */
+ /*
+ * A length == 0 record is the end of buffer marker. Wrap around and
+ * read the message at the start of the buffer as *this* one, and
+ * return the one after that.
+ */
+ if (!msg->len) {
+ msg = (struct printk_log *)log_buf;
+ return msg->len;
+ }
+ return idx + msg->len;
+}
+
+/* get record by index; idx must point to valid msg */
+static inline struct printk_log *log_from_idx(u32 idx)
+{
+ char *log_buf = log_buf_addr_get();
+ struct printk_log *msg = (struct printk_log *)(log_buf + idx);
+
+ /*
+ * A length == 0 record is the end of buffer marker. Wrap around and
+ * read the message at the start of the buffer.
+ */
+ if (!msg->len)
+ return (struct printk_log *)log_buf;
+ return msg;
+}
+
+/* human readable text of the record */
+static inline char *log_text(const struct printk_log *msg)
+{
+ return (char *)msg + sizeof(struct printk_log);
+}
+
+/* optional key/value pair dictionary attached to the record */
+static inline char *log_dict(const struct printk_log *msg)
+{
+ return (char *)msg + sizeof(struct printk_log) + msg->text_len;
+}
+
+#else
+
+static inline ssize_t msg_print_ext_header(char *buf, size_t size,
+ struct printk_log *msg, u64 seq,
+ enum log_flags prev_flags)
+{
+ return 0;
+}
+
+static inline ssize_t msg_print_ext_body(char *buf, size_t size,
+ char *dict, size_t dict_len,
+ char *text, size_t text_len)
+{
+ return 0;
+}
+
+static inline size_t msg_print_text(const struct printk_log *msg,
+ enum log_flags prev, bool syslog, char *buf,
+ size_t size);
+{
+ return 0;
+}
+
+static inline u32 log_next(u32 idx)
+{
+ return 0;
+}
+
+static inline struct printk_log *log_from_idx(u32 idx)
+{
+ return NULL;
+}
+
+static inline char *log_text(const struct printk_log *msg)
+{
+ return NULL;
+}
+
+static inline char *log_dict(const struct printk_log *msg)
+{
+ return NULL;
+}
+
+#endif
+
+#endif /* _PRINTK_PRINTK_H */
--
1.9.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [RFC v3 1/9] printk: extract kmsg-related routines from printk.c to kmsg.c
2015-10-19 12:58 ` [RFC v3 1/9] printk: extract kmsg-related routines from printk.c to kmsg.c Paul Osmialowski
@ 2015-10-19 13:53 ` kbuild test robot
2015-10-19 13:59 ` kbuild test robot
1 sibling, 0 replies; 23+ messages in thread
From: kbuild test robot @ 2015-10-19 13:53 UTC (permalink / raw)
Cc: kbuild-all, Jonathan Corbet, Arnd Bergmann, Andrew Morton,
Petr Mladek, Greg Kroah-Hartman, Daniel Mack, Kay Sievers,
Joe Perches, Tejun Heo, linux-kernel, linux-doc, linux-api,
Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
[-- Attachment #1: Type: text/plain, Size: 9762 bytes --]
Hi Paul,
[auto build test ERROR on next-20151016 -- if it's inappropriate base, please suggest rules for selecting the more suitable base]
url: https://github.com/0day-ci/linux/commits/Paul-Osmialowski/Additional-kmsg-devices/20151019-211509
config: x86_64-allnoconfig (attached as .config)
reproduce:
# save the attached .config to linux build tree
make ARCH=x86_64
All error/warnings (new ones prefixed by >>):
In file included from kernel/printk/printk.c:50:0:
>> kernel/printk/printk.h:195:1: error: expected identifier or '(' before '{' token
{
^
>> kernel/printk/printk.c:1541:0: warning: "LOG_LINE_MAX" redefined
#define LOG_LINE_MAX 0
^
In file included from kernel/printk/printk.c:50:0:
kernel/printk/printk.h:10:0: note: this is the location of the previous definition
#define LOG_LINE_MAX (1024 - PREFIX_MAX)
^
>> kernel/printk/printk.c:1542:0: warning: "PREFIX_MAX" redefined
#define PREFIX_MAX 0
^
In file included from kernel/printk/printk.c:50:0:
kernel/printk/printk.h:9:0: note: this is the location of the previous definition
#define PREFIX_MAX 32
^
>> kernel/printk/printk.h:192:22: warning: 'msg_print_text' used but never defined
static inline size_t msg_print_text(const struct printk_log *msg,
^
vim +195 kernel/printk/printk.h
3
4 #include <linux/printk.h>
5 #include <linux/spinlock_types.h>
6 #include <linux/types.h>
7 #include <linux/wait.h>
8
> 9 #define PREFIX_MAX 32
10 #define LOG_LINE_MAX (1024 - PREFIX_MAX)
11
12 /*
13 * The printk log buffer consists of a chain of concatenated variable
14 * length records. Every record starts with a record header, containing
15 * the overall length of the record.
16 *
17 * The heads to the first and last entry in the buffer, as well as the
18 * sequence numbers of these entries are maintained when messages are
19 * stored.
20 *
21 * If the heads indicate available messages, the length in the header
22 * tells the start next message. A length == 0 for the next message
23 * indicates a wrap-around to the beginning of the buffer.
24 *
25 * Every record carries the monotonic timestamp in microseconds, as well as
26 * the standard userspace syslog level and syslog facility. The usual
27 * kernel messages use LOG_KERN; userspace-injected messages always carry
28 * a matching syslog facility, by default LOG_USER. The origin of every
29 * message can be reliably determined that way.
30 *
31 * The human readable log message directly follows the message header. The
32 * length of the message text is stored in the header, the stored message
33 * is not terminated.
34 *
35 * Optionally, a message can carry a dictionary of properties (key/value pairs),
36 * to provide userspace with a machine-readable message context.
37 *
38 * Examples for well-defined, commonly used property names are:
39 * DEVICE=b12:8 device identifier
40 * b12:8 block dev_t
41 * c127:3 char dev_t
42 * n8 netdev ifindex
43 * +sound:card0 subsystem:devname
44 * SUBSYSTEM=pci driver-core subsystem name
45 *
46 * Valid characters in property names are [a-zA-Z0-9.-_]. The plain text value
47 * follows directly after a '=' character. Every property is terminated by
48 * a '\0' character. The last property is not terminated.
49 *
50 * Example of a message structure:
51 * 0000 ff 8f 00 00 00 00 00 00 monotonic time in nsec
52 * 0008 34 00 record is 52 bytes long
53 * 000a 0b 00 text is 11 bytes long
54 * 000c 1f 00 dictionary is 23 bytes long
55 * 000e 03 00 LOG_KERN (facility) LOG_ERR (level)
56 * 0010 69 74 27 73 20 61 20 6c "it's a l"
57 * 69 6e 65 "ine"
58 * 001b 44 45 56 49 43 "DEVIC"
59 * 45 3d 62 38 3a 32 00 44 "E=b8:2\0D"
60 * 52 49 56 45 52 3d 62 75 "RIVER=bu"
61 * 67 "g"
62 * 0032 00 00 00 padding to next message header
63 *
64 * The 'struct printk_log' buffer header must never be directly exported to
65 * userspace, it is a kernel-private implementation detail that might
66 * need to be changed in the future, when the requirements change.
67 *
68 * /dev/kmsg exports the structured data in the following line format:
69 * "<level>,<sequnum>,<tstamp>,<contflag>[,additional_vals, ... ];<msg txt>\n"
70 *
71 * Users of the export format should ignore possible additional values
72 * separated by ',', and find the message after the ';' character.
73 *
74 * The optional key/value pairs are attached as continuation lines starting
75 * with a space character and terminated by a newline. All possible
76 * non-prinatable characters are escaped in the "\xff" notation.
77 */
78
79 enum log_flags {
80 LOG_NOCONS = 1, /* already flushed, do not print to console */
81 LOG_NEWLINE = 2, /* text ended with a newline */
82 LOG_PREFIX = 4, /* text started with a prefix */
83 LOG_CONT = 8, /* text is a fragment of a continuation line */
84 };
85
86 struct printk_log {
87 u64 ts_nsec; /* timestamp in nanoseconds */
88 u16 len; /* length of entire record */
89 u16 text_len; /* length of text buffer */
90 u16 dict_len; /* length of dictionary buffer */
91 u8 facility; /* syslog facility */
92 u8 flags:5; /* internal record flags */
93 u8 level:3; /* syslog level */
94 };
95
96 /*
97 * The logbuf_lock protects kmsg buffer, indices, counters. This can be taken
98 * within the scheduler's rq lock. It must be released before calling
99 * console_unlock() or anything else that might wake up a process.
100 */
101 extern raw_spinlock_t logbuf_lock;
102
103 #ifdef CONFIG_PRINTK
104
105 extern wait_queue_head_t log_wait;
106
107 /* index and sequence number of the first record stored in the buffer */
108 extern u64 log_first_seq;
109 extern u32 log_first_idx;
110
111 /* index and sequence number of the next record to store in the buffer */
112 extern u64 log_next_seq;
113 extern u32 log_next_idx;
114
115 /* the next printk record to read after the last 'clear' command */
116 extern u64 clear_seq;
117 extern u32 clear_idx;
118
119 ssize_t msg_print_ext_header(char *buf, size_t size,
120 struct printk_log *msg, u64 seq,
121 enum log_flags prev_flags);
122
123 ssize_t msg_print_ext_body(char *buf, size_t size,
124 char *dict, size_t dict_len,
125 char *text, size_t text_len);
126
127 size_t msg_print_text(const struct printk_log *msg, enum log_flags prev,
128 bool syslog, char *buf, size_t size);
129
130 /* get next record; idx must point to valid msg */
131 static inline u32 log_next(u32 idx)
132 {
133 char *log_buf = log_buf_addr_get();
134 struct printk_log *msg = (struct printk_log *)(log_buf + idx);
135
136 /* length == 0 indicates the end of the buffer; wrap */
137 /*
138 * A length == 0 record is the end of buffer marker. Wrap around and
139 * read the message at the start of the buffer as *this* one, and
140 * return the one after that.
141 */
142 if (!msg->len) {
143 msg = (struct printk_log *)log_buf;
144 return msg->len;
145 }
146 return idx + msg->len;
147 }
148
149 /* get record by index; idx must point to valid msg */
150 static inline struct printk_log *log_from_idx(u32 idx)
151 {
152 char *log_buf = log_buf_addr_get();
153 struct printk_log *msg = (struct printk_log *)(log_buf + idx);
154
155 /*
156 * A length == 0 record is the end of buffer marker. Wrap around and
157 * read the message at the start of the buffer.
158 */
159 if (!msg->len)
160 return (struct printk_log *)log_buf;
161 return msg;
162 }
163
164 /* human readable text of the record */
165 static inline char *log_text(const struct printk_log *msg)
166 {
167 return (char *)msg + sizeof(struct printk_log);
168 }
169
170 /* optional key/value pair dictionary attached to the record */
171 static inline char *log_dict(const struct printk_log *msg)
172 {
173 return (char *)msg + sizeof(struct printk_log) + msg->text_len;
174 }
175
176 #else
177
178 static inline ssize_t msg_print_ext_header(char *buf, size_t size,
179 struct printk_log *msg, u64 seq,
180 enum log_flags prev_flags)
181 {
182 return 0;
183 }
184
185 static inline ssize_t msg_print_ext_body(char *buf, size_t size,
186 char *dict, size_t dict_len,
187 char *text, size_t text_len)
188 {
189 return 0;
190 }
191
> 192 static inline size_t msg_print_text(const struct printk_log *msg,
193 enum log_flags prev, bool syslog, char *buf,
194 size_t size);
> 195 {
196 return 0;
197 }
198
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
[-- Attachment #2: .config.gz --]
[-- Type: application/octet-stream, Size: 6159 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [RFC v3 1/9] printk: extract kmsg-related routines from printk.c to kmsg.c
2015-10-19 12:58 ` [RFC v3 1/9] printk: extract kmsg-related routines from printk.c to kmsg.c Paul Osmialowski
2015-10-19 13:53 ` kbuild test robot
@ 2015-10-19 13:59 ` kbuild test robot
1 sibling, 0 replies; 23+ messages in thread
From: kbuild test robot @ 2015-10-19 13:59 UTC (permalink / raw)
Cc: kbuild-all, Jonathan Corbet, Arnd Bergmann, Andrew Morton,
Petr Mladek, Greg Kroah-Hartman, Daniel Mack, Kay Sievers,
Joe Perches, Tejun Heo, linux-kernel, linux-doc, linux-api,
Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
[-- Attachment #1: Type: text/plain, Size: 6304 bytes --]
Hi Paul,
[auto build test ERROR on next-20151016 -- if it's inappropriate base, please suggest rules for selecting the more suitable base]
url: https://github.com/0day-ci/linux/commits/Paul-Osmialowski/Additional-kmsg-devices/20151019-211509
config: i386-defconfig (attached as .config)
reproduce:
# save the attached .config to linux build tree
make ARCH=i386
All error/warnings (new ones prefixed by >>):
In file included from include/linux/fs.h:5:0,
from kernel/printk/kmsg.c:5:
kernel/printk/kmsg.c: In function 'devkmsg_read':
include/linux/wait.h:400:31: error: 'TASK_INTERRUPTIBLE' undeclared (first use in this function)
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
^
include/linux/wait.h:225:52: note: in definition of macro '___wait_event'
long __int = prepare_to_wait_event(&wq, &__wait, state);\
^
>> include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
>> kernel/printk/kmsg.c:105:9: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_wait,
^
include/linux/wait.h:400:31: note: each undeclared identifier is reported only once for each function it appears in
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
^
include/linux/wait.h:225:52: note: in definition of macro '___wait_event'
long __int = prepare_to_wait_event(&wq, &__wait, state);\
^
>> include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
>> kernel/printk/kmsg.c:105:9: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_wait,
^
include/linux/wait.h:198:43: error: 'TASK_KILLABLE' undeclared (first use in this function)
state == TASK_INTERRUPTIBLE || state == TASK_KILLABLE) \
^
include/linux/wait.h:230:7: note: in expansion of macro '___wait_is_interruptible'
if (___wait_is_interruptible(state) && __int) { \
^
include/linux/wait.h:400:2: note: in expansion of macro '___wait_event'
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
^
>> include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
>> kernel/printk/kmsg.c:105:9: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_wait,
^
>> include/linux/wait.h:401:9: error: implicit declaration of function 'schedule' [-Werror=implicit-function-declaration]
schedule())
^
include/linux/wait.h:240:3: note: in definition of macro '___wait_event'
cmd; \
^
>> include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
>> kernel/printk/kmsg.c:105:9: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_wait,
^
cc1: some warnings being treated as errors
vim +/schedule +401 include/linux/wait.h
82e06c81 Shaohua Li 2013-11-14 394 if (condition) \
82e06c81 Shaohua Li 2013-11-14 395 break; \
82e06c81 Shaohua Li 2013-11-14 396 __wait_event_cmd(wq, condition, cmd1, cmd2); \
82e06c81 Shaohua Li 2013-11-14 397 } while (0)
82e06c81 Shaohua Li 2013-11-14 398
35a2af94 Peter Zijlstra 2013-10-02 399 #define __wait_event_interruptible(wq, condition) \
35a2af94 Peter Zijlstra 2013-10-02 @400 ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
f13f4c41 Peter Zijlstra 2013-10-02 @401 schedule())
^1da177e Linus Torvalds 2005-04-16 402
^1da177e Linus Torvalds 2005-04-16 403 /**
^1da177e Linus Torvalds 2005-04-16 404 * wait_event_interruptible - sleep until a condition gets true
^1da177e Linus Torvalds 2005-04-16 405 * @wq: the waitqueue to wait on
^1da177e Linus Torvalds 2005-04-16 406 * @condition: a C expression for the event to wait for
^1da177e Linus Torvalds 2005-04-16 407 *
^1da177e Linus Torvalds 2005-04-16 408 * The process is put to sleep (TASK_INTERRUPTIBLE) until the
^1da177e Linus Torvalds 2005-04-16 409 * @condition evaluates to true or a signal is received.
^1da177e Linus Torvalds 2005-04-16 410 * The @condition is checked each time the waitqueue @wq is woken up.
^1da177e Linus Torvalds 2005-04-16 411 *
^1da177e Linus Torvalds 2005-04-16 412 * wake_up() has to be called after changing any variable that could
^1da177e Linus Torvalds 2005-04-16 413 * change the result of the wait condition.
^1da177e Linus Torvalds 2005-04-16 414 *
^1da177e Linus Torvalds 2005-04-16 415 * The function will return -ERESTARTSYS if it was interrupted by a
^1da177e Linus Torvalds 2005-04-16 416 * signal and 0 if @condition evaluated to true.
^1da177e Linus Torvalds 2005-04-16 417 */
^1da177e Linus Torvalds 2005-04-16 418 #define wait_event_interruptible(wq, condition) \
^1da177e Linus Torvalds 2005-04-16 419 ({ \
^1da177e Linus Torvalds 2005-04-16 420 int __ret = 0; \
e22b886a Peter Zijlstra 2014-09-24 421 might_sleep(); \
^1da177e Linus Torvalds 2005-04-16 422 if (!(condition)) \
35a2af94 Peter Zijlstra 2013-10-02 @423 __ret = __wait_event_interruptible(wq, condition); \
^1da177e Linus Torvalds 2005-04-16 424 __ret; \
^1da177e Linus Torvalds 2005-04-16 425 })
^1da177e Linus Torvalds 2005-04-16 426
:::::: The code at line 401 was first introduced by commit
:::::: f13f4c41c9cf9cd61c896e46e4e7ba2687e2af9c sched/wait: Collapse __wait_event_interruptible()
:::::: TO: Peter Zijlstra <peterz@infradead.org>
:::::: CC: Ingo Molnar <mingo@kernel.org>
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
[-- Attachment #2: .config.gz --]
[-- Type: application/octet-stream, Size: 23978 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread
* [RFC v3 2/9] printk: add one function for storing log in proper format
2015-10-19 12:58 [RFC v3 0/9] Additional kmsg devices Paul Osmialowski
2015-10-19 12:58 ` [RFC v3 1/9] printk: extract kmsg-related routines from printk.c to kmsg.c Paul Osmialowski
@ 2015-10-19 12:58 ` Paul Osmialowski
2015-10-19 12:58 ` [RFC v3 3/9] kmsg: introduce additional kmsg devices support Paul Osmialowski
` (6 subsequent siblings)
8 siblings, 0 replies; 23+ messages in thread
From: Paul Osmialowski @ 2015-10-19 12:58 UTC (permalink / raw)
To: Jonathan Corbet, Arnd Bergmann, Andrew Morton, Petr Mladek,
Greg Kroah-Hartman, Daniel Mack, Kay Sievers, Joe Perches,
Tejun Heo, linux-kernel, linux-doc, linux-api
Cc: Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
From: Marcin Niesluchowski <m.niesluchow@samsung.com>
Preparation commit for future changes purpose.
Separate code responsible for storing log message in proper format
from operations on consoles by putting it in another function.
Signed-off-by: Marcin Niesluchowski <m.niesluchow@samsung.com>
Signed-off-by: Paul Osmialowski <p.osmialowsk@samsung.com>
---
kernel/printk/printk.c | 222 ++++++++++++++++++++++++++-----------------------
1 file changed, 119 insertions(+), 103 deletions(-)
diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index 50c48c7..ee80655 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -181,6 +181,27 @@ static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
static char *log_buf = __log_buf;
static u32 log_buf_len = __LOG_BUF_LEN;
+/*
+ * Continuation lines are buffered, and not committed to the record buffer
+ * until the line is complete, or a race forces it. The line fragments
+ * though, are printed immediately to the consoles to ensure everything has
+ * reached the console in case of a kernel crash.
+ */
+static struct cont {
+ char buf[LOG_LINE_MAX];
+ size_t len; /* length == 0 means unused buffer */
+ size_t cons; /* bytes written to console */
+ struct task_struct *owner; /* task of first print*/
+ u64 ts_nsec; /* time of first print */
+ u8 level; /* log level of first message */
+ u8 facility; /* log facility of first message */
+ enum log_flags flags; /* prefix, newline flags */
+ bool flushed:1; /* buffer sealed and committed */
+} cont;
+
+static void cont_flush(enum log_flags flags);
+static bool cont_add(int facility, int level, const char *text, size_t len);
+
/* Return log buffer address */
char *log_buf_addr_get(void)
{
@@ -332,6 +353,102 @@ static int log_store(int facility, int level,
return msg->text_len;
}
+static int log_format_and_store(int facility, int level,
+ const char *dict, size_t dictlen,
+ const char *fmt, va_list args)
+{
+ static char textbuf[LOG_LINE_MAX];
+ char *text = textbuf;
+ size_t text_len = 0;
+ enum log_flags lflags = 0;
+ int printed_len = 0;
+
+ /*
+ * The printf needs to come first; we need the syslog
+ * prefix which might be passed-in as a parameter.
+ */
+ text_len = vscnprintf(text, sizeof(textbuf), fmt, args);
+
+ /* mark and strip a trailing newline */
+ if (text_len && text[text_len-1] == '\n') {
+ text_len--;
+ lflags |= LOG_NEWLINE;
+ }
+
+ /* strip kernel syslog prefix and extract log level or control flags */
+ if (facility == 0) {
+ int kern_level = printk_get_level(text);
+
+ if (kern_level) {
+ const char *end_of_header = printk_skip_level(text);
+
+ switch (kern_level) {
+ case '0' ... '7':
+ if (level == LOGLEVEL_DEFAULT)
+ level = kern_level - '0';
+ /* fallthrough */
+ case 'd': /* KERN_DEFAULT */
+ lflags |= LOG_PREFIX;
+ }
+ /*
+ * No need to check length here because vscnprintf
+ * put '\0' at the end of the string. Only valid and
+ * newly printed level is detected.
+ */
+ text_len -= end_of_header - text;
+ text = (char *)end_of_header;
+ }
+ }
+
+ if (level == LOGLEVEL_DEFAULT)
+ level = default_message_loglevel;
+
+ if (dict)
+ lflags |= LOG_PREFIX|LOG_NEWLINE;
+
+ if (!(lflags & LOG_NEWLINE)) {
+ /*
+ * Flush the conflicting buffer. An earlier newline was missing,
+ * or another task also prints continuation lines.
+ */
+ if (cont.len && (lflags & LOG_PREFIX || cont.owner != current))
+ cont_flush(LOG_NEWLINE);
+
+ /* buffer line if possible, otherwise store it right away */
+ if (cont_add(facility, level, text, text_len))
+ printed_len += text_len;
+ else
+ printed_len += log_store(facility, level,
+ lflags | LOG_CONT, 0,
+ dict, dictlen, text, text_len);
+ } else {
+ bool stored = false;
+
+ /*
+ * If an earlier newline was missing and it was the same task,
+ * either merge it with the current buffer and flush, or if
+ * there was a race with interrupts (prefix == true) then just
+ * flush it out and store this line separately.
+ * If the preceding printk was from a different task and missed
+ * a newline, flush and append the newline.
+ */
+ if (cont.len) {
+ if (cont.owner == current && !(lflags & LOG_PREFIX))
+ stored = cont_add(facility, level, text,
+ text_len);
+ cont_flush(LOG_NEWLINE);
+ }
+
+ if (stored)
+ printed_len += text_len;
+ else
+ printed_len += log_store(facility, level,
+ lflags, 0, dict, dictlen,
+ text, text_len);
+ }
+ return printed_len;
+}
+
int dmesg_restrict = IS_ENABLED(CONFIG_SECURITY_DMESG_RESTRICT);
static int syslog_action_restricted(int type)
@@ -1165,24 +1282,6 @@ static inline void printk_delay(void)
}
}
-/*
- * Continuation lines are buffered, and not committed to the record buffer
- * until the line is complete, or a race forces it. The line fragments
- * though, are printed immediately to the consoles to ensure everything has
- * reached the console in case of a kernel crash.
- */
-static struct cont {
- char buf[LOG_LINE_MAX];
- size_t len; /* length == 0 means unused buffer */
- size_t cons; /* bytes written to console */
- struct task_struct *owner; /* task of first print*/
- u64 ts_nsec; /* time of first print */
- u8 level; /* log level of first message */
- u8 facility; /* log facility of first message */
- enum log_flags flags; /* prefix, newline flags */
- bool flushed:1; /* buffer sealed and committed */
-} cont;
-
static void cont_flush(enum log_flags flags)
{
if (cont.flushed)
@@ -1278,10 +1377,6 @@ asmlinkage int vprintk_emit(int facility, int level,
const char *fmt, va_list args)
{
static int recursion_bug;
- static char textbuf[LOG_LINE_MAX];
- char *text = textbuf;
- size_t text_len = 0;
- enum log_flags lflags = 0;
unsigned long flags;
int this_cpu;
int printed_len = 0;
@@ -1335,87 +1430,8 @@ asmlinkage int vprintk_emit(int facility, int level,
strlen(recursion_msg));
}
- /*
- * The printf needs to come first; we need the syslog
- * prefix which might be passed-in as a parameter.
- */
- text_len = vscnprintf(text, sizeof(textbuf), fmt, args);
-
- /* mark and strip a trailing newline */
- if (text_len && text[text_len-1] == '\n') {
- text_len--;
- lflags |= LOG_NEWLINE;
- }
-
- /* strip kernel syslog prefix and extract log level or control flags */
- if (facility == 0) {
- int kern_level = printk_get_level(text);
-
- if (kern_level) {
- const char *end_of_header = printk_skip_level(text);
- switch (kern_level) {
- case '0' ... '7':
- if (level == LOGLEVEL_DEFAULT)
- level = kern_level - '0';
- /* fallthrough */
- case 'd': /* KERN_DEFAULT */
- lflags |= LOG_PREFIX;
- }
- /*
- * No need to check length here because vscnprintf
- * put '\0' at the end of the string. Only valid and
- * newly printed level is detected.
- */
- text_len -= end_of_header - text;
- text = (char *)end_of_header;
- }
- }
-
- if (level == LOGLEVEL_DEFAULT)
- level = default_message_loglevel;
-
- if (dict)
- lflags |= LOG_PREFIX|LOG_NEWLINE;
-
- if (!(lflags & LOG_NEWLINE)) {
- /*
- * Flush the conflicting buffer. An earlier newline was missing,
- * or another task also prints continuation lines.
- */
- if (cont.len && (lflags & LOG_PREFIX || cont.owner != current))
- cont_flush(LOG_NEWLINE);
-
- /* buffer line if possible, otherwise store it right away */
- if (cont_add(facility, level, text, text_len))
- printed_len += text_len;
- else
- printed_len += log_store(facility, level,
- lflags | LOG_CONT, 0,
- dict, dictlen, text, text_len);
- } else {
- bool stored = false;
-
- /*
- * If an earlier newline was missing and it was the same task,
- * either merge it with the current buffer and flush, or if
- * there was a race with interrupts (prefix == true) then just
- * flush it out and store this line separately.
- * If the preceding printk was from a different task and missed
- * a newline, flush and append the newline.
- */
- if (cont.len) {
- if (cont.owner == current && !(lflags & LOG_PREFIX))
- stored = cont_add(facility, level, text,
- text_len);
- cont_flush(LOG_NEWLINE);
- }
-
- if (stored)
- printed_len += text_len;
- else
- printed_len += log_store(facility, level, lflags, 0,
- dict, dictlen, text, text_len);
- }
+ printed_len += log_format_and_store(facility, level, dict, dictlen,
+ fmt, args);
logbuf_cpu = UINT_MAX;
raw_spin_unlock(&logbuf_lock);
--
1.9.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [RFC v3 3/9] kmsg: introduce additional kmsg devices support
2015-10-19 12:58 [RFC v3 0/9] Additional kmsg devices Paul Osmialowski
2015-10-19 12:58 ` [RFC v3 1/9] printk: extract kmsg-related routines from printk.c to kmsg.c Paul Osmialowski
2015-10-19 12:58 ` [RFC v3 2/9] printk: add one function for storing log in proper format Paul Osmialowski
@ 2015-10-19 12:58 ` Paul Osmialowski
2015-10-19 14:10 ` kbuild test robot
2015-10-19 12:58 ` [RFC v3 5/9] kmsg: add function for adding and deleting additional buffers Paul Osmialowski
` (5 subsequent siblings)
8 siblings, 1 reply; 23+ messages in thread
From: Paul Osmialowski @ 2015-10-19 12:58 UTC (permalink / raw)
To: Jonathan Corbet, Arnd Bergmann, Andrew Morton, Petr Mladek,
Greg Kroah-Hartman, Daniel Mack, Kay Sievers, Joe Perches,
Tejun Heo, linux-kernel, linux-doc, linux-api
Cc: Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
From: Marcin Niesluchowski <m.niesluchow@samsung.com>
kmsg device provides operations on cyclic logging buffer used mainly
by kernel but also in userspace by privileged processes.
Additional kmsg devices keep the same log format but may be added
dynamically with custom size.
Signed-off-by: Marcin Niesluchowski <m.niesluchow@samsung.com>
Signed-off-by: Paul Osmialowski <p.osmialowsk@samsung.com>
---
fs/proc/kmsg.c | 4 +-
kernel/printk/kmsg.c | 301 ++++++++++++++++++++++++++++++++--------------
kernel/printk/printk.c | 317 ++++++++++++++++++++++++++-----------------------
kernel/printk/printk.h | 69 +++++++----
4 files changed, 431 insertions(+), 260 deletions(-)
diff --git a/fs/proc/kmsg.c b/fs/proc/kmsg.c
index 05f8dcd..0d354e4 100644
--- a/fs/proc/kmsg.c
+++ b/fs/proc/kmsg.c
@@ -17,7 +17,7 @@
#include <asm/uaccess.h>
#include <asm/io.h>
-extern wait_queue_head_t log_wait;
+extern wait_queue_head_t *log_wait;
static int kmsg_open(struct inode * inode, struct file * file)
{
@@ -41,7 +41,7 @@ static ssize_t kmsg_read(struct file *file, char __user *buf,
static unsigned int kmsg_poll(struct file *file, poll_table *wait)
{
- poll_wait(file, &log_wait, wait);
+ poll_wait(file, log_wait, wait);
if (do_syslog(SYSLOG_ACTION_SIZE_UNREAD, NULL, 0, SYSLOG_FROM_PROC))
return POLLIN | POLLRDNORM;
return 0;
diff --git a/kernel/printk/kmsg.c b/kernel/printk/kmsg.c
index 260b2ee..23d4160 100644
--- a/kernel/printk/kmsg.c
+++ b/kernel/printk/kmsg.c
@@ -29,6 +29,34 @@ struct devkmsg_user {
char buf[CONSOLE_EXT_LOG_MAX];
};
+static int kmsg_sys_write(int minor, int level, const char *fmt, ...)
+{
+ va_list args;
+ int ret = -ENXIO;
+ struct log_buffer *log_b;
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(log_b, &log_buf.list, list) {
+ if (log_b->minor != minor)
+ continue;
+
+ raw_spin_lock(&log_b->lock);
+
+ va_start(args, fmt);
+ log_format_and_store(log_b, 1 /* LOG_USER */, level,
+ NULL, 0, fmt, args);
+ va_end(args);
+ wake_up_interruptible(&log_b->wait);
+
+ raw_spin_unlock(&log_b->lock);
+
+ ret = 0;
+ break;
+ }
+ rcu_read_unlock();
+ return ret;
+}
+
static ssize_t devkmsg_write(struct kiocb *iocb, struct iov_iter *from)
{
char *buf, *line;
@@ -37,6 +65,7 @@ static ssize_t devkmsg_write(struct kiocb *iocb, struct iov_iter *from)
int facility = 1; /* LOG_USER */
size_t len = iov_iter_count(from);
ssize_t ret = len;
+ int minor = iminor(iocb->ki_filp->f_inode);
if (len > LOG_LINE_MAX)
return -EINVAL;
@@ -74,51 +103,57 @@ static ssize_t devkmsg_write(struct kiocb *iocb, struct iov_iter *from)
}
}
- printk_emit(facility, level, NULL, 0, "%s", line);
+ if (minor == log_buf.minor) {
+ printk_emit(facility, level, NULL, 0, "%s", line);
+ } else {
+ int error = kmsg_sys_write(minor, level, "%s", line);
+
+ if (error)
+ ret = error;
+ }
+
kfree(buf);
return ret;
}
-static ssize_t devkmsg_read(struct file *file, char __user *buf,
- size_t count, loff_t *ppos)
+static ssize_t kmsg_read(struct log_buffer *log_b, struct file *file,
+ char __user *buf, size_t count, loff_t *ppos)
{
struct devkmsg_user *user = file->private_data;
struct printk_log *msg;
size_t len;
ssize_t ret;
- if (!user)
- return -EBADF;
-
ret = mutex_lock_interruptible(&user->lock);
if (ret)
return ret;
- raw_spin_lock_irq(&logbuf_lock);
- while (user->seq == log_next_seq) {
+
+ raw_spin_lock_irq(&log_b->lock);
+ while (user->seq == log_b->next_seq) {
if (file->f_flags & O_NONBLOCK) {
ret = -EAGAIN;
- raw_spin_unlock_irq(&logbuf_lock);
+ raw_spin_unlock_irq(&log_b->lock);
goto out;
}
- raw_spin_unlock_irq(&logbuf_lock);
- ret = wait_event_interruptible(log_wait,
- user->seq != log_next_seq);
+ raw_spin_unlock_irq(&log_b->lock);
+ ret = wait_event_interruptible(log_b->wait,
+ user->seq != log_b->next_seq);
if (ret)
goto out;
- raw_spin_lock_irq(&logbuf_lock);
+ raw_spin_lock_irq(&log_b->lock);
}
- if (user->seq < log_first_seq) {
+ if (user->seq < log_b->first_seq) {
/* our last seen message is gone, return error and reset */
- user->idx = log_first_idx;
- user->seq = log_first_seq;
+ user->idx = log_b->first_idx;
+ user->seq = log_b->first_seq;
ret = -EPIPE;
- raw_spin_unlock_irq(&logbuf_lock);
+ raw_spin_unlock_irq(&log_b->lock);
goto out;
}
- msg = log_from_idx(user->idx);
+ msg = log_from_idx(log_b, user->idx);
len = msg_print_ext_header(user->buf, sizeof(user->buf),
msg, user->seq, user->prev);
len += msg_print_ext_body(user->buf + len, sizeof(user->buf) - len,
@@ -126,9 +161,9 @@ static ssize_t devkmsg_read(struct file *file, char __user *buf,
log_text(msg), msg->text_len);
user->prev = msg->flags;
- user->idx = log_next(user->idx);
+ user->idx = log_next(log_b, user->idx);
user->seq++;
- raw_spin_unlock_irq(&logbuf_lock);
+ raw_spin_unlock_irq(&log_b->lock);
if (len > count) {
ret = -EINVAL;
@@ -145,80 +180,144 @@ out:
return ret;
}
-static loff_t devkmsg_llseek(struct file *file, loff_t offset, int whence)
+static ssize_t devkmsg_read(struct file *file, char __user *buf,
+ size_t count, loff_t *ppos)
{
struct devkmsg_user *user = file->private_data;
- loff_t ret = 0;
+ ssize_t ret = -ENXIO;
+ int minor = iminor(file->f_inode);
+ struct log_buffer *log_b;
if (!user)
return -EBADF;
- if (offset)
- return -ESPIPE;
- raw_spin_lock_irq(&logbuf_lock);
+ if (minor == log_buf.minor)
+ return kmsg_read(&log_buf, file, buf, count, ppos);
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(log_b, &log_buf.list, list) {
+ if (log_b->minor == minor) {
+ ret = kmsg_read(log_b, file, buf, count, ppos);
+ break;
+ }
+ }
+ rcu_read_unlock();
+ return ret;
+}
+
+static loff_t kmsg_llseek(struct log_buffer *log_b, struct file *file,
+ int whence)
+{
+ struct devkmsg_user *user = file->private_data;
+ loff_t ret = 0;
+
+ raw_spin_lock_irq(&log_b->lock);
switch (whence) {
case SEEK_SET:
/* the first record */
- user->idx = log_first_idx;
- user->seq = log_first_seq;
+ user->idx = log_b->first_idx;
+ user->seq = log_b->first_seq;
break;
case SEEK_DATA:
+ /* no clear index for kmsg_sys buffers */
+ if (log_b != &log_buf) {
+ ret = -EINVAL;
+ break;
+ }
/*
* The first record after the last SYSLOG_ACTION_CLEAR,
* like issued by 'dmesg -c'. Reading /dev/kmsg itself
* changes no global state, and does not clear anything.
*/
- user->idx = clear_idx;
- user->seq = clear_seq;
+ user->idx = log_b->clear_idx;
+ user->seq = log_b->clear_seq;
break;
case SEEK_END:
/* after the last record */
- user->idx = log_next_idx;
- user->seq = log_next_seq;
+ user->idx = log_b->next_idx;
+ user->seq = log_b->next_seq;
break;
default:
ret = -EINVAL;
}
- raw_spin_unlock_irq(&logbuf_lock);
+ raw_spin_unlock_irq(&log_b->lock);
return ret;
}
-static unsigned int devkmsg_poll(struct file *file, poll_table *wait)
+static loff_t devkmsg_llseek(struct file *file, loff_t offset, int whence)
{
struct devkmsg_user *user = file->private_data;
- int ret = 0;
+ loff_t ret = -ENXIO;
+ int minor = iminor(file->f_inode);
+ struct log_buffer *log_b;
if (!user)
- return POLLERR|POLLNVAL;
+ return -EBADF;
+ if (offset)
+ return -ESPIPE;
- poll_wait(file, &log_wait, wait);
+ if (minor == log_buf.minor)
+ return kmsg_llseek(&log_buf, file, whence);
- raw_spin_lock_irq(&logbuf_lock);
- if (user->seq < log_next_seq) {
+ rcu_read_lock();
+ list_for_each_entry_rcu(log_b, &log_buf.list, list) {
+ if (log_b->minor == minor) {
+ ret = kmsg_llseek(log_b, file, whence);
+ break;
+ }
+ }
+ rcu_read_unlock();
+ return ret;
+}
+
+static unsigned int kmsg_poll(struct log_buffer *log_b,
+ struct file *file, poll_table *wait)
+{
+ struct devkmsg_user *user = file->private_data;
+ int ret = 0;
+
+ poll_wait(file, &log_b->wait, wait);
+
+ raw_spin_lock_irq(&log_b->lock);
+ if (user->seq < log_b->next_seq) {
/* return error when data has vanished underneath us */
- if (user->seq < log_first_seq)
+ if (user->seq < log_b->first_seq)
ret = POLLIN|POLLRDNORM|POLLERR|POLLPRI;
else
ret = POLLIN|POLLRDNORM;
}
- raw_spin_unlock_irq(&logbuf_lock);
+ raw_spin_unlock_irq(&log_b->lock);
return ret;
}
-static int devkmsg_open(struct inode *inode, struct file *file)
+static unsigned int devkmsg_poll(struct file *file, poll_table *wait)
{
- struct devkmsg_user *user;
- int err;
+ struct devkmsg_user *user = file->private_data;
+ int ret = POLLERR|POLLNVAL;
+ int minor = iminor(file->f_inode);
+ struct log_buffer *log_b;
- /* write-only does not need any file context */
- if ((file->f_flags & O_ACCMODE) == O_WRONLY)
- return 0;
+ if (!user)
+ return POLLERR|POLLNVAL;
- err = check_syslog_permissions(SYSLOG_ACTION_READ_ALL,
- SYSLOG_FROM_READER);
- if (err)
- return err;
+ if (minor == log_buf.minor)
+ return kmsg_poll(&log_buf, file, wait);
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(log_b, &log_buf.list, list) {
+ if (log_b->minor == minor) {
+ ret = kmsg_poll(log_b, file, wait);
+ break;
+ }
+ }
+ rcu_read_unlock();
+ return ret;
+}
+
+static int kmsg_open(struct log_buffer *log_b, struct file *file)
+{
+ struct devkmsg_user *user;
user = kmalloc(sizeof(struct devkmsg_user), GFP_KERNEL);
if (!user)
@@ -226,15 +325,45 @@ static int devkmsg_open(struct inode *inode, struct file *file)
mutex_init(&user->lock);
- raw_spin_lock_irq(&logbuf_lock);
- user->idx = log_first_idx;
- user->seq = log_first_seq;
- raw_spin_unlock_irq(&logbuf_lock);
+ raw_spin_lock_irq(&log_b->lock);
+ user->idx = log_b->first_idx;
+ user->seq = log_b->first_seq;
+ raw_spin_unlock_irq(&log_b->lock);
file->private_data = user;
return 0;
}
+static int devkmsg_open(struct inode *inode, struct file *file)
+{
+ int ret = -ENXIO;
+ int minor = iminor(file->f_inode);
+ struct log_buffer *log_b;
+
+ /* write-only does not need any file context */
+ if ((file->f_flags & O_ACCMODE) == O_WRONLY)
+ return 0;
+
+ if (minor == log_buf.minor) {
+ ret = check_syslog_permissions(SYSLOG_ACTION_READ_ALL,
+ SYSLOG_FROM_READER);
+ if (ret)
+ return ret;
+
+ return kmsg_open(&log_buf, file);
+ }
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(log_b, &log_buf.list, list) {
+ if (log_b->minor == minor) {
+ ret = kmsg_open(log_b, file);
+ break;
+ }
+ }
+ rcu_read_unlock();
+ return ret;
+}
+
static int devkmsg_release(struct inode *inode, struct file *file)
{
struct devkmsg_user *user = file->private_data;
@@ -341,12 +470,12 @@ void kmsg_dump(enum kmsg_dump_reason reason)
/* initialize iterator with data about the stored records */
dumper->active = true;
- raw_spin_lock_irqsave(&logbuf_lock, flags);
- dumper->cur_seq = clear_seq;
- dumper->cur_idx = clear_idx;
- dumper->next_seq = log_next_seq;
- dumper->next_idx = log_next_idx;
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+ raw_spin_lock_irqsave(&log_buf.lock, flags);
+ dumper->cur_seq = log_buf.clear_seq;
+ dumper->cur_idx = log_buf.clear_idx;
+ dumper->next_seq = log_buf.next_seq;
+ dumper->next_idx = log_buf.next_idx;
+ raw_spin_unlock_irqrestore(&log_buf.lock, flags);
/* invoke dumper which will iterate over records */
dumper->dump(dumper, reason);
@@ -386,20 +515,20 @@ bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog,
if (!dumper->active)
goto out;
- if (dumper->cur_seq < log_first_seq) {
+ if (dumper->cur_seq < log_buf.first_seq) {
/* messages are gone, move to first available one */
- dumper->cur_seq = log_first_seq;
- dumper->cur_idx = log_first_idx;
+ dumper->cur_seq = log_buf.first_seq;
+ dumper->cur_idx = log_buf.first_idx;
}
/* last entry */
- if (dumper->cur_seq >= log_next_seq)
+ if (dumper->cur_seq >= log_buf.next_seq)
goto out;
- msg = log_from_idx(dumper->cur_idx);
+ msg = log_from_idx(&log_buf, dumper->cur_idx);
l = msg_print_text(msg, 0, syslog, line, size);
- dumper->cur_idx = log_next(dumper->cur_idx);
+ dumper->cur_idx = log_next(&log_buf, dumper->cur_idx);
dumper->cur_seq++;
ret = true;
out:
@@ -431,9 +560,9 @@ bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog,
unsigned long flags;
bool ret;
- raw_spin_lock_irqsave(&logbuf_lock, flags);
+ raw_spin_lock_irqsave(&log_buf.lock, flags);
ret = kmsg_dump_get_line_nolock(dumper, syslog, line, size, len);
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+ raw_spin_unlock_irqrestore(&log_buf.lock, flags);
return ret;
}
@@ -473,16 +602,16 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
if (!dumper->active)
goto out;
- raw_spin_lock_irqsave(&logbuf_lock, flags);
- if (dumper->cur_seq < log_first_seq) {
+ raw_spin_lock_irqsave(&log_buf.lock, flags);
+ if (dumper->cur_seq < log_buf.first_seq) {
/* messages are gone, move to first available one */
- dumper->cur_seq = log_first_seq;
- dumper->cur_idx = log_first_idx;
+ dumper->cur_seq = log_buf.first_seq;
+ dumper->cur_idx = log_buf.first_idx;
}
/* last entry */
if (dumper->cur_seq >= dumper->next_seq) {
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+ raw_spin_unlock_irqrestore(&log_buf.lock, flags);
goto out;
}
@@ -491,10 +620,10 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
idx = dumper->cur_idx;
prev = 0;
while (seq < dumper->next_seq) {
- struct printk_log *msg = log_from_idx(idx);
+ struct printk_log *msg = log_from_idx(&log_buf, idx);
l += msg_print_text(msg, prev, true, NULL, 0);
- idx = log_next(idx);
+ idx = log_next(&log_buf, idx);
seq++;
prev = msg->flags;
}
@@ -504,10 +633,10 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
idx = dumper->cur_idx;
prev = 0;
while (l > size && seq < dumper->next_seq) {
- struct printk_log *msg = log_from_idx(idx);
+ struct printk_log *msg = log_from_idx(&log_buf, idx);
l -= msg_print_text(msg, prev, true, NULL, 0);
- idx = log_next(idx);
+ idx = log_next(&log_buf, idx);
seq++;
prev = msg->flags;
}
@@ -518,10 +647,10 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
l = 0;
while (seq < dumper->next_seq) {
- struct printk_log *msg = log_from_idx(idx);
+ struct printk_log *msg = log_from_idx(&log_buf, idx);
l += msg_print_text(msg, prev, syslog, buf + l, size - l);
- idx = log_next(idx);
+ idx = log_next(&log_buf, idx);
seq++;
prev = msg->flags;
}
@@ -529,7 +658,7 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
dumper->next_seq = next_seq;
dumper->next_idx = next_idx;
ret = true;
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+ raw_spin_unlock_irqrestore(&log_buf.lock, flags);
out:
if (len)
*len = l;
@@ -549,10 +678,10 @@ EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
*/
void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper)
{
- dumper->cur_seq = clear_seq;
- dumper->cur_idx = clear_idx;
- dumper->next_seq = log_next_seq;
- dumper->next_idx = log_next_idx;
+ dumper->cur_seq = log_buf.clear_seq;
+ dumper->cur_idx = log_buf.clear_idx;
+ dumper->next_seq = log_buf.next_seq;
+ dumper->next_idx = log_buf.next_idx;
}
/**
@@ -567,8 +696,8 @@ void kmsg_dump_rewind(struct kmsg_dumper *dumper)
{
unsigned long flags;
- raw_spin_lock_irqsave(&logbuf_lock, flags);
+ raw_spin_lock_irqsave(&log_buf.lock, flags);
kmsg_dump_rewind_nolock(dumper);
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+ raw_spin_unlock_irqrestore(&log_buf.lock, flags);
}
EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index ee80655..e9ac4ba 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -146,10 +146,7 @@ EXPORT_SYMBOL(console_set_on_cmdline);
/* Flag: console code may call schedule() */
static int console_may_schedule;
-DEFINE_RAW_SPINLOCK(logbuf_lock);
-
#ifdef CONFIG_PRINTK
-DECLARE_WAIT_QUEUE_HEAD(log_wait);
/* the next printk record to read by syslog(READ) or /proc/kmsg */
static u64 syslog_seq;
static u32 syslog_idx;
@@ -161,25 +158,31 @@ static u64 console_seq;
static u32 console_idx;
static enum log_flags console_prev;
-u64 log_first_seq;
-u32 log_first_idx;
-
-u64 log_next_seq;
-u32 log_next_idx;
-
-u64 clear_seq;
-u32 clear_idx;
-
/* record buffer */
#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
#define LOG_ALIGN 4
#else
#define LOG_ALIGN __alignof__(struct printk_log)
#endif
-#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
-static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
-static char *log_buf = __log_buf;
-static u32 log_buf_len = __LOG_BUF_LEN;
+#define __LOG_BUF_K_LEN (1 << CONFIG_LOG_BUF_SHIFT)
+static char __log_buf_k[__LOG_BUF_K_LEN] __aligned(LOG_ALIGN);
+
+struct log_buffer log_buf = {
+ .list = LIST_HEAD_INIT(log_buf.list),
+ .buf = __log_buf_k,
+ .len = __LOG_BUF_K_LEN,
+ .lock = __RAW_SPIN_LOCK_UNLOCKED(log_buf.lock),
+ .wait = __WAIT_QUEUE_HEAD_INITIALIZER(log_buf.wait),
+ .first_seq = 0,
+ .first_idx = 0,
+ .next_seq = 0,
+ .next_idx = 0,
+ .clear_seq = 0,
+ .clear_idx = 0,
+ .minor = 0,
+};
+
+wait_queue_head_t *log_wait = &log_buf.wait;
/*
* Continuation lines are buffered, and not committed to the record buffer
@@ -205,13 +208,13 @@ static bool cont_add(int facility, int level, const char *text, size_t len);
/* Return log buffer address */
char *log_buf_addr_get(void)
{
- return log_buf;
+ return log_buf.buf;
}
/* Return log buffer size */
u32 log_buf_len_get(void)
{
- return log_buf_len;
+ return log_buf.len;
}
/*
@@ -223,14 +226,14 @@ u32 log_buf_len_get(void)
* If the buffer is empty, we must respect the position of the indexes.
* They cannot be reset to the beginning of the buffer.
*/
-static int logbuf_has_space(u32 msg_size, bool empty)
+static int logbuf_has_space(struct log_buffer *log_b, u32 msg_size, bool empty)
{
u32 free;
- if (log_next_idx > log_first_idx || empty)
- free = max(log_buf_len - log_next_idx, log_first_idx);
+ if (log_b->next_idx > log_b->first_idx || empty)
+ free = max(log_b->len - log_b->next_idx, log_b->first_idx);
else
- free = log_first_idx - log_next_idx;
+ free = log_b->first_idx - log_b->next_idx;
/*
* We need space also for an empty header that signalizes wrapping
@@ -239,18 +242,18 @@ static int logbuf_has_space(u32 msg_size, bool empty)
return free >= msg_size + sizeof(struct printk_log);
}
-static int log_make_free_space(u32 msg_size)
+static int log_make_free_space(struct log_buffer *log_b, u32 msg_size)
{
- while (log_first_seq < log_next_seq) {
- if (logbuf_has_space(msg_size, false))
+ while (log_b->first_seq < log_b->next_seq) {
+ if (logbuf_has_space(log_b, msg_size, false))
return 0;
/* drop old messages until we have enough contiguous space */
- log_first_idx = log_next(log_first_idx);
- log_first_seq++;
+ log_b->first_idx = log_next(log_b, log_b->first_idx);
+ log_b->first_seq++;
}
/* sequence numbers are equal, so the log buffer is empty */
- if (logbuf_has_space(msg_size, true))
+ if (logbuf_has_space(log_b, msg_size, true))
return 0;
return -ENOMEM;
@@ -276,14 +279,15 @@ static u32 msg_used_size(u16 text_len, u16 dict_len, u32 *pad_len)
#define MAX_LOG_TAKE_PART 4
static const char trunc_msg[] = "<truncated>";
-static u32 truncate_msg(u16 *text_len, u16 *trunc_msg_len,
+static u32 truncate_msg(struct log_buffer *log_b,
+ u16 *text_len, u16 *trunc_msg_len,
u16 *dict_len, u32 *pad_len)
{
/*
* The message should not take the whole buffer. Otherwise, it might
* get removed too soon.
*/
- u32 max_text_len = log_buf_len / MAX_LOG_TAKE_PART;
+ u32 max_text_len = log_b->len / MAX_LOG_TAKE_PART;
if (*text_len > max_text_len)
*text_len = max_text_len;
/* enable the warning message */
@@ -295,7 +299,8 @@ static u32 truncate_msg(u16 *text_len, u16 *trunc_msg_len,
}
/* insert record into the buffer, discard old ones, update heads */
-static int log_store(int facility, int level,
+static int log_store(struct log_buffer *log_b,
+ int facility, int level,
enum log_flags flags, u64 ts_nsec,
const char *dict, u16 dict_len,
const char *text, u16 text_len)
@@ -307,27 +312,28 @@ static int log_store(int facility, int level,
/* number of '\0' padding bytes to next message */
size = msg_used_size(text_len, dict_len, &pad_len);
- if (log_make_free_space(size)) {
+ if (log_make_free_space(log_b, size)) {
/* truncate the message if it is too long for empty buffer */
- size = truncate_msg(&text_len, &trunc_msg_len,
+ size = truncate_msg(log_b, &text_len, &trunc_msg_len,
&dict_len, &pad_len);
/* survive when the log buffer is too small for trunc_msg */
- if (log_make_free_space(size))
+ if (log_make_free_space(log_b, size))
return 0;
}
- if (log_next_idx + size + sizeof(struct printk_log) > log_buf_len) {
+ if (log_b->next_idx + size + sizeof(struct printk_log) > log_b->len) {
/*
* This message + an additional empty header does not fit
* at the end of the buffer. Add an empty header with len == 0
* to signify a wrap around.
*/
- memset(log_buf + log_next_idx, 0, sizeof(struct printk_log));
- log_next_idx = 0;
+ memset(log_b->buf + log_b->next_idx, 0,
+ sizeof(struct printk_log));
+ log_b->next_idx = 0;
}
/* fill message */
- msg = (struct printk_log *)(log_buf + log_next_idx);
+ msg = (struct printk_log *)(log_b->buf + log_b->next_idx);
memcpy(log_text(msg), text, text_len);
msg->text_len = text_len;
if (trunc_msg_len) {
@@ -347,15 +353,16 @@ static int log_store(int facility, int level,
msg->len = size;
/* insert message */
- log_next_idx += msg->len;
- log_next_seq++;
+ log_b->next_idx += msg->len;
+ log_b->next_seq++;
return msg->text_len;
}
-static int log_format_and_store(int facility, int level,
- const char *dict, size_t dictlen,
- const char *fmt, va_list args)
+int log_format_and_store(struct log_buffer *log_b,
+ int facility, int level,
+ const char *dict, size_t dictlen,
+ const char *fmt, va_list args)
{
static char textbuf[LOG_LINE_MAX];
char *text = textbuf;
@@ -406,6 +413,10 @@ static int log_format_and_store(int facility, int level,
if (dict)
lflags |= LOG_PREFIX|LOG_NEWLINE;
+ if (log_b != &log_buf)
+ return log_store(log_b, facility, level, lflags, 0,
+ dict, dictlen, text, text_len);
+
if (!(lflags & LOG_NEWLINE)) {
/*
* Flush the conflicting buffer. An earlier newline was missing,
@@ -418,7 +429,7 @@ static int log_format_and_store(int facility, int level,
if (cont_add(facility, level, text, text_len))
printed_len += text_len;
else
- printed_len += log_store(facility, level,
+ printed_len += log_store(log_b, facility, level,
lflags | LOG_CONT, 0,
dict, dictlen, text, text_len);
} else {
@@ -442,7 +453,7 @@ static int log_format_and_store(int facility, int level,
if (stored)
printed_len += text_len;
else
- printed_len += log_store(facility, level,
+ printed_len += log_store(log_b, facility, level,
lflags, 0, dict, dictlen,
text, text_len);
}
@@ -585,9 +596,11 @@ ssize_t msg_print_ext_body(char *buf, size_t size,
void log_buf_kexec_setup(void)
{
VMCOREINFO_SYMBOL(log_buf);
- VMCOREINFO_SYMBOL(log_buf_len);
- VMCOREINFO_SYMBOL(log_first_idx);
- VMCOREINFO_SYMBOL(log_next_idx);
+ VMCOREINFO_STRUCT_SIZE(log_buffer);
+ VMCOREINFO_OFFSET(log_buffer, buf);
+ VMCOREINFO_OFFSET(log_buffer, len);
+ VMCOREINFO_OFFSET(log_buffer, first_idx);
+ VMCOREINFO_OFFSET(log_buffer, next_idx);
/*
* Export struct printk_log size and field offsets. User space tools can
* parse it and detect any changes to structure down the line.
@@ -608,7 +621,7 @@ static void __init log_buf_len_update(unsigned size)
{
if (size)
size = roundup_pow_of_two(size);
- if (size > log_buf_len)
+ if (size > log_buf.len)
new_log_buf_len = size;
}
@@ -641,16 +654,16 @@ static void __init log_buf_add_cpu(void)
cpu_extra = (num_possible_cpus() - 1) * __LOG_CPU_MAX_BUF_LEN;
/* by default this will only continue through for large > 64 CPUs */
- if (cpu_extra <= __LOG_BUF_LEN / 2)
+ if (cpu_extra <= __LOG_BUF_K_LEN / 2)
return;
- pr_info("log_buf_len individual max cpu contribution: %d bytes\n",
+ pr_info("log_buf.len individual max cpu contribution: %d bytes\n",
__LOG_CPU_MAX_BUF_LEN);
- pr_info("log_buf_len total cpu_extra contributions: %d bytes\n",
+ pr_info("log_buf.len total cpu_extra contributions: %d bytes\n",
cpu_extra);
- pr_info("log_buf_len min size: %d bytes\n", __LOG_BUF_LEN);
+ pr_info("log_buf.len min size: %d bytes\n", __LOG_BUF_K_LEN);
- log_buf_len_update(cpu_extra + __LOG_BUF_LEN);
+ log_buf_len_update(cpu_extra + __LOG_BUF_K_LEN);
}
#else /* !CONFIG_SMP */
static inline void log_buf_add_cpu(void) {}
@@ -662,7 +675,7 @@ void __init setup_log_buf(int early)
char *new_log_buf;
int free;
- if (log_buf != __log_buf)
+ if (log_buf.buf != __log_buf_k)
return;
if (!early && !new_log_buf_len)
@@ -680,22 +693,22 @@ void __init setup_log_buf(int early)
}
if (unlikely(!new_log_buf)) {
- pr_err("log_buf_len: %ld bytes not available\n",
+ pr_err("log_buf.len: %ld bytes not available\n",
new_log_buf_len);
return;
}
- raw_spin_lock_irqsave(&logbuf_lock, flags);
- log_buf_len = new_log_buf_len;
- log_buf = new_log_buf;
+ raw_spin_lock_irqsave(&log_buf.lock, flags);
+ log_buf.len = new_log_buf_len;
+ log_buf.buf = new_log_buf;
new_log_buf_len = 0;
- free = __LOG_BUF_LEN - log_next_idx;
- memcpy(log_buf, __log_buf, __LOG_BUF_LEN);
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+ free = __LOG_BUF_K_LEN - log_buf.next_idx;
+ memcpy(log_buf.buf, __log_buf_k, __LOG_BUF_K_LEN);
+ raw_spin_unlock_irqrestore(&log_buf.lock, flags);
- pr_info("log_buf_len: %d bytes\n", log_buf_len);
+ pr_info("log_buf.len: %d bytes\n", log_buf.len);
pr_info("early log buf free: %d(%d%%)\n",
- free, (free * 100) / __LOG_BUF_LEN);
+ free, (free * 100) / __LOG_BUF_K_LEN);
}
static bool __read_mostly ignore_loglevel;
@@ -883,26 +896,26 @@ static int syslog_print(char __user *buf, int size)
size_t n;
size_t skip;
- raw_spin_lock_irq(&logbuf_lock);
- if (syslog_seq < log_first_seq) {
+ raw_spin_lock_irq(&log_buf.lock);
+ if (syslog_seq < log_buf.first_seq) {
/* messages are gone, move to first one */
- syslog_seq = log_first_seq;
- syslog_idx = log_first_idx;
+ syslog_seq = log_buf.first_seq;
+ syslog_idx = log_buf.first_idx;
syslog_prev = 0;
syslog_partial = 0;
}
- if (syslog_seq == log_next_seq) {
- raw_spin_unlock_irq(&logbuf_lock);
+ if (syslog_seq == log_buf.next_seq) {
+ raw_spin_unlock_irq(&log_buf.lock);
break;
}
skip = syslog_partial;
- msg = log_from_idx(syslog_idx);
+ msg = log_from_idx(&log_buf, syslog_idx);
n = msg_print_text(msg, syslog_prev, true, text,
LOG_LINE_MAX + PREFIX_MAX);
if (n - syslog_partial <= size) {
/* message fits into buffer, move forward */
- syslog_idx = log_next(syslog_idx);
+ syslog_idx = log_next(&log_buf, syslog_idx);
syslog_seq++;
syslog_prev = msg->flags;
n -= syslog_partial;
@@ -913,7 +926,7 @@ static int syslog_print(char __user *buf, int size)
syslog_partial += n;
} else
n = 0;
- raw_spin_unlock_irq(&logbuf_lock);
+ raw_spin_unlock_irq(&log_buf.lock);
if (!n)
break;
@@ -942,54 +955,54 @@ static int syslog_print_all(char __user *buf, int size, bool clear)
if (!text)
return -ENOMEM;
- raw_spin_lock_irq(&logbuf_lock);
+ raw_spin_lock_irq(&log_buf.lock);
if (buf) {
u64 next_seq;
u64 seq;
u32 idx;
enum log_flags prev;
- if (clear_seq < log_first_seq) {
+ if (log_buf.clear_seq < log_buf.first_seq) {
/* messages are gone, move to first available one */
- clear_seq = log_first_seq;
- clear_idx = log_first_idx;
+ log_buf.clear_seq = log_buf.first_seq;
+ log_buf.clear_idx = log_buf.first_idx;
}
/*
* Find first record that fits, including all following records,
* into the user-provided buffer for this dump.
*/
- seq = clear_seq;
- idx = clear_idx;
+ seq = log_buf.clear_seq;
+ idx = log_buf.clear_idx;
prev = 0;
- while (seq < log_next_seq) {
- struct printk_log *msg = log_from_idx(idx);
+ while (seq < log_buf.next_seq) {
+ struct printk_log *msg = log_from_idx(&log_buf, idx);
len += msg_print_text(msg, prev, true, NULL, 0);
prev = msg->flags;
- idx = log_next(idx);
+ idx = log_next(&log_buf, idx);
seq++;
}
/* move first record forward until length fits into the buffer */
- seq = clear_seq;
- idx = clear_idx;
+ seq = log_buf.clear_seq;
+ idx = log_buf.clear_idx;
prev = 0;
- while (len > size && seq < log_next_seq) {
- struct printk_log *msg = log_from_idx(idx);
+ while (len > size && seq < log_buf.next_seq) {
+ struct printk_log *msg = log_from_idx(&log_buf, idx);
len -= msg_print_text(msg, prev, true, NULL, 0);
prev = msg->flags;
- idx = log_next(idx);
+ idx = log_next(&log_buf, idx);
seq++;
}
/* last message fitting into this dump */
- next_seq = log_next_seq;
+ next_seq = log_buf.next_seq;
len = 0;
while (len >= 0 && seq < next_seq) {
- struct printk_log *msg = log_from_idx(idx);
+ struct printk_log *msg = log_from_idx(&log_buf, idx);
int textlen;
textlen = msg_print_text(msg, prev, true, text,
@@ -998,31 +1011,31 @@ static int syslog_print_all(char __user *buf, int size, bool clear)
len = textlen;
break;
}
- idx = log_next(idx);
+ idx = log_next(&log_buf, idx);
seq++;
prev = msg->flags;
- raw_spin_unlock_irq(&logbuf_lock);
+ raw_spin_unlock_irq(&log_buf.lock);
if (copy_to_user(buf + len, text, textlen))
len = -EFAULT;
else
len += textlen;
- raw_spin_lock_irq(&logbuf_lock);
+ raw_spin_lock_irq(&log_buf.lock);
- if (seq < log_first_seq) {
+ if (seq < log_buf.first_seq) {
/* messages are gone, move to next one */
- seq = log_first_seq;
- idx = log_first_idx;
+ seq = log_buf.first_seq;
+ idx = log_buf.first_idx;
prev = 0;
}
}
}
if (clear) {
- clear_seq = log_next_seq;
- clear_idx = log_next_idx;
+ log_buf.clear_seq = log_buf.next_seq;
+ log_buf.clear_idx = log_buf.next_idx;
}
- raw_spin_unlock_irq(&logbuf_lock);
+ raw_spin_unlock_irq(&log_buf.lock);
kfree(text);
return len;
@@ -1054,8 +1067,8 @@ int do_syslog(int type, char __user *buf, int len, int source)
error = -EFAULT;
goto out;
}
- error = wait_event_interruptible(log_wait,
- syslog_seq != log_next_seq);
+ error = wait_event_interruptible(log_buf.wait,
+ syslog_seq != log_buf.next_seq);
if (error)
goto out;
error = syslog_print(buf, len);
@@ -1109,11 +1122,11 @@ int do_syslog(int type, char __user *buf, int len, int source)
break;
/* Number of chars in the log buffer */
case SYSLOG_ACTION_SIZE_UNREAD:
- raw_spin_lock_irq(&logbuf_lock);
- if (syslog_seq < log_first_seq) {
+ raw_spin_lock_irq(&log_buf.lock);
+ if (syslog_seq < log_buf.first_seq) {
/* messages are gone, move to first one */
- syslog_seq = log_first_seq;
- syslog_idx = log_first_idx;
+ syslog_seq = log_buf.first_seq;
+ syslog_idx = log_buf.first_idx;
syslog_prev = 0;
syslog_partial = 0;
}
@@ -1123,28 +1136,30 @@ int do_syslog(int type, char __user *buf, int len, int source)
* for pending data, not the size; return the count of
* records, not the length.
*/
- error = log_next_seq - syslog_seq;
+ error = log_buf.next_seq - syslog_seq;
} else {
u64 seq = syslog_seq;
u32 idx = syslog_idx;
enum log_flags prev = syslog_prev;
error = 0;
- while (seq < log_next_seq) {
- struct printk_log *msg = log_from_idx(idx);
+ while (seq < log_buf.next_seq) {
+ struct printk_log *msg = log_from_idx(&log_buf,
+ idx);
- error += msg_print_text(msg, prev, true, NULL, 0);
- idx = log_next(idx);
+ error += msg_print_text(msg, prev, true,
+ NULL, 0);
+ idx = log_next(&log_buf, idx);
seq++;
prev = msg->flags;
}
error -= syslog_partial;
}
- raw_spin_unlock_irq(&logbuf_lock);
+ raw_spin_unlock_irq(&log_buf.lock);
break;
/* Size of the log buffer */
case SYSLOG_ACTION_SIZE_BUFFER:
- error = log_buf_len;
+ error = log_buf.len;
break;
default:
error = -EINVAL;
@@ -1211,7 +1226,7 @@ static void zap_locks(void)
debug_locks_off();
/* If a crash is occurring, make sure we can't deadlock */
- raw_spin_lock_init(&logbuf_lock);
+ raw_spin_lock_init(&log_buf.lock);
/* And make sure that we print immediately */
sema_init(&console_sem, 1);
}
@@ -1295,8 +1310,9 @@ static void cont_flush(enum log_flags flags)
* console; wait for the console to pick up the rest of the
* line. LOG_NOCONS suppresses a duplicated output.
*/
- log_store(cont.facility, cont.level, flags | LOG_NOCONS,
- cont.ts_nsec, NULL, 0, cont.buf, cont.len);
+ log_store(&log_buf, cont.facility, cont.level,
+ flags | LOG_NOCONS, cont.ts_nsec, NULL, 0,
+ cont.buf, cont.len);
cont.flags = flags;
cont.flushed = true;
} else {
@@ -1304,7 +1320,7 @@ static void cont_flush(enum log_flags flags)
* If no fragment of this line ever reached the console,
* just submit it to the store and free the buffer.
*/
- log_store(cont.facility, cont.level, flags, 0,
+ log_store(&log_buf, cont.facility, cont.level, flags, 0,
NULL, 0, cont.buf, cont.len);
cont.len = 0;
}
@@ -1381,7 +1397,7 @@ asmlinkage int vprintk_emit(int facility, int level,
int this_cpu;
int printed_len = 0;
bool in_sched = false;
- /* cpu currently holding logbuf_lock in this function */
+ /* cpu currently holding log_buf.lock in this function */
static unsigned int logbuf_cpu = UINT_MAX;
if (level == LOGLEVEL_SCHED) {
@@ -1416,7 +1432,7 @@ asmlinkage int vprintk_emit(int facility, int level,
}
lockdep_off();
- raw_spin_lock(&logbuf_lock);
+ raw_spin_lock(&log_buf.lock);
logbuf_cpu = this_cpu;
if (unlikely(recursion_bug)) {
@@ -1425,16 +1441,17 @@ asmlinkage int vprintk_emit(int facility, int level,
recursion_bug = 0;
/* emit KERN_CRIT message */
- printed_len += log_store(0, 2, LOG_PREFIX|LOG_NEWLINE, 0,
+ printed_len += log_store(&log_buf, 0, 2,
+ LOG_PREFIX|LOG_NEWLINE, 0,
NULL, 0, recursion_msg,
strlen(recursion_msg));
}
- printed_len += log_format_and_store(facility, level, dict, dictlen,
- fmt, args);
+ printed_len += log_format_and_store(&log_buf, facility, level,
+ dict, dictlen, fmt, args);
logbuf_cpu = UINT_MAX;
- raw_spin_unlock(&logbuf_lock);
+ raw_spin_unlock(&log_buf.lock);
lockdep_on();
local_irq_restore(flags);
@@ -1557,14 +1574,18 @@ EXPORT_SYMBOL(printk);
#define LOG_LINE_MAX 0
#define PREFIX_MAX 0
+static struct log_buffer log_buf = {
+ .lock = __RAW_SPIN_LOCK_UNLOCKED(log_buf.lock),
+ .first_seq = 0,
+ .first_idx = 0,
+ .next_seq = 0,
+};
+
static u64 syslog_seq;
static u32 syslog_idx;
static u64 console_seq;
static u32 console_idx;
static enum log_flags syslog_prev;
-static u64 log_first_seq;
-static u32 log_first_idx;
-static u64 log_next_seq;
static enum log_flags console_prev;
static struct cont {
size_t len;
@@ -1809,7 +1830,7 @@ static void console_cont_flush(char *text, size_t size)
unsigned long flags;
size_t len;
- raw_spin_lock_irqsave(&logbuf_lock, flags);
+ raw_spin_lock_irqsave(&log_buf.lock, flags);
if (!cont.len)
goto out;
@@ -1819,18 +1840,18 @@ static void console_cont_flush(char *text, size_t size)
* busy. The earlier ones need to be printed before this one, we
* did not flush any fragment so far, so just let it queue up.
*/
- if (console_seq < log_next_seq && !cont.cons)
+ if (console_seq < log_buf.next_seq && !cont.cons)
goto out;
len = cont_print_text(text, size);
- raw_spin_unlock(&logbuf_lock);
+ raw_spin_unlock(&log_buf.lock);
stop_critical_timings();
call_console_drivers(cont.level, NULL, 0, text, len);
start_critical_timings();
local_irq_restore(flags);
return;
out:
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+ raw_spin_unlock_irqrestore(&log_buf.lock, flags);
}
/**
@@ -1872,34 +1893,34 @@ again:
size_t len;
int level;
- raw_spin_lock_irqsave(&logbuf_lock, flags);
- if (seen_seq != log_next_seq) {
+ raw_spin_lock_irqsave(&log_buf.lock, flags);
+ if (seen_seq != log_buf.next_seq) {
wake_klogd = true;
- seen_seq = log_next_seq;
+ seen_seq = log_buf.next_seq;
}
- if (console_seq < log_first_seq) {
+ if (console_seq < log_buf.first_seq) {
len = sprintf(text, "** %u printk messages dropped ** ",
- (unsigned)(log_first_seq - console_seq));
+ (unsigned)(log_buf.first_seq - console_seq));
/* messages are gone, move to first one */
- console_seq = log_first_seq;
- console_idx = log_first_idx;
+ console_seq = log_buf.first_seq;
+ console_idx = log_buf.first_idx;
console_prev = 0;
} else {
len = 0;
}
skip:
- if (console_seq == log_next_seq)
+ if (console_seq == log_buf.next_seq)
break;
- msg = log_from_idx(console_idx);
+ msg = log_from_idx(&log_buf, console_idx);
if (msg->flags & LOG_NOCONS) {
/*
* Skip record we have buffered and already printed
* directly to the console when we received it.
*/
- console_idx = log_next(console_idx);
+ console_idx = log_next(&log_buf, console_idx);
console_seq++;
/*
* We will get here again when we register a new
@@ -1923,10 +1944,10 @@ skip:
log_dict(msg), msg->dict_len,
log_text(msg), msg->text_len);
}
- console_idx = log_next(console_idx);
+ console_idx = log_next(&log_buf, console_idx);
console_seq++;
console_prev = msg->flags;
- raw_spin_unlock(&logbuf_lock);
+ raw_spin_unlock(&log_buf.lock);
stop_critical_timings(); /* don't trace print latency */
call_console_drivers(level, ext_text, ext_len, text, len);
@@ -1939,7 +1960,7 @@ skip:
if (unlikely(exclusive_console))
exclusive_console = NULL;
- raw_spin_unlock(&logbuf_lock);
+ raw_spin_unlock(&log_buf.lock);
up_console_sem();
@@ -1949,9 +1970,9 @@ skip:
* there's a new owner and the console_unlock() from them will do the
* flush, no worries.
*/
- raw_spin_lock(&logbuf_lock);
- retry = console_seq != log_next_seq;
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+ raw_spin_lock(&log_buf.lock);
+ retry = console_seq != log_buf.next_seq;
+ raw_spin_unlock_irqrestore(&log_buf.lock, flags);
if (retry && console_trylock())
goto again;
@@ -2195,11 +2216,11 @@ void register_console(struct console *newcon)
* console_unlock(); will print out the buffered messages
* for us.
*/
- raw_spin_lock_irqsave(&logbuf_lock, flags);
+ raw_spin_lock_irqsave(&log_buf.lock, flags);
console_seq = syslog_seq;
console_idx = syslog_idx;
console_prev = syslog_prev;
- raw_spin_unlock_irqrestore(&logbuf_lock, flags);
+ raw_spin_unlock_irqrestore(&log_buf.lock, flags);
/*
* We're about to replay the log buffer. Only do this to the
* just-registered console to avoid excessive message spam to
@@ -2313,7 +2334,7 @@ static void wake_up_klogd_work_func(struct irq_work *irq_work)
}
if (pending & PRINTK_PENDING_WAKEUP)
- wake_up_interruptible(&log_wait);
+ wake_up_interruptible(&log_buf.wait);
}
static DEFINE_PER_CPU(struct irq_work, wake_up_klogd_work) = {
@@ -2324,7 +2345,7 @@ static DEFINE_PER_CPU(struct irq_work, wake_up_klogd_work) = {
void wake_up_klogd(void)
{
preempt_disable();
- if (waitqueue_active(&log_wait)) {
+ if (waitqueue_active(&log_buf.wait)) {
this_cpu_or(printk_pending, PRINTK_PENDING_WAKEUP);
irq_work_queue(this_cpu_ptr(&wake_up_klogd_work));
}
diff --git a/kernel/printk/printk.h b/kernel/printk/printk.h
index 0416793..38c9278 100644
--- a/kernel/printk/printk.h
+++ b/kernel/printk/printk.h
@@ -93,28 +93,38 @@ struct printk_log {
u8 level:3; /* syslog level */
};
+struct log_buffer {
+#ifdef CONFIG_PRINTK
+ struct list_head list; /* kmsg as head of the list */
+ char *buf; /* cyclic log buffer */
+ u32 len; /* buffer length */
+ wait_queue_head_t wait; /* wait queue for kmsg buffer */
+#endif
/*
- * The logbuf_lock protects kmsg buffer, indices, counters. This can be taken
- * within the scheduler's rq lock. It must be released before calling
- * console_unlock() or anything else that might wake up a process.
+ * The lock protects kmsg buffer, indices, counters. This can be taken within
+ * the scheduler's rq lock. It must be released before calling console_unlock()
+ * or anything else that might wake up a process.
*/
-extern raw_spinlock_t logbuf_lock;
+ raw_spinlock_t lock;
+
+ u64 first_seq; /* sequence number of the first record stored */
+ u32 first_idx; /* index of the first record stored */
+ u64 next_seq; /* sequence number of next record to store */
#ifdef CONFIG_PRINTK
+ u32 next_idx; /* index of the next record to store */
-extern wait_queue_head_t log_wait;
+ /* the next printk record to read after the last 'clear' command */
+ u64 clear_seq;
+ u32 clear_idx;
-/* index and sequence number of the first record stored in the buffer */
-extern u64 log_first_seq;
-extern u32 log_first_idx;
+ int minor; /* minor representing buffer device */
+#endif
+};
-/* index and sequence number of the next record to store in the buffer */
-extern u64 log_next_seq;
-extern u32 log_next_idx;
+#ifdef CONFIG_PRINTK
-/* the next printk record to read after the last 'clear' command */
-extern u64 clear_seq;
-extern u32 clear_idx;
+extern struct log_buffer log_buf;
ssize_t msg_print_ext_header(char *buf, size_t size,
struct printk_log *msg, u64 seq,
@@ -128,10 +138,9 @@ size_t msg_print_text(const struct printk_log *msg, enum log_flags prev,
bool syslog, char *buf, size_t size);
/* get next record; idx must point to valid msg */
-static inline u32 log_next(u32 idx)
+static inline u32 log_next(struct log_buffer *log_b, u32 idx)
{
- char *log_buf = log_buf_addr_get();
- struct printk_log *msg = (struct printk_log *)(log_buf + idx);
+ struct printk_log *msg = (struct printk_log *)(log_b->buf + idx);
/* length == 0 indicates the end of the buffer; wrap */
/*
@@ -140,24 +149,23 @@ static inline u32 log_next(u32 idx)
* return the one after that.
*/
if (!msg->len) {
- msg = (struct printk_log *)log_buf;
+ msg = (struct printk_log *)log_b->buf;
return msg->len;
}
return idx + msg->len;
}
/* get record by index; idx must point to valid msg */
-static inline struct printk_log *log_from_idx(u32 idx)
+static inline struct printk_log *log_from_idx(struct log_buffer *log_b, u32 idx)
{
- char *log_buf = log_buf_addr_get();
- struct printk_log *msg = (struct printk_log *)(log_buf + idx);
+ struct printk_log *msg = (struct printk_log *)(log_b->buf + idx);
/*
* A length == 0 record is the end of buffer marker. Wrap around and
* read the message at the start of the buffer.
*/
if (!msg->len)
- return (struct printk_log *)log_buf;
+ return (struct printk_log *)log_b->buf;
return msg;
}
@@ -173,6 +181,11 @@ static inline char *log_dict(const struct printk_log *msg)
return (char *)msg + sizeof(struct printk_log) + msg->text_len;
}
+int log_format_and_store(struct log_buffer *log_b,
+ int facility, int level,
+ const char *dict, size_t dictlen,
+ const char *fmt, va_list args);
+
#else
static inline ssize_t msg_print_ext_header(char *buf, size_t size,
@@ -196,12 +209,12 @@ static inline size_t msg_print_text(const struct printk_log *msg,
return 0;
}
-static inline u32 log_next(u32 idx)
+static inline u32 log_next(struct log_buffer *log_b, u32 idx)
{
return 0;
}
-static inline struct printk_log *log_from_idx(u32 idx)
+static inline struct printk_log *log_from_idx(struct log_buffer *log_b, u32 idx)
{
return NULL;
}
@@ -216,6 +229,14 @@ static inline char *log_dict(const struct printk_log *msg)
return NULL;
}
+static inline int log_format_and_store(struct log_buffer *log_b,
+ int facility, int level,
+ const char *dict, size_t dictlen,
+ const char *fmt, va_list args)
+{
+ return 0;
+}
+
#endif
#endif /* _PRINTK_PRINTK_H */
--
1.9.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [RFC v3 3/9] kmsg: introduce additional kmsg devices support
2015-10-19 12:58 ` [RFC v3 3/9] kmsg: introduce additional kmsg devices support Paul Osmialowski
@ 2015-10-19 14:10 ` kbuild test robot
0 siblings, 0 replies; 23+ messages in thread
From: kbuild test robot @ 2015-10-19 14:10 UTC (permalink / raw)
Cc: kbuild-all, Jonathan Corbet, Arnd Bergmann, Andrew Morton,
Petr Mladek, Greg Kroah-Hartman, Daniel Mack, Kay Sievers,
Joe Perches, Tejun Heo, linux-kernel, linux-doc, linux-api,
Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
[-- Attachment #1: Type: text/plain, Size: 5258 bytes --]
Hi Marcin,
[auto build test WARNING on next-20151016 -- if it's inappropriate base, please suggest rules for selecting the more suitable base]
url: https://github.com/0day-ci/linux/commits/Paul-Osmialowski/Additional-kmsg-devices/20151019-211509
config: i386-defconfig (attached as .config)
reproduce:
# save the attached .config to linux build tree
make ARCH=i386
All warnings (new ones prefixed by >>):
In file included from include/linux/fs.h:5:0,
from kernel/printk/kmsg.c:5:
kernel/printk/kmsg.c: In function 'kmsg_sys_write':
include/linux/wait.h:171:47: error: 'TASK_INTERRUPTIBLE' undeclared (first use in this function)
#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
^
>> kernel/printk/kmsg.c:49:3: note: in expansion of macro 'wake_up_interruptible'
wake_up_interruptible(&log_b->wait);
^
include/linux/wait.h:171:47: note: each undeclared identifier is reported only once for each function it appears in
#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
^
>> kernel/printk/kmsg.c:49:3: note: in expansion of macro 'wake_up_interruptible'
wake_up_interruptible(&log_b->wait);
^
kernel/printk/kmsg.c: In function 'kmsg_read':
include/linux/wait.h:400:31: error: 'TASK_INTERRUPTIBLE' undeclared (first use in this function)
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
^
include/linux/wait.h:225:52: note: in definition of macro '___wait_event'
long __int = prepare_to_wait_event(&wq, &__wait, state);\
^
include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
kernel/printk/kmsg.c:140:9: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_b->wait,
^
include/linux/wait.h:198:43: error: 'TASK_KILLABLE' undeclared (first use in this function)
state == TASK_INTERRUPTIBLE || state == TASK_KILLABLE) \
^
include/linux/wait.h:230:7: note: in expansion of macro '___wait_is_interruptible'
if (___wait_is_interruptible(state) && __int) { \
^
include/linux/wait.h:400:2: note: in expansion of macro '___wait_event'
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
^
include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
kernel/printk/kmsg.c:140:9: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_b->wait,
^
include/linux/wait.h:401:9: error: implicit declaration of function 'schedule' [-Werror=implicit-function-declaration]
schedule())
^
include/linux/wait.h:240:3: note: in definition of macro '___wait_event'
cmd; \
^
include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
kernel/printk/kmsg.c:140:9: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_b->wait,
^
cc1: some warnings being treated as errors
vim +/wake_up_interruptible +49 kernel/printk/kmsg.c
1 #include <linux/printk.h>
2 #include <linux/kernel.h>
3 #include <linux/errno.h>
4 #include <linux/fcntl.h>
> 5 #include <linux/fs.h>
6 #include <linux/kmsg_dump.h>
7 #include <linux/moduleparam.h>
8 #include <linux/mutex.h>
9 #include <linux/spinlock.h>
10 #include <linux/slab.h>
11 #include <linux/poll.h>
12 #include <linux/rculist.h>
13 #include <linux/rcupdate.h>
14 #include <linux/stat.h>
15 #include <linux/syslog.h>
16 #include <linux/uio.h>
17 #include <linux/wait.h>
18
19 #include <asm/uaccess.h>
20
21 #include "printk.h"
22
23 /* /dev/kmsg - userspace message inject/listen interface */
24 struct devkmsg_user {
25 u64 seq;
26 u32 idx;
27 enum log_flags prev;
28 struct mutex lock;
29 char buf[CONSOLE_EXT_LOG_MAX];
30 };
31
32 static int kmsg_sys_write(int minor, int level, const char *fmt, ...)
33 {
34 va_list args;
35 int ret = -ENXIO;
36 struct log_buffer *log_b;
37
38 rcu_read_lock();
39 list_for_each_entry_rcu(log_b, &log_buf.list, list) {
40 if (log_b->minor != minor)
41 continue;
42
43 raw_spin_lock(&log_b->lock);
44
45 va_start(args, fmt);
46 log_format_and_store(log_b, 1 /* LOG_USER */, level,
47 NULL, 0, fmt, args);
48 va_end(args);
> 49 wake_up_interruptible(&log_b->wait);
50
51 raw_spin_unlock(&log_b->lock);
52
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
[-- Attachment #2: .config.gz --]
[-- Type: application/octet-stream, Size: 23978 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread
* [RFC v3 5/9] kmsg: add function for adding and deleting additional buffers
2015-10-19 12:58 [RFC v3 0/9] Additional kmsg devices Paul Osmialowski
` (2 preceding siblings ...)
2015-10-19 12:58 ` [RFC v3 3/9] kmsg: introduce additional kmsg devices support Paul Osmialowski
@ 2015-10-19 12:58 ` Paul Osmialowski
2015-10-19 18:20 ` kbuild test robot
2015-10-19 12:58 ` [RFC v3 6/9] kmsg: add ioctl for adding and deleting kmsg* devices Paul Osmialowski
` (4 subsequent siblings)
8 siblings, 1 reply; 23+ messages in thread
From: Paul Osmialowski @ 2015-10-19 12:58 UTC (permalink / raw)
To: Jonathan Corbet, Arnd Bergmann, Andrew Morton, Petr Mladek,
Greg Kroah-Hartman, Daniel Mack, Kay Sievers, Joe Perches,
Tejun Heo, linux-kernel, linux-doc, linux-api
Cc: Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
From: Marcin Niesluchowski <m.niesluchow@samsung.com>
Additional kmsg buffers should be created and deleted dynamically.
Adding two functions
* kmsg_sys_buffer_add() creates additional kmsg buffer returning minor
* kmsg_sys_buffer_del() deletes one based on provided minor
Signed-off-by: Marcin Niesluchowski <m.niesluchow@samsung.com>
Signed-off-by: Paul Osmialowski <p.osmialowsk@samsung.com>
---
include/linux/printk.h | 9 +++++
kernel/printk/kmsg.c | 107 +++++++++++++++++++++++++++++++++++++++++++++++--
kernel/printk/printk.c | 12 ++++++
kernel/printk/printk.h | 4 ++
4 files changed, 129 insertions(+), 3 deletions(-)
diff --git a/include/linux/printk.h b/include/linux/printk.h
index 67840e0..35111e8 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -431,6 +431,8 @@ extern const struct file_operations kmsg_fops;
extern struct device *init_kmsg(int minor, umode_t mode);
extern int kmsg_memory_open(struct inode *inode, struct file *filp);
extern int kmsg_mode(int minor, umode_t *mode);
+extern int kmsg_sys_buffer_add(size_t size, umode_t mode);
+extern void kmsg_sys_buffer_del(int minor);
#else
@@ -449,6 +451,13 @@ static inline int kmsg_mode(int minor, umode_t *mode)
return -ENXIO;
}
+static inline int kmsg_sys_buffer_add(size_t size, umode_t mode)
+{
+ return -ENXIO;
+}
+
+static inline void kmsg_sys_buffer_del(int minor) {}
+
#endif
enum {
diff --git a/kernel/printk/kmsg.c b/kernel/printk/kmsg.c
index 7fcd628..184575b 100644
--- a/kernel/printk/kmsg.c
+++ b/kernel/printk/kmsg.c
@@ -18,6 +18,7 @@
#include <linux/device.h>
#include <linux/major.h>
#include <linux/kdev_t.h>
+#include <linux/kref.h>
#include <asm/uaccess.h>
@@ -140,8 +141,20 @@ static ssize_t kmsg_read(struct log_buffer *log_b, struct file *file,
}
raw_spin_unlock_irq(&log_b->lock);
- ret = wait_event_interruptible(log_b->wait,
- user->seq != log_b->next_seq);
+ if (log_b == &log_buf) {
+ ret = wait_event_interruptible(log_b->wait,
+ user->seq != log_b->next_seq);
+ } else {
+ rcu_read_unlock();
+ kref_get(&log_b->refcount);
+ ret = wait_event_interruptible(log_b->wait,
+ user->seq != log_b->next_seq);
+ if (log_b->minor == -1)
+ ret = -ENXIO;
+ if (kref_put(&log_b->refcount, log_buf_release))
+ ret = -ENXIO;
+ rcu_read_lock();
+ }
if (ret)
goto out;
raw_spin_lock_irq(&log_b->lock);
@@ -310,8 +323,14 @@ static unsigned int devkmsg_poll(struct file *file, poll_table *wait)
rcu_read_lock();
list_for_each_entry_rcu(log_b, &log_buf.list, list) {
if (log_b->minor == minor) {
+ kref_get(&log_b->refcount);
+ rcu_read_unlock();
+
ret = kmsg_poll(log_b, file, wait);
- break;
+
+ if (kref_put(&log_b->refcount, log_buf_release))
+ return POLLERR|POLLNVAL;
+ return ret;
}
}
rcu_read_unlock();
@@ -427,6 +446,88 @@ int kmsg_mode(int minor, umode_t *mode)
return ret;
}
+static DEFINE_SPINLOCK(kmsg_sys_list_lock);
+
+int kmsg_sys_buffer_add(size_t size, umode_t mode)
+{
+ unsigned long flags;
+ int minor = log_buf.minor;
+ struct log_buffer *log_b;
+ struct log_buffer *log_b_new;
+
+ if (size < LOG_LINE_MAX + PREFIX_MAX)
+ return -EINVAL;
+
+ log_b_new = kzalloc(sizeof(struct log_buffer), GFP_KERNEL);
+ if (!log_b_new)
+ return -ENOMEM;
+
+ log_b_new->buf = kmalloc(size, GFP_KERNEL);
+ if (!log_b_new->buf) {
+ kfree(log_b_new);
+ return -ENOMEM;
+ }
+
+ log_b_new->len = size;
+ log_b_new->lock = __RAW_SPIN_LOCK_UNLOCKED(log_b_new->lock);
+ init_waitqueue_head(&log_b_new->wait);
+ kref_init(&log_b_new->refcount);
+ log_b_new->mode = mode;
+
+ kref_get(&log_b_new->refcount);
+
+ spin_lock_irqsave(&kmsg_sys_list_lock, flags);
+
+ list_for_each_entry(log_b, &log_buf.list, list) {
+ if (log_b->minor - minor > 1)
+ break;
+
+ minor = log_b->minor;
+ }
+
+ if (!(minor & MINORMASK)) {
+ kref_put(&log_b->refcount, log_buf_release);
+ spin_unlock_irqrestore(&kmsg_sys_list_lock, flags);
+ return -ERANGE;
+ }
+
+ minor += 1;
+ log_b_new->minor = minor;
+
+ list_add_tail_rcu(&log_b_new->list, &log_b->list);
+
+ spin_unlock_irqrestore(&kmsg_sys_list_lock, flags);
+
+ return minor;
+}
+
+void kmsg_sys_buffer_del(int minor)
+{
+ unsigned long flags;
+ struct log_buffer *log_b;
+
+ spin_lock_irqsave(&kmsg_sys_list_lock, flags);
+
+ list_for_each_entry(log_b, &log_buf.list, list) {
+ if (log_b->minor == minor)
+ break;
+ }
+
+ if (log_b == &log_buf) {
+ spin_unlock_irqrestore(&kmsg_sys_list_lock, flags);
+ return;
+ }
+
+ list_del_rcu(&log_b->list);
+
+ spin_unlock_irqrestore(&kmsg_sys_list_lock, flags);
+
+ log_b->minor = -1;
+ wake_up_interruptible(&log_b->wait);
+
+ kref_put(&log_b->refcount, log_buf_release);
+}
+
static DEFINE_SPINLOCK(dump_list_lock);
static LIST_HEAD(dump_list);
diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index beabebb..cfedbe9 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -41,6 +41,8 @@
#include <linux/irq_work.h>
#include <linux/utsname.h>
#include <linux/ctype.h>
+#include <linux/kref.h>
+#include <linux/slab.h>
#include <asm/uaccess.h>
@@ -173,6 +175,7 @@ struct log_buffer log_buf = {
.len = __LOG_BUF_K_LEN,
.lock = __RAW_SPIN_LOCK_UNLOCKED(log_buf.lock),
.wait = __WAIT_QUEUE_HEAD_INITIALIZER(log_buf.wait),
+ .refcount = { .refcount = { .counter = 0 } },
.first_seq = 0,
.first_idx = 0,
.next_seq = 0,
@@ -218,6 +221,15 @@ u32 log_buf_len_get(void)
return log_buf.len;
}
+void log_buf_release(struct kref *ref)
+{
+ struct log_buffer *log_b = container_of(ref, struct log_buffer,
+ refcount);
+
+ kfree(log_b->buf);
+ kfree(log_b);
+}
+
/*
* Check whether there is enough free space for the given message.
*
diff --git a/kernel/printk/printk.h b/kernel/printk/printk.h
index 0755100..64f8878 100644
--- a/kernel/printk/printk.h
+++ b/kernel/printk/printk.h
@@ -5,6 +5,7 @@
#include <linux/spinlock_types.h>
#include <linux/types.h>
#include <linux/wait.h>
+#include <linux/kref.h>
#define PREFIX_MAX 32
#define LOG_LINE_MAX (1024 - PREFIX_MAX)
@@ -99,6 +100,7 @@ struct log_buffer {
char *buf; /* cyclic log buffer */
u32 len; /* buffer length */
wait_queue_head_t wait; /* wait queue for kmsg buffer */
+ struct kref refcount; /* refcount for kmsg_sys buffers */
#endif
/*
* The lock protects kmsg buffer, indices, counters. This can be taken within
@@ -127,6 +129,8 @@ struct log_buffer {
extern struct log_buffer log_buf;
+void log_buf_release(struct kref *ref);
+
ssize_t msg_print_ext_header(char *buf, size_t size,
struct printk_log *msg, u64 seq,
enum log_flags prev_flags);
--
1.9.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [RFC v3 5/9] kmsg: add function for adding and deleting additional buffers
2015-10-19 12:58 ` [RFC v3 5/9] kmsg: add function for adding and deleting additional buffers Paul Osmialowski
@ 2015-10-19 18:20 ` kbuild test robot
0 siblings, 0 replies; 23+ messages in thread
From: kbuild test robot @ 2015-10-19 18:20 UTC (permalink / raw)
Cc: kbuild-all, Jonathan Corbet, Arnd Bergmann, Andrew Morton,
Petr Mladek, Greg Kroah-Hartman, Daniel Mack, Kay Sievers,
Joe Perches, Tejun Heo, linux-kernel, linux-doc, linux-api,
Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
Hi Marcin,
[auto build test WARNING on next-20151016 -- if it's inappropriate base, please suggest rules for selecting the more suitable base]
url: https://github.com/0day-ci/linux/commits/Paul-Osmialowski/Additional-kmsg-devices/20151019-211509
reproduce:
# apt-get install sparse
make ARCH=x86_64 allmodconfig
make C=1 CF=-D__CHECK_ENDIAN__
sparse warnings: (new ones prefixed by >>)
>> include/linux/rcupdate.h:915:9: sparse: context imbalance in 'kmsg_read' - unexpected unlock
vim +/kmsg_read +915 include/linux/rcupdate.h
f27bc4873 Paul E. McKenney 2014-05-04 899 * that that preemption never happens within any RCU read-side critical
f27bc4873 Paul E. McKenney 2014-05-04 900 * section whose outermost rcu_read_unlock() is called with irqs disabled.
f27bc4873 Paul E. McKenney 2014-05-04 901 * This approach relies on the fact that rt_mutex_unlock() currently only
f27bc4873 Paul E. McKenney 2014-05-04 902 * acquires irq-disabled locks.
f27bc4873 Paul E. McKenney 2014-05-04 903 *
f27bc4873 Paul E. McKenney 2014-05-04 904 * The second of these two approaches is best in most situations,
f27bc4873 Paul E. McKenney 2014-05-04 905 * however, the first approach can also be useful, at least to those
f27bc4873 Paul E. McKenney 2014-05-04 906 * developers willing to keep abreast of the set of locks acquired by
f27bc4873 Paul E. McKenney 2014-05-04 907 * rt_mutex_unlock().
f27bc4873 Paul E. McKenney 2014-05-04 908 *
3d76c0829 Paul E. McKenney 2009-09-28 909 * See rcu_read_lock() for more information.
3d76c0829 Paul E. McKenney 2009-09-28 910 */
bc33f24bd Paul E. McKenney 2009-08-22 911 static inline void rcu_read_unlock(void)
bc33f24bd Paul E. McKenney 2009-08-22 912 {
f78f5b90c Paul E. McKenney 2015-06-18 913 RCU_LOCKDEP_WARN(!rcu_is_watching(),
bde23c689 Heiko Carstens 2012-02-01 914 "rcu_read_unlock() used illegally while idle");
bc33f24bd Paul E. McKenney 2009-08-22 @915 __release(RCU);
bc33f24bd Paul E. McKenney 2009-08-22 916 __rcu_read_unlock();
d24209bb6 Paul E. McKenney 2015-01-21 917 rcu_lock_release(&rcu_lock_map); /* Keep acq info for rls diags. */
bc33f24bd Paul E. McKenney 2009-08-22 918 }
^1da177e4 Linus Torvalds 2005-04-16 919
^1da177e4 Linus Torvalds 2005-04-16 920 /**
ca5ecddfa Paul E. McKenney 2010-04-28 921 * rcu_read_lock_bh() - mark the beginning of an RCU-bh critical section
^1da177e4 Linus Torvalds 2005-04-16 922 *
^1da177e4 Linus Torvalds 2005-04-16 923 * This is equivalent of rcu_read_lock(), but to be used when updates
:::::: The code at line 915 was first introduced by commit
:::::: bc33f24bdca8b6e97376e3a182ab69e6cdefa989 rcu: Consolidate sparse and lockdep declarations in include/linux/rcupdate.h
:::::: TO: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
:::::: CC: Ingo Molnar <mingo@elte.hu>
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
^ permalink raw reply [flat|nested] 23+ messages in thread
* [RFC v3 6/9] kmsg: add ioctl for adding and deleting kmsg* devices
2015-10-19 12:58 [RFC v3 0/9] Additional kmsg devices Paul Osmialowski
` (3 preceding siblings ...)
2015-10-19 12:58 ` [RFC v3 5/9] kmsg: add function for adding and deleting additional buffers Paul Osmialowski
@ 2015-10-19 12:58 ` Paul Osmialowski
2015-10-19 13:19 ` Arnd Bergmann
2015-10-19 12:58 ` [RFC v3 7/9] kmsg: add ioctl for kmsg* devices operating on buffers Paul Osmialowski
` (3 subsequent siblings)
8 siblings, 1 reply; 23+ messages in thread
From: Paul Osmialowski @ 2015-10-19 12:58 UTC (permalink / raw)
To: Jonathan Corbet, Arnd Bergmann, Andrew Morton, Petr Mladek,
Greg Kroah-Hartman, Daniel Mack, Kay Sievers, Joe Perches,
Tejun Heo, linux-kernel, linux-doc, linux-api
Cc: Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
From: Marcin Niesluchowski <m.niesluchow@samsung.com>
There is no possibility to add/delete kmsg* buffers from userspace.
Adds following ioctl for main kmsg device adding and deleting
additional kmsg devices:
* KMSG_CMD_BUFFER_ADD
* KMSG_CMD_BUFFER_DEL
Signed-off-by: Marcin Niesluchowski <m.niesluchow@samsung.com>
Signed-off-by: Paul Osmialowski <p.osmialowsk@samsung.com>
---
Documentation/ioctl/ioctl-number.txt | 1 +
drivers/char/mem.c | 2 +-
include/linux/printk.h | 7 ++
include/uapi/linux/Kbuild | 1 +
include/uapi/linux/kmsg_ioctl.h | 30 +++++++++
kernel/printk/kmsg.c | 123 +++++++++++++++++++++++++++++++++++
6 files changed, 163 insertions(+), 1 deletion(-)
create mode 100644 include/uapi/linux/kmsg_ioctl.h
diff --git a/Documentation/ioctl/ioctl-number.txt b/Documentation/ioctl/ioctl-number.txt
index 43e6923..76dec8b 100644
--- a/Documentation/ioctl/ioctl-number.txt
+++ b/Documentation/ioctl/ioctl-number.txt
@@ -319,6 +319,7 @@ Code Seq#(hex) Include File Comments
<mailto:vgo@ratio.de>
0xB1 00-1F PPPoX <mailto:mostrows@styx.uwaterloo.ca>
0xB3 00 linux/mmc/ioctl.h
+0xBB 00-02 uapi/linux/kmsg_ioctl.h
0xC0 00-0F linux/usb/iowarrior.h
0xCA 00-0F uapi/misc/cxl.h
0xCA 80-8F uapi/scsi/cxlflash_ioctl.h
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 7d46234..ac824de 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -808,7 +808,7 @@ static int memory_open(struct inode *inode, struct file *filp)
minor = iminor(inode);
if (minor >= ARRAY_SIZE(devlist))
- return kmsg_memory_open(inode, filp);
+ return kmsg_memory_open_ext(inode, filp);
dev = &devlist[minor];
if (!dev->fops)
diff --git a/include/linux/printk.h b/include/linux/printk.h
index 35111e8..294adab 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -427,9 +427,11 @@ extern struct class *mem_class;
#define KMSG_MINOR 11
extern const struct file_operations kmsg_fops;
+extern const struct file_operations kmsg_fops_ext;
extern struct device *init_kmsg(int minor, umode_t mode);
extern int kmsg_memory_open(struct inode *inode, struct file *filp);
+extern int kmsg_memory_open_ext(struct inode *inode, struct file *filp);
extern int kmsg_mode(int minor, umode_t *mode);
extern int kmsg_sys_buffer_add(size_t size, umode_t mode);
extern void kmsg_sys_buffer_del(int minor);
@@ -446,6 +448,11 @@ static inline int kmsg_memory_open(struct inode *inode, struct file *filp)
return -ENXIO;
}
+static inline int kmsg_memory_open_ext(struct inode *inode, struct file *filp)
+{
+ return -ENXIO;
+}
+
static inline int kmsg_mode(int minor, umode_t *mode)
{
return -ENXIO;
diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild
index e777078..d998999 100644
--- a/include/uapi/linux/Kbuild
+++ b/include/uapi/linux/Kbuild
@@ -225,6 +225,7 @@ header-y += kernel-page-flags.h
header-y += kexec.h
header-y += keyboard.h
header-y += keyctl.h
+header-y += kmsg_ioctl.h
ifneq ($(wildcard $(srctree)/arch/$(SRCARCH)/include/uapi/asm/kvm.h \
$(srctree)/arch/$(SRCARCH)/include/asm/kvm.h),)
diff --git a/include/uapi/linux/kmsg_ioctl.h b/include/uapi/linux/kmsg_ioctl.h
new file mode 100644
index 0000000..89c0c61
--- /dev/null
+++ b/include/uapi/linux/kmsg_ioctl.h
@@ -0,0 +1,30 @@
+/*
+ * This is ioctl include for kmsg* devices
+ */
+
+#ifndef _KMSG_IOCTL_H_
+#define _KMSG_IOCTL_H_
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+struct kmsg_cmd_buffer_add {
+ size_t size;
+ unsigned short mode;
+ int minor;
+} __attribute__((packed));
+
+#define KMSG_IOCTL_MAGIC 0xBB
+
+/*
+ * A ioctl interface for kmsg device.
+ *
+ * KMSG_CMD_BUFFER_ADD: Creates additional kmsg device based on its size
+ * and mode. Minor of created device is put.
+ * KMSG_CMD_BUFFER_DEL: Removes additional kmsg device based on its minor
+ */
+#define KMSG_CMD_BUFFER_ADD _IOWR(KMSG_IOCTL_MAGIC, 0x00, \
+ struct kmsg_cmd_buffer_add)
+#define KMSG_CMD_BUFFER_DEL _IOW(KMSG_IOCTL_MAGIC, 0x01, int)
+
+#endif
diff --git a/kernel/printk/kmsg.c b/kernel/printk/kmsg.c
index 184575b..f91a64a 100644
--- a/kernel/printk/kmsg.c
+++ b/kernel/printk/kmsg.c
@@ -22,8 +22,12 @@
#include <asm/uaccess.h>
+#include <uapi/linux/kmsg_ioctl.h>
+
#include "printk.h"
+#define KMSG_MAX_MINOR_LEN 20
+
/* /dev/kmsg - userspace message inject/listen interface */
struct devkmsg_user {
u64 seq;
@@ -407,6 +411,118 @@ const struct file_operations kmsg_fops = {
.release = devkmsg_release,
};
+static int kmsg_open_ext(struct inode *inode, struct file *file)
+{
+ return kmsg_fops.open(inode, file);
+}
+
+static ssize_t kmsg_write_iter_ext(struct kiocb *iocb, struct iov_iter *from)
+{
+ return kmsg_fops.write_iter(iocb, from);
+}
+
+static ssize_t kmsg_read_ext(struct file *file, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ return kmsg_fops.read(file, buf, count, ppos);
+}
+
+static loff_t kmsg_llseek_ext(struct file *file, loff_t offset, int whence)
+{
+ return kmsg_fops.llseek(file, offset, whence);
+}
+
+static unsigned int kmsg_poll_ext(struct file *file,
+ struct poll_table_struct *wait)
+{
+ return kmsg_fops.poll(file, wait);
+}
+
+static long kmsg_ioctl_buffers(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ void __user *argp = (void __user *)arg;
+ size_t size;
+ umode_t mode;
+ char name[4 + KMSG_MAX_MINOR_LEN + 1];
+ struct device *dev;
+ int minor;
+
+ if (iminor(file->f_inode) != log_buf.minor)
+ return -ENOTTY;
+
+ switch (cmd) {
+ case KMSG_CMD_BUFFER_ADD:
+ if (copy_from_user(&size, argp, sizeof(size)))
+ return -EFAULT;
+ argp += sizeof(size);
+ if (copy_from_user(&mode, argp, sizeof(mode)))
+ return -EFAULT;
+ argp += sizeof(mode);
+ minor = kmsg_sys_buffer_add(size, mode);
+ if (minor < 0)
+ return minor;
+ sprintf(name, "kmsg%d", minor);
+ dev = device_create(mem_class, NULL, MKDEV(MEM_MAJOR, minor),
+ NULL, name);
+ if (IS_ERR(dev)) {
+ kmsg_sys_buffer_del(minor);
+ return PTR_ERR(dev);
+ }
+ if (copy_to_user(argp, &minor, sizeof(minor))) {
+ device_destroy(mem_class, MKDEV(MEM_MAJOR, minor));
+ kmsg_sys_buffer_del(minor);
+ return -EFAULT;
+ }
+ return 0;
+ case KMSG_CMD_BUFFER_DEL:
+ if (copy_from_user(&minor, argp, sizeof(minor)))
+ return -EFAULT;
+ if (minor <= log_buf.minor)
+ return -EINVAL;
+ device_destroy(mem_class, MKDEV(MEM_MAJOR, minor));
+ kmsg_sys_buffer_del(minor);
+ return 0;
+ }
+ return -ENOTTY;
+}
+
+static long kmsg_unlocked_ioctl_ext(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ long ret = kmsg_ioctl_buffers(file, cmd, arg);
+
+ if (ret == -ENOTTY)
+ return kmsg_fops.unlocked_ioctl(file, cmd, arg);
+ return ret;
+}
+
+static long kmsg_compat_ioctl_ext(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ long ret = kmsg_ioctl_buffers(file, cmd, arg);
+
+ if (ret == -ENOTTY)
+ return kmsg_fops.compat_ioctl(file, cmd, arg);
+ return ret;
+}
+
+static int kmsg_release_ext(struct inode *inode, struct file *file)
+{
+ return kmsg_fops.release(inode, file);
+}
+
+const struct file_operations kmsg_fops_ext = {
+ .open = kmsg_open_ext,
+ .read = kmsg_read_ext,
+ .write_iter = kmsg_write_iter_ext,
+ .llseek = kmsg_llseek_ext,
+ .poll = kmsg_poll_ext,
+ .unlocked_ioctl = kmsg_unlocked_ioctl_ext,
+ .compat_ioctl = kmsg_compat_ioctl_ext,
+ .release = kmsg_release_ext,
+};
+
/* Should be used for device registration */
struct device *init_kmsg(int minor, umode_t mode)
{
@@ -423,6 +539,13 @@ int kmsg_memory_open(struct inode *inode, struct file *filp)
return kmsg_fops.open(inode, filp);
}
+int kmsg_memory_open_ext(struct inode *inode, struct file *filp)
+{
+ filp->f_op = &kmsg_fops_ext;
+
+ return kmsg_fops_ext.open(inode, filp);
+}
+
int kmsg_mode(int minor, umode_t *mode)
{
int ret = -ENXIO;
--
1.9.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [RFC v3 6/9] kmsg: add ioctl for adding and deleting kmsg* devices
2015-10-19 12:58 ` [RFC v3 6/9] kmsg: add ioctl for adding and deleting kmsg* devices Paul Osmialowski
@ 2015-10-19 13:19 ` Arnd Bergmann
0 siblings, 0 replies; 23+ messages in thread
From: Arnd Bergmann @ 2015-10-19 13:19 UTC (permalink / raw)
To: Paul Osmialowski
Cc: Jonathan Corbet, Andrew Morton, Petr Mladek, Greg Kroah-Hartman,
Daniel Mack, Kay Sievers, Joe Perches, Tejun Heo, linux-kernel,
linux-doc, linux-api, Marcin Niesluchowski, Karol Lewandowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
On Monday 19 October 2015 14:58:20 Paul Osmialowski wrote:
> +
> +struct kmsg_cmd_buffer_add {
> + size_t size;
> + unsigned short mode;
> + int minor;
> +} __attribute__((packed));
> +
> +#define KMSG_IOCTL_MAGIC 0xBB
> +
> +/*
>
Try to avoid using packed unaligned data structures. Here I would
just use __u64 and __u32 members.
> + case KMSG_CMD_BUFFER_ADD:
> + if (copy_from_user(&size, argp, sizeof(size)))
> + return -EFAULT;
> + argp += sizeof(size);
> + if (copy_from_user(&mode, argp, sizeof(mode)))
> + return -EFAULT;
This is a rather unusual way to access the data. Just copy the
entire structure to the stack.
Arnd
^ permalink raw reply [flat|nested] 23+ messages in thread
* [RFC v3 7/9] kmsg: add ioctl for kmsg* devices operating on buffers
2015-10-19 12:58 [RFC v3 0/9] Additional kmsg devices Paul Osmialowski
` (4 preceding siblings ...)
2015-10-19 12:58 ` [RFC v3 6/9] kmsg: add ioctl for adding and deleting kmsg* devices Paul Osmialowski
@ 2015-10-19 12:58 ` Paul Osmialowski
2015-10-19 12:58 ` [RFC v3 8/9] kmsg: add predefined _PID, _TID, _COMM keywords to kmsg* log dict Paul Osmialowski
` (2 subsequent siblings)
8 siblings, 0 replies; 23+ messages in thread
From: Paul Osmialowski @ 2015-10-19 12:58 UTC (permalink / raw)
To: Jonathan Corbet, Arnd Bergmann, Andrew Morton, Petr Mladek,
Greg Kroah-Hartman, Daniel Mack, Kay Sievers, Joe Perches,
Tejun Heo, linux-kernel, linux-doc, linux-api
Cc: Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
From: Marcin Niesluchowski <m.niesluchow@samsung.com>
There is no possibility to clear additional kmsg buffers,
get size of them or know what size should be passed to read
file operation (too small size causes it to retrun -EINVAL).
Add following ioctls which solve those issues:
* KMSG_CMD_GET_BUF_SIZE
* KMSG_CMD_GET_READ_SIZE_MAX
* KMSG_CMD_CLEAR
Signed-off-by: Marcin Niesluchowski <m.niesluchow@samsung.com>
Signed-off-by: Paul Osmialowski <p.osmialowsk@samsung.com>
---
Documentation/ioctl/ioctl-number.txt | 2 +-
include/uapi/linux/kmsg_ioctl.h | 15 ++++++++++
kernel/printk/kmsg.c | 57 ++++++++++++++++++++++++++++++++++--
3 files changed, 71 insertions(+), 3 deletions(-)
diff --git a/Documentation/ioctl/ioctl-number.txt b/Documentation/ioctl/ioctl-number.txt
index 76dec8b..d36bb04 100644
--- a/Documentation/ioctl/ioctl-number.txt
+++ b/Documentation/ioctl/ioctl-number.txt
@@ -319,7 +319,7 @@ Code Seq#(hex) Include File Comments
<mailto:vgo@ratio.de>
0xB1 00-1F PPPoX <mailto:mostrows@styx.uwaterloo.ca>
0xB3 00 linux/mmc/ioctl.h
-0xBB 00-02 uapi/linux/kmsg_ioctl.h
+0xBB 00-83 uapi/linux/kmsg_ioctl.h
0xC0 00-0F linux/usb/iowarrior.h
0xCA 00-0F uapi/misc/cxl.h
0xCA 80-8F uapi/scsi/cxlflash_ioctl.h
diff --git a/include/uapi/linux/kmsg_ioctl.h b/include/uapi/linux/kmsg_ioctl.h
index 89c0c61..2389d9f 100644
--- a/include/uapi/linux/kmsg_ioctl.h
+++ b/include/uapi/linux/kmsg_ioctl.h
@@ -27,4 +27,19 @@ struct kmsg_cmd_buffer_add {
struct kmsg_cmd_buffer_add)
#define KMSG_CMD_BUFFER_DEL _IOW(KMSG_IOCTL_MAGIC, 0x01, int)
+/*
+ * A ioctl interface for kmsg* devices.
+ *
+ * KMSG_CMD_GET_BUF_SIZE: Retrieve cyclic log buffer size associated with
+ * device.
+ * KMSG_CMD_GET_READ_SIZE_MAX: Retrieve max size of data read by kmsg read
+ * operation.
+ * KMSG_CMD_CLEAR: Clears cyclic log buffer. After that operation
+ * there is no data to read from buffer unless
+ * logs are written.
+ */
+#define KMSG_CMD_GET_BUF_SIZE _IOR(KMSG_IOCTL_MAGIC, 0x80, __u32)
+#define KMSG_CMD_GET_READ_SIZE_MAX _IOR(KMSG_IOCTL_MAGIC, 0x81, __u32)
+#define KMSG_CMD_CLEAR _IO(KMSG_IOCTL_MAGIC, 0x82)
+
#endif
diff --git a/kernel/printk/kmsg.c b/kernel/printk/kmsg.c
index f91a64a..0f56fc9 100644
--- a/kernel/printk/kmsg.c
+++ b/kernel/printk/kmsg.c
@@ -246,8 +246,9 @@ static loff_t kmsg_llseek(struct log_buffer *log_b, struct file *file,
}
/*
* The first record after the last SYSLOG_ACTION_CLEAR,
- * like issued by 'dmesg -c'. Reading /dev/kmsg itself
- * changes no global state, and does not clear anything.
+ * like issued by 'dmesg -c' or KMSG_CMD_CLEAR ioctl
+ * command. Reading /dev/kmsg itself changes no global
+ * state, and does not clear anything.
*/
user->idx = log_b->clear_idx;
user->seq = log_b->clear_seq;
@@ -390,6 +391,56 @@ static int devkmsg_open(struct inode *inode, struct file *file)
return ret;
}
+static long kmsg_ioctl(struct log_buffer *log_b, unsigned int cmd,
+ unsigned long arg)
+{
+ void __user *argp = (void __user *)arg;
+ static const u32 read_size_max = CONSOLE_EXT_LOG_MAX;
+
+ switch (cmd) {
+ case KMSG_CMD_GET_BUF_SIZE:
+ if (copy_to_user(argp, &log_b->len, sizeof(u32)))
+ return -EFAULT;
+ break;
+ case KMSG_CMD_GET_READ_SIZE_MAX:
+ if (copy_to_user(argp, &read_size_max, sizeof(u32)))
+ return -EFAULT;
+ break;
+ case KMSG_CMD_CLEAR:
+ if (!capable(CAP_SYSLOG))
+ return -EPERM;
+ raw_spin_lock_irq(&log_b->lock);
+ log_b->clear_seq = log_b->next_seq;
+ log_b->clear_idx = log_b->next_idx;
+ raw_spin_unlock_irq(&log_b->lock);
+ break;
+ default:
+ return -ENOTTY;
+ }
+ return 0;
+}
+
+static long devkmsg_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ long ret = -ENXIO;
+ int minor = iminor(file->f_inode);
+ struct log_buffer *log_b;
+
+ if (minor == log_buf.minor)
+ return kmsg_ioctl(&log_buf, cmd, arg);
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(log_b, &log_buf.list, list) {
+ if (log_b->minor == minor) {
+ ret = kmsg_ioctl(log_b, cmd, arg);
+ break;
+ }
+ }
+ rcu_read_unlock();
+ return ret;
+}
+
static int devkmsg_release(struct inode *inode, struct file *file)
{
struct devkmsg_user *user = file->private_data;
@@ -408,6 +459,8 @@ const struct file_operations kmsg_fops = {
.write_iter = devkmsg_write,
.llseek = devkmsg_llseek,
.poll = devkmsg_poll,
+ .unlocked_ioctl = devkmsg_ioctl,
+ .compat_ioctl = devkmsg_ioctl,
.release = devkmsg_release,
};
--
1.9.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [RFC v3 8/9] kmsg: add predefined _PID, _TID, _COMM keywords to kmsg* log dict
2015-10-19 12:58 [RFC v3 0/9] Additional kmsg devices Paul Osmialowski
` (5 preceding siblings ...)
2015-10-19 12:58 ` [RFC v3 7/9] kmsg: add ioctl for kmsg* devices operating on buffers Paul Osmialowski
@ 2015-10-19 12:58 ` Paul Osmialowski
2015-10-19 13:53 ` kbuild test robot
` (2 more replies)
[not found] ` <1445259503-18158-1-git-send-email-p.osmialowsk-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>
2015-10-19 13:26 ` [RFC v3 0/9] Additional kmsg devices Richard Weinberger
8 siblings, 3 replies; 23+ messages in thread
From: Paul Osmialowski @ 2015-10-19 12:58 UTC (permalink / raw)
To: Jonathan Corbet, Arnd Bergmann, Andrew Morton, Petr Mladek,
Greg Kroah-Hartman, Daniel Mack, Kay Sievers, Joe Perches,
Tejun Heo, linux-kernel, linux-doc, linux-api
Cc: Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
From: Marcin Niesluchowski <m.niesluchow@samsung.com>
kmsg* devices write operation wrote no dict along with message
Due to usage of kmsg devices in userspace dict has been added
identifying pid, tid and comm of writing process.
Signed-off-by: Marcin Niesluchowski <m.niesluchow@samsung.com>
Signed-off-by: Paul Osmialowski <p.osmialowsk@samsung.com>
---
kernel/printk/kmsg.c | 40 ++++++++++++++++++++++++++++++++++++----
1 file changed, 36 insertions(+), 4 deletions(-)
diff --git a/kernel/printk/kmsg.c b/kernel/printk/kmsg.c
index 0f56fc9..8c904fe 100644
--- a/kernel/printk/kmsg.c
+++ b/kernel/printk/kmsg.c
@@ -28,6 +28,17 @@
#define KMSG_MAX_MINOR_LEN 20
+#define MAX_PID_LEN 20
+#define MAX_TID_LEN 20
+/*
+ * Fromat below describes dict appended to message written from userspace:
+ * "_PID=<pid>\0_TID=<tid>\0_COMM=<comm>"
+ * KMSG_DICT_MAX_LEN definition represents maximal length of this dict.
+ */
+#define KMSG_DICT_MAX_LEN (5 + MAX_PID_LEN + 1 + \
+ 5 + MAX_TID_LEN + 1 + \
+ 6 + TASK_COMM_LEN)
+
/* /dev/kmsg - userspace message inject/listen interface */
struct devkmsg_user {
u64 seq;
@@ -37,7 +48,23 @@ struct devkmsg_user {
char buf[CONSOLE_EXT_LOG_MAX];
};
-static int kmsg_sys_write(int minor, int level, const char *fmt, ...)
+static size_t set_kmsg_dict(char *buf)
+{
+ size_t len;
+
+ len = sprintf(buf, "_PID=%d", task_tgid_nr(current)) + 1;
+ len += sprintf(buf + len, "_TID=%d", task_pid_nr(current)) + 1;
+ memcpy(buf + len, "_COMM=", 6);
+ len += 6;
+ get_task_comm(buf + len, current);
+ while (buf[len] != '\0')
+ len++;
+ return len;
+}
+
+static int kmsg_sys_write(int minor, int level,
+ const char *dict, size_t dictlen,
+ const char *fmt, ...)
{
va_list args;
int ret = -ENXIO;
@@ -52,7 +79,7 @@ static int kmsg_sys_write(int minor, int level, const char *fmt, ...)
va_start(args, fmt);
log_format_and_store(log_b, 1 /* LOG_USER */, level,
- NULL, 0, fmt, args);
+ dict, dictlen, fmt, args);
va_end(args);
wake_up_interruptible(&log_b->wait);
@@ -72,6 +99,8 @@ static ssize_t devkmsg_write(struct kiocb *iocb, struct iov_iter *from)
int level = default_message_loglevel;
int facility = 1; /* LOG_USER */
size_t len = iov_iter_count(from);
+ char dict[KMSG_DICT_MAX_LEN];
+ size_t dictlen;
ssize_t ret = len;
int minor = iminor(iocb->ki_filp->f_inode);
@@ -111,10 +140,13 @@ static ssize_t devkmsg_write(struct kiocb *iocb, struct iov_iter *from)
}
}
+ dictlen = set_kmsg_dict(dict);
+
if (minor == log_buf.minor) {
- printk_emit(facility, level, NULL, 0, "%s", line);
+ printk_emit(facility, level, dict, dictlen, "%s", line);
} else {
- int error = kmsg_sys_write(minor, level, "%s", line);
+ int error = kmsg_sys_write(minor, level, dict, dictlen,
+ "%s", line);
if (error)
ret = error;
--
1.9.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [RFC v3 8/9] kmsg: add predefined _PID, _TID, _COMM keywords to kmsg* log dict
2015-10-19 12:58 ` [RFC v3 8/9] kmsg: add predefined _PID, _TID, _COMM keywords to kmsg* log dict Paul Osmialowski
@ 2015-10-19 13:53 ` kbuild test robot
2015-10-19 14:11 ` kbuild test robot
2015-10-19 17:45 ` Andy Lutomirski
2 siblings, 0 replies; 23+ messages in thread
From: kbuild test robot @ 2015-10-19 13:53 UTC (permalink / raw)
Cc: kbuild-all, Jonathan Corbet, Arnd Bergmann, Andrew Morton,
Petr Mladek, Greg Kroah-Hartman, Daniel Mack, Kay Sievers,
Joe Perches, Tejun Heo, linux-kernel, linux-doc, linux-api,
Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
[-- Attachment #1: Type: text/plain, Size: 7633 bytes --]
Hi Marcin,
[auto build test ERROR on next-20151016 -- if it's inappropriate base, please suggest rules for selecting the more suitable base]
url: https://github.com/0day-ci/linux/commits/Paul-Osmialowski/Additional-kmsg-devices/20151019-211509
config: i386-randconfig-s1-201542 (attached as .config)
reproduce:
# save the attached .config to linux build tree
make ARCH=i386
All error/warnings (new ones prefixed by >>):
kernel/printk/kmsg.c: In function 'set_kmsg_dict':
>> kernel/printk/kmsg.c:55:32: error: implicit declaration of function 'task_tgid_nr' [-Werror=implicit-function-declaration]
len = sprintf(buf, "_PID=%d", task_tgid_nr(current)) + 1;
^
>> kernel/printk/kmsg.c:56:39: error: implicit declaration of function 'task_pid_nr' [-Werror=implicit-function-declaration]
len += sprintf(buf + len, "_TID=%d", task_pid_nr(current)) + 1;
^
>> kernel/printk/kmsg.c:59:2: error: implicit declaration of function 'get_task_comm' [-Werror=implicit-function-declaration]
get_task_comm(buf + len, current);
^
In file included from include/linux/fs.h:5:0,
from kernel/printk/kmsg.c:5:
kernel/printk/kmsg.c: In function 'kmsg_sys_write':
include/linux/wait.h:171:47: error: 'TASK_INTERRUPTIBLE' undeclared (first use in this function)
#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
^
kernel/printk/kmsg.c:84:3: note: in expansion of macro 'wake_up_interruptible'
wake_up_interruptible(&log_b->wait);
^
include/linux/wait.h:171:47: note: each undeclared identifier is reported only once for each function it appears in
#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
^
kernel/printk/kmsg.c:84:3: note: in expansion of macro 'wake_up_interruptible'
wake_up_interruptible(&log_b->wait);
^
kernel/printk/kmsg.c: In function 'devkmsg_write':
>> kernel/printk/kmsg.c:40:10: error: 'TASK_COMM_LEN' undeclared (first use in this function)
6 + TASK_COMM_LEN)
^
kernel/printk/kmsg.c:102:12: note: in expansion of macro 'KMSG_DICT_MAX_LEN'
char dict[KMSG_DICT_MAX_LEN];
^
>> kernel/printk/kmsg.c:102:7: warning: unused variable 'dict' [-Wunused-variable]
char dict[KMSG_DICT_MAX_LEN];
^
In file included from include/linux/fs.h:5:0,
from kernel/printk/kmsg.c:5:
kernel/printk/kmsg.c: In function 'kmsg_read':
include/linux/wait.h:400:31: error: 'TASK_INTERRUPTIBLE' undeclared (first use in this function)
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
^
include/linux/wait.h:225:52: note: in definition of macro '___wait_event'
long __int = prepare_to_wait_event(&wq, &__wait, state);\
^
include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
kernel/printk/kmsg.c:181:10: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_b->wait,
^
include/linux/wait.h:198:43: error: 'TASK_KILLABLE' undeclared (first use in this function)
state == TASK_INTERRUPTIBLE || state == TASK_KILLABLE) \
^
include/linux/wait.h:230:7: note: in expansion of macro '___wait_is_interruptible'
if (___wait_is_interruptible(state) && __int) { \
^
include/linux/wait.h:400:2: note: in expansion of macro '___wait_event'
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
^
include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
kernel/printk/kmsg.c:181:10: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_b->wait,
^
include/linux/wait.h:401:9: error: implicit declaration of function 'schedule' [-Werror=implicit-function-declaration]
schedule())
^
include/linux/wait.h:240:3: note: in definition of macro '___wait_event'
cmd; \
^
include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
kernel/printk/kmsg.c:181:10: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_b->wait,
^
kernel/printk/kmsg.c: In function 'kmsg_sys_buffer_del':
include/linux/wait.h:171:47: error: 'TASK_INTERRUPTIBLE' undeclared (first use in this function)
#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
^
kernel/printk/kmsg.c:734:2: note: in expansion of macro 'wake_up_interruptible'
wake_up_interruptible(&log_b->wait);
^
cc1: some warnings being treated as errors
vim +/task_tgid_nr +55 kernel/printk/kmsg.c
34 * Fromat below describes dict appended to message written from userspace:
35 * "_PID=<pid>\0_TID=<tid>\0_COMM=<comm>"
36 * KMSG_DICT_MAX_LEN definition represents maximal length of this dict.
37 */
38 #define KMSG_DICT_MAX_LEN (5 + MAX_PID_LEN + 1 + \
39 5 + MAX_TID_LEN + 1 + \
> 40 6 + TASK_COMM_LEN)
41
42 /* /dev/kmsg - userspace message inject/listen interface */
43 struct devkmsg_user {
44 u64 seq;
45 u32 idx;
46 enum log_flags prev;
47 struct mutex lock;
48 char buf[CONSOLE_EXT_LOG_MAX];
49 };
50
51 static size_t set_kmsg_dict(char *buf)
52 {
53 size_t len;
54
> 55 len = sprintf(buf, "_PID=%d", task_tgid_nr(current)) + 1;
> 56 len += sprintf(buf + len, "_TID=%d", task_pid_nr(current)) + 1;
57 memcpy(buf + len, "_COMM=", 6);
58 len += 6;
> 59 get_task_comm(buf + len, current);
60 while (buf[len] != '\0')
61 len++;
62 return len;
63 }
64
65 static int kmsg_sys_write(int minor, int level,
66 const char *dict, size_t dictlen,
67 const char *fmt, ...)
68 {
69 va_list args;
70 int ret = -ENXIO;
71 struct log_buffer *log_b;
72
73 rcu_read_lock();
74 list_for_each_entry_rcu(log_b, &log_buf.list, list) {
75 if (log_b->minor != minor)
76 continue;
77
78 raw_spin_lock(&log_b->lock);
79
80 va_start(args, fmt);
81 log_format_and_store(log_b, 1 /* LOG_USER */, level,
82 dict, dictlen, fmt, args);
83 va_end(args);
> 84 wake_up_interruptible(&log_b->wait);
85
86 raw_spin_unlock(&log_b->lock);
87
88 ret = 0;
89 break;
90 }
91 rcu_read_unlock();
92 return ret;
93 }
94
95 static ssize_t devkmsg_write(struct kiocb *iocb, struct iov_iter *from)
96 {
97 char *buf, *line;
98 int i;
99 int level = default_message_loglevel;
100 int facility = 1; /* LOG_USER */
101 size_t len = iov_iter_count(from);
> 102 char dict[KMSG_DICT_MAX_LEN];
103 size_t dictlen;
104 ssize_t ret = len;
105 int minor = iminor(iocb->ki_filp->f_inode);
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
[-- Attachment #2: .config.gz --]
[-- Type: application/octet-stream, Size: 23426 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [RFC v3 8/9] kmsg: add predefined _PID, _TID, _COMM keywords to kmsg* log dict
2015-10-19 12:58 ` [RFC v3 8/9] kmsg: add predefined _PID, _TID, _COMM keywords to kmsg* log dict Paul Osmialowski
2015-10-19 13:53 ` kbuild test robot
@ 2015-10-19 14:11 ` kbuild test robot
2015-10-19 17:45 ` Andy Lutomirski
2 siblings, 0 replies; 23+ messages in thread
From: kbuild test robot @ 2015-10-19 14:11 UTC (permalink / raw)
Cc: kbuild-all, Jonathan Corbet, Arnd Bergmann, Andrew Morton,
Petr Mladek, Greg Kroah-Hartman, Daniel Mack, Kay Sievers,
Joe Perches, Tejun Heo, linux-kernel, linux-doc, linux-api,
Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
[-- Attachment #1: Type: text/plain, Size: 6234 bytes --]
Hi Marcin,
[auto build test WARNING on next-20151016 -- if it's inappropriate base, please suggest rules for selecting the more suitable base]
url: https://github.com/0day-ci/linux/commits/Paul-Osmialowski/Additional-kmsg-devices/20151019-211509
config: i386-defconfig (attached as .config)
reproduce:
# save the attached .config to linux build tree
make ARCH=i386
All warnings (new ones prefixed by >>):
kernel/printk/kmsg.c: In function 'set_kmsg_dict':
kernel/printk/kmsg.c:55:32: error: implicit declaration of function 'task_tgid_nr' [-Werror=implicit-function-declaration]
len = sprintf(buf, "_PID=%d", task_tgid_nr(current)) + 1;
^
kernel/printk/kmsg.c:56:39: error: implicit declaration of function 'task_pid_nr' [-Werror=implicit-function-declaration]
len += sprintf(buf + len, "_TID=%d", task_pid_nr(current)) + 1;
^
kernel/printk/kmsg.c:59:2: error: implicit declaration of function 'get_task_comm' [-Werror=implicit-function-declaration]
get_task_comm(buf + len, current);
^
In file included from include/linux/fs.h:5:0,
from kernel/printk/kmsg.c:5:
kernel/printk/kmsg.c: In function 'kmsg_sys_write':
include/linux/wait.h:171:47: error: 'TASK_INTERRUPTIBLE' undeclared (first use in this function)
#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
^
kernel/printk/kmsg.c:84:3: note: in expansion of macro 'wake_up_interruptible'
wake_up_interruptible(&log_b->wait);
^
include/linux/wait.h:171:47: note: each undeclared identifier is reported only once for each function it appears in
#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
^
kernel/printk/kmsg.c:84:3: note: in expansion of macro 'wake_up_interruptible'
wake_up_interruptible(&log_b->wait);
^
kernel/printk/kmsg.c: In function 'devkmsg_write':
kernel/printk/kmsg.c:40:10: error: 'TASK_COMM_LEN' undeclared (first use in this function)
6 + TASK_COMM_LEN)
^
>> kernel/printk/kmsg.c:102:12: note: in expansion of macro 'KMSG_DICT_MAX_LEN'
char dict[KMSG_DICT_MAX_LEN];
^
kernel/printk/kmsg.c:102:7: warning: unused variable 'dict' [-Wunused-variable]
char dict[KMSG_DICT_MAX_LEN];
^
In file included from include/linux/fs.h:5:0,
from kernel/printk/kmsg.c:5:
kernel/printk/kmsg.c: In function 'kmsg_read':
include/linux/wait.h:400:31: error: 'TASK_INTERRUPTIBLE' undeclared (first use in this function)
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
^
include/linux/wait.h:225:52: note: in definition of macro '___wait_event'
long __int = prepare_to_wait_event(&wq, &__wait, state);\
^
include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
kernel/printk/kmsg.c:181:10: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_b->wait,
^
include/linux/wait.h:198:43: error: 'TASK_KILLABLE' undeclared (first use in this function)
state == TASK_INTERRUPTIBLE || state == TASK_KILLABLE) \
^
include/linux/wait.h:230:7: note: in expansion of macro '___wait_is_interruptible'
if (___wait_is_interruptible(state) && __int) { \
^
include/linux/wait.h:400:2: note: in expansion of macro '___wait_event'
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
^
include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
kernel/printk/kmsg.c:181:10: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_b->wait,
^
include/linux/wait.h:401:9: error: implicit declaration of function 'schedule' [-Werror=implicit-function-declaration]
schedule())
^
include/linux/wait.h:240:3: note: in definition of macro '___wait_event'
cmd; \
^
include/linux/wait.h:423:11: note: in expansion of macro '__wait_event_interruptible'
__ret = __wait_event_interruptible(wq, condition); \
^
kernel/printk/kmsg.c:181:10: note: in expansion of macro 'wait_event_interruptible'
ret = wait_event_interruptible(log_b->wait,
^
kernel/printk/kmsg.c: In function 'kmsg_sys_buffer_del':
include/linux/wait.h:171:47: error: 'TASK_INTERRUPTIBLE' undeclared (first use in this function)
#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
^
kernel/printk/kmsg.c:734:2: note: in expansion of macro 'wake_up_interruptible'
wake_up_interruptible(&log_b->wait);
^
cc1: some warnings being treated as errors
vim +/KMSG_DICT_MAX_LEN +102 kernel/printk/kmsg.c
78 raw_spin_lock(&log_b->lock);
79
80 va_start(args, fmt);
81 log_format_and_store(log_b, 1 /* LOG_USER */, level,
82 dict, dictlen, fmt, args);
83 va_end(args);
> 84 wake_up_interruptible(&log_b->wait);
85
86 raw_spin_unlock(&log_b->lock);
87
88 ret = 0;
89 break;
90 }
91 rcu_read_unlock();
92 return ret;
93 }
94
95 static ssize_t devkmsg_write(struct kiocb *iocb, struct iov_iter *from)
96 {
97 char *buf, *line;
98 int i;
99 int level = default_message_loglevel;
100 int facility = 1; /* LOG_USER */
101 size_t len = iov_iter_count(from);
> 102 char dict[KMSG_DICT_MAX_LEN];
103 size_t dictlen;
104 ssize_t ret = len;
105 int minor = iminor(iocb->ki_filp->f_inode);
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
[-- Attachment #2: .config.gz --]
[-- Type: application/octet-stream, Size: 23978 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [RFC v3 8/9] kmsg: add predefined _PID, _TID, _COMM keywords to kmsg* log dict
2015-10-19 12:58 ` [RFC v3 8/9] kmsg: add predefined _PID, _TID, _COMM keywords to kmsg* log dict Paul Osmialowski
2015-10-19 13:53 ` kbuild test robot
2015-10-19 14:11 ` kbuild test robot
@ 2015-10-19 17:45 ` Andy Lutomirski
[not found] ` <CALCETrW2CgnS5pwS278ipLOSQi95UOT-osoSpshGwFmBf7TgRQ-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org>
2 siblings, 1 reply; 23+ messages in thread
From: Andy Lutomirski @ 2015-10-19 17:45 UTC (permalink / raw)
To: Paul Osmialowski
Cc: Jonathan Corbet, Arnd Bergmann, Andrew Morton, Petr Mladek,
Greg Kroah-Hartman, Daniel Mack, Kay Sievers, Joe Perches,
Tejun Heo, linux-kernel@vger.kernel.org,
linux-doc@vger.kernel.org, Linux API, Marcin Niesluchowski,
Karol Lewandowski, Bartlomiej Zolnierkiewicz, Shuah Khan
On Mon, Oct 19, 2015 at 5:58 AM, Paul Osmialowski
<p.osmialowsk@samsung.com> wrote:
> From: Marcin Niesluchowski <m.niesluchow@samsung.com>
>
> kmsg* devices write operation wrote no dict along with message
> Due to usage of kmsg devices in userspace dict has been added
> identifying pid, tid and comm of writing process.
Does this affect even the normal /dev/kmsg?
> -static int kmsg_sys_write(int minor, int level, const char *fmt, ...)
> +static size_t set_kmsg_dict(char *buf)
> +{
> + size_t len;
> +
> + len = sprintf(buf, "_PID=%d", task_tgid_nr(current)) + 1;
> + len += sprintf(buf + len, "_TID=%d", task_pid_nr(current)) + 1;
> + memcpy(buf + len, "_COMM=", 6);
> + len += 6;
> + get_task_comm(buf + len, current);
> + while (buf[len] != '\0')
> + len++;
len += strlen(buf); ?
Is it obvious for some reason that this doesn't overflow buf?
Why is task_pid_nr acceptable here? Isn't this intended for use in namespaces?
--Andy
^ permalink raw reply [flat|nested] 23+ messages in thread
[parent not found: <1445259503-18158-1-git-send-email-p.osmialowsk-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>]
* [RFC v3 4/9] kmsg: add additional buffers support to memory class
[not found] ` <1445259503-18158-1-git-send-email-p.osmialowsk-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>
@ 2015-10-19 12:58 ` Paul Osmialowski
[not found] ` <1445259503-18158-5-git-send-email-p.osmialowsk-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>
2015-10-19 12:58 ` [RFC v3 9/9] kmsg: selftests Paul Osmialowski
1 sibling, 1 reply; 23+ messages in thread
From: Paul Osmialowski @ 2015-10-19 12:58 UTC (permalink / raw)
To: Jonathan Corbet, Arnd Bergmann, Andrew Morton, Petr Mladek,
Greg Kroah-Hartman, Daniel Mack, Kay Sievers, Joe Perches,
Tejun Heo, linux-kernel-u79uwXL29TY76Z2rM5mHXA,
linux-doc-u79uwXL29TY76Z2rM5mHXA,
linux-api-u79uwXL29TY76Z2rM5mHXA
Cc: Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
From: Marcin Niesluchowski <m.niesluchow-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>
Memory class does not support additional kmsg buffers.
Add additional kmsg buffers support to:
* devnode() callback of "mem" class
* file operations of major "mem" character device
Signed-off-by: Marcin Niesluchowski <m.niesluchow-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>
Signed-off-by: Paul Osmialowski <p.osmialowsk-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>
---
drivers/char/mem.c | 27 ++++++++++++++++++++-------
include/linux/printk.h | 32 ++++++++++++++++++++++++++++++++
kernel/printk/kmsg.c | 42 ++++++++++++++++++++++++++++++++++++++++++
kernel/printk/printk.c | 1 +
kernel/printk/printk.h | 1 +
5 files changed, 96 insertions(+), 7 deletions(-)
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 6b1721f..7d46234 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -799,9 +799,6 @@ static const struct memdev {
[7] = { "full", 0666, &full_fops, 0 },
[8] = { "random", 0666, &random_fops, 0 },
[9] = { "urandom", 0666, &urandom_fops, 0 },
-#ifdef CONFIG_PRINTK
- [11] = { "kmsg", 0644, &kmsg_fops, 0 },
-#endif
};
static int memory_open(struct inode *inode, struct file *filp)
@@ -811,7 +808,7 @@ static int memory_open(struct inode *inode, struct file *filp)
minor = iminor(inode);
if (minor >= ARRAY_SIZE(devlist))
- return -ENXIO;
+ return kmsg_memory_open(inode, filp);
dev = &devlist[minor];
if (!dev->fops)
@@ -833,16 +830,28 @@ static const struct file_operations memory_fops = {
static char *mem_devnode(struct device *dev, umode_t *mode)
{
- if (mode && devlist[MINOR(dev->devt)].mode)
- *mode = devlist[MINOR(dev->devt)].mode;
+ int minor = MINOR(dev->devt);
+
+ if (!mode)
+ goto out;
+
+ if (minor >= ARRAY_SIZE(devlist)) {
+ kmsg_mode(minor, mode);
+ goto out;
+ }
+
+ if (devlist[minor].mode)
+ *mode = devlist[minor].mode;
+out:
return NULL;
}
-static struct class *mem_class;
+struct class *mem_class;
static int __init chr_dev_init(void)
{
int minor;
+ struct device *kmsg;
if (register_chrdev(MEM_MAJOR, "mem", &memory_fops))
printk("unable to get major %d for memory devs\n", MEM_MAJOR);
@@ -866,6 +875,10 @@ static int __init chr_dev_init(void)
NULL, devlist[minor].name);
}
+ kmsg = init_kmsg(KMSG_MINOR, 0644);
+ if (IS_ERR(kmsg))
+ return PTR_ERR(kmsg);
+
return tty_init();
}
diff --git a/include/linux/printk.h b/include/linux/printk.h
index 9729565..67840e0 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -417,8 +417,40 @@ do { \
no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
#endif
+struct file;
+struct inode;
+
+#ifdef CONFIG_PRINTK
+
+extern struct class *mem_class;
+
+#define KMSG_MINOR 11
+
extern const struct file_operations kmsg_fops;
+extern struct device *init_kmsg(int minor, umode_t mode);
+extern int kmsg_memory_open(struct inode *inode, struct file *filp);
+extern int kmsg_mode(int minor, umode_t *mode);
+
+#else
+
+static inline struct device *init_kmsg(int minor, umode_t mode)
+{
+ return NULL;
+}
+
+static inline int kmsg_memory_open(struct inode *inode, struct file *filp)
+{
+ return -ENXIO;
+}
+
+static inline int kmsg_mode(int minor, umode_t *mode)
+{
+ return -ENXIO;
+}
+
+#endif
+
enum {
DUMP_PREFIX_NONE,
DUMP_PREFIX_ADDRESS,
diff --git a/kernel/printk/kmsg.c b/kernel/printk/kmsg.c
index 23d4160..7fcd628 100644
--- a/kernel/printk/kmsg.c
+++ b/kernel/printk/kmsg.c
@@ -15,6 +15,9 @@
#include <linux/syslog.h>
#include <linux/uio.h>
#include <linux/wait.h>
+#include <linux/device.h>
+#include <linux/major.h>
+#include <linux/kdev_t.h>
#include <asm/uaccess.h>
@@ -385,6 +388,45 @@ const struct file_operations kmsg_fops = {
.release = devkmsg_release,
};
+/* Should be used for device registration */
+struct device *init_kmsg(int minor, umode_t mode)
+{
+ log_buf.minor = minor;
+ log_buf.mode = mode;
+ return device_create(mem_class, NULL, MKDEV(MEM_MAJOR, minor),
+ NULL, "kmsg");
+}
+
+int kmsg_memory_open(struct inode *inode, struct file *filp)
+{
+ filp->f_op = &kmsg_fops;
+
+ return kmsg_fops.open(inode, filp);
+}
+
+int kmsg_mode(int minor, umode_t *mode)
+{
+ int ret = -ENXIO;
+ struct log_buffer *log_b;
+
+ if (minor == log_buf.minor) {
+ *mode = log_buf.mode;
+ return 0;
+ }
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(log_b, &log_buf.list, list) {
+ if (log_b->minor == minor) {
+ *mode = log_b->mode;
+ ret = 0;
+ break;
+ }
+ }
+ rcu_read_unlock();
+
+ return ret;
+}
+
static DEFINE_SPINLOCK(dump_list_lock);
static LIST_HEAD(dump_list);
diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index e9ac4ba..beabebb 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -179,6 +179,7 @@ struct log_buffer log_buf = {
.next_idx = 0,
.clear_seq = 0,
.clear_idx = 0,
+ .mode = 0,
.minor = 0,
};
diff --git a/kernel/printk/printk.h b/kernel/printk/printk.h
index 38c9278..0755100 100644
--- a/kernel/printk/printk.h
+++ b/kernel/printk/printk.h
@@ -118,6 +118,7 @@ struct log_buffer {
u64 clear_seq;
u32 clear_idx;
+ int mode; /* mode of device */
int minor; /* minor representing buffer device */
#endif
};
--
1.9.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [RFC v3 9/9] kmsg: selftests
[not found] ` <1445259503-18158-1-git-send-email-p.osmialowsk-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>
2015-10-19 12:58 ` [RFC v3 4/9] kmsg: add additional buffers support to memory class Paul Osmialowski
@ 2015-10-19 12:58 ` Paul Osmialowski
2015-10-22 0:32 ` Michael Ellerman
1 sibling, 1 reply; 23+ messages in thread
From: Paul Osmialowski @ 2015-10-19 12:58 UTC (permalink / raw)
To: Jonathan Corbet, Arnd Bergmann, Andrew Morton, Petr Mladek,
Greg Kroah-Hartman, Daniel Mack, Kay Sievers, Joe Perches,
Tejun Heo, linux-kernel-u79uwXL29TY76Z2rM5mHXA,
linux-doc-u79uwXL29TY76Z2rM5mHXA,
linux-api-u79uwXL29TY76Z2rM5mHXA
Cc: Marcin Niesluchowski, Karol Lewandowski, Paul Osmialowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
This patch adds selftests framework and four test scenarios for kmsg.
The framework shape and code was inspired by similar selftests framework
for kdbus.
Signed-off-by: Paul Osmialowski <p.osmialowsk-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>
---
samples/kmsg/kmsg-api.h | 44 +++
tools/testing/selftests/Makefile | 1 +
tools/testing/selftests/kmsg/.gitignore | 1 +
tools/testing/selftests/kmsg/Makefile | 30 ++
tools/testing/selftests/kmsg/kmsg-test.c | 329 +++++++++++++++++++++
tools/testing/selftests/kmsg/kmsg-test.h | 34 +++
tools/testing/selftests/kmsg/test-buffer-add-del.c | 76 +++++
.../kmsg/test-buffer-add-write-read-del.c | 161 ++++++++++
.../kmsg/test-buffer-buf-multithreaded-torture.c | 199 +++++++++++++
.../selftests/kmsg/test-buffer-buf-torture.c | 139 +++++++++
10 files changed, 1014 insertions(+)
create mode 100644 samples/kmsg/kmsg-api.h
create mode 100644 tools/testing/selftests/kmsg/.gitignore
create mode 100644 tools/testing/selftests/kmsg/Makefile
create mode 100644 tools/testing/selftests/kmsg/kmsg-test.c
create mode 100644 tools/testing/selftests/kmsg/kmsg-test.h
create mode 100644 tools/testing/selftests/kmsg/test-buffer-add-del.c
create mode 100644 tools/testing/selftests/kmsg/test-buffer-add-write-read-del.c
create mode 100644 tools/testing/selftests/kmsg/test-buffer-buf-multithreaded-torture.c
create mode 100644 tools/testing/selftests/kmsg/test-buffer-buf-torture.c
diff --git a/samples/kmsg/kmsg-api.h b/samples/kmsg/kmsg-api.h
new file mode 100644
index 0000000..9004acd
--- /dev/null
+++ b/samples/kmsg/kmsg-api.h
@@ -0,0 +1,44 @@
+#ifndef KMSG_API_H
+#define KMSG_API_H
+
+#include <stdint.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <linux/kmsg_ioctl.h>
+
+static inline int kmsg_cmd_buffer_add(int fd, struct kmsg_cmd_buffer_add *cmd)
+{
+ int ret = ioctl(fd, KMSG_CMD_BUFFER_ADD, cmd);
+
+ return (ret < 0) ? (errno > 0 ? -errno : -EINVAL) : 0;
+}
+
+static inline int kmsg_cmd_buffer_del(int fd, int *minor)
+{
+ int ret = ioctl(fd, KMSG_CMD_BUFFER_DEL, minor);
+
+ return (ret < 0) ? (errno > 0 ? -errno : -EINVAL) : 0;
+}
+
+static inline int kmsg_cmd_get_buf_size(int fd, uint32_t *size)
+{
+ int ret = ioctl(fd, KMSG_CMD_GET_BUF_SIZE, size);
+
+ return (ret < 0) ? (errno > 0 ? -errno : -EINVAL) : 0;
+}
+
+static inline int kmsg_cmd_get_read_size_max(int fd, uint32_t *max_size)
+{
+ int ret = ioctl(fd, KMSG_CMD_GET_READ_SIZE_MAX, max_size);
+
+ return (ret < 0) ? (errno > 0 ? -errno : -EINVAL) : 0;
+}
+
+static inline int kmsg_cmd_clear(int fd)
+{
+ int ret = ioctl(fd, KMSG_CMD_CLEAR);
+
+ return (ret < 0) ? (errno > 0 ? -errno : -EINVAL) : 0;
+}
+
+#endif /* KMSG_API_H */
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index bf4ece6..b7bdf58 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -7,6 +7,7 @@ TARGETS += ftrace
TARGETS += futex
TARGETS += kcmp
TARGETS += kdbus
+TARGETS += kmsg
TARGETS += lib
TARGETS += membarrier
TARGETS += memfd
diff --git a/tools/testing/selftests/kmsg/.gitignore b/tools/testing/selftests/kmsg/.gitignore
new file mode 100644
index 0000000..687d517
--- /dev/null
+++ b/tools/testing/selftests/kmsg/.gitignore
@@ -0,0 +1 @@
+kmsg-test
diff --git a/tools/testing/selftests/kmsg/Makefile b/tools/testing/selftests/kmsg/Makefile
new file mode 100644
index 0000000..b4ba892
--- /dev/null
+++ b/tools/testing/selftests/kmsg/Makefile
@@ -0,0 +1,30 @@
+CFLAGS += -I../../../../usr/include/
+CFLAGS += -I../../../../samples/kmsg/
+CFLAGS += -I../../../../include/uapi/
+CFLAGS += -std=gnu99 -Wall
+CFLAGS += -DKBUILD_MODNAME=\"kmsg\" -D_GNU_SOURCE
+CFLAGS += -pthread
+LDLIBS += -pthread
+
+OBJS= \
+ kmsg-test.o \
+ test-buffer-add-del.o \
+ test-buffer-add-write-read-del.o \
+ test-buffer-buf-torture.o \
+ test-buffer-buf-multithreaded-torture.o
+
+all: kmsg-test
+
+include ../lib.mk
+
+%.o: %.c kmsg-test.h
+ $(CC) $(CFLAGS) -c $< -o $@
+
+kmsg-test: $(OBJS)
+ $(CC) $(CFLAGS) $^ $(LDLIBS) -o $@
+
+run_tests:
+ ./kmsg-test --tap
+
+clean:
+ rm -f *.o kmsg-test
diff --git a/tools/testing/selftests/kmsg/kmsg-test.c b/tools/testing/selftests/kmsg/kmsg-test.c
new file mode 100644
index 0000000..4f17b73
--- /dev/null
+++ b/tools/testing/selftests/kmsg/kmsg-test.c
@@ -0,0 +1,329 @@
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+
+#include "kmsg-test.h"
+
+struct kmsg_test {
+ const char *name;
+ const char *desc;
+ int (*func)(const struct kmsg_test_args *args);
+};
+
+static const struct kmsg_test tests[] = {
+ {
+ .name = "buffer-add-del",
+ .desc = "create and delete kmsg devices",
+ .func = kmsg_test_buffer_add_del,
+ }, {
+ .name = "buffer-add-write-read-del",
+ .desc = "create w/r and del kmsg device",
+ .func = kmsg_test_buffer_add_write_read_del,
+ }, {
+ .name = "buffer-buf-torture",
+ .desc = "fill more than whole buffer can hold",
+ .func = kmsg_test_buffer_buf_torture,
+ }, {
+ .name = "buffer-buf-multitheaded-torture",
+ .desc = "fill from many threads",
+ .func = kmsg_test_buffer_buf_multithreaded_torture,
+ },
+};
+
+#define N_TESTS ARRAY_SIZE(tests)
+
+FILE *kmsg_get_device(int minor, const char *mode)
+{
+ char path[80] = "";
+ dev_t dev = makedev(1, minor);
+
+ if (minor < 0) {
+ printf("Invalid minor number %d\n", minor);
+ return NULL;
+ }
+
+ snprintf(path, sizeof(path), "/tmp/kmsg-%d", minor);
+
+ if (access(path, F_OK) < 0) {
+ if (mknod(path, S_IFCHR | 0600, dev)) {
+ printf("Cannot create device %s with minor %d\n",
+ path, minor);
+ return NULL;
+ }
+ }
+
+ if (access(path, F_OK) < 0) {
+ printf("Cannot access device %s\n", path);
+ return NULL;
+ }
+
+ return fopen(path, mode);
+}
+
+int kmsg_drop_device(int minor)
+{
+ char path[80] = "";
+
+ if (minor < 0) {
+ printf("Invalid minor number %d\n", minor);
+ return -1;
+ }
+
+ snprintf(path, sizeof(path), "/tmp/kmsg-%d", minor);
+
+ return unlink(path);
+}
+
+static void usage(const char *argv0)
+{
+ unsigned int i, j;
+
+ printf("Usage: %s [options]\n"
+ "Options:\n"
+ "\t-x, --loop Run in a loop\n"
+ "\t-f, --fork Fork before running a test\n"
+ "\t-h, --help Print this help\n"
+ "\t-t, --test <test-id> Run one specific test only\n"
+ "\t-w, --wait <secs> Wait <secs> before actually starting test\n"
+ "\n", argv0);
+
+ printf("By default, all test are run once, and a summary is printed.\n"
+ "Available tests for --test:\n\n");
+
+ for (i = 0; i < N_TESTS; i++) {
+ const struct kmsg_test *t = tests + i;
+
+ printf("\t%s", t->name);
+
+ for (j = 0; j < 24 - strlen(t->name); j++)
+ printf(" ");
+
+ printf("Test %s\n", t->desc);
+ }
+
+ printf("\n");
+ printf("Note that some tests may, if run specifically by --test, ");
+ printf("behave differently, and not terminate by themselves.\n");
+
+ exit(EXIT_FAILURE);
+}
+
+static void print_test_result(int ret)
+{
+ switch (ret) {
+ case TEST_OK:
+ printf("OK");
+ break;
+ case TEST_SKIP:
+ printf("SKIPPED");
+ break;
+ case TEST_ERR:
+ printf("ERROR");
+ break;
+ }
+}
+
+static int test_run(const struct kmsg_test *t,
+ const struct kmsg_test_args *kmsg_args,
+ int wait)
+{
+ int ret;
+
+ if (wait > 0) {
+ printf("Sleeping %d seconds before running test ...\n", wait);
+ sleep(wait);
+ }
+
+ ret = t->func(kmsg_args);
+ return ret;
+}
+
+static int test_run_forked(const struct kmsg_test *t,
+ const struct kmsg_test_args *kmsg_args,
+ int wait)
+{
+ int ret;
+ pid_t pid;
+
+ pid = fork();
+ if (pid < 0) {
+ return TEST_ERR;
+ } else if (pid == 0) {
+ ret = test_run(t, kmsg_args, wait);
+ _exit(ret);
+ }
+
+ pid = waitpid(pid, &ret, 0);
+ if (pid <= 0)
+ return TEST_ERR;
+ else if (!WIFEXITED(ret))
+ return TEST_ERR;
+ else
+ return WEXITSTATUS(ret);
+}
+
+static int start_all_tests(const struct kmsg_test_args *kmsg_args)
+{
+ int ret;
+ unsigned int fail_cnt = 0;
+ unsigned int skip_cnt = 0;
+ unsigned int ok_cnt = 0;
+ unsigned int i, n;
+ const struct kmsg_test *t;
+
+ for (i = 0; i < N_TESTS; i++) {
+ t = tests + i;
+
+ printf("Testing %s (%s) ", t->desc, t->name);
+ for (n = 0; n < 60 - strlen(t->desc) - strlen(t->name); n++)
+ printf(".");
+ printf(" ");
+
+ ret = test_run_forked(t, kmsg_args, 0);
+ switch (ret) {
+ case TEST_OK:
+ ok_cnt++;
+ break;
+ case TEST_SKIP:
+ skip_cnt++;
+ break;
+ case TEST_ERR:
+ fail_cnt++;
+ break;
+ }
+
+ print_test_result(ret);
+ printf("\n");
+ }
+
+ printf("\nSUMMARY: %u tests passed, %u skipped, %u failed\n",
+ ok_cnt, skip_cnt, fail_cnt);
+
+ return fail_cnt > 0 ? TEST_ERR : TEST_OK;
+}
+
+static int start_one_test(const struct kmsg_test_args *kmsg_args)
+{
+ int i, ret;
+ bool test_found = false;
+ const struct kmsg_test *t;
+
+ for (i = 0; i < N_TESTS; i++) {
+ t = tests + i;
+
+ if (strcmp(t->name, kmsg_args->test))
+ continue;
+
+ do {
+ test_found = true;
+ if (kmsg_args->fork)
+ ret = test_run_forked(t, kmsg_args,
+ kmsg_args->wait);
+ else
+ ret = test_run(t, kmsg_args,
+ kmsg_args->wait);
+
+ printf("Testing %s: ", t->desc);
+ print_test_result(ret);
+ printf("\n");
+
+ if (ret != TEST_OK)
+ break;
+ } while (kmsg_args->loop);
+
+ return ret;
+ }
+
+ if (!test_found) {
+ printf("Unknown test-id '%s'\n", kmsg_args->test);
+ return TEST_ERR;
+ }
+
+ return TEST_OK;
+}
+
+static int start_tests(const struct kmsg_test_args *kmsg_args)
+{
+ int ret = 0;
+
+ if (kmsg_args->test) {
+ ret = start_one_test(kmsg_args);
+ } else {
+ do {
+ ret = start_all_tests(kmsg_args);
+ if (ret != TEST_OK)
+ break;
+ } while (kmsg_args->loop);
+ }
+
+ return ret;
+}
+
+int main(int argc, char *argv[])
+{
+ int t, ret = 0;
+ struct kmsg_test_args *kmsg_args;
+ char *exec = basename(argv[0]);
+
+ kmsg_args = malloc(sizeof(*kmsg_args));
+ if (!kmsg_args) {
+ printf("unable to malloc() kmsg_args\n");
+ return EXIT_FAILURE;
+ }
+
+ memset(kmsg_args, 0, sizeof(*kmsg_args));
+
+ static const struct option options[] = {
+ { "loop", no_argument, NULL, 'x' },
+ { "help", no_argument, NULL, 'h' },
+ { "test", required_argument, NULL, 't' },
+ { "wait", required_argument, NULL, 'w' },
+ { "fork", no_argument, NULL, 'f' },
+ {}
+ };
+
+ if (strcmp(exec, "kmsg-test") != 0)
+ kmsg_args->test = exec;
+
+ while ((t = getopt_long(argc, argv, "hxfm:r:t:b:w:a",
+ options, NULL)) >= 0) {
+ switch (t) {
+ case 'x':
+ kmsg_args->loop = 1;
+ break;
+
+ case 't':
+ kmsg_args->test = optarg;
+ break;
+
+ case 'w':
+ kmsg_args->wait = strtol(optarg, NULL, 10);
+ break;
+
+ case 'f':
+ kmsg_args->fork = 1;
+ break;
+
+ default:
+ case 'h':
+ usage(argv[0]);
+ }
+ }
+
+ ret = start_tests(kmsg_args);
+ if (ret == TEST_ERR)
+ return EXIT_FAILURE;
+
+ free(kmsg_args);
+
+ return 0;
+}
diff --git a/tools/testing/selftests/kmsg/kmsg-test.h b/tools/testing/selftests/kmsg/kmsg-test.h
new file mode 100644
index 0000000..b9ce896
--- /dev/null
+++ b/tools/testing/selftests/kmsg/kmsg-test.h
@@ -0,0 +1,34 @@
+#ifndef _KMSG_TEST_H_
+#define _KMSG_TEST_H_
+
+#include <stdio.h>
+
+#define DEV_KMSG "/dev/kmsg"
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
+
+#define KMSG_REQUESTED_BUF_SIZE (1024 * 256)
+
+enum {
+ TEST_OK,
+ TEST_SKIP,
+ TEST_ERR,
+};
+
+struct kmsg_test_args {
+ int loop;
+ int wait;
+ int fork;
+ const char *test;
+};
+
+FILE *kmsg_get_device(int minor, const char *mode);
+int kmsg_drop_device(int minor);
+
+int kmsg_test_buffer_add_del(const struct kmsg_test_args *args);
+int kmsg_test_buffer_add_write_read_del(const struct kmsg_test_args *args);
+int kmsg_test_buffer_buf_torture(const struct kmsg_test_args *args);
+int kmsg_test_buffer_buf_multithreaded_torture(
+ const struct kmsg_test_args *args);
+
+#endif /* _KMSG_TEST_H_ */
diff --git a/tools/testing/selftests/kmsg/test-buffer-add-del.c b/tools/testing/selftests/kmsg/test-buffer-add-del.c
new file mode 100644
index 0000000..22b69ac
--- /dev/null
+++ b/tools/testing/selftests/kmsg/test-buffer-add-del.c
@@ -0,0 +1,76 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <kmsg-api.h>
+
+#include "kmsg-test.h"
+
+int kmsg_test_buffer_add_del(const struct kmsg_test_args *args)
+{
+ int i;
+ int fd = open(DEV_KMSG, O_RDWR);
+ struct kmsg_cmd_buffer_add cmd = { 0 };
+ int minors[] = { -1, -1, -1, -1 };
+ FILE *fds[ARRAY_SIZE(minors)];
+ int retval = TEST_OK;
+ uint32_t size;
+
+ if (fd < 0) {
+ printf("Failed: cannot open %s\n", DEV_KMSG);
+ return TEST_ERR;
+ }
+
+ for (i = 0; i < ARRAY_SIZE(minors); i++) {
+ fds[i] = NULL;
+ cmd.size = KMSG_REQUESTED_BUF_SIZE;
+ cmd.mode = 0662;
+ if (kmsg_cmd_buffer_add(fd, &cmd)) {
+ printf("Failed to add buffer\n");
+ goto error;
+ }
+ if (cmd.minor < 0) {
+ printf("Minor number < 0\n");
+ goto error;
+ }
+ minors[i] = cmd.minor;
+ fds[i] = kmsg_get_device(minors[i], "r");
+ if (!fds[i]) {
+ printf("Cannot get device %d\n", i);
+ goto error;
+ }
+ size = 0;
+ if (kmsg_cmd_get_buf_size(fileno(fds[i]), &size)) {
+ printf("Cannot get buf size on defice %d\n", i);
+ goto error;
+ }
+ if (size != KMSG_REQUESTED_BUF_SIZE) {
+ printf("Invalid buf size on device %d\n", i);
+ goto error;
+ }
+ }
+
+ goto cleanup;
+
+error:
+ retval = TEST_ERR;
+
+cleanup:
+ for (i = 0; i < ARRAY_SIZE(minors); i++) {
+ if (minors[i] < 0)
+ continue;
+ if (fds[i])
+ fclose(fds[i]);
+ if (kmsg_drop_device(minors[i])) {
+ printf("Failed to delete device file %d\n", i);
+ retval = TEST_ERR;
+ }
+ if (kmsg_cmd_buffer_del(fd, &minors[i])) {
+ printf("Failed to delete buffer %d\n", i);
+ retval = TEST_ERR;
+ }
+ }
+ close(fd);
+ return retval;
+}
diff --git a/tools/testing/selftests/kmsg/test-buffer-add-write-read-del.c b/tools/testing/selftests/kmsg/test-buffer-add-write-read-del.c
new file mode 100644
index 0000000..ab4223f
--- /dev/null
+++ b/tools/testing/selftests/kmsg/test-buffer-add-write-read-del.c
@@ -0,0 +1,161 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <kmsg-api.h>
+
+#include "kmsg-test.h"
+
+static const char *message(char *buff, size_t size, int i, int j)
+{
+ snprintf(buff, size, "Test message (%d, %d)", i, j);
+ return buff;
+}
+
+int kmsg_test_buffer_add_write_read_del(const struct kmsg_test_args *args)
+{
+ int i, j;
+ int fd = open(DEV_KMSG, O_RDWR);
+ struct kmsg_cmd_buffer_add cmd = { 0 };
+ int minors[] = { -1, -1, -1, -1 };
+ FILE *fds[ARRAY_SIZE(minors)];
+ FILE *log[ARRAY_SIZE(minors)];
+ int logfd;
+ int retval = TEST_OK;
+ uint32_t size;
+ char txt[80] = "";
+ char *buff = NULL;
+ const char *msg;
+ char *msgend;
+
+ if (fd < 0) {
+ printf("Failed: cannot open %s\n", DEV_KMSG);
+ return TEST_ERR;
+ }
+
+ for (i = 0; i < ARRAY_SIZE(minors); i++) {
+ fds[i] = NULL;
+ log[i] = NULL;
+ cmd.size = KMSG_REQUESTED_BUF_SIZE;
+ cmd.mode = 0662;
+ if (kmsg_cmd_buffer_add(fd, &cmd)) {
+ printf("Failed to add buffer\n");
+ goto error;
+ }
+ if (cmd.minor < 0) {
+ printf("Minor number < 0\n");
+ goto error;
+ }
+ minors[i] = cmd.minor;
+
+ fds[i] = kmsg_get_device(minors[i], "w");
+ if (!fds[i]) {
+ printf("Cannot get device %d for write\n", i);
+ goto error;
+ }
+ size = 0;
+ if (kmsg_cmd_get_buf_size(fileno(fds[i]), &size)) {
+ printf("Cannot get buf size on defice %d\n", i);
+ goto error;
+ }
+ if (size != KMSG_REQUESTED_BUF_SIZE) {
+ printf("Invalid buf size on device %d\n", i);
+ goto error;
+ }
+ log[i] = kmsg_get_device(minors[i], "r");
+ if (!log[i]) {
+ printf("Cannot get device %d for read\n", i);
+ goto error;
+ }
+ size = 0;
+ if (kmsg_cmd_get_buf_size(fileno(log[i]), &size)) {
+ printf("Cannot get buf size on defice %d\n", i);
+ goto error;
+ }
+ if (size != KMSG_REQUESTED_BUF_SIZE) {
+ printf("Invalid buf size on device %d\n", i);
+ goto error;
+ }
+
+ for (j = 0; j <= i; j++) {
+ if (kmsg_cmd_clear(fileno(fds[j]))) {
+ printf("Cannot clear buffer on device %d\n", j);
+ goto error;
+ }
+ fprintf(fds[j], "%s\n", message(txt, ARRAY_SIZE(txt),
+ i, j));
+ fflush(fds[j]);
+ }
+
+ for (j = 0; j <= i; j++) {
+ logfd = fileno(log[j]);
+ size = 0;
+ if (kmsg_cmd_get_read_size_max(logfd, &size)) {
+ printf("Cannot get buf size on device %d\n", j);
+ goto error;
+ }
+ if (!size) {
+ printf("Expected non-zero buf size on %d\n", j);
+ goto error;
+ }
+ buff = malloc(size);
+ if (!buff) {
+ printf("Out of memory\n");
+ goto error;
+ }
+ if (read(logfd, buff, size) <= 0) {
+ printf("Could not read from buffer %d\n", j);
+ goto error;
+ }
+ msg = strchr(buff, ';');
+ msgend = strchr(buff, '\n');
+ if ((!msg) || (!msgend)) {
+ printf("Could not read stored log on %d\n", j);
+ goto error;
+ }
+ msg++;
+ *msgend = 0;
+ if (strcmp(msg, message(txt, ARRAY_SIZE(txt), i, j))) {
+ printf("Messages do not match on %d\n", j);
+ goto error;
+ }
+ free(buff);
+ buff = NULL;
+ }
+ }
+
+ goto cleanup;
+
+error:
+ retval = TEST_ERR;
+
+cleanup:
+ for (i = 0; i < ARRAY_SIZE(minors); i++) {
+ if (minors[i] < 0)
+ continue;
+ if (fds[i])
+ fclose(fds[i]);
+ if (log[i]) {
+ if (kmsg_cmd_clear(fileno(log[i]))) {
+ printf("Failed to clear device %d\n", i);
+ retval = TEST_ERR;
+ }
+ fclose(log[i]);
+ }
+ if (kmsg_drop_device(minors[i])) {
+ printf("Failed to delete device file %d\n", i);
+ retval = TEST_ERR;
+ }
+ if (kmsg_cmd_buffer_del(fd, &minors[i])) {
+ printf("Failed to delete buffer %d\n", i);
+ retval = TEST_ERR;
+ }
+ }
+ close(fd);
+ if (buff)
+ free(buff);
+ return retval;
+}
diff --git a/tools/testing/selftests/kmsg/test-buffer-buf-multithreaded-torture.c b/tools/testing/selftests/kmsg/test-buffer-buf-multithreaded-torture.c
new file mode 100644
index 0000000..5510b13
--- /dev/null
+++ b/tools/testing/selftests/kmsg/test-buffer-buf-multithreaded-torture.c
@@ -0,0 +1,199 @@
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <kmsg-api.h>
+
+#include "kmsg-test.h"
+
+#define SOME_BUFF_SIZE 4096
+#define THREADS_PER_DEVICE 10
+
+static bool ok = true;
+static bool nok = !true;
+
+static void *kmsg_test_thread_func(void *data)
+{
+ char buff[SOME_BUFF_SIZE];
+ int minor = *((int *)data);
+ FILE *f = kmsg_get_device(minor, "w");
+ int fd;
+ void *retval = &ok;
+ int iter;
+ ssize_t s;
+ uint32_t size, done;
+ uint32_t max_size;
+
+ memset(buff, 'A', ARRAY_SIZE(buff));
+ buff[ARRAY_SIZE(buff) - 1] = 0;
+
+ if (!f) {
+ printf("Cannot get device for write\n");
+ return &nok;
+ }
+ fd = fileno(f);
+
+ size = 0;
+ if (kmsg_cmd_get_buf_size(fd, &size)) {
+ printf("Cannot get buf size\n");
+ goto error;
+ }
+ if (size != KMSG_REQUESTED_BUF_SIZE) {
+ printf("Invalid buf size\n");
+ goto error;
+ }
+
+ if (kmsg_cmd_clear(fd)) {
+ printf("Cannot clear buffer\n");
+ goto error;
+ }
+
+ iter = 0;
+ while (done < (KMSG_REQUESTED_BUF_SIZE * 2)) {
+ s = write(fd, buff, ARRAY_SIZE(buff));
+ if (s < 0) {
+ printf("Cannot write iteration %d\n", iter);
+ goto error;
+ }
+ done += s;
+
+ max_size = 0;
+ if (kmsg_cmd_get_read_size_max(fd, &max_size)) {
+ printf("Cannot get max_size\n");
+ goto error;
+ }
+ if (!max_size) {
+ printf("Expected non-zero max_size\n");
+ goto error;
+ }
+
+ iter++;
+ }
+
+ goto cleanup;
+
+error:
+ retval = &nok;
+
+cleanup:
+ fclose(f);
+
+ return retval;
+}
+
+int kmsg_test_buffer_buf_multithreaded_torture(
+ const struct kmsg_test_args *args)
+{
+ int i, j;
+ int fd = open(DEV_KMSG, O_RDWR);
+ struct kmsg_cmd_buffer_add cmd = { 0 };
+ int minors[] = { -1, -1, -1, -1 };
+ FILE *log[ARRAY_SIZE(minors)];
+ int retval = TEST_OK;
+ pthread_t threads[ARRAY_SIZE(minors)][THREADS_PER_DEVICE];
+ bool started[ARRAY_SIZE(minors)][THREADS_PER_DEVICE];
+ uint32_t size;
+ uint32_t max_size;
+ void *retptr;
+
+ for (i = 0; i < ARRAY_SIZE(minors); i++)
+ for (j = 0; j < THREADS_PER_DEVICE; j++)
+ started[i][j] = false;
+
+ if (fd < 0) {
+ printf("Failed: cannot open %s\n", DEV_KMSG);
+ return TEST_ERR;
+ }
+
+ for (i = 0; i < ARRAY_SIZE(minors); i++) {
+ log[i] = NULL;
+ cmd.size = KMSG_REQUESTED_BUF_SIZE;
+ cmd.mode = 0662;
+ if (kmsg_cmd_buffer_add(fd, &cmd)) {
+ printf("Failed to add buffer\n");
+ goto error;
+ }
+ if (cmd.minor < 0) {
+ printf("Minor number < 0\n");
+ goto error;
+ }
+ minors[i] = cmd.minor;
+
+ log[i] = kmsg_get_device(minors[i], "r");
+ if (!log[i]) {
+ printf("Cannot get device %d for read\n", i);
+ goto error;
+ }
+ size = 0;
+ if (kmsg_cmd_get_buf_size(fileno(log[i]), &size)) {
+ printf("Cannot get buf size on defice %d\n", i);
+ goto error;
+ }
+ if (size != KMSG_REQUESTED_BUF_SIZE) {
+ printf("Invalid buf size on device %d\n", i);
+ goto error;
+ }
+
+ for (j = 0; j < THREADS_PER_DEVICE; j++) {
+ if (pthread_create(&threads[i][j], NULL,
+ kmsg_test_thread_func, &minors[i])) {
+ printf("Cannot create thread %d for dev %d\n",
+ j, i);
+ goto error;
+ }
+ started[i][j] = true;
+ }
+ }
+
+ goto cleanup;
+
+error:
+ retval = TEST_ERR;
+
+cleanup:
+ for (i = 0; i < ARRAY_SIZE(minors); i++) {
+ for (j = 0; j < THREADS_PER_DEVICE; j++)
+ if (started[i][j]) {
+ if (pthread_join(threads[i][j], &retptr)) {
+ printf("pthread_join() failed %d:%d\n",
+ i, j);
+ retval = TEST_ERR;
+ }
+ if (!(*((bool *)retptr)))
+ retval = TEST_ERR;
+ }
+ if (minors[i] < 0)
+ continue;
+ if (log[i]) {
+ max_size = 0;
+ if (kmsg_cmd_get_read_size_max(fileno(log[i]),
+ &max_size)) {
+ printf("Cannot get max_size\n");
+ retval = TEST_ERR;
+ }
+ if (!max_size) {
+ printf("Expected non-zero max_size\n");
+ retval = TEST_ERR;
+ }
+ if (kmsg_cmd_clear(fileno(log[i]))) {
+ printf("Failed to clear device %d\n", i);
+ retval = TEST_ERR;
+ }
+ fclose(log[i]);
+ }
+ if (kmsg_drop_device(minors[i])) {
+ printf("Failed to delete device file %d\n", i);
+ retval = TEST_ERR;
+ }
+ if (kmsg_cmd_buffer_del(fd, &minors[i])) {
+ printf("Failed to delete buffer %d\n", i);
+ retval = TEST_ERR;
+ }
+ }
+ close(fd);
+ return retval;
+}
diff --git a/tools/testing/selftests/kmsg/test-buffer-buf-torture.c b/tools/testing/selftests/kmsg/test-buffer-buf-torture.c
new file mode 100644
index 0000000..700a2fa
--- /dev/null
+++ b/tools/testing/selftests/kmsg/test-buffer-buf-torture.c
@@ -0,0 +1,139 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <kmsg-api.h>
+
+#include "kmsg-test.h"
+
+#define SOME_BUFF_SIZE 4096
+
+int kmsg_test_buffer_buf_torture(const struct kmsg_test_args *args)
+{
+ int i, iter;
+ int fd = open(DEV_KMSG, O_RDWR);
+ struct kmsg_cmd_buffer_add cmd = { 0 };
+ int minors[] = { -1, -1, -1, -1 };
+ FILE *fds[ARRAY_SIZE(minors)];
+ FILE *log[ARRAY_SIZE(minors)];
+ int retval = TEST_OK;
+ char buff[SOME_BUFF_SIZE];
+ ssize_t s;
+ int logfd;
+ uint32_t size, done;
+ uint32_t max_size;
+
+ memset(buff, 'A', ARRAY_SIZE(buff));
+ buff[ARRAY_SIZE(buff) - 1] = 0;
+
+ if (fd < 0) {
+ printf("Failed: cannot open %s\n", DEV_KMSG);
+ return TEST_ERR;
+ }
+
+ for (i = 0; i < ARRAY_SIZE(minors); i++) {
+ fds[i] = NULL;
+ log[i] = NULL;
+ cmd.size = KMSG_REQUESTED_BUF_SIZE;
+ cmd.mode = 0662;
+ if (kmsg_cmd_buffer_add(fd, &cmd)) {
+ printf("Failed to add buffer\n");
+ goto error;
+ }
+ if (cmd.minor < 0) {
+ printf("Minor number < 0\n");
+ goto error;
+ }
+ minors[i] = cmd.minor;
+
+ fds[i] = kmsg_get_device(minors[i], "w");
+ if (!fds[i]) {
+ printf("Cannot get device %d for write\n", i);
+ goto error;
+ }
+ size = 0;
+ if (kmsg_cmd_get_buf_size(fileno(fds[i]), &size)) {
+ printf("Cannot get buf size on defice %d\n", i);
+ goto error;
+ }
+ if (size != KMSG_REQUESTED_BUF_SIZE) {
+ printf("Invalid buf size on device %d\n", i);
+ goto error;
+ }
+ log[i] = kmsg_get_device(minors[i], "r");
+ if (!log[i]) {
+ printf("Cannot get device %d for read\n", i);
+ goto error;
+ }
+ size = 0;
+ if (kmsg_cmd_get_buf_size(fileno(log[i]), &size)) {
+ printf("Cannot get buf size on defice %d\n", i);
+ goto error;
+ }
+ if (size != KMSG_REQUESTED_BUF_SIZE) {
+ printf("Invalid buf size on device %d\n", i);
+ goto error;
+ }
+
+ logfd = fileno(fds[i]);
+ if (kmsg_cmd_clear(logfd)) {
+ printf("Cannot clear buffer on device %d\n", i);
+ goto error;
+ }
+
+ iter = 0;
+ while (done < (KMSG_REQUESTED_BUF_SIZE * 2)) {
+ s = write(logfd, buff, ARRAY_SIZE(buff));
+ if (s < 0) {
+ printf("Cannot write %d to device %d, %s\n",
+ iter, i, strerror(errno));
+ goto error;
+ }
+ done += s;
+
+ max_size = 0;
+ if (kmsg_cmd_get_read_size_max(logfd, &max_size)) {
+ printf("Cannot get max_size on device %d\n", i);
+ goto error;
+ }
+ if (!max_size) {
+ printf("Expected non-zero max_size on %d\n", i);
+ goto error;
+ }
+
+ iter++;
+ }
+ }
+
+ goto cleanup;
+
+error:
+ retval = TEST_ERR;
+
+cleanup:
+ for (i = 0; i < ARRAY_SIZE(minors); i++) {
+ if (minors[i] < 0)
+ continue;
+ if (fds[i])
+ fclose(fds[i]);
+ if (log[i]) {
+ if (kmsg_cmd_clear(fileno(log[i]))) {
+ printf("Failed to clear device %d\n", i);
+ retval = TEST_ERR;
+ }
+ fclose(log[i]);
+ }
+ if (kmsg_drop_device(minors[i])) {
+ printf("Failed to delete device file %d\n", i);
+ retval = TEST_ERR;
+ }
+ if (kmsg_cmd_buffer_del(fd, &minors[i])) {
+ printf("Failed to delete buffer %d\n", i);
+ retval = TEST_ERR;
+ }
+ }
+ close(fd);
+ return retval;
+}
--
1.9.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [RFC v3 9/9] kmsg: selftests
2015-10-19 12:58 ` [RFC v3 9/9] kmsg: selftests Paul Osmialowski
@ 2015-10-22 0:32 ` Michael Ellerman
0 siblings, 0 replies; 23+ messages in thread
From: Michael Ellerman @ 2015-10-22 0:32 UTC (permalink / raw)
To: Paul Osmialowski, Jonathan Corbet, Arnd Bergmann, Andrew Morton,
Petr Mladek, Greg Kroah-Hartman, Daniel Mack, Kay Sievers,
Joe Perches, Tejun Heo, linux-kernel, linux-doc, linux-api
Cc: Marcin Niesluchowski, Karol Lewandowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
On Mon, 2015-10-19 at 14:58 +0200, Paul Osmialowski wrote:
> This patch adds selftests framework and four test scenarios for kmsg.
>
> The framework shape and code was inspired by similar selftests framework
> for kdbus.
> diff --git a/tools/testing/selftests/kmsg/Makefile b/tools/testing/selftests/kmsg/Makefile
> new file mode 100644
> index 0000000..b4ba892
> --- /dev/null
> +++ b/tools/testing/selftests/kmsg/Makefile
> @@ -0,0 +1,30 @@
> +CFLAGS += -I../../../../usr/include/
> +CFLAGS += -I../../../../samples/kmsg/
> +CFLAGS += -I../../../../include/uapi/
Please don't directly include the unexported kernel headers.
> +CFLAGS += -std=gnu99 -Wall
> +CFLAGS += -DKBUILD_MODNAME=\"kmsg\" -D_GNU_SOURCE
Are you building userspace code here? I'm not sure why you need KBUILD_MODNAME.
> +CFLAGS += -pthread
> +LDLIBS += -pthread
> +
> +OBJS= \
> + kmsg-test.o \
> + test-buffer-add-del.o \
> + test-buffer-add-write-read-del.o \
> + test-buffer-buf-torture.o \
> + test-buffer-buf-multithreaded-torture.o
> +
> +all: kmsg-test
> +
> +include ../lib.mk
> +
> +%.o: %.c kmsg-test.h
> + $(CC) $(CFLAGS) -c $< -o $@
> +
> +kmsg-test: $(OBJS)
> + $(CC) $(CFLAGS) $^ $(LDLIBS) -o $@
Those look the same as the implicit rules to me, so I don't think you need to
spell them out.
> +
> +run_tests:
> + ./kmsg-test --tap
This should be giving you a warning about redefining run_tests.
It sounds like you don't actually need to pass --tap, so you don't need to
override run_tests.
So you should just define:
TEST_PROGS := kmsg-test
Before you include lib.mk and then both the run and emit rules will work
without any more work on your part.
cheers
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [RFC v3 0/9] Additional kmsg devices
2015-10-19 12:58 [RFC v3 0/9] Additional kmsg devices Paul Osmialowski
` (7 preceding siblings ...)
[not found] ` <1445259503-18158-1-git-send-email-p.osmialowsk-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>
@ 2015-10-19 13:26 ` Richard Weinberger
8 siblings, 0 replies; 23+ messages in thread
From: Richard Weinberger @ 2015-10-19 13:26 UTC (permalink / raw)
To: Paul Osmialowski
Cc: Jonathan Corbet, Arnd Bergmann, Andrew Morton, Petr Mladek,
Greg Kroah-Hartman, Daniel Mack, Kay Sievers, Joe Perches,
Tejun Heo, LKML, linux-doc@vger.kernel.org, open list:ABI/API,
Marcin Niesluchowski, Karol Lewandowski,
Bartlomiej Zolnierkiewicz, Shuah Khan
On Mon, Oct 19, 2015 at 2:58 PM, Paul Osmialowski
<p.osmialowsk@samsung.com> wrote:
> Dear All,
>
> This is the third iteration of Marcin Niesluchowski's serie of patches
> extending kmsg interface with ability to dynamically create (and destroy)
> kmsg-like devices which can be used by userspace for logging.
>
> In this iteration, following Joe Perches's suggestion, I've extracted
> kmsg related functions from printk.c to a new file, kmsg.c.
>
> Best regards,
> Paul
>
> Marcin Niesluchowski (7):
> printk: add one function for storing log in proper format
> kmsg: introduce additional kmsg devices support
> kmsg: add additional buffers support to memory class
> kmsg: add function for adding and deleting additional buffers
> kmsg: add ioctl for adding and deleting kmsg* devices
> kmsg: add ioctl for kmsg* devices operating on buffers
> kmsg: add predefined _PID, _TID, _COMM keywords to kmsg* log dict
>
> Paul Osmialowski (2):
> printk: extract kmsg-related routines from printk.c to kmsg.c
> kmsg: selftests
Not CC'ing critical voices it not very nice. 8-)
As I replied to v1 of this series, IHMO we should not encourage
userspace tools to use kmsg as their poor-man's syslog.
Everything what this series does in kernel space can also be done
in userspace.
Just my two cents.
--
Thanks,
//richard
^ permalink raw reply [flat|nested] 23+ messages in thread