Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0a295e67 authored by Tejun Heo's avatar Tejun Heo Committed by Linus Torvalds
Browse files

printk: factor out message formatting from devkmsg_read() 



The extended message formatting used for /dev/kmsg will be used implement
extended consoles.  Factor out msg_print_ext_header() and
msg_print_ext_body() from devkmsg_read().

This is pure restructuring.

Signed-off-by: default avatarTejun Heo <tj@kernel.org>
Cc: David Miller <davem@davemloft.net>
Cc: Kay Sievers <kay@vrfy.org>
Reviewed-by: default avatarPetr Mladek <pmladek@suse.cz>
Cc: Tetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent d43ff430

kernel/printk/printk.c

+80 −66
Original line number Diff line number Diff line
@@ -511,6 +511,81 @@ 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,

				    enum log_flags prev_flags)

{

	u64 ts_usec = msg->ts_nsec;

	char cont = '-';



	do_div(ts_usec, 1000);



	/*

	 * If we couldn't merge continuation line fragments during the print,

	 * export the stored flags to allow an optional external merge of the

	 * records. Merging the records isn't always neccessarily correct, like

	 * when we hit a race during printing. In most cases though, it produces

	 * better readable output. 'c' in the record flags mark the first

	 * fragment of a line, '+' the following.

	 */

	if (msg->flags & LOG_CONT && !(prev_flags & LOG_CONT))

		cont = 'c';

	else if ((msg->flags & LOG_CONT) ||

		 ((prev_flags & LOG_CONT) && !(msg->flags & LOG_PREFIX)))

		cont = '+';



	return scnprintf(buf, size, "%u,%llu,%llu,%c;",

		       (msg->facility << 3) | msg->level, seq, ts_usec, cont);

}



static ssize_t msg_print_ext_body(char *buf, size_t size,

				  char *dict, size_t dict_len,

				  char *text, size_t text_len)

{

	char *p = buf, *e = buf + size;

	size_t i;



	/* escape non-printable characters */

	for (i = 0; i < text_len; i++) {

		unsigned char c = text[i];



		if (c < ' ' || c >= 127 || c == '\\')

			p += scnprintf(p, e - p, "\\x%02x", c);

		else

			append_char(&p, e, c);

	}

	append_char(&p, e, '\n');



	if (dict_len) {

		bool line = true;



		for (i = 0; i < dict_len; i++) {

			unsigned char c = dict[i];



			if (line) {

				append_char(&p, e, ' ');

				line = false;

			}



			if (c == '\0') {

				append_char(&p, e, '\n');

				line = true;

				continue;

			}



			if (c < ' ' || c >= 127 || c == '\\') {

				p += scnprintf(p, e - p, "\\x%02x", c);

				continue;

			}



			append_char(&p, e, c);

		}

		append_char(&p, e, '\n');

	}



	return p - buf;

}



/* /dev/kmsg - userspace message inject/listen interface */

struct devkmsg_user {

	u64 seq;
@@ -575,19 +650,12 @@ static ssize_t devkmsg_read(struct file *file, char __user *buf, 
{

	struct devkmsg_user *user = file->private_data;

	struct printk_log *msg;

	char *p, *e;

	u64 ts_usec;

	size_t i;

	char cont = '-';

	size_t len;

	ssize_t ret;



	if (!user)

		return -EBADF;



	p = user->buf;

	e = user->buf + sizeof(user->buf);



	ret = mutex_lock_interruptible(&user->lock);

	if (ret)

		return ret;
@@ -617,71 +685,17 @@ static ssize_t devkmsg_read(struct file *file, char __user *buf, 
	}



	msg = log_from_idx(user->idx);

	ts_usec = msg->ts_nsec;

	do_div(ts_usec, 1000);

	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);



	/*

	 * If we couldn't merge continuation line fragments during the print,

	 * export the stored flags to allow an optional external merge of the

	 * records. Merging the records isn't always neccessarily correct, like

	 * when we hit a race during printing. In most cases though, it produces

	 * better readable output. 'c' in the record flags mark the first

	 * fragment of a line, '+' the following.

	 */

	if (msg->flags & LOG_CONT && !(user->prev & LOG_CONT))

		cont = 'c';

	else if ((msg->flags & LOG_CONT) ||

		 ((user->prev & LOG_CONT) && !(msg->flags & LOG_PREFIX)))

		cont = '+';



	p += scnprintf(p, e - p, "%u,%llu,%llu,%c;",

		       (msg->facility << 3) | msg->level,

		       user->seq, ts_usec, cont);

	user->prev = msg->flags;



	/* escape non-printable characters */

	for (i = 0; i < msg->text_len; i++) {

		unsigned char c = log_text(msg)[i];



		if (c < ' ' || c >= 127 || c == '\\')

			p += scnprintf(p, e - p, "\\x%02x", c);

		else

			append_char(&p, e, c);

	}

	append_char(&p, e, '\n');



	if (msg->dict_len) {

		bool line = true;



		for (i = 0; i < msg->dict_len; i++) {

			unsigned char c = log_dict(msg)[i];



			if (line) {

				append_char(&p, e, ' ');

				line = false;

			}



			if (c == '\0') {

				append_char(&p, e, '\n');

				line = true;

				continue;

			}



			if (c < ' ' || c >= 127 || c == '\\') {

				p += scnprintf(p, e - p, "\\x%02x", c);

				continue;

			}



			append_char(&p, e, c);

		}

		append_char(&p, e, '\n');

	}



	user->idx = log_next(user->idx);

	user->seq++;

	raw_spin_unlock_irq(&logbuf_lock);



	len = p - user->buf;

	if (len > count) {

		ret = -EINVAL;

		goto out;