Discard data from stdio

Accept and discard unstructured data coming from stdio.

This commit is mainly to make the later changes more readable.

Change-Id: I0428eef0b3f9517e14b8de282003436e5296b66d
Signed-off-by: Łukasz Stelmach <l.stelmach@samsung.com>

diff --git a/kernel/logger.c b/kernel/logger.c
index 853a862..b5a8d2b 100644 (file)
--- a/kernel/logger.c
+++ b/kernel/logger.c
@@ -616,11 +616,17 @@ static ssize_t do_write_log_from_user(struct logger_log *log,
 static ssize_t logger_aio_write(struct kiocb *iocb, const struct iovec *iov,
                         unsigned long nr_segs, loff_t ppos)
 {
-       struct logger_log *log = file_get_log(iocb->ki_filp);
+       struct file *file = iocb->ki_filp;
+       struct logger_writer *writer = file->private_data;
+       struct logger_log *log = file_get_log(file);
        size_t orig;
        struct logger_entry header;
        struct timespec now;
        ssize_t ret = 0;
+       bool from_stdio = false;
+
+       if (writer->tag && writer->prio >= 2)
+               from_stdio = true;
 
        now = current_kernel_time();
 
@@ -638,35 +644,40 @@ static ssize_t logger_aio_write(struct kiocb *iocb, const struct iovec *iov,
 
        mutex_lock(&log->mutex);
 
-       orig = log->w_off;
+       /* Prepend messages from STDOUT and STDERR with a tag and prio */
+       if (from_stdio) {
+               return 0;
+       } else {
+               orig = log->w_off;
 
-       /*
-        * Fix up any readers, pulling them forward to the first readable
-        * entry after (what will be) the new write offset. We do this now
-        * because if we partially fail, we can end up with clobbered log
-        * entries that encroach on readable buffer.
-        */
-       fix_up_readers(log, sizeof(struct logger_entry) + header.len);
+               /*
+                * Fix up any readers, pulling them forward to the first readable
+                * entry after (what will be) the new write offset. We do this now
+                * because if we partially fail, we can end up with clobbered log
+                * entries that encroach on readable buffer.
+                */
+               fix_up_readers(log, sizeof(struct logger_entry) + header.len);
 
-       do_write_log(log, &header, sizeof(struct logger_entry));
+               do_write_log(log, &header, sizeof(struct logger_entry));
 
-       while (nr_segs-- > 0) {
-               size_t len;
-               ssize_t nr;
+               while (nr_segs-- > 0) {
+                       size_t len;
+                       ssize_t nr;
 
-               /* figure out how much of this vector we can keep */
-               len = min_t(size_t, iov->iov_len, header.len - ret);
+                       /* figure out how much of this vector we can keep */
+                       len = min_t(size_t, iov->iov_len, header.len - ret);
 
-               /* write out this segment's payload */
-               nr = do_write_log_from_user(log, iov->iov_base, len);
-               if (unlikely(nr < 0)) {
-                       log->w_off = orig;
-                       mutex_unlock(&log->mutex);
-                       return nr;
-               }
+                       /* write out this segment's payload */
+                       nr = do_write_log_from_user(log, iov->iov_base, len);
+                       if (unlikely(nr < 0)) {
+                               log->w_off = orig;
+                               mutex_unlock(&log->mutex);
+                               return nr;
+                       }
 
-               iov++;
-               ret += nr;
+                       iov++;
+                       ret += nr;
+               }
        }
 
        mutex_unlock(&log->mutex);