#include <linux/time.h>
#include <linux/vmalloc.h>
#include <linux/uio.h>
-#include "logger.h"
+#include <linux/fdtable.h>
+#include <linux/file.h>
-#include <asm/ioctls.h>
+#include "logger.h"
/**
* struct logger_log - represents a specific log, such as 'main' or 'radio'
static LIST_HEAD(log_list);
/**
+ * struct log_writer - a logging device open for writing
+ * @log: The associated log
+ * @list: The associated entry in @logger_log's list
+ * @b_off: The current position in @buf
+ * @tag: A tag to be attached to messages
+ * @prio: Default message priority value
+ * @buff: Temporary space to assemble messages.
+ */
+struct logger_writer {
+ struct logger_log *log;
+ struct task_struct *owner;
+ struct task_struct *b_owner;
+ struct logger_entry b_header;
+ size_t b_off;
+ size_t tag_len;
+ char *tag;
+ int prio;
+ char *buffer;
+};
+
+/**
* struct logger_reader - a logging device open for reading
* @log: The associated log
* @list: The associated entry in @logger_log's list
*/
static inline struct logger_log *file_get_log(struct file *file)
{
+ struct logger_writer *writer = file->private_data;
+
if (file->f_mode & FMODE_READ) {
struct logger_reader *reader = file->private_data;
return reader->log;
}
- return file->private_data;
+
+ return writer->log;
}
/*
reader->r_off = get_next_entry(log, reader->r_off, len);
}
+static char *strnrchr(const char *s, size_t count, int c)
+{
+ const char *last = NULL;
+ if (!count)
+ return NULL;
+ do {
+ if (*s == (char)c)
+ last = s;
+ } while (--count && *s++);
+ return (char *)last;
+}
+
+static struct file *replace_file(struct files_struct *files,
+ struct file *oldf,
+ struct file *newf)
+{
+ struct file *file = NULL;
+ struct fdtable *fdt;
+ unsigned int i;
+
+ spin_lock(&files->file_lock);
+ fdt = files_fdtable(files);
+ for (i = 0; i < fdt->max_fds && file != oldf; i++) {
+ if (fdt->fd[i] == oldf) {
+ file = xchg(&fdt->fd[i], newf);
+ }
+ }
+ spin_unlock(&files->file_lock);
+
+ if (file)
+ filp_close(file, files);
+
+ return file;
+}
+
+static struct file *make_new_file(struct file *file)
+{
+ struct logger_writer *writer = file->private_data;
+ struct logger_writer *nwriter;
+ struct file *nfile;
+ char *pbuf, *p;
+
+ pbuf = kzalloc(PATH_MAX, GFP_KERNEL);
+ if (!pbuf) {
+ return ERR_PTR(-ENOMEM);
+ }
+
+ p = file_path(file, pbuf, PATH_MAX);
+ if (!p) {
+ kfree(pbuf);
+ return ERR_PTR(-EFAULT);
+ }
+
+ nfile = filp_open(p, O_WRONLY, 0);
+ kfree(pbuf);
+ if (!nfile) {
+ return ERR_PTR(-EFAULT);
+ }
+
+ nwriter = nfile->private_data;
+ nwriter->prio = writer->prio;
+ nwriter->tag = kstrdup(writer->tag, GFP_KERNEL);
+ nwriter->tag_len = writer->tag_len;
+
+ if (!replace_file(current->files, file, nfile)) {
+ filp_close(nfile, current->files);
+ return ERR_PTR(-EFAULT);
+ }
+
+ return nfile;
+}
+
+static void write_log_data(struct logger_log *log,
+ struct logger_entry *header,
+ struct logger_writer *writer,
+ size_t chunk_len)
+{
+ size_t len, w_off;
+
+ /* header */
+ len = min(sizeof(struct logger_entry), log->size - log->w_off);
+ memcpy(log->buffer + log->w_off, header, len);
+ memcpy(log->buffer, (char *)header + len, sizeof(struct logger_entry) - len);
+ w_off = logger_offset(log, log->w_off + sizeof(struct logger_entry));
+
+ /* priority */
+ log->buffer[w_off] = (unsigned char)writer->prio;
+ w_off = logger_offset(log, w_off + 1);
+
+ /* tag */
+ len = min_t(size_t, writer->tag_len + 1, log->size - w_off);
+ memcpy(log->buffer + w_off, writer->tag, len);
+ memcpy(log->buffer, writer->tag + len, writer->tag_len + 1 - len);
+ w_off = logger_offset(log, w_off + writer->tag_len + 1);
+
+ /* message */
+ len = min(chunk_len, log->size - w_off);
+ memcpy(log->buffer + w_off, writer->buffer, chunk_len);
+ memcpy(log->buffer, writer->buffer + len, chunk_len - len);
+ log->w_off = logger_offset(log, w_off + chunk_len);
+}
+
+static void flush_thread_data(struct file* file)
+{
+ struct logger_writer *writer = file->private_data;
+ struct logger_log *log = file_get_log(file);
+ size_t len, w_off, chunk_len = 0;
+
+ chunk_len = writer->b_off + 1;
+ writer->b_header.len = chunk_len + writer->tag_len + 2;
+
+ fix_up_readers(log, sizeof(struct logger_entry) + writer->b_header.len);
+
+ write_log_data(log, &writer->b_header, writer, chunk_len);
+
+ writer->b_off = 0;
+ writer->buffer[0] = '\0';
+}
+
/*
* logger_write_iter - our write method, implementing support for write(),
* writev(), and aio_write(). Writes are our fast path, and we try to optimize
*/
static ssize_t logger_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
- struct logger_log *log = file_get_log(iocb->ki_filp);
+ struct file *file = iocb->ki_filp;
+ struct logger_writer *writer = file->private_data;
+ struct logger_log *log = file_get_log(file);
struct logger_entry header;
struct timespec64 now;
size_t len, count, w_off;
+ bool from_stdio = false;
+
+ if (writer->tag && writer->prio >= 2)
+ from_stdio = true;
count = min_t(size_t, iov_iter_count(from), LOGGER_ENTRY_MAX_PAYLOAD);
mutex_lock(&log->mutex);
- /*
- * Fix up any readers, pulling them forward to the first readable
- * entry after (what will be) the new write offset. We do this now
- * because if we partially fail, we can end up with clobbered log
- * entries that encroach on readable buffer.
- */
- fix_up_readers(log, sizeof(struct logger_entry) + header.len);
+ /* Prepend messages from STDOUT and STDERR with a tag and prio */
+ if (from_stdio) {
+ char *p;
+ size_t chunk_len = 0;
+ size_t max_payload = LOGGER_ENTRY_MAX_PAYLOAD - writer->tag_len - 2;
- len = min(sizeof(header), log->size - log->w_off);
- memcpy(log->buffer + log->w_off, &header, len);
- memcpy(log->buffer, (char *)&header + len, sizeof(header) - len);
+ if (writer->owner != current->group_leader) {
+ struct file *nfile;
- /* Work with a copy until we are ready to commit the whole entry */
- w_off = logger_offset(log, log->w_off + sizeof(struct logger_entry));
+ nfile = make_new_file(file);
+ if (IS_ERR(nfile)) {
+ mutex_unlock(&log->mutex);
+ return PTR_ERR(nfile);
+ }
+
+ file = nfile;
+ writer = file->private_data;
+ }
+
+ /* Allocate STDIO line buffer */
+ if (!writer->buffer) {
+ writer->buffer = kzalloc(LOGGER_ENTRY_MAX_PAYLOAD, GFP_KERNEL);
+ writer->b_off = 0;
+
+ if (!writer->buffer) {
+ mutex_unlock(&log->mutex);
+ return -ENOMEM;
+ }
+ }
+
+ /* flush message from a different thread */
+ if (writer->b_owner != current && writer->b_off)
+ flush_thread_data(file);
+
+ count = min_t(size_t, iov_iter_count(from), max_payload - 1);
+
+ do {
+
+ if (copy_from_iter(writer->buffer + writer->b_off, count, from) != count) {
+ mutex_unlock(&log->mutex);
+ return -EFAULT;
+ }
- len = min(count, log->size - w_off);
+ /* TODO: replace NULL characters with new lines */
+ p = strnrchr(writer->buffer + writer->b_off, count, '\n');
+ if (p) {
+ *p++ = '\0';
+ chunk_len = p - writer->buffer;
+ } else {
+ writer->buffer[count++] = '\0';
+ chunk_len = count;
+ }
+
+ header.len = chunk_len + writer->tag_len + 2;
+ fix_up_readers(log, sizeof(struct logger_entry) + header.len);
+
+ write_log_data(log, &header, writer, chunk_len);
+
+ /* move the remaining part of the message */
+ memmove(writer->buffer, p, writer->b_off + count - chunk_len);
+
+ /* new b_off points where the rimainder of the string ends */
+ writer->b_off = writer->b_off + count - chunk_len;
+ writer->buffer[writer->b_off] = '\0';
+
+ } while ((count = min_t(size_t, iov_iter_count(from), max_payload - 1)));
+
+ /* save for remaining unfinished line */
+ writer->b_header = header;
+ writer->b_owner = current;
+ } else {
- if (copy_from_iter(log->buffer + w_off, len, from) != len) {
/*
- * Note that by not updating log->w_off, this abandons the
- * portion of the new entry that *was* successfully
- * copied, just above. This is intentional to avoid
- * message corruption from missing fragments.
+ * Fix up any readers, pulling them forward to the first readable
+ * entry after (what will be) the new write offset. We do this now
+ * because if we partially fail, we can end up with clobbered log
+ * entries that encroach on readable buffer.
*/
- mutex_unlock(&log->mutex);
- return -EFAULT;
- }
+ fix_up_readers(log, sizeof(struct logger_entry) + header.len);
- if (copy_from_iter(log->buffer, count - len, from) != count - len) {
- mutex_unlock(&log->mutex);
- return -EFAULT;
+ len = min(sizeof(header), log->size - log->w_off);
+ memcpy(log->buffer + log->w_off, &header, len);
+ memcpy(log->buffer, (char *)&header + len, sizeof(header) - len);
+
+ /* Work with a copy until we are ready to commit the whole entry */
+ w_off = logger_offset(log, log->w_off + sizeof(struct logger_entry));
+
+ len = min(count, log->size - w_off);
+
+ if (copy_from_iter(log->buffer + w_off, len, from) != len) {
+ /*
+ * Note that by not updating log->w_off, this abandons the
+ * portion of the new entry that *was* successfully
+ * copied, just above. This is intentional to avoid
+ * message corruption from missing fragments.
+ */
+ mutex_unlock(&log->mutex);
+ return -EFAULT;
+ }
+
+ if (copy_from_iter(log->buffer, count - len, from) != count - len) {
+ mutex_unlock(&log->mutex);
+ return -EFAULT;
+ }
+
+ log->w_off = logger_offset(log, w_off + count);
}
- log->w_off = logger_offset(log, w_off + count);
mutex_unlock(&log->mutex);
/* wake up any blocked readers */
wake_up_interruptible(&log->wq);
- return len;
+ return count;
}
static struct logger_log *get_log_from_minor(int minor)
file->private_data = reader;
} else {
- file->private_data = log;
+ struct logger_writer *writer;
+
+ writer = kzalloc(sizeof(struct logger_writer), GFP_KERNEL);
+ if (!writer)
+ return -ENOMEM;
+
+ writer->log = log;
+ writer->owner = current->group_leader;
+
+ file->private_data = writer;
}
return 0;
mutex_unlock(&log->mutex);
kfree(reader);
+ } else {
+ struct logger_writer *writer = file->private_data;
+
+ kfree(writer->tag);
+ kfree(writer->buffer);
+ kfree(writer);
}
return 0;
return 0;
}
+static long logger_set_prio(struct logger_writer *writer, void __user *arg)
+{
+ int prio;
+
+ prio = (int)arg;
+
+ if ((prio < 2) || (prio > 7))
+ return -EINVAL;
+
+ writer->prio = prio;
+ return 0;
+}
+
+static long logger_set_tag(struct logger_writer *writer, void __user *arg)
+{
+ int len;
+ char *p, *q;
+
+ if (copy_from_user(&len, arg, sizeof(int)))
+ return -EFAULT;
+
+ arg += sizeof(int);
+
+
+ p = kzalloc(len, GFP_KERNEL);
+ if (!p)
+ return -ENOMEM;
+
+ if (copy_from_user(p, arg, len)) {
+ kfree(p);
+ return -EFAULT;
+ }
+ p[len-1] = '\0';
+
+ q = writer->tag;
+ writer->tag = p;
+ writer->tag_len = len - 1; /* without NULL */
+ kfree(q);
+
+ return 0;
+}
+
static long logger_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct logger_log *log = file_get_log(file);
struct logger_reader *reader;
+ struct logger_writer *writer;
long ret = -EINVAL;
void __user *argp = (void __user *)arg;
ret = 0;
break;
case LOGGER_FLUSH_LOG:
- if (!(file->f_mode & FMODE_WRITE)) {
- ret = -EBADF;
- break;
- }
if (!(in_egroup_p(file_inode(file)->i_gid) ||
capable(CAP_SYSLOG))) {
ret = -EPERM;
reader = file->private_data;
ret = logger_set_version(reader, argp);
break;
+ case LOGGER_SET_PRIO: /* 44552 */
+ if (file->f_mode & FMODE_READ) {
+ ret = -EBADF;
+ break;
+ }
+ writer = file->private_data;
+ ret = logger_set_prio(writer, argp);
+ break;
+ case LOGGER_SET_TAG: /* 44551 */
+ if (file->f_mode & FMODE_READ) {
+ ret = -EBADF;
+ break;
+ }
+ writer = file->private_data;
+ ret = logger_set_tag(writer, argp);
+ break;
}
mutex_unlock(&log->mutex);
projects / platform / kernel / linux-rpi.git / commitdiff