2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* linux/kernel/printk.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
*
|
|
|
|
* Modified to make sys_syslog() more flexible: added commands to
|
|
|
|
* return the last 4k of kernel messages, regardless of whether
|
|
|
|
* they've been read or not. Added option to suppress kernel printk's
|
|
|
|
* to the console. Added hook for sending the console messages
|
|
|
|
* elsewhere, in preparation for a serial line console (someday).
|
|
|
|
* Ted Ts'o, 2/11/93.
|
|
|
|
* Modified for sysctl support, 1/8/97, Chris Horn.
|
2005-10-30 16:02:46 -07:00
|
|
|
* Fixed SMP synchronization, 08/08/99, Manfred Spraul
|
2006-01-14 18:43:54 -07:00
|
|
|
* manfred@colorfullife.com
|
2005-04-16 16:20:36 -06:00
|
|
|
* Rewrote bits to get rid of console_lock
|
2008-10-15 23:01:59 -06:00
|
|
|
* 01Mar01 Andrew Morton
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/tty_driver.h>
|
|
|
|
#include <linux/console.h>
|
|
|
|
#include <linux/init.h>
|
2007-10-16 02:23:46 -06:00
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/nmi.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/module.h>
|
2006-06-25 06:48:15 -06:00
|
|
|
#include <linux/moduleparam.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/interrupt.h> /* For in_interrupt() */
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/security.h>
|
|
|
|
#include <linux/bootmem.h>
|
2011-05-24 18:13:20 -06:00
|
|
|
#include <linux/memblock.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/syscalls.h>
|
2009-04-02 17:58:57 -06:00
|
|
|
#include <linux/kexec.h>
|
2010-05-20 20:04:27 -06:00
|
|
|
#include <linux/kdb.h>
|
2009-09-22 08:18:09 -06:00
|
|
|
#include <linux/ratelimit.h>
|
2009-10-16 06:09:18 -06:00
|
|
|
#include <linux/kmsg_dump.h>
|
2010-02-03 16:36:43 -07:00
|
|
|
#include <linux/syslog.h>
|
2010-06-03 23:11:25 -06:00
|
|
|
#include <linux/cpu.h>
|
|
|
|
#include <linux/notifier.h>
|
2011-01-12 17:59:43 -07:00
|
|
|
#include <linux/rculist.h>
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
#include <linux/poll.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
2011-11-24 12:03:08 -07:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/printk.h>
|
|
|
|
|
2008-01-30 05:33:06 -07:00
|
|
|
/*
|
|
|
|
* Architectures can override it:
|
|
|
|
*/
|
2008-05-12 07:44:40 -06:00
|
|
|
void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
|
2008-01-30 05:33:06 -07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* printk's without a loglevel use this.. */
|
2011-03-22 17:34:23 -06:00
|
|
|
#define DEFAULT_MESSAGE_LOGLEVEL CONFIG_DEFAULT_MESSAGE_LOGLEVEL
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* We show everything that is MORE important than this.. */
|
|
|
|
#define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */
|
|
|
|
#define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG */
|
|
|
|
|
|
|
|
DECLARE_WAIT_QUEUE_HEAD(log_wait);
|
|
|
|
|
|
|
|
int console_printk[4] = {
|
|
|
|
DEFAULT_CONSOLE_LOGLEVEL, /* console_loglevel */
|
|
|
|
DEFAULT_MESSAGE_LOGLEVEL, /* default_message_loglevel */
|
|
|
|
MINIMUM_CONSOLE_LOGLEVEL, /* minimum_console_loglevel */
|
|
|
|
DEFAULT_CONSOLE_LOGLEVEL, /* default_console_loglevel */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
2007-02-17 12:10:16 -07:00
|
|
|
* Low level drivers may need that to know if they can schedule in
|
2005-04-16 16:20:36 -06:00
|
|
|
* their unblank() callback or not. So let's export it.
|
|
|
|
*/
|
|
|
|
int oops_in_progress;
|
|
|
|
EXPORT_SYMBOL(oops_in_progress);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* console_sem protects the console_drivers list, and also
|
|
|
|
* provides serialisation for access to the entire console
|
|
|
|
* driver system.
|
|
|
|
*/
|
2010-09-07 08:33:43 -06:00
|
|
|
static DEFINE_SEMAPHORE(console_sem);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct console *console_drivers;
|
2008-06-02 05:19:08 -06:00
|
|
|
EXPORT_SYMBOL_GPL(console_drivers);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* This is used for debugging the mess that is the VT code by
|
|
|
|
* keeping track if we have the console semaphore held. It's
|
|
|
|
* definitely not the perfect debug tool (we don't know if _WE_
|
|
|
|
* hold it are racing, but it helps tracking those weird code
|
|
|
|
* path in the console code where we end up in places I want
|
|
|
|
* locked without the console sempahore held
|
|
|
|
*/
|
2006-06-19 19:16:01 -06:00
|
|
|
static int console_locked, console_suspended;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-03-22 17:34:21 -06:00
|
|
|
/*
|
|
|
|
* If exclusive_console is non-NULL then only this console is to be printed to.
|
|
|
|
*/
|
|
|
|
static struct console *exclusive_console;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Array of consoles built from command line options (console=)
|
|
|
|
*/
|
|
|
|
struct console_cmdline
|
|
|
|
{
|
|
|
|
char name[8]; /* Name of the driver */
|
|
|
|
int index; /* Minor dev. to use */
|
|
|
|
char *options; /* Options for the driver */
|
2008-04-30 01:54:51 -06:00
|
|
|
#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
|
|
|
|
char *brl_options; /* Options for braille driver */
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
#define MAX_CMDLINECONSOLES 8
|
|
|
|
|
|
|
|
static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
|
|
|
|
static int selected_console = -1;
|
|
|
|
static int preferred_console = -1;
|
xen: Enable console tty by default in domU if it's not a dummy
Without console= arguments on the kernel command line, the first
console to register becomes enabled and the preferred console (the one
behind /dev/console). This is normally tty (assuming
CONFIG_VT_CONSOLE is enabled, which it commonly is).
This is okay as long tty is a useful console. But unless we have the
PV framebuffer, and it is enabled for this domain, tty0 in domU is
merely a dummy. In that case, we want the preferred console to be the
Xen console hvc0, and we want it without having to fiddle with the
kernel command line. Commit b8c2d3dfbc117dff26058fbac316b8acfc2cb5f7
did that for us.
Since we now have the PV framebuffer, we want to enable and prefer tty
again, but only when PVFB is enabled. But even then we still want to
enable the Xen console as well.
Problem: when tty registers, we can't yet know whether the PVFB is
enabled. By the time we can know (xenstore is up), the console setup
game is over.
Solution: enable console tty by default, but keep hvc as the preferred
console. Change the preferred console to tty when PVFB probes
successfully, unless we've been given console kernel parameters.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-26 16:31:07 -06:00
|
|
|
int console_set_on_cmdline;
|
|
|
|
EXPORT_SYMBOL(console_set_on_cmdline);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Flag: console code may call schedule() */
|
|
|
|
static int console_may_schedule;
|
|
|
|
|
2012-05-02 18:29:13 -06:00
|
|
|
/*
|
|
|
|
* 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 both 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.
|
|
|
|
*
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
* 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 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;<message text>\n"
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* Users of the export format should ignore possible additional values
|
|
|
|
* separated by ',', and find the message after the ';' character.
|
2012-05-02 18:29:13 -06:00
|
|
|
*/
|
|
|
|
|
2012-06-28 01:38:53 -06:00
|
|
|
enum log_flags {
|
2012-07-09 13:15:42 -06:00
|
|
|
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 */
|
2012-06-28 01:38:53 -06:00
|
|
|
};
|
|
|
|
|
2012-05-02 18:29:13 -06:00
|
|
|
struct 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 */
|
2012-06-28 01:38:53 -06:00
|
|
|
u8 facility; /* syslog facility */
|
|
|
|
u8 flags:5; /* internal record flags */
|
|
|
|
u8 level:3; /* syslog level */
|
2012-05-02 18:29:13 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The logbuf_lock protects kmsg buffer, indices, counters. It is also
|
|
|
|
* used in interesting ways to provide interlocking in console_unlock();
|
|
|
|
*/
|
|
|
|
static DEFINE_RAW_SPINLOCK(logbuf_lock);
|
2005-05-01 09:59:02 -06:00
|
|
|
|
2012-07-16 19:35:29 -06:00
|
|
|
#ifdef CONFIG_PRINTK
|
2012-05-08 17:37:51 -06:00
|
|
|
/* the next printk record to read by syslog(READ) or /proc/kmsg */
|
|
|
|
static u64 syslog_seq;
|
|
|
|
static u32 syslog_idx;
|
2012-07-09 13:15:42 -06:00
|
|
|
static enum log_flags syslog_prev;
|
2012-07-09 11:05:10 -06:00
|
|
|
static size_t syslog_partial;
|
2012-05-02 18:29:13 -06:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
2012-07-16 19:35:30 -06:00
|
|
|
/* the next printk record to write to the console */
|
|
|
|
static u64 console_seq;
|
|
|
|
static u32 console_idx;
|
|
|
|
static enum log_flags console_prev;
|
|
|
|
|
2012-05-02 18:29:13 -06:00
|
|
|
/* the next printk record to read after the last 'clear' command */
|
|
|
|
static u64 clear_seq;
|
|
|
|
static u32 clear_idx;
|
|
|
|
|
2012-07-16 19:35:29 -06:00
|
|
|
#define PREFIX_MAX 32
|
|
|
|
#define LOG_LINE_MAX 1024 - PREFIX_MAX
|
2012-05-08 17:37:51 -06:00
|
|
|
|
|
|
|
/* record buffer */
|
2012-06-05 00:52:34 -06:00
|
|
|
#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
|
2012-05-10 16:14:33 -06:00
|
|
|
#define LOG_ALIGN 4
|
|
|
|
#else
|
2012-06-05 00:52:34 -06:00
|
|
|
#define LOG_ALIGN __alignof__(struct log)
|
2012-05-10 16:14:33 -06:00
|
|
|
#endif
|
2012-05-08 17:37:51 -06:00
|
|
|
#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
|
2012-05-10 16:14:33 -06:00
|
|
|
static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
|
2012-05-08 17:37:51 -06:00
|
|
|
static char *log_buf = __log_buf;
|
|
|
|
static u32 log_buf_len = __LOG_BUF_LEN;
|
|
|
|
|
|
|
|
/* cpu currently holding logbuf_lock */
|
|
|
|
static volatile unsigned int logbuf_cpu = UINT_MAX;
|
2012-05-02 18:29:13 -06:00
|
|
|
|
|
|
|
/* human readable text of the record */
|
|
|
|
static char *log_text(const struct log *msg)
|
|
|
|
{
|
|
|
|
return (char *)msg + sizeof(struct log);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* optional key/value pair dictionary attached to the record */
|
|
|
|
static char *log_dict(const struct log *msg)
|
|
|
|
{
|
|
|
|
return (char *)msg + sizeof(struct log) + msg->text_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get record by index; idx must point to valid msg */
|
|
|
|
static struct log *log_from_idx(u32 idx)
|
|
|
|
{
|
|
|
|
struct log *msg = (struct 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 log *)log_buf;
|
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get next record; idx must point to valid msg */
|
|
|
|
static u32 log_next(u32 idx)
|
|
|
|
{
|
|
|
|
struct log *msg = (struct 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 log *)log_buf;
|
|
|
|
return msg->len;
|
|
|
|
}
|
|
|
|
return idx + msg->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* insert record into the buffer, discard old ones, update heads */
|
|
|
|
static void log_store(int facility, int level,
|
2012-06-28 01:38:53 -06:00
|
|
|
enum log_flags flags, u64 ts_nsec,
|
2012-05-02 18:29:13 -06:00
|
|
|
const char *dict, u16 dict_len,
|
|
|
|
const char *text, u16 text_len)
|
|
|
|
{
|
|
|
|
struct log *msg;
|
|
|
|
u32 size, pad_len;
|
|
|
|
|
|
|
|
/* number of '\0' padding bytes to next message */
|
|
|
|
size = sizeof(struct log) + text_len + dict_len;
|
|
|
|
pad_len = (-size) & (LOG_ALIGN - 1);
|
|
|
|
size += pad_len;
|
|
|
|
|
|
|
|
while (log_first_seq < log_next_seq) {
|
|
|
|
u32 free;
|
|
|
|
|
|
|
|
if (log_next_idx > log_first_idx)
|
|
|
|
free = max(log_buf_len - log_next_idx, log_first_idx);
|
|
|
|
else
|
|
|
|
free = log_first_idx - log_next_idx;
|
|
|
|
|
|
|
|
if (free > size + sizeof(struct log))
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* drop old messages until we have enough contiuous space */
|
|
|
|
log_first_idx = log_next(log_first_idx);
|
|
|
|
log_first_seq++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (log_next_idx + size + sizeof(struct log) >= log_buf_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 log));
|
|
|
|
log_next_idx = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fill message */
|
|
|
|
msg = (struct log *)(log_buf + log_next_idx);
|
|
|
|
memcpy(log_text(msg), text, text_len);
|
|
|
|
msg->text_len = text_len;
|
|
|
|
memcpy(log_dict(msg), dict, dict_len);
|
|
|
|
msg->dict_len = dict_len;
|
2012-06-28 01:38:53 -06:00
|
|
|
msg->facility = facility;
|
|
|
|
msg->level = level & 7;
|
|
|
|
msg->flags = flags & 0x1f;
|
|
|
|
if (ts_nsec > 0)
|
|
|
|
msg->ts_nsec = ts_nsec;
|
|
|
|
else
|
|
|
|
msg->ts_nsec = local_clock();
|
2012-05-02 18:29:13 -06:00
|
|
|
memset(log_dict(msg) + dict_len, 0, pad_len);
|
|
|
|
msg->len = sizeof(struct log) + text_len + dict_len + pad_len;
|
|
|
|
|
|
|
|
/* insert message */
|
|
|
|
log_next_idx += msg->len;
|
|
|
|
log_next_seq++;
|
|
|
|
}
|
2005-05-01 09:59:02 -06:00
|
|
|
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
/* /dev/kmsg - userspace message inject/listen interface */
|
|
|
|
struct devkmsg_user {
|
|
|
|
u64 seq;
|
|
|
|
u32 idx;
|
kmsg - export "continuation record" flag to /dev/kmsg
In some cases we are forced to store individual records for a continuation
line print.
Export a flag to allow the external re-construction of the line. The flag
allows us to apply a similar logic externally which is used internally when
the console, /proc/kmsg or the syslog() output is printed.
$ cat /dev/kmsg
4,165,0,-;Free swap = 0kB
4,166,0,-;Total swap = 0kB
6,167,0,c;[
4,168,0,+;0
4,169,0,+;1
4,170,0,+;2
4,171,0,+;3
4,172,0,+;]
6,173,0,-;[0 1 2 3 ]
6,174,0,-;Console: colour VGA+ 80x25
6,175,0,-;console [tty0] enabled
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-07-16 19:35:30 -06:00
|
|
|
enum log_flags prev;
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
struct mutex lock;
|
|
|
|
char buf[8192];
|
|
|
|
};
|
|
|
|
|
|
|
|
static ssize_t devkmsg_writev(struct kiocb *iocb, const struct iovec *iv,
|
|
|
|
unsigned long count, loff_t pos)
|
|
|
|
{
|
|
|
|
char *buf, *line;
|
|
|
|
int i;
|
|
|
|
int level = default_message_loglevel;
|
|
|
|
int facility = 1; /* LOG_USER */
|
|
|
|
size_t len = iov_length(iv, count);
|
|
|
|
ssize_t ret = len;
|
|
|
|
|
|
|
|
if (len > LOG_LINE_MAX)
|
|
|
|
return -EINVAL;
|
|
|
|
buf = kmalloc(len+1, GFP_KERNEL);
|
|
|
|
if (buf == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
line = buf;
|
|
|
|
for (i = 0; i < count; i++) {
|
2012-07-30 15:40:08 -06:00
|
|
|
if (copy_from_user(line, iv[i].iov_base, iv[i].iov_len)) {
|
|
|
|
ret = -EFAULT;
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
goto out;
|
2012-07-30 15:40:08 -06:00
|
|
|
}
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
line += iv[i].iov_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
line[len] = '\0';
|
|
|
|
|
|
|
|
printk_emit(facility, level, NULL, 0, "%s", line);
|
|
|
|
out:
|
|
|
|
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 log *msg;
|
2012-05-08 05:04:17 -06:00
|
|
|
u64 ts_usec;
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
size_t i;
|
kmsg - export "continuation record" flag to /dev/kmsg
In some cases we are forced to store individual records for a continuation
line print.
Export a flag to allow the external re-construction of the line. The flag
allows us to apply a similar logic externally which is used internally when
the console, /proc/kmsg or the syslog() output is printed.
$ cat /dev/kmsg
4,165,0,-;Free swap = 0kB
4,166,0,-;Total swap = 0kB
6,167,0,c;[
4,168,0,+;0
4,169,0,+;1
4,170,0,+;2
4,171,0,+;3
4,172,0,+;]
6,173,0,-;[0 1 2 3 ]
6,174,0,-;Console: colour VGA+ 80x25
6,175,0,-;console [tty0] enabled
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-07-16 19:35:30 -06:00
|
|
|
char cont = '-';
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
size_t len;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
if (!user)
|
|
|
|
return -EBADF;
|
|
|
|
|
printk: use mutex lock to stop syslog_seq from going wild
Although syslog_seq and log_next_seq stuff are protected by logbuf_lock
spin log, it's not enough. Say we have two processes A and B, and let
syslog_seq = N, while log_next_seq = N + 1, and the two processes both
come to syslog_print at almost the same time. And No matter which
process get the spin lock first, it will increase syslog_seq by one,
then release spin lock; thus later, another process increase syslog_seq
by one again. In this case, syslog_seq is bigger than syslog_next_seq.
And latter, it would make:
wait_event_interruptiable(log_wait, syslog != log_next_seq)
don't wait any more even there is no new write comes. Thus it introduce
a infinite loop reading.
I can easily see this kind of issue by the following steps:
# cat /proc/kmsg # at meantime, I don't kill rsyslog
# So they are the two processes.
# xinit # I added drm.debug=6 in the kernel parameter line,
# so that it will produce lots of message and let that
# issue happen
It's 100% reproducable on my side. And my disk will be filled up by
/var/log/messages in a quite short time.
So, introduce a mutex_lock to stop syslog_seq from going wild just like
what devkmsg_read() does. It does fix this issue as expected.
v2: use mutex_lock_interruptiable() instead (comments from Kay)
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Fengguang Wu <fengguang.wu@intel.com>
Acked-By: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-06-16 07:21:51 -06:00
|
|
|
ret = mutex_lock_interruptible(&user->lock);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-07-06 10:50:08 -06:00
|
|
|
raw_spin_lock_irq(&logbuf_lock);
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
while (user->seq == log_next_seq) {
|
|
|
|
if (file->f_flags & O_NONBLOCK) {
|
|
|
|
ret = -EAGAIN;
|
2012-07-06 10:50:08 -06:00
|
|
|
raw_spin_unlock_irq(&logbuf_lock);
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-07-06 10:50:08 -06:00
|
|
|
raw_spin_unlock_irq(&logbuf_lock);
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
ret = wait_event_interruptible(log_wait,
|
|
|
|
user->seq != log_next_seq);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2012-07-06 10:50:08 -06:00
|
|
|
raw_spin_lock_irq(&logbuf_lock);
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2012-07-06 10:50:08 -06:00
|
|
|
raw_spin_unlock_irq(&logbuf_lock);
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
msg = log_from_idx(user->idx);
|
2012-05-08 05:04:17 -06:00
|
|
|
ts_usec = msg->ts_nsec;
|
|
|
|
do_div(ts_usec, 1000);
|
kmsg - export "continuation record" flag to /dev/kmsg
In some cases we are forced to store individual records for a continuation
line print.
Export a flag to allow the external re-construction of the line. The flag
allows us to apply a similar logic externally which is used internally when
the console, /proc/kmsg or the syslog() output is printed.
$ cat /dev/kmsg
4,165,0,-;Free swap = 0kB
4,166,0,-;Total swap = 0kB
6,167,0,c;[
4,168,0,+;0
4,169,0,+;1
4,170,0,+;2
4,171,0,+;3
4,172,0,+;]
6,173,0,-;[0 1 2 3 ]
6,174,0,-;Console: colour VGA+ 80x25
6,175,0,-;console [tty0] enabled
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-07-16 19:35:30 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 = '+';
|
|
|
|
|
|
|
|
len = sprintf(user->buf, "%u,%llu,%llu,%c;",
|
|
|
|
(msg->facility << 3) | msg->level,
|
|
|
|
user->seq, ts_usec, cont);
|
|
|
|
user->prev = msg->flags;
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
|
|
|
|
/* escape non-printable characters */
|
|
|
|
for (i = 0; i < msg->text_len; i++) {
|
2012-05-13 15:30:46 -06:00
|
|
|
unsigned char c = log_text(msg)[i];
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
|
2012-07-06 10:50:09 -06:00
|
|
|
if (c < ' ' || c >= 127 || c == '\\')
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
len += sprintf(user->buf + len, "\\x%02x", c);
|
|
|
|
else
|
|
|
|
user->buf[len++] = c;
|
|
|
|
}
|
|
|
|
user->buf[len++] = '\n';
|
|
|
|
|
|
|
|
if (msg->dict_len) {
|
|
|
|
bool line = true;
|
|
|
|
|
|
|
|
for (i = 0; i < msg->dict_len; i++) {
|
2012-05-13 15:30:46 -06:00
|
|
|
unsigned char c = log_dict(msg)[i];
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
|
|
|
|
if (line) {
|
|
|
|
user->buf[len++] = ' ';
|
|
|
|
line = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c == '\0') {
|
|
|
|
user->buf[len++] = '\n';
|
|
|
|
line = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-07-06 10:50:09 -06:00
|
|
|
if (c < ' ' || c >= 127 || c == '\\') {
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
len += sprintf(user->buf + len, "\\x%02x", c);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
user->buf[len++] = c;
|
|
|
|
}
|
|
|
|
user->buf[len++] = '\n';
|
|
|
|
}
|
|
|
|
|
|
|
|
user->idx = log_next(user->idx);
|
|
|
|
user->seq++;
|
2012-07-06 10:50:08 -06:00
|
|
|
raw_spin_unlock_irq(&logbuf_lock);
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2012-07-06 10:50:08 -06:00
|
|
|
raw_spin_lock_irq(&logbuf_lock);
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
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;
|
|
|
|
}
|
2012-07-06 10:50:08 -06:00
|
|
|
raw_spin_unlock_irq(&logbuf_lock);
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
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);
|
|
|
|
|
2012-07-06 10:50:08 -06:00
|
|
|
raw_spin_lock_irq(&logbuf_lock);
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
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;
|
|
|
|
ret = POLLIN|POLLRDNORM;
|
|
|
|
}
|
2012-07-06 10:50:08 -06:00
|
|
|
raw_spin_unlock_irq(&logbuf_lock);
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
|
|
|
|
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 = security_syslog(SYSLOG_ACTION_READ_ALL);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
user = kmalloc(sizeof(struct devkmsg_user), GFP_KERNEL);
|
|
|
|
if (!user)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
mutex_init(&user->lock);
|
|
|
|
|
2012-07-06 10:50:08 -06:00
|
|
|
raw_spin_lock_irq(&logbuf_lock);
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
user->idx = log_first_idx;
|
|
|
|
user->seq = log_first_seq;
|
2012-07-06 10:50:08 -06:00
|
|
|
raw_spin_unlock_irq(&logbuf_lock);
|
kmsg: export printk records to the /dev/kmsg interface
Support for multiple concurrent readers of /dev/kmsg, with read(),
seek(), poll() support. Output of message sequence numbers, to allow
userspace log consumers to reliably reconnect and reconstruct their
state at any given time. After open("/dev/kmsg"), read() always
returns *all* buffered records. If only future messages should be
read, SEEK_END can be used. In case records get overwritten while
/dev/kmsg is held open, or records get faster overwritten than they
are read, the next read() will return -EPIPE and the current reading
position gets updated to the next available record. The passed
sequence numbers allow the log consumer to calculate the amount of
lost messages.
[root@mop ~]# cat /dev/kmsg
5,0,0;Linux version 3.4.0-rc1+ (kay@mop) (gcc version 4.7.0 20120315 ...
6,159,423091;ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff])
7,160,424069;pci_root PNP0A03:00: host bridge window [io 0x0000-0x0cf7] (ignored)
SUBSYSTEM=acpi
DEVICE=+acpi:PNP0A03:00
6,339,5140900;NET: Registered protocol family 10
30,340,5690716;udevd[80]: starting version 181
6,341,6081421;FDC 0 is a S82078B
6,345,6154686;microcode: CPU0 sig=0x623, pf=0x0, revision=0x0
7,346,6156968;sr 1:0:0:0: Attached scsi CD-ROM sr0
SUBSYSTEM=scsi
DEVICE=+scsi:1:0:0:0
6,347,6289375;microcode: CPU1 sig=0x623, pf=0x0, revision=0x0
Cc: Karel Zak <kzak@redhat.com>
Tested-by: William Douglas <william.douglas@intel.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-05-02 18:29:41 -06:00
|
|
|
|
|
|
|
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,
|
|
|
|
.aio_write = devkmsg_writev,
|
|
|
|
.llseek = devkmsg_llseek,
|
|
|
|
.poll = devkmsg_poll,
|
|
|
|
.release = devkmsg_release,
|
|
|
|
};
|
|
|
|
|
2009-04-02 17:58:57 -06:00
|
|
|
#ifdef CONFIG_KEXEC
|
|
|
|
/*
|
|
|
|
* This appends the listed symbols to /proc/vmcoreinfo
|
|
|
|
*
|
|
|
|
* /proc/vmcoreinfo is used by various utiilties, like crash and makedumpfile to
|
|
|
|
* obtain access to symbols that are otherwise very difficult to locate. These
|
|
|
|
* symbols are specifically used so that utilities can access and extract the
|
|
|
|
* dmesg log from a vmcore file after a crash.
|
|
|
|
*/
|
|
|
|
void log_buf_kexec_setup(void)
|
|
|
|
{
|
|
|
|
VMCOREINFO_SYMBOL(log_buf);
|
|
|
|
VMCOREINFO_SYMBOL(log_buf_len);
|
2012-05-02 18:29:13 -06:00
|
|
|
VMCOREINFO_SYMBOL(log_first_idx);
|
|
|
|
VMCOREINFO_SYMBOL(log_next_idx);
|
2012-07-18 11:18:12 -06:00
|
|
|
/*
|
|
|
|
* Export struct log size and field offsets. User space tools can
|
|
|
|
* parse it and detect any changes to structure down the line.
|
|
|
|
*/
|
|
|
|
VMCOREINFO_STRUCT_SIZE(log);
|
|
|
|
VMCOREINFO_OFFSET(log, ts_nsec);
|
|
|
|
VMCOREINFO_OFFSET(log, len);
|
|
|
|
VMCOREINFO_OFFSET(log, text_len);
|
|
|
|
VMCOREINFO_OFFSET(log, dict_len);
|
2009-04-02 17:58:57 -06:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-05-24 18:13:20 -06:00
|
|
|
/* requested log_buf_len from kernel cmdline */
|
|
|
|
static unsigned long __initdata new_log_buf_len;
|
|
|
|
|
|
|
|
/* save requested log_buf_len since it's too early to process it */
|
2005-04-16 16:20:36 -06:00
|
|
|
static int __init log_buf_len_setup(char *str)
|
|
|
|
{
|
2008-02-06 02:37:02 -07:00
|
|
|
unsigned size = memparse(str, &str);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (size)
|
|
|
|
size = roundup_pow_of_two(size);
|
2011-05-24 18:13:20 -06:00
|
|
|
if (size > log_buf_len)
|
|
|
|
new_log_buf_len = size;
|
|
|
|
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-05-24 18:13:20 -06:00
|
|
|
early_param("log_buf_len", log_buf_len_setup);
|
|
|
|
|
|
|
|
void __init setup_log_buf(int early)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
char *new_log_buf;
|
|
|
|
int free;
|
|
|
|
|
|
|
|
if (!new_log_buf_len)
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-24 18:13:20 -06:00
|
|
|
if (early) {
|
|
|
|
unsigned long mem;
|
|
|
|
|
|
|
|
mem = memblock_alloc(new_log_buf_len, PAGE_SIZE);
|
2011-07-12 01:58:09 -06:00
|
|
|
if (!mem)
|
2011-05-24 18:13:20 -06:00
|
|
|
return;
|
|
|
|
new_log_buf = __va(mem);
|
|
|
|
} else {
|
|
|
|
new_log_buf = alloc_bootmem_nopanic(new_log_buf_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(!new_log_buf)) {
|
|
|
|
pr_err("log_buf_len: %ld bytes not available\n",
|
|
|
|
new_log_buf_len);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-07-25 09:50:36 -06:00
|
|
|
raw_spin_lock_irqsave(&logbuf_lock, flags);
|
2011-05-24 18:13:20 -06:00
|
|
|
log_buf_len = new_log_buf_len;
|
|
|
|
log_buf = new_log_buf;
|
|
|
|
new_log_buf_len = 0;
|
2012-05-02 18:29:13 -06:00
|
|
|
free = __LOG_BUF_LEN - log_next_idx;
|
|
|
|
memcpy(log_buf, __log_buf, __LOG_BUF_LEN);
|
2009-07-25 09:50:36 -06:00
|
|
|
raw_spin_unlock_irqrestore(&logbuf_lock, flags);
|
2011-05-24 18:13:20 -06:00
|
|
|
|
|
|
|
pr_info("log_buf_len: %d\n", log_buf_len);
|
|
|
|
pr_info("early log buf free: %d(%d%%)\n",
|
|
|
|
free, (free * 100) / __LOG_BUF_LEN);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-12-17 16:59:56 -07:00
|
|
|
static bool __read_mostly ignore_loglevel;
|
|
|
|
|
|
|
|
static int __init ignore_loglevel_setup(char *str)
|
|
|
|
{
|
|
|
|
ignore_loglevel = 1;
|
|
|
|
printk(KERN_INFO "debug: ignoring loglevel setting.\n");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
early_param("ignore_loglevel", ignore_loglevel_setup);
|
|
|
|
module_param(ignore_loglevel, bool, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(ignore_loglevel, "ignore loglevel setting, to"
|
|
|
|
"print all kernel messages to the console.");
|
|
|
|
|
2007-10-16 02:23:46 -06:00
|
|
|
#ifdef CONFIG_BOOT_PRINTK_DELAY
|
|
|
|
|
2010-10-26 15:22:48 -06:00
|
|
|
static int boot_delay; /* msecs delay after each printk during bootup */
|
2009-09-22 17:43:31 -06:00
|
|
|
static unsigned long long loops_per_msec; /* based on boot_delay */
|
2007-10-16 02:23:46 -06:00
|
|
|
|
|
|
|
static int __init boot_delay_setup(char *str)
|
|
|
|
{
|
|
|
|
unsigned long lpj;
|
|
|
|
|
|
|
|
lpj = preset_lpj ? preset_lpj : 1000000; /* some guess */
|
|
|
|
loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
|
|
|
|
|
|
|
|
get_option(&str, &boot_delay);
|
|
|
|
if (boot_delay > 10 * 1000)
|
|
|
|
boot_delay = 0;
|
|
|
|
|
2009-09-22 17:43:31 -06:00
|
|
|
pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
|
|
|
|
"HZ: %d, loops_per_msec: %llu\n",
|
|
|
|
boot_delay, preset_lpj, lpj, HZ, loops_per_msec);
|
2007-10-16 02:23:46 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("boot_delay=", boot_delay_setup);
|
|
|
|
|
2012-12-17 16:59:56 -07:00
|
|
|
static void boot_delay_msec(int level)
|
2007-10-16 02:23:46 -06:00
|
|
|
{
|
|
|
|
unsigned long long k;
|
|
|
|
unsigned long timeout;
|
|
|
|
|
2012-12-17 16:59:56 -07:00
|
|
|
if ((boot_delay == 0 || system_state != SYSTEM_BOOTING)
|
|
|
|
|| (level >= console_loglevel && !ignore_loglevel)) {
|
2007-10-16 02:23:46 -06:00
|
|
|
return;
|
2012-12-17 16:59:56 -07:00
|
|
|
}
|
2007-10-16 02:23:46 -06:00
|
|
|
|
2009-09-22 17:43:31 -06:00
|
|
|
k = (unsigned long long)loops_per_msec * boot_delay;
|
2007-10-16 02:23:46 -06:00
|
|
|
|
|
|
|
timeout = jiffies + msecs_to_jiffies(boot_delay);
|
|
|
|
while (k) {
|
|
|
|
k--;
|
|
|
|
cpu_relax();
|
|
|
|
/*
|
|
|
|
* use (volatile) jiffies to prevent
|
|
|
|
* compiler reduction; loop termination via jiffies
|
|
|
|
* is secondary and may or may not happen.
|
|
|
|
*/
|
|
|
|
if (time_after(jiffies, timeout))
|
|
|
|
break;
|
|
|
|
touch_nmi_watchdog();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
2012-12-17 16:59:56 -07:00
|
|
|
static inline void boot_delay_msec(int level)
|
2007-10-16 02:23:46 -06:00
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-11-11 15:05:18 -07:00
|
|
|
#ifdef CONFIG_SECURITY_DMESG_RESTRICT
|
|
|
|
int dmesg_restrict = 1;
|
|
|
|
#else
|
|
|
|
int dmesg_restrict;
|
|
|
|
#endif
|
|
|
|
|
2011-02-10 18:53:55 -07:00
|
|
|
static int syslog_action_restricted(int type)
|
|
|
|
{
|
|
|
|
if (dmesg_restrict)
|
|
|
|
return 1;
|
|
|
|
/* Unless restricted, we allow "read all" and "get buffer size" for everybody */
|
|
|
|
return type != SYSLOG_ACTION_READ_ALL && type != SYSLOG_ACTION_SIZE_BUFFER;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int check_syslog_permissions(int type, bool from_file)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* If this is from /proc/kmsg and we've already opened it, then we've
|
|
|
|
* already done the capabilities checks at open time.
|
|
|
|
*/
|
|
|
|
if (from_file && type != SYSLOG_ACTION_OPEN)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (syslog_action_restricted(type)) {
|
|
|
|
if (capable(CAP_SYSLOG))
|
|
|
|
return 0;
|
|
|
|
/* For historical reasons, accept CAP_SYS_ADMIN too, with a warning */
|
|
|
|
if (capable(CAP_SYS_ADMIN)) {
|
2011-08-07 22:22:43 -06:00
|
|
|
printk_once(KERN_WARNING "%s (%d): "
|
|
|
|
"Attempt to access syslog with CAP_SYS_ADMIN "
|
|
|
|
"but no CAP_SYSLOG (deprecated).\n",
|
|
|
|
current->comm, task_pid_nr(current));
|
2011-02-10 18:53:55 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-02 18:29:13 -06:00
|
|
|
#if defined(CONFIG_PRINTK_TIME)
|
|
|
|
static bool printk_time = 1;
|
|
|
|
#else
|
|
|
|
static bool printk_time;
|
|
|
|
#endif
|
|
|
|
module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
|
|
|
|
|
2012-06-28 01:38:53 -06:00
|
|
|
static size_t print_time(u64 ts, char *buf)
|
|
|
|
{
|
|
|
|
unsigned long rem_nsec;
|
|
|
|
|
|
|
|
if (!printk_time)
|
|
|
|
return 0;
|
|
|
|
|
printk: fix incorrect length from print_time() when seconds > 99999
print_prefix() passes a NULL buf to print_time() to get the length of
the time prefix; when printk times are enabled, the current code just
returns the constant 15, which matches the format "[%5lu.%06lu] " used
to print the time value. However, this is obviously incorrect when the
whole seconds part of the time gets beyond 5 digits (100000 seconds is a
bit more than a day of uptime).
The simple fix is to use snprintf(NULL, 0, ...) to calculate the actual
length of the time prefix. This could be micro-optimized but it seems
better to have simpler, more readable code here.
The bug leads to the syslog system call miscomputing which messages fit
into the userspace buffer. If there are enough messages to fill
log_buf_len and some have a timestamp >= 100000, dmesg may fail with:
# dmesg
klogctl: Bad address
When this happens, strace shows that the failure is indeed EFAULT due to
the kernel mistakenly accessing past the end of dmesg's buffer, since
dmesg asks the kernel how big a buffer it needs, allocates a bit more,
and then gets an error when it asks the kernel to fill it:
syslog(0xa, 0, 0) = 1048576
mmap(NULL, 1052672, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fa4d25d2000
syslog(0x3, 0x7fa4d25d2010, 0x100008) = -1 EFAULT (Bad address)
As far as I can see, the bug has been there as long as print_time(),
which comes from commit 084681d14e42 ("printk: flush continuation lines
immediately to console") in 3.5-rc5.
Signed-off-by: Roland Dreier <roland@purestorage.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Joe Perches <joe@perches.com>
Cc: Sylvain Munaut <s.munaut@whatever-company.com>
Cc: <stable@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-01-04 16:35:50 -07:00
|
|
|
rem_nsec = do_div(ts, 1000000000);
|
|
|
|
|
2012-06-28 01:38:53 -06:00
|
|
|
if (!buf)
|
printk: fix incorrect length from print_time() when seconds > 99999
print_prefix() passes a NULL buf to print_time() to get the length of
the time prefix; when printk times are enabled, the current code just
returns the constant 15, which matches the format "[%5lu.%06lu] " used
to print the time value. However, this is obviously incorrect when the
whole seconds part of the time gets beyond 5 digits (100000 seconds is a
bit more than a day of uptime).
The simple fix is to use snprintf(NULL, 0, ...) to calculate the actual
length of the time prefix. This could be micro-optimized but it seems
better to have simpler, more readable code here.
The bug leads to the syslog system call miscomputing which messages fit
into the userspace buffer. If there are enough messages to fill
log_buf_len and some have a timestamp >= 100000, dmesg may fail with:
# dmesg
klogctl: Bad address
When this happens, strace shows that the failure is indeed EFAULT due to
the kernel mistakenly accessing past the end of dmesg's buffer, since
dmesg asks the kernel how big a buffer it needs, allocates a bit more,
and then gets an error when it asks the kernel to fill it:
syslog(0xa, 0, 0) = 1048576
mmap(NULL, 1052672, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fa4d25d2000
syslog(0x3, 0x7fa4d25d2010, 0x100008) = -1 EFAULT (Bad address)
As far as I can see, the bug has been there as long as print_time(),
which comes from commit 084681d14e42 ("printk: flush continuation lines
immediately to console") in 3.5-rc5.
Signed-off-by: Roland Dreier <roland@purestorage.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Joe Perches <joe@perches.com>
Cc: Sylvain Munaut <s.munaut@whatever-company.com>
Cc: <stable@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-01-04 16:35:50 -07:00
|
|
|
return snprintf(NULL, 0, "[%5lu.000000] ", (unsigned long)ts);
|
2012-06-28 01:38:53 -06:00
|
|
|
|
|
|
|
return sprintf(buf, "[%5lu.%06lu] ",
|
|
|
|
(unsigned long)ts, rem_nsec / 1000);
|
|
|
|
}
|
|
|
|
|
2012-05-13 15:30:46 -06:00
|
|
|
static size_t print_prefix(const struct log *msg, bool syslog, char *buf)
|
2012-05-09 20:30:45 -06:00
|
|
|
{
|
2012-05-13 15:30:46 -06:00
|
|
|
size_t len = 0;
|
2012-07-06 10:50:09 -06:00
|
|
|
unsigned int prefix = (msg->facility << 3) | msg->level;
|
2012-05-09 20:30:45 -06:00
|
|
|
|
2012-05-13 15:30:46 -06:00
|
|
|
if (syslog) {
|
|
|
|
if (buf) {
|
2012-07-06 10:50:09 -06:00
|
|
|
len += sprintf(buf, "<%u>", prefix);
|
2012-05-13 15:30:46 -06:00
|
|
|
} else {
|
|
|
|
len += 3;
|
2012-07-06 10:50:09 -06:00
|
|
|
if (prefix > 999)
|
|
|
|
len += 3;
|
|
|
|
else if (prefix > 99)
|
|
|
|
len += 2;
|
|
|
|
else if (prefix > 9)
|
2012-05-13 15:30:46 -06:00
|
|
|
len++;
|
|
|
|
}
|
|
|
|
}
|
2012-05-09 20:30:45 -06:00
|
|
|
|
2012-06-28 01:38:53 -06:00
|
|
|
len += print_time(msg->ts_nsec, buf ? buf + len : NULL);
|
2012-05-13 15:30:46 -06:00
|
|
|
return len;
|
2012-05-09 20:30:45 -06:00
|
|
|
}
|
|
|
|
|
2012-07-09 13:15:42 -06:00
|
|
|
static size_t msg_print_text(const struct log *msg, enum log_flags prev,
|
|
|
|
bool syslog, char *buf, size_t size)
|
2012-05-02 18:29:13 -06:00
|
|
|
{
|
2012-05-13 15:30:46 -06:00
|
|
|
const char *text = log_text(msg);
|
|
|
|
size_t text_size = msg->text_len;
|
2012-07-09 13:15:42 -06:00
|
|
|
bool prefix = true;
|
|
|
|
bool newline = true;
|
2012-05-13 15:30:46 -06:00
|
|
|
size_t len = 0;
|
|
|
|
|
2012-07-09 13:15:42 -06:00
|
|
|
if ((prev & LOG_CONT) && !(msg->flags & LOG_PREFIX))
|
|
|
|
prefix = false;
|
|
|
|
|
|
|
|
if (msg->flags & LOG_CONT) {
|
|
|
|
if ((prev & LOG_CONT) && !(prev & LOG_NEWLINE))
|
|
|
|
prefix = false;
|
|
|
|
|
|
|
|
if (!(msg->flags & LOG_NEWLINE))
|
|
|
|
newline = false;
|
|
|
|
}
|
|
|
|
|
2012-05-13 15:30:46 -06:00
|
|
|
do {
|
|
|
|
const char *next = memchr(text, '\n', text_size);
|
|
|
|
size_t text_len;
|
|
|
|
|
|
|
|
if (next) {
|
|
|
|
text_len = next - text;
|
|
|
|
next++;
|
|
|
|
text_size -= next - text;
|
|
|
|
} else {
|
|
|
|
text_len = text_size;
|
|
|
|
}
|
2012-05-02 18:29:13 -06:00
|
|
|
|
2012-05-13 15:30:46 -06:00
|
|
|
if (buf) {
|
|
|
|
if (print_prefix(msg, syslog, NULL) +
|
2012-07-16 19:35:29 -06:00
|
|
|
text_len + 1 >= size - len)
|
2012-05-13 15:30:46 -06:00
|
|
|
break;
|
2012-05-02 18:29:13 -06:00
|
|
|
|
2012-07-09 13:15:42 -06:00
|
|
|
if (prefix)
|
|
|
|
len += print_prefix(msg, syslog, buf + len);
|
2012-05-13 15:30:46 -06:00
|
|
|
memcpy(buf + len, text, text_len);
|
|
|
|
len += text_len;
|
2012-07-09 13:15:42 -06:00
|
|
|
if (next || newline)
|
|
|
|
buf[len++] = '\n';
|
2012-05-13 15:30:46 -06:00
|
|
|
} else {
|
|
|
|
/* SYSLOG_ACTION_* buffer size only calculation */
|
2012-07-09 13:15:42 -06:00
|
|
|
if (prefix)
|
|
|
|
len += print_prefix(msg, syslog, NULL);
|
|
|
|
len += text_len;
|
|
|
|
if (next || newline)
|
|
|
|
len++;
|
2012-05-13 15:30:46 -06:00
|
|
|
}
|
2012-05-02 18:29:13 -06:00
|
|
|
|
2012-07-09 13:15:42 -06:00
|
|
|
prefix = true;
|
2012-05-13 15:30:46 -06:00
|
|
|
text = next;
|
|
|
|
} while (text);
|
2012-05-02 18:29:13 -06:00
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int syslog_print(char __user *buf, int size)
|
|
|
|
{
|
|
|
|
char *text;
|
2012-05-13 15:30:46 -06:00
|
|
|
struct log *msg;
|
2012-06-22 09:36:09 -06:00
|
|
|
int len = 0;
|
2012-05-02 18:29:13 -06:00
|
|
|
|
2012-07-16 19:35:29 -06:00
|
|
|
text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
|
2012-05-02 18:29:13 -06:00
|
|
|
if (!text)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2012-06-22 09:36:09 -06:00
|
|
|
while (size > 0) {
|
|
|
|
size_t n;
|
2012-07-09 11:05:10 -06:00
|
|
|
size_t skip;
|
2012-06-22 09:36:09 -06:00
|
|
|
|
|
|
|
raw_spin_lock_irq(&logbuf_lock);
|
|
|
|
if (syslog_seq < log_first_seq) {
|
|
|
|
/* messages are gone, move to first one */
|
|
|
|
syslog_seq = log_first_seq;
|
|
|
|
syslog_idx = log_first_idx;
|
2012-07-09 13:15:42 -06:00
|
|
|
syslog_prev = 0;
|
2012-07-09 11:05:10 -06:00
|
|
|
syslog_partial = 0;
|
2012-06-22 09:36:09 -06:00
|
|
|
}
|
|
|
|
if (syslog_seq == log_next_seq) {
|
|
|
|
raw_spin_unlock_irq(&logbuf_lock);
|
|
|
|
break;
|
|
|
|
}
|
2012-07-09 11:05:10 -06:00
|
|
|
|
|
|
|
skip = syslog_partial;
|
2012-06-22 09:36:09 -06:00
|
|
|
msg = log_from_idx(syslog_idx);
|
2012-07-16 19:35:29 -06:00
|
|
|
n = msg_print_text(msg, syslog_prev, true, text,
|
|
|
|
LOG_LINE_MAX + PREFIX_MAX);
|
2012-07-09 11:05:10 -06:00
|
|
|
if (n - syslog_partial <= size) {
|
|
|
|
/* message fits into buffer, move forward */
|
2012-06-22 09:36:09 -06:00
|
|
|
syslog_idx = log_next(syslog_idx);
|
|
|
|
syslog_seq++;
|
2012-07-09 13:15:42 -06:00
|
|
|
syslog_prev = msg->flags;
|
2012-07-09 11:05:10 -06:00
|
|
|
n -= syslog_partial;
|
|
|
|
syslog_partial = 0;
|
|
|
|
} else if (!len){
|
|
|
|
/* partial read(), remember position */
|
|
|
|
n = size;
|
|
|
|
syslog_partial += n;
|
2012-06-22 09:36:09 -06:00
|
|
|
} else
|
|
|
|
n = 0;
|
|
|
|
raw_spin_unlock_irq(&logbuf_lock);
|
|
|
|
|
|
|
|
if (!n)
|
|
|
|
break;
|
|
|
|
|
2012-07-09 11:05:10 -06:00
|
|
|
if (copy_to_user(buf, text + skip, n)) {
|
2012-06-22 09:36:09 -06:00
|
|
|
if (!len)
|
|
|
|
len = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
2012-07-09 11:05:10 -06:00
|
|
|
|
|
|
|
len += n;
|
|
|
|
size -= n;
|
|
|
|
buf += n;
|
2012-05-02 18:29:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
kfree(text);
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int syslog_print_all(char __user *buf, int size, bool clear)
|
|
|
|
{
|
|
|
|
char *text;
|
|
|
|
int len = 0;
|
|
|
|
|
2012-07-16 19:35:29 -06:00
|
|
|
text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
|
2012-05-02 18:29:13 -06:00
|
|
|
if (!text)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
raw_spin_lock_irq(&logbuf_lock);
|
|
|
|
if (buf) {
|
|
|
|
u64 next_seq;
|
|
|
|
u64 seq;
|
|
|
|
u32 idx;
|
2012-07-09 13:15:42 -06:00
|
|
|
enum log_flags prev;
|
2012-05-02 18:29:13 -06:00
|
|
|
|
|
|
|
if (clear_seq < log_first_seq) {
|
|
|
|
/* messages are gone, move to first available one */
|
|
|
|
clear_seq = log_first_seq;
|
|
|
|
clear_idx = log_first_idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find first record that fits, including all following records,
|
|
|
|
* into the user-provided buffer for this dump.
|
2012-06-15 06:07:51 -06:00
|
|
|
*/
|
2012-05-02 18:29:13 -06:00
|
|
|
seq = clear_seq;
|
|
|
|
idx = clear_idx;
|
2012-07-09 13:15:42 -06:00
|
|
|
prev = 0;
|
2012-05-02 18:29:13 -06:00
|
|
|
while (seq < log_next_seq) {
|
2012-05-13 15:30:46 -06:00
|
|
|
struct log *msg = log_from_idx(idx);
|
|
|
|
|
2012-07-09 13:15:42 -06:00
|
|
|
len += msg_print_text(msg, prev, true, NULL, 0);
|
2012-08-10 13:07:09 -06:00
|
|
|
prev = msg->flags;
|
2012-05-02 18:29:13 -06:00
|
|
|
idx = log_next(idx);
|
|
|
|
seq++;
|
|
|
|
}
|
2012-06-15 06:07:51 -06:00
|
|
|
|
|
|
|
/* move first record forward until length fits into the buffer */
|
2012-05-02 18:29:13 -06:00
|
|
|
seq = clear_seq;
|
|
|
|
idx = clear_idx;
|
2012-07-09 13:15:42 -06:00
|
|
|
prev = 0;
|
2012-05-02 18:29:13 -06:00
|
|
|
while (len > size && seq < log_next_seq) {
|
2012-05-13 15:30:46 -06:00
|
|
|
struct log *msg = log_from_idx(idx);
|
|
|
|
|
2012-07-09 13:15:42 -06:00
|
|
|
len -= msg_print_text(msg, prev, true, NULL, 0);
|
2012-08-10 13:07:09 -06:00
|
|
|
prev = msg->flags;
|
2012-05-02 18:29:13 -06:00
|
|
|
idx = log_next(idx);
|
|
|
|
seq++;
|
|
|
|
}
|
|
|
|
|
2012-06-15 06:07:51 -06:00
|
|
|
/* last message fitting into this dump */
|
2012-05-02 18:29:13 -06:00
|
|
|
next_seq = log_next_seq;
|
|
|
|
|
|
|
|
len = 0;
|
2012-07-09 13:15:42 -06:00
|
|
|
prev = 0;
|
2012-05-02 18:29:13 -06:00
|
|
|
while (len >= 0 && seq < next_seq) {
|
2012-05-13 15:30:46 -06:00
|
|
|
struct log *msg = log_from_idx(idx);
|
2012-05-02 18:29:13 -06:00
|
|
|
int textlen;
|
|
|
|
|
2012-07-16 19:35:29 -06:00
|
|
|
textlen = msg_print_text(msg, prev, true, text,
|
|
|
|
LOG_LINE_MAX + PREFIX_MAX);
|
2012-05-02 18:29:13 -06:00
|
|
|
if (textlen < 0) {
|
|
|
|
len = textlen;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
idx = log_next(idx);
|
|
|
|
seq++;
|
2012-07-09 13:15:42 -06:00
|
|
|
prev = msg->flags;
|
2012-05-02 18:29:13 -06:00
|
|
|
|
|
|
|
raw_spin_unlock_irq(&logbuf_lock);
|
|
|
|
if (copy_to_user(buf + len, text, textlen))
|
|
|
|
len = -EFAULT;
|
|
|
|
else
|
|
|
|
len += textlen;
|
|
|
|
raw_spin_lock_irq(&logbuf_lock);
|
|
|
|
|
|
|
|
if (seq < log_first_seq) {
|
|
|
|
/* messages are gone, move to next one */
|
|
|
|
seq = log_first_seq;
|
|
|
|
idx = log_first_idx;
|
2012-07-09 13:15:42 -06:00
|
|
|
prev = 0;
|
2012-05-02 18:29:13 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (clear) {
|
|
|
|
clear_seq = log_next_seq;
|
|
|
|
clear_idx = log_next_idx;
|
|
|
|
}
|
|
|
|
raw_spin_unlock_irq(&logbuf_lock);
|
|
|
|
|
|
|
|
kfree(text);
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2010-02-03 16:36:43 -07:00
|
|
|
int do_syslog(int type, char __user *buf, int len, bool from_file)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-05-02 18:29:13 -06:00
|
|
|
bool clear = false;
|
|
|
|
static int saved_console_loglevel = -1;
|
2011-02-10 18:53:55 -07:00
|
|
|
int error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-02-10 18:53:55 -07:00
|
|
|
error = check_syslog_permissions(type, from_file);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
2010-11-15 16:36:29 -07:00
|
|
|
|
|
|
|
error = security_syslog(type);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
switch (type) {
|
2010-02-03 16:37:13 -07:00
|
|
|
case SYSLOG_ACTION_CLOSE: /* Close log */
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2010-02-03 16:37:13 -07:00
|
|
|
case SYSLOG_ACTION_OPEN: /* Open log */
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2010-02-03 16:37:13 -07:00
|
|
|
case SYSLOG_ACTION_READ: /* Read from log */
|
2005-04-16 16:20:36 -06:00
|
|
|
error = -EINVAL;
|
|
|
|
if (!buf || len < 0)
|
|
|
|
goto out;
|
|
|
|
error = 0;
|
|
|
|
if (!len)
|
|
|
|
goto out;
|
|
|
|
if (!access_ok(VERIFY_WRITE, buf, len)) {
|
|
|
|
error = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-10-30 16:02:46 -07:00
|
|
|
error = wait_event_interruptible(log_wait,
|
2012-05-02 18:29:13 -06:00
|
|
|
syslog_seq != log_next_seq);
|
kmsg: properly handle concurrent non-blocking read() from /proc/kmsg
The /proc/kmsg read() interface is internally simply wired up to a sequence
of syslog() syscalls, which might are racy between their checks and actions,
regarding concurrency.
In the (very uncommon) case of concurrent readers of /dev/kmsg, relying on
usual O_NONBLOCK behavior, the recently introduced mutex might block an
O_NONBLOCK reader in read(), when poll() returns for it, but another process
has already read the data in the meantime. We've seen that while running
artificial test setups and tools that "fight" about /proc/kmsg data.
This restores the original /proc/kmsg behavior, where in case of concurrent
read()s, poll() might wake up but the read() syscall will just return 0 to
the caller, while another process has "stolen" the data.
This is in the general case not the expected behavior, but it is the exact
same one, that can easily be triggered with a 3.4 kernel, and some tools
might just rely on it.
The mutex is not needed, the original integrity issue which introduced it,
is in the meantime covered by:
"fill buffer with more than a single message for SYSLOG_ACTION_READ"
116e90b23f74d303e8d607c7a7d54f60f14ab9f2
Cc: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Acked-by: Jan Beulich <jbeulich@suse.com>
Signed-off-by: Kay Sievers <kay@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-07-06 10:50:09 -06:00
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
2012-05-02 18:29:13 -06:00
|
|
|
error = syslog_print(buf, len);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2010-02-03 16:37:13 -07:00
|
|
|
/* Read/clear last kernel messages */
|
|
|
|
case SYSLOG_ACTION_READ_CLEAR:
|
2012-05-02 18:29:13 -06:00
|
|
|
clear = true;
|
2005-04-16 16:20:36 -06:00
|
|
|
/* FALL THRU */
|
2010-02-03 16:37:13 -07:00
|
|
|
/* Read last kernel messages */
|
|
|
|
case SYSLOG_ACTION_READ_ALL:
|
2005-04-16 16:20:36 -06:00
|
|
|
error = -EINVAL;
|
|
|
|
if (!buf || len < 0)
|
|
|
|
goto out;
|
|
|
|
error = 0;
|
|
|
|
if (!len)
|
|
|
|
goto out;
|
|
|
|
if (!access_ok(VERIFY_WRITE, buf, len)) {
|
|
|
|
error = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-05-02 18:29:13 -06:00
|
|
|
error = syslog_print_all(buf, len, clear);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2010-02-03 16:37:13 -07:00
|
|
|
/* Clear ring buffer */
|
|
|
|
case SYSLOG_ACTION_CLEAR:
|
2012-05-02 18:29:13 -06:00
|
|
|
syslog_print_all(NULL, 0, true);
|
2012-06-22 15:12:19 -06:00
|
|
|
break;
|
2010-02-03 16:37:13 -07:00
|
|
|
/* Disable logging to console */
|
|
|
|
case SYSLOG_ACTION_CONSOLE_OFF:
|
2009-07-06 05:31:48 -06:00
|
|
|
if (saved_console_loglevel == -1)
|
|
|
|
saved_console_loglevel = console_loglevel;
|
2005-04-16 16:20:36 -06:00
|
|
|
console_loglevel = minimum_console_loglevel;
|
|
|
|
break;
|
2010-02-03 16:37:13 -07:00
|
|
|
/* Enable logging to console */
|
|
|
|
case SYSLOG_ACTION_CONSOLE_ON:
|
2009-07-06 05:31:48 -06:00
|
|
|
if (saved_console_loglevel != -1) {
|
|
|
|
console_loglevel = saved_console_loglevel;
|
|
|
|
saved_console_loglevel = -1;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2010-02-03 16:37:13 -07:00
|
|
|
/* Set level of messages printed to console */
|
|
|
|
case SYSLOG_ACTION_CONSOLE_LEVEL:
|
2005-04-16 16:20:36 -06:00
|
|
|
error = -EINVAL;
|
|
|
|
if (len < 1 || len > 8)
|
|
|
|
goto out;
|
|
|
|
if (len < minimum_console_loglevel)
|
|
|
|
len = minimum_console_loglevel;
|
|
|
|
console_loglevel = len;
|
2009-07-06 05:31:48 -06:00
|
|
|
/* Implicitly re-enable logging to console */
|
|
|
|
saved_console_loglevel = -1;
|
2005-04-16 16:20:36 -06:00
|
|
|
error = 0;
|
|
|
|
break;
|
2010-02-03 16:37:13 -07:00
|
|
|
/* Number of chars in the log buffer */
|
|
|
|
case SYSLOG_ACTION_SIZE_UNREAD:
|
2012-05-02 18:29:13 -06:00
|
|
|
raw_spin_lock_irq(&logbuf_lock);
|
|
|
|
if (syslog_seq < log_first_seq) {
|
|
|
|
/* messages are gone, move to first one */
|
|
|
|
syslog_seq = log_first_seq;
|
|
|
|
syslog_idx = log_first_idx;
|
2012-07-09 13:15:42 -06:00
|
|
|
syslog_prev = 0;
|
2012-07-09 11:05:10 -06:00
|
|
|
syslog_partial = 0;
|
2012-05-02 18:29:13 -06:00
|
|
|
}
|
|
|
|
if (from_file) {
|
|
|
|
/*
|
|
|
|
* Short-cut for poll(/"proc/kmsg") which simply checks
|
|
|
|
* for pending data, not the size; return the count of
|
|
|
|
* records, not the length.
|
|
|
|
*/
|
|
|
|
error = log_next_idx - syslog_idx;
|
|
|
|
} else {
|
2012-07-09 13:15:42 -06:00
|
|
|
u64 seq = syslog_seq;
|
|
|
|
u32 idx = syslog_idx;
|
|
|
|
enum log_flags prev = syslog_prev;
|
2012-05-02 18:29:13 -06:00
|
|
|
|
|
|
|
error = 0;
|
|
|
|
while (seq < log_next_seq) {
|
2012-05-13 15:30:46 -06:00
|
|
|
struct log *msg = log_from_idx(idx);
|
|
|
|
|
2012-07-09 13:15:42 -06:00
|
|
|
error += msg_print_text(msg, prev, true, NULL, 0);
|
2012-05-02 18:29:13 -06:00
|
|
|
idx = log_next(idx);
|
|
|
|
seq++;
|
2012-07-09 13:15:42 -06:00
|
|
|
prev = msg->flags;
|
2012-05-02 18:29:13 -06:00
|
|
|
}
|
2012-07-09 11:05:10 -06:00
|
|
|
error -= syslog_partial;
|
2012-05-02 18:29:13 -06:00
|
|
|
}
|
|
|
|
raw_spin_unlock_irq(&logbuf_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2010-02-03 16:37:13 -07:00
|
|
|
/* Size of the log buffer */
|
|
|
|
case SYSLOG_ACTION_SIZE_BUFFER:
|
2005-04-16 16:20:36 -06:00
|
|
|
error = log_buf_len;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
error = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2009-01-14 06:14:29 -07:00
|
|
|
SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-02-03 16:36:43 -07:00
|
|
|
return do_syslog(type, buf, len, SYSLOG_FROM_CALL);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Call the console drivers, asking them to write out
|
|
|
|
* log_buf[start] to log_buf[end - 1].
|
2011-01-25 16:07:35 -07:00
|
|
|
* The console_lock must be held.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2012-05-02 18:29:13 -06:00
|
|
|
static void call_console_drivers(int level, const char *text, size_t len)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-05-02 18:29:13 -06:00
|
|
|
struct console *con;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-02 18:29:13 -06:00
|
|
|
trace_console(text, 0, len, len);
|
|
|
|
|
|
|
|
if (level >= console_loglevel && !ignore_loglevel)
|
|
|
|
return;
|
|
|
|
if (!console_drivers)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for_each_console(con) {
|
|
|
|
if (exclusive_console && con != exclusive_console)
|
|
|
|
continue;
|
|
|
|
if (!(con->flags & CON_ENABLED))
|
|
|
|
continue;
|
|
|
|
if (!con->write)
|
|
|
|
continue;
|
|
|
|
if (!cpu_online(smp_processor_id()) &&
|
|
|
|
!(con->flags & CON_ANYTIME))
|
|
|
|
continue;
|
|
|
|
con->write(con, text, len);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Zap console related locks when oopsing. Only zap at most once
|
|
|
|
* every 10 seconds, to leave time for slow consoles to print a
|
|
|
|
* full oops.
|
|
|
|
*/
|
|
|
|
static void zap_locks(void)
|
|
|
|
{
|
|
|
|
static unsigned long oops_timestamp;
|
|
|
|
|
|
|
|
if (time_after_eq(jiffies, oops_timestamp) &&
|
2005-10-30 16:02:46 -07:00
|
|
|
!time_after(jiffies, oops_timestamp + 30 * HZ))
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
oops_timestamp = jiffies;
|
|
|
|
|
2011-06-07 03:17:30 -06:00
|
|
|
debug_locks_off();
|
2005-04-16 16:20:36 -06:00
|
|
|
/* If a crash is occurring, make sure we can't deadlock */
|
2009-07-25 09:50:36 -06:00
|
|
|
raw_spin_lock_init(&logbuf_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* And make sure that we print immediately */
|
2010-09-07 08:33:43 -06:00
|
|
|
sema_init(&console_sem, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-06-25 06:47:40 -06:00
|
|
|
/* Check if we have any console registered that can be called early in boot. */
|
|
|
|
static int have_callable_console(void)
|
|
|
|
{
|
|
|
|
struct console *con;
|
|
|
|
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
for_each_console(con)
|
2006-06-25 06:47:40 -06:00
|
|
|
if (con->flags & CON_ANYTIME)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-03-24 20:25:08 -06:00
|
|
|
/*
|
|
|
|
* Can we actually use the console at this time on this cpu?
|
|
|
|
*
|
|
|
|
* Console drivers may assume that per-cpu resources have
|
|
|
|
* been allocated. So unless they're explicitly marked as
|
|
|
|
* being able to cope (CON_ANYTIME) don't call them until
|
|
|
|
* this CPU is officially up.
|
|
|
|
*/
|
|
|
|
static inline int can_use_console(unsigned int cpu)
|
|
|
|
{
|
|
|
|
return cpu_online(cpu) || have_callable_console();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to get console ownership to actually show the kernel
|
|
|
|
* messages from a 'printk'. Return true (and with the
|
2011-01-25 16:07:35 -07:00
|
|
|
* console_lock held, and 'console_locked' set) if it
|
2008-03-24 20:25:08 -06:00
|
|
|
* is successful, false otherwise.
|
|
|
|
*
|
|
|
|
* This gets called with the 'logbuf_lock' spinlock held and
|
|
|
|
* interrupts disabled. It should return with 'lockbuf_lock'
|
|
|
|
* released but interrupts still disabled.
|
|
|
|
*/
|
2011-01-25 16:07:35 -07:00
|
|
|
static int console_trylock_for_printk(unsigned int cpu)
|
2010-10-26 15:22:47 -06:00
|
|
|
__releases(&logbuf_lock)
|
2008-03-24 20:25:08 -06:00
|
|
|
{
|
2011-06-07 03:15:33 -06:00
|
|
|
int retval = 0, wake = 0;
|
2008-03-24 20:25:08 -06:00
|
|
|
|
2011-01-25 16:07:35 -07:00
|
|
|
if (console_trylock()) {
|
2008-04-15 14:09:54 -06:00
|
|
|
retval = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we can't use the console, we need to release
|
|
|
|
* the console semaphore by hand to avoid flushing
|
|
|
|
* the buffer. We need to hold the console semaphore
|
|
|
|
* in order to do this test safely.
|
|
|
|
*/
|
|
|
|
if (!can_use_console(cpu)) {
|
|
|
|
console_locked = 0;
|
2011-06-07 03:15:33 -06:00
|
|
|
wake = 1;
|
2008-04-15 14:09:54 -06:00
|
|
|
retval = 0;
|
|
|
|
}
|
|
|
|
}
|
2012-05-02 18:29:13 -06:00
|
|
|
logbuf_cpu = UINT_MAX;
|
2011-06-07 03:15:33 -06:00
|
|
|
if (wake)
|
|
|
|
up(&console_sem);
|
2009-07-25 09:50:36 -06:00
|
|
|
raw_spin_unlock(&logbuf_lock);
|
2008-03-24 20:25:08 -06:00
|
|
|
return retval;
|
|
|
|
}
|
2008-01-25 13:07:58 -07:00
|
|
|
|
2009-09-22 17:43:33 -06:00
|
|
|
int printk_delay_msec __read_mostly;
|
|
|
|
|
|
|
|
static inline void printk_delay(void)
|
|
|
|
{
|
|
|
|
if (unlikely(printk_delay_msec)) {
|
|
|
|
int m = printk_delay_msec;
|
|
|
|
|
|
|
|
while (m--) {
|
|
|
|
mdelay(1);
|
|
|
|
touch_nmi_watchdog();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-28 01:38:53 -06:00
|
|
|
/*
|
|
|
|
* 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 level of first message */
|
2012-07-16 19:35:30 -06:00
|
|
|
enum log_flags flags; /* prefix, newline flags */
|
2012-06-28 01:38:53 -06:00
|
|
|
bool flushed:1; /* buffer sealed and committed */
|
|
|
|
} cont;
|
|
|
|
|
2012-07-16 19:35:29 -06:00
|
|
|
static void cont_flush(enum log_flags flags)
|
2012-06-28 01:38:53 -06:00
|
|
|
{
|
|
|
|
if (cont.flushed)
|
|
|
|
return;
|
|
|
|
if (cont.len == 0)
|
|
|
|
return;
|
|
|
|
|
2012-07-16 19:35:30 -06:00
|
|
|
if (cont.cons) {
|
|
|
|
/*
|
|
|
|
* If a fragment of this line was directly flushed to the
|
|
|
|
* 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);
|
|
|
|
cont.flags = flags;
|
|
|
|
cont.flushed = true;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* 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,
|
|
|
|
NULL, 0, cont.buf, cont.len);
|
|
|
|
cont.len = 0;
|
|
|
|
}
|
2012-06-28 01:38:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool cont_add(int facility, int level, const char *text, size_t len)
|
|
|
|
{
|
|
|
|
if (cont.len && cont.flushed)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (cont.len + len > sizeof(cont.buf)) {
|
2012-07-16 19:35:29 -06:00
|
|
|
/* the line gets too long, split it up in separate records */
|
|
|
|
cont_flush(LOG_CONT);
|
2012-06-28 01:38:53 -06:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!cont.len) {
|
|
|
|
cont.facility = facility;
|
|
|
|
cont.level = level;
|
|
|
|
cont.owner = current;
|
|
|
|
cont.ts_nsec = local_clock();
|
2012-07-16 19:35:30 -06:00
|
|
|
cont.flags = 0;
|
2012-06-28 01:38:53 -06:00
|
|
|
cont.cons = 0;
|
|
|
|
cont.flushed = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(cont.buf + cont.len, text, len);
|
|
|
|
cont.len += len;
|
2012-07-16 19:35:30 -06:00
|
|
|
|
|
|
|
if (cont.len > (sizeof(cont.buf) * 80) / 100)
|
|
|
|
cont_flush(LOG_CONT);
|
|
|
|
|
2012-06-28 01:38:53 -06:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t cont_print_text(char *text, size_t size)
|
|
|
|
{
|
|
|
|
size_t textlen = 0;
|
|
|
|
size_t len;
|
|
|
|
|
2012-07-16 19:35:30 -06:00
|
|
|
if (cont.cons == 0 && (console_prev & LOG_NEWLINE)) {
|
2012-06-28 01:38:53 -06:00
|
|
|
textlen += print_time(cont.ts_nsec, text);
|
|
|
|
size -= textlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
len = cont.len - cont.cons;
|
|
|
|
if (len > 0) {
|
|
|
|
if (len+1 > size)
|
|
|
|
len = size-1;
|
|
|
|
memcpy(text + textlen, cont.buf + cont.cons, len);
|
|
|
|
textlen += len;
|
|
|
|
cont.cons = cont.len;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cont.flushed) {
|
2012-07-16 19:35:30 -06:00
|
|
|
if (cont.flags & LOG_NEWLINE)
|
|
|
|
text[textlen++] = '\n';
|
2012-06-28 01:38:53 -06:00
|
|
|
/* got everything, release buffer */
|
|
|
|
cont.len = 0;
|
|
|
|
}
|
|
|
|
return textlen;
|
|
|
|
}
|
|
|
|
|
2012-05-02 18:29:13 -06:00
|
|
|
asmlinkage int vprintk_emit(int facility, int level,
|
|
|
|
const char *dict, size_t dictlen,
|
|
|
|
const char *fmt, va_list args)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-05-02 18:29:13 -06:00
|
|
|
static int recursion_bug;
|
|
|
|
static char textbuf[LOG_LINE_MAX];
|
|
|
|
char *text = textbuf;
|
2012-05-14 12:46:27 -06:00
|
|
|
size_t text_len;
|
2012-07-09 13:15:42 -06:00
|
|
|
enum log_flags lflags = 0;
|
2008-05-12 13:21:04 -06:00
|
|
|
unsigned long flags;
|
2008-01-25 13:07:58 -07:00
|
|
|
int this_cpu;
|
2012-05-02 18:29:13 -06:00
|
|
|
int printed_len = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-12-17 16:59:56 -07:00
|
|
|
boot_delay_msec(level);
|
2009-09-22 17:43:33 -06:00
|
|
|
printk_delay();
|
2007-10-16 02:23:46 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* This stops the holder of console_sem just where we want him */
|
2011-06-07 03:17:30 -06:00
|
|
|
local_irq_save(flags);
|
2008-01-25 13:07:58 -07:00
|
|
|
this_cpu = smp_processor_id();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ouch, printk recursed into itself!
|
|
|
|
*/
|
2012-05-02 18:29:13 -06:00
|
|
|
if (unlikely(logbuf_cpu == this_cpu)) {
|
2008-01-25 13:07:58 -07:00
|
|
|
/*
|
|
|
|
* If a crash is occurring during printk() on this CPU,
|
|
|
|
* then try to get the crash message out but make sure
|
|
|
|
* we can't deadlock. Otherwise just return to avoid the
|
|
|
|
* recursion and return - but flag the recursion so that
|
|
|
|
* it can be printed at the next appropriate moment:
|
|
|
|
*/
|
2011-06-07 03:17:30 -06:00
|
|
|
if (!oops_in_progress && !lockdep_recursing(current)) {
|
2008-05-12 13:21:04 -06:00
|
|
|
recursion_bug = 1;
|
2008-01-25 13:07:58 -07:00
|
|
|
goto out_restore_irqs;
|
|
|
|
}
|
|
|
|
zap_locks();
|
|
|
|
}
|
|
|
|
|
2006-07-03 01:24:58 -06:00
|
|
|
lockdep_off();
|
2009-07-25 09:50:36 -06:00
|
|
|
raw_spin_lock(&logbuf_lock);
|
2012-05-02 18:29:13 -06:00
|
|
|
logbuf_cpu = this_cpu;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-05-12 13:21:04 -06:00
|
|
|
if (recursion_bug) {
|
2012-05-02 18:29:13 -06:00
|
|
|
static const char recursion_msg[] =
|
|
|
|
"BUG: recent printk recursion!";
|
|
|
|
|
2008-05-12 13:21:04 -06:00
|
|
|
recursion_bug = 0;
|
2012-05-02 18:29:13 -06:00
|
|
|
printed_len += strlen(recursion_msg);
|
|
|
|
/* emit KERN_CRIT message */
|
2012-07-09 13:15:42 -06:00
|
|
|
log_store(0, 2, LOG_PREFIX|LOG_NEWLINE, 0,
|
2012-06-28 01:38:53 -06:00
|
|
|
NULL, 0, recursion_msg, printed_len);
|
2008-01-25 13:07:58 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-02 18:29:13 -06:00
|
|
|
/*
|
|
|
|
* The printf needs to come first; we need the syslog
|
|
|
|
* prefix which might be passed-in as a parameter.
|
|
|
|
*/
|
2012-05-14 12:46:27 -06:00
|
|
|
text_len = vscnprintf(text, sizeof(textbuf), fmt, args);
|
2009-06-16 11:57:02 -06:00
|
|
|
|
2012-05-02 18:29:13 -06:00
|
|
|
/* mark and strip a trailing newline */
|
2012-05-14 12:46:27 -06:00
|
|
|
if (text_len && text[text_len-1] == '\n') {
|
|
|
|
text_len--;
|
2012-07-09 13:15:42 -06:00
|
|
|
lflags |= LOG_NEWLINE;
|
2012-05-02 18:29:13 -06:00
|
|
|
}
|
2011-03-12 19:19:51 -07:00
|
|
|
|
2012-07-30 15:40:19 -06:00
|
|
|
/* 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 == -1)
|
|
|
|
level = kern_level - '0';
|
|
|
|
case 'd': /* KERN_DEFAULT */
|
|
|
|
lflags |= LOG_PREFIX;
|
|
|
|
case 'c': /* KERN_CONT */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
text_len -= end_of_header - text;
|
|
|
|
text = (char *)end_of_header;
|
2009-06-16 11:57:02 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-14 12:46:27 -06:00
|
|
|
if (level == -1)
|
|
|
|
level = default_message_loglevel;
|
2011-03-12 19:19:51 -07:00
|
|
|
|
2012-07-09 13:15:42 -06:00
|
|
|
if (dict)
|
|
|
|
lflags |= LOG_PREFIX|LOG_NEWLINE;
|
2008-05-12 13:21:04 -06:00
|
|
|
|
2012-07-09 13:15:42 -06:00
|
|
|
if (!(lflags & LOG_NEWLINE)) {
|
2012-06-28 01:38:53 -06:00
|
|
|
/*
|
|
|
|
* Flush the conflicting buffer. An earlier newline was missing,
|
|
|
|
* or another task also prints continuation lines.
|
|
|
|
*/
|
2012-07-09 13:15:42 -06:00
|
|
|
if (cont.len && (lflags & LOG_PREFIX || cont.owner != current))
|
2012-07-16 19:35:30 -06:00
|
|
|
cont_flush(LOG_NEWLINE);
|
2012-05-14 12:46:27 -06:00
|
|
|
|
2012-06-28 01:38:53 -06:00
|
|
|
/* buffer line if possible, otherwise store it right away */
|
|
|
|
if (!cont_add(facility, level, text, text_len))
|
2012-07-09 13:15:42 -06:00
|
|
|
log_store(facility, level, lflags | LOG_CONT, 0,
|
2012-06-28 01:38:53 -06:00
|
|
|
dict, dictlen, text, text_len);
|
2012-05-09 20:32:53 -06:00
|
|
|
} else {
|
2012-06-28 01:38:53 -06:00
|
|
|
bool stored = false;
|
2012-05-14 12:46:27 -06:00
|
|
|
|
2012-06-28 01:38:53 -06:00
|
|
|
/*
|
2012-06-29 09:40:11 -06:00
|
|
|
* 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.
|
2012-06-28 01:38:53 -06:00
|
|
|
*/
|
|
|
|
if (cont.len && cont.owner == current) {
|
2012-07-09 13:15:42 -06:00
|
|
|
if (!(lflags & LOG_PREFIX))
|
2012-06-29 09:40:11 -06:00
|
|
|
stored = cont_add(facility, level, text, text_len);
|
2012-07-16 19:35:30 -06:00
|
|
|
cont_flush(LOG_NEWLINE);
|
2012-05-14 12:46:27 -06:00
|
|
|
}
|
2012-06-28 01:38:53 -06:00
|
|
|
|
|
|
|
if (!stored)
|
2012-07-09 13:15:42 -06:00
|
|
|
log_store(facility, level, lflags, 0,
|
2012-06-28 01:38:53 -06:00
|
|
|
dict, dictlen, text, text_len);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2012-06-28 01:38:53 -06:00
|
|
|
printed_len += text_len;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-24 20:25:08 -06:00
|
|
|
/*
|
2012-05-02 18:29:13 -06:00
|
|
|
* Try to acquire and then immediately release the console semaphore.
|
|
|
|
* The release will print out buffers and wake up /dev/kmsg and syslog()
|
|
|
|
* users.
|
2008-03-24 20:25:08 -06:00
|
|
|
*
|
2012-05-02 18:29:13 -06:00
|
|
|
* The console_trylock_for_printk() function will release 'logbuf_lock'
|
|
|
|
* regardless of whether it actually gets the console semaphore or not.
|
2008-03-24 20:25:08 -06:00
|
|
|
*/
|
2011-01-25 16:07:35 -07:00
|
|
|
if (console_trylock_for_printk(this_cpu))
|
|
|
|
console_unlock();
|
2006-06-25 06:47:40 -06:00
|
|
|
|
2008-03-24 20:25:08 -06:00
|
|
|
lockdep_on();
|
2008-01-25 13:07:58 -07:00
|
|
|
out_restore_irqs:
|
2011-06-07 03:17:30 -06:00
|
|
|
local_irq_restore(flags);
|
2006-06-25 06:47:40 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return printed_len;
|
|
|
|
}
|
2012-05-02 18:29:13 -06:00
|
|
|
EXPORT_SYMBOL(vprintk_emit);
|
|
|
|
|
|
|
|
asmlinkage int vprintk(const char *fmt, va_list args)
|
|
|
|
{
|
|
|
|
return vprintk_emit(0, -1, NULL, 0, fmt, args);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
EXPORT_SYMBOL(vprintk);
|
|
|
|
|
2012-05-02 18:29:13 -06:00
|
|
|
asmlinkage int printk_emit(int facility, int level,
|
|
|
|
const char *dict, size_t dictlen,
|
|
|
|
const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
r = vprintk_emit(facility, level, dict, dictlen, fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(printk_emit);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* printk - print a kernel message
|
|
|
|
* @fmt: format string
|
|
|
|
*
|
|
|
|
* This is printk(). It can be called from any context. We want it to work.
|
|
|
|
*
|
|
|
|
* We try to grab the console_lock. If we succeed, it's easy - we log the
|
|
|
|
* output and call the console drivers. If we fail to get the semaphore, we
|
|
|
|
* place the output into the log buffer and return. The current holder of
|
|
|
|
* the console_sem will notice the new output in console_unlock(); and will
|
|
|
|
* send it to the consoles before releasing the lock.
|
|
|
|
*
|
|
|
|
* One effect of this deferred printing is that code which calls printk() and
|
|
|
|
* then changes console_loglevel may break. This is because console_loglevel
|
|
|
|
* is inspected when the actual printing occurs.
|
|
|
|
*
|
|
|
|
* See also:
|
|
|
|
* printf(3)
|
|
|
|
*
|
|
|
|
* See the vsnprintf() documentation for format string extensions over C99.
|
|
|
|
*/
|
|
|
|
asmlinkage int printk(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
#ifdef CONFIG_KGDB_KDB
|
|
|
|
if (unlikely(kdb_trap_printk)) {
|
|
|
|
va_start(args, fmt);
|
|
|
|
r = vkdb_printf(fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
va_start(args, fmt);
|
|
|
|
r = vprintk_emit(0, -1, NULL, 0, fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(printk);
|
2012-05-08 17:37:51 -06:00
|
|
|
|
2012-07-16 19:35:29 -06:00
|
|
|
#else /* CONFIG_PRINTK */
|
2005-05-01 09:59:02 -06:00
|
|
|
|
2012-07-16 19:35:29 -06:00
|
|
|
#define LOG_LINE_MAX 0
|
|
|
|
#define PREFIX_MAX 0
|
2012-05-08 17:37:51 -06:00
|
|
|
#define LOG_LINE_MAX 0
|
2012-07-16 19:35:29 -06:00
|
|
|
static u64 syslog_seq;
|
|
|
|
static u32 syslog_idx;
|
2012-07-16 19:35:30 -06:00
|
|
|
static u64 console_seq;
|
|
|
|
static u32 console_idx;
|
2012-07-16 19:35:29 -06:00
|
|
|
static enum log_flags syslog_prev;
|
|
|
|
static u64 log_first_seq;
|
|
|
|
static u32 log_first_idx;
|
|
|
|
static u64 log_next_seq;
|
2012-07-16 19:35:30 -06:00
|
|
|
static enum log_flags console_prev;
|
2012-06-28 01:38:53 -06:00
|
|
|
static struct cont {
|
|
|
|
size_t len;
|
|
|
|
size_t cons;
|
|
|
|
u8 level;
|
|
|
|
bool flushed:1;
|
|
|
|
} cont;
|
2012-05-08 17:37:51 -06:00
|
|
|
static struct log *log_from_idx(u32 idx) { return NULL; }
|
|
|
|
static u32 log_next(u32 idx) { return 0; }
|
|
|
|
static void call_console_drivers(int level, const char *text, size_t len) {}
|
2012-07-09 13:15:42 -06:00
|
|
|
static size_t msg_print_text(const struct log *msg, enum log_flags prev,
|
|
|
|
bool syslog, char *buf, size_t size) { return 0; }
|
2012-06-28 01:38:53 -06:00
|
|
|
static size_t cont_print_text(char *text, size_t size) { return 0; }
|
2005-05-01 09:59:02 -06:00
|
|
|
|
2012-05-08 17:37:51 -06:00
|
|
|
#endif /* CONFIG_PRINTK */
|
2005-05-01 09:59:02 -06:00
|
|
|
|
2008-04-30 01:54:51 -06:00
|
|
|
static int __add_preferred_console(char *name, int idx, char *options,
|
|
|
|
char *brl_options)
|
|
|
|
{
|
|
|
|
struct console_cmdline *c;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if this tty is not yet registered, and
|
|
|
|
* if we have a slot free.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
|
|
|
|
if (strcmp(console_cmdline[i].name, name) == 0 &&
|
|
|
|
console_cmdline[i].index == idx) {
|
|
|
|
if (!brl_options)
|
|
|
|
selected_console = i;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (i == MAX_CMDLINECONSOLES)
|
|
|
|
return -E2BIG;
|
|
|
|
if (!brl_options)
|
|
|
|
selected_console = i;
|
|
|
|
c = &console_cmdline[i];
|
|
|
|
strlcpy(c->name, name, sizeof(c->name));
|
|
|
|
c->options = options;
|
|
|
|
#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
|
|
|
|
c->brl_options = brl_options;
|
|
|
|
#endif
|
|
|
|
c->index = idx;
|
|
|
|
return 0;
|
|
|
|
}
|
2006-03-24 04:18:19 -07:00
|
|
|
/*
|
|
|
|
* Set up a list of consoles. Called from init/main.c
|
|
|
|
*/
|
|
|
|
static int __init console_setup(char *str)
|
|
|
|
{
|
2007-07-16 00:37:27 -06:00
|
|
|
char buf[sizeof(console_cmdline[0].name) + 4]; /* 4 for index */
|
2008-04-30 01:54:51 -06:00
|
|
|
char *s, *options, *brl_options = NULL;
|
2006-03-24 04:18:19 -07:00
|
|
|
int idx;
|
|
|
|
|
2008-04-30 01:54:51 -06:00
|
|
|
#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
|
|
|
|
if (!memcmp(str, "brl,", 4)) {
|
|
|
|
brl_options = "";
|
|
|
|
str += 4;
|
|
|
|
} else if (!memcmp(str, "brl=", 4)) {
|
|
|
|
brl_options = str + 4;
|
|
|
|
str = strchr(brl_options, ',');
|
|
|
|
if (!str) {
|
|
|
|
printk(KERN_ERR "need port name after brl=\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
*(str++) = 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-03-24 04:18:19 -07:00
|
|
|
/*
|
|
|
|
* Decode str into name, index, options.
|
|
|
|
*/
|
|
|
|
if (str[0] >= '0' && str[0] <= '9') {
|
2007-07-16 00:37:27 -06:00
|
|
|
strcpy(buf, "ttyS");
|
|
|
|
strncpy(buf + 4, str, sizeof(buf) - 5);
|
2006-03-24 04:18:19 -07:00
|
|
|
} else {
|
2007-07-16 00:37:27 -06:00
|
|
|
strncpy(buf, str, sizeof(buf) - 1);
|
2006-03-24 04:18:19 -07:00
|
|
|
}
|
2007-07-16 00:37:27 -06:00
|
|
|
buf[sizeof(buf) - 1] = 0;
|
2006-03-24 04:18:19 -07:00
|
|
|
if ((options = strchr(str, ',')) != NULL)
|
|
|
|
*(options++) = 0;
|
|
|
|
#ifdef __sparc__
|
|
|
|
if (!strcmp(str, "ttya"))
|
2007-07-16 00:37:27 -06:00
|
|
|
strcpy(buf, "ttyS0");
|
2006-03-24 04:18:19 -07:00
|
|
|
if (!strcmp(str, "ttyb"))
|
2007-07-16 00:37:27 -06:00
|
|
|
strcpy(buf, "ttyS1");
|
2006-03-24 04:18:19 -07:00
|
|
|
#endif
|
2007-07-16 00:37:27 -06:00
|
|
|
for (s = buf; *s; s++)
|
2006-03-24 04:18:19 -07:00
|
|
|
if ((*s >= '0' && *s <= '9') || *s == ',')
|
|
|
|
break;
|
|
|
|
idx = simple_strtoul(s, NULL, 10);
|
|
|
|
*s = 0;
|
|
|
|
|
2008-04-30 01:54:51 -06:00
|
|
|
__add_preferred_console(buf, idx, options, brl_options);
|
xen: Enable console tty by default in domU if it's not a dummy
Without console= arguments on the kernel command line, the first
console to register becomes enabled and the preferred console (the one
behind /dev/console). This is normally tty (assuming
CONFIG_VT_CONSOLE is enabled, which it commonly is).
This is okay as long tty is a useful console. But unless we have the
PV framebuffer, and it is enabled for this domain, tty0 in domU is
merely a dummy. In that case, we want the preferred console to be the
Xen console hvc0, and we want it without having to fiddle with the
kernel command line. Commit b8c2d3dfbc117dff26058fbac316b8acfc2cb5f7
did that for us.
Since we now have the PV framebuffer, we want to enable and prefer tty
again, but only when PVFB is enabled. But even then we still want to
enable the Xen console as well.
Problem: when tty registers, we can't yet know whether the PVFB is
enabled. By the time we can know (xenstore is up), the console setup
game is over.
Solution: enable console tty by default, but keep hvc as the preferred
console. Change the preferred console to tty when PVFB probes
successfully, unless we've been given console kernel parameters.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-26 16:31:07 -06:00
|
|
|
console_set_on_cmdline = 1;
|
2006-03-24 04:18:19 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("console=", console_setup);
|
|
|
|
|
2005-05-16 22:53:47 -06:00
|
|
|
/**
|
|
|
|
* add_preferred_console - add a device to the list of preferred consoles.
|
2005-11-13 17:08:14 -07:00
|
|
|
* @name: device name
|
|
|
|
* @idx: device index
|
|
|
|
* @options: options for this console
|
2005-05-16 22:53:47 -06:00
|
|
|
*
|
|
|
|
* The last preferred console added will be used for kernel messages
|
|
|
|
* and stdin/out/err for init. Normally this is used by console_setup
|
|
|
|
* above to handle user-supplied console arguments; however it can also
|
|
|
|
* be used by arch-specific code either to override the user or more
|
|
|
|
* commonly to provide a default console (ie from PROM variables) when
|
|
|
|
* the user has not supplied one.
|
|
|
|
*/
|
2007-12-29 02:19:49 -07:00
|
|
|
int add_preferred_console(char *name, int idx, char *options)
|
2005-05-16 22:53:47 -06:00
|
|
|
{
|
2008-04-30 01:54:51 -06:00
|
|
|
return __add_preferred_console(name, idx, options, NULL);
|
2005-05-16 22:53:47 -06:00
|
|
|
}
|
|
|
|
|
2007-08-03 08:07:43 -06:00
|
|
|
int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, char *options)
|
serial: convert early_uart to earlycon for 8250
Beacuse SERIAL_PORT_DFNS is removed from include/asm-i386/serial.h and
include/asm-x86_64/serial.h. the serial8250_ports need to be probed late in
serial initializing stage. the console_init=>serial8250_console_init=>
register_console=>serial8250_console_setup will return -ENDEV, and console
ttyS0 can not be enabled at that time. need to wait till uart_add_one_port in
drivers/serial/serial_core.c to call register_console to get console ttyS0.
that is too late.
Make early_uart to use early_param, so uart console can be used earlier. Make
it to be bootconsole with CON_BOOT flag, so can use console handover feature.
and it will switch to corresponding normal serial console automatically.
new command line will be:
console=uart8250,io,0x3f8,9600n8
console=uart8250,mmio,0xff5e0000,115200n8
or
earlycon=uart8250,io,0x3f8,9600n8
earlycon=uart8250,mmio,0xff5e0000,115200n8
it will print in very early stage:
Early serial console at I/O port 0x3f8 (options '9600n8')
console [uart0] enabled
later for console it will print:
console handover: boot [uart0] -> real [ttyS0]
Signed-off-by: <yinghai.lu@sun.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Bjorn Helgaas <bjorn.helgaas@hp.com>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Gerd Hoffmann <kraxel@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-16 00:37:59 -06:00
|
|
|
{
|
|
|
|
struct console_cmdline *c;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
|
|
|
|
if (strcmp(console_cmdline[i].name, name) == 0 &&
|
|
|
|
console_cmdline[i].index == idx) {
|
|
|
|
c = &console_cmdline[i];
|
2008-04-30 01:54:52 -06:00
|
|
|
strlcpy(c->name, name_new, sizeof(c->name));
|
serial: convert early_uart to earlycon for 8250
Beacuse SERIAL_PORT_DFNS is removed from include/asm-i386/serial.h and
include/asm-x86_64/serial.h. the serial8250_ports need to be probed late in
serial initializing stage. the console_init=>serial8250_console_init=>
register_console=>serial8250_console_setup will return -ENDEV, and console
ttyS0 can not be enabled at that time. need to wait till uart_add_one_port in
drivers/serial/serial_core.c to call register_console to get console ttyS0.
that is too late.
Make early_uart to use early_param, so uart console can be used earlier. Make
it to be bootconsole with CON_BOOT flag, so can use console handover feature.
and it will switch to corresponding normal serial console automatically.
new command line will be:
console=uart8250,io,0x3f8,9600n8
console=uart8250,mmio,0xff5e0000,115200n8
or
earlycon=uart8250,io,0x3f8,9600n8
earlycon=uart8250,mmio,0xff5e0000,115200n8
it will print in very early stage:
Early serial console at I/O port 0x3f8 (options '9600n8')
console [uart0] enabled
later for console it will print:
console handover: boot [uart0] -> real [ttyS0]
Signed-off-by: <yinghai.lu@sun.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Bjorn Helgaas <bjorn.helgaas@hp.com>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Gerd Hoffmann <kraxel@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-16 00:37:59 -06:00
|
|
|
c->name[sizeof(c->name) - 1] = 0;
|
|
|
|
c->options = options;
|
|
|
|
c->index = idx_new;
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
/* not found */
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-01-12 16:02:18 -07:00
|
|
|
bool console_suspend_enabled = 1;
|
2007-10-18 04:04:50 -06:00
|
|
|
EXPORT_SYMBOL(console_suspend_enabled);
|
|
|
|
|
|
|
|
static int __init console_suspend_disable(char *str)
|
|
|
|
{
|
|
|
|
console_suspend_enabled = 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("no_console_suspend", console_suspend_disable);
|
2011-10-31 18:11:27 -06:00
|
|
|
module_param_named(console_suspend, console_suspend_enabled,
|
|
|
|
bool, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(console_suspend, "suspend console during suspend"
|
|
|
|
" and hibernate operations");
|
2007-10-18 04:04:50 -06:00
|
|
|
|
2006-06-19 19:16:01 -06:00
|
|
|
/**
|
|
|
|
* suspend_console - suspend the console subsystem
|
|
|
|
*
|
|
|
|
* This disables printk() while we go into suspend states
|
|
|
|
*/
|
|
|
|
void suspend_console(void)
|
|
|
|
{
|
2007-10-18 04:04:50 -06:00
|
|
|
if (!console_suspend_enabled)
|
|
|
|
return;
|
2008-07-23 22:28:32 -06:00
|
|
|
printk("Suspending console(s) (use no_console_suspend to debug)\n");
|
2011-01-25 16:07:35 -07:00
|
|
|
console_lock();
|
2006-06-19 19:16:01 -06:00
|
|
|
console_suspended = 1;
|
2009-02-13 18:07:24 -07:00
|
|
|
up(&console_sem);
|
2006-06-19 19:16:01 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void resume_console(void)
|
|
|
|
{
|
2007-10-18 04:04:50 -06:00
|
|
|
if (!console_suspend_enabled)
|
|
|
|
return;
|
2009-02-13 18:07:24 -07:00
|
|
|
down(&console_sem);
|
2006-06-19 19:16:01 -06:00
|
|
|
console_suspended = 0;
|
2011-01-25 16:07:35 -07:00
|
|
|
console_unlock();
|
2006-06-19 19:16:01 -06:00
|
|
|
}
|
|
|
|
|
2010-06-03 23:11:25 -06:00
|
|
|
/**
|
|
|
|
* console_cpu_notify - print deferred console messages after CPU hotplug
|
|
|
|
* @self: notifier struct
|
|
|
|
* @action: CPU hotplug event
|
|
|
|
* @hcpu: unused
|
|
|
|
*
|
|
|
|
* If printk() is called from a CPU that is not online yet, the messages
|
|
|
|
* will be spooled but will not show up on the console. This function is
|
|
|
|
* called when a new CPU comes online (or fails to come up), and ensures
|
|
|
|
* that any such output gets printed.
|
|
|
|
*/
|
|
|
|
static int __cpuinit console_cpu_notify(struct notifier_block *self,
|
|
|
|
unsigned long action, void *hcpu)
|
|
|
|
{
|
|
|
|
switch (action) {
|
|
|
|
case CPU_ONLINE:
|
|
|
|
case CPU_DEAD:
|
|
|
|
case CPU_DOWN_FAILED:
|
|
|
|
case CPU_UP_CANCELED:
|
2011-01-25 16:07:35 -07:00
|
|
|
console_lock();
|
|
|
|
console_unlock();
|
2010-06-03 23:11:25 -06:00
|
|
|
}
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
2011-01-25 16:07:35 -07:00
|
|
|
* console_lock - lock the console system for exclusive use.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2011-01-25 16:07:35 -07:00
|
|
|
* Acquires a lock which guarantees that the caller has
|
2005-04-16 16:20:36 -06:00
|
|
|
* exclusive access to the console system and the console_drivers list.
|
|
|
|
*
|
|
|
|
* Can sleep, returns nothing.
|
|
|
|
*/
|
2011-01-25 16:07:35 -07:00
|
|
|
void console_lock(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-09-17 17:03:31 -06:00
|
|
|
might_sleep();
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
down(&console_sem);
|
2009-02-13 18:07:24 -07:00
|
|
|
if (console_suspended)
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
console_locked = 1;
|
|
|
|
console_may_schedule = 1;
|
|
|
|
}
|
2011-01-25 16:07:35 -07:00
|
|
|
EXPORT_SYMBOL(console_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-01-25 16:07:35 -07:00
|
|
|
/**
|
|
|
|
* console_trylock - try to lock the console system for exclusive use.
|
|
|
|
*
|
|
|
|
* Tried to acquire a lock which guarantees that the caller has
|
|
|
|
* exclusive access to the console system and the console_drivers list.
|
|
|
|
*
|
|
|
|
* returns 1 on success, and 0 on failure to acquire the lock.
|
|
|
|
*/
|
|
|
|
int console_trylock(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
if (down_trylock(&console_sem))
|
2011-01-25 16:07:35 -07:00
|
|
|
return 0;
|
2009-02-13 18:07:24 -07:00
|
|
|
if (console_suspended) {
|
|
|
|
up(&console_sem);
|
2011-01-25 16:07:35 -07:00
|
|
|
return 0;
|
2009-02-13 18:07:24 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
console_locked = 1;
|
|
|
|
console_may_schedule = 0;
|
2011-01-25 16:07:35 -07:00
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-01-25 16:07:35 -07:00
|
|
|
EXPORT_SYMBOL(console_trylock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
int is_console_locked(void)
|
|
|
|
{
|
|
|
|
return console_locked;
|
|
|
|
}
|
|
|
|
|
2012-02-27 02:47:00 -07:00
|
|
|
/*
|
2012-05-02 18:29:13 -06:00
|
|
|
* Delayed printk version, for scheduler-internal messages:
|
2012-02-27 02:47:00 -07:00
|
|
|
*/
|
|
|
|
#define PRINTK_BUF_SIZE 512
|
|
|
|
|
|
|
|
#define PRINTK_PENDING_WAKEUP 0x01
|
|
|
|
#define PRINTK_PENDING_SCHED 0x02
|
|
|
|
|
2008-08-08 13:47:09 -06:00
|
|
|
static DEFINE_PER_CPU(int, printk_pending);
|
2012-02-27 02:47:00 -07:00
|
|
|
static DEFINE_PER_CPU(char [PRINTK_BUF_SIZE], printk_sched_buf);
|
2008-08-08 13:47:09 -06:00
|
|
|
|
|
|
|
void printk_tick(void)
|
2007-02-10 02:46:19 -07:00
|
|
|
{
|
2010-11-26 09:22:16 -07:00
|
|
|
if (__this_cpu_read(printk_pending)) {
|
2012-02-27 02:47:00 -07:00
|
|
|
int pending = __this_cpu_xchg(printk_pending, 0);
|
|
|
|
if (pending & PRINTK_PENDING_SCHED) {
|
|
|
|
char *buf = __get_cpu_var(printk_sched_buf);
|
|
|
|
printk(KERN_WARNING "[sched_delayed] %s", buf);
|
|
|
|
}
|
|
|
|
if (pending & PRINTK_PENDING_WAKEUP)
|
|
|
|
wake_up_interruptible(&log_wait);
|
2008-08-08 13:47:09 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int printk_needs_cpu(int cpu)
|
|
|
|
{
|
2010-11-26 09:22:16 -07:00
|
|
|
if (cpu_is_offline(cpu))
|
2010-11-26 05:00:59 -07:00
|
|
|
printk_tick();
|
2010-11-26 09:22:16 -07:00
|
|
|
return __this_cpu_read(printk_pending);
|
2008-08-08 13:47:09 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void wake_up_klogd(void)
|
|
|
|
{
|
|
|
|
if (waitqueue_active(&log_wait))
|
2012-02-27 02:47:00 -07:00
|
|
|
this_cpu_or(printk_pending, PRINTK_PENDING_WAKEUP);
|
2007-02-10 02:46:19 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 19:35:30 -06:00
|
|
|
static void console_cont_flush(char *text, size_t size)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
raw_spin_lock_irqsave(&logbuf_lock, flags);
|
|
|
|
|
|
|
|
if (!cont.len)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We still queue earlier records, likely because the console was
|
|
|
|
* 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)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
len = cont_print_text(text, size);
|
|
|
|
raw_spin_unlock(&logbuf_lock);
|
|
|
|
stop_critical_timings();
|
|
|
|
call_console_drivers(cont.level, text, len);
|
|
|
|
start_critical_timings();
|
|
|
|
local_irq_restore(flags);
|
|
|
|
return;
|
|
|
|
out:
|
|
|
|
raw_spin_unlock_irqrestore(&logbuf_lock, flags);
|
|
|
|
}
|
2012-05-02 18:29:13 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
2011-01-25 16:07:35 -07:00
|
|
|
* console_unlock - unlock the console system
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2011-01-25 16:07:35 -07:00
|
|
|
* Releases the console_lock which the caller holds on the console system
|
2005-04-16 16:20:36 -06:00
|
|
|
* and the console driver list.
|
|
|
|
*
|
2011-01-25 16:07:35 -07:00
|
|
|
* While the console_lock was held, console output may have been buffered
|
|
|
|
* by printk(). If this is the case, console_unlock(); emits
|
|
|
|
* the output prior to releasing the lock.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2012-05-08 17:37:51 -06:00
|
|
|
* If there is output waiting, we wake /dev/kmsg and syslog() users.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2011-01-25 16:07:35 -07:00
|
|
|
* console_unlock(); may be called from any context.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2011-01-25 16:07:35 -07:00
|
|
|
void console_unlock(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-07-16 19:35:29 -06:00
|
|
|
static char text[LOG_LINE_MAX + PREFIX_MAX];
|
2012-05-02 18:29:13 -06:00
|
|
|
static u64 seen_seq;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long flags;
|
2012-05-02 18:29:13 -06:00
|
|
|
bool wake_klogd = false;
|
|
|
|
bool retry;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-19 19:16:01 -06:00
|
|
|
if (console_suspended) {
|
2009-02-13 18:07:24 -07:00
|
|
|
up(&console_sem);
|
2006-06-19 19:16:01 -06:00
|
|
|
return;
|
|
|
|
}
|
2006-08-05 13:14:16 -06:00
|
|
|
|
|
|
|
console_may_schedule = 0;
|
|
|
|
|
2012-06-28 01:38:53 -06:00
|
|
|
/* flush buffered message fragment immediately to console */
|
2012-07-16 19:35:30 -06:00
|
|
|
console_cont_flush(text, sizeof(text));
|
2011-06-22 03:20:09 -06:00
|
|
|
again:
|
2012-05-02 18:29:13 -06:00
|
|
|
for (;;) {
|
|
|
|
struct log *msg;
|
2012-05-13 15:30:46 -06:00
|
|
|
size_t len;
|
2012-05-02 18:29:13 -06:00
|
|
|
int level;
|
|
|
|
|
2009-07-25 09:50:36 -06:00
|
|
|
raw_spin_lock_irqsave(&logbuf_lock, flags);
|
2012-05-02 18:29:13 -06:00
|
|
|
if (seen_seq != log_next_seq) {
|
|
|
|
wake_klogd = true;
|
|
|
|
seen_seq = log_next_seq;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (console_seq < log_first_seq) {
|
|
|
|
/* messages are gone, move to first one */
|
|
|
|
console_seq = log_first_seq;
|
|
|
|
console_idx = log_first_idx;
|
2012-07-09 13:15:42 -06:00
|
|
|
console_prev = 0;
|
2012-05-02 18:29:13 -06:00
|
|
|
}
|
2012-06-28 01:38:53 -06:00
|
|
|
skip:
|
2012-05-02 18:29:13 -06:00
|
|
|
if (console_seq == log_next_seq)
|
|
|
|
break;
|
|
|
|
|
|
|
|
msg = log_from_idx(console_idx);
|
2012-06-28 01:38:53 -06:00
|
|
|
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_seq++;
|
2012-07-06 10:50:09 -06:00
|
|
|
/*
|
|
|
|
* We will get here again when we register a new
|
|
|
|
* CON_PRINTBUFFER console. Clear the flag so we
|
|
|
|
* will properly dump everything later.
|
|
|
|
*/
|
|
|
|
msg->flags &= ~LOG_NOCONS;
|
2012-07-16 19:35:30 -06:00
|
|
|
console_prev = msg->flags;
|
2012-06-28 01:38:53 -06:00
|
|
|
goto skip;
|
|
|
|
}
|
2012-05-09 20:30:45 -06:00
|
|
|
|
2012-06-28 01:38:53 -06:00
|
|
|
level = msg->level;
|
2012-07-09 13:15:42 -06:00
|
|
|
len = msg_print_text(msg, console_prev, false,
|
|
|
|
text, sizeof(text));
|
2012-05-02 18:29:13 -06:00
|
|
|
console_idx = log_next(console_idx);
|
|
|
|
console_seq++;
|
2012-07-09 13:15:42 -06:00
|
|
|
console_prev = msg->flags;
|
2009-07-25 09:50:36 -06:00
|
|
|
raw_spin_unlock(&logbuf_lock);
|
2012-05-02 18:29:13 -06:00
|
|
|
|
2008-05-12 13:20:42 -06:00
|
|
|
stop_critical_timings(); /* don't trace print latency */
|
2012-05-02 18:29:13 -06:00
|
|
|
call_console_drivers(level, text, len);
|
2008-05-12 13:20:42 -06:00
|
|
|
start_critical_timings();
|
2005-04-16 16:20:36 -06:00
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
console_locked = 0;
|
2011-03-22 17:34:21 -06:00
|
|
|
|
|
|
|
/* Release the exclusive_console once it is used */
|
|
|
|
if (unlikely(exclusive_console))
|
|
|
|
exclusive_console = NULL;
|
|
|
|
|
2009-07-25 09:50:36 -06:00
|
|
|
raw_spin_unlock(&logbuf_lock);
|
2011-06-22 03:20:09 -06:00
|
|
|
|
2011-06-07 03:15:33 -06:00
|
|
|
up(&console_sem);
|
2011-06-22 03:20:09 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Someone could have filled up the buffer again, so re-check if there's
|
|
|
|
* something to flush. In case we cannot trylock the console_sem again,
|
|
|
|
* there's a new owner and the console_unlock() from them will do the
|
|
|
|
* flush, no worries.
|
|
|
|
*/
|
2009-07-25 09:50:36 -06:00
|
|
|
raw_spin_lock(&logbuf_lock);
|
2012-05-02 18:29:13 -06:00
|
|
|
retry = console_seq != log_next_seq;
|
2011-12-08 15:34:13 -07:00
|
|
|
raw_spin_unlock_irqrestore(&logbuf_lock, flags);
|
|
|
|
|
2011-06-22 03:20:09 -06:00
|
|
|
if (retry && console_trylock())
|
|
|
|
goto again;
|
|
|
|
|
2007-02-10 02:46:19 -07:00
|
|
|
if (wake_klogd)
|
|
|
|
wake_up_klogd();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-01-25 16:07:35 -07:00
|
|
|
EXPORT_SYMBOL(console_unlock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-13 17:08:14 -07:00
|
|
|
/**
|
|
|
|
* console_conditional_schedule - yield the CPU if required
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* If the console code is currently allowed to sleep, and
|
|
|
|
* if this CPU should yield the CPU to another task, do
|
|
|
|
* so here.
|
|
|
|
*
|
2011-01-25 16:07:35 -07:00
|
|
|
* Must be called within console_lock();.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
void __sched console_conditional_schedule(void)
|
|
|
|
{
|
|
|
|
if (console_may_schedule)
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(console_conditional_schedule);
|
|
|
|
|
|
|
|
void console_unblank(void)
|
|
|
|
{
|
|
|
|
struct console *c;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* console_unblank can no longer be called in interrupt context unless
|
|
|
|
* oops_in_progress is set to 1..
|
|
|
|
*/
|
|
|
|
if (oops_in_progress) {
|
|
|
|
if (down_trylock(&console_sem) != 0)
|
|
|
|
return;
|
|
|
|
} else
|
2011-01-25 16:07:35 -07:00
|
|
|
console_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
console_locked = 1;
|
|
|
|
console_may_schedule = 0;
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
for_each_console(c)
|
2005-04-16 16:20:36 -06:00
|
|
|
if ((c->flags & CON_ENABLED) && c->unblank)
|
|
|
|
c->unblank();
|
2011-01-25 16:07:35 -07:00
|
|
|
console_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the console tty driver structure and its associated index
|
|
|
|
*/
|
|
|
|
struct tty_driver *console_device(int *index)
|
|
|
|
{
|
|
|
|
struct console *c;
|
|
|
|
struct tty_driver *driver = NULL;
|
|
|
|
|
2011-01-25 16:07:35 -07:00
|
|
|
console_lock();
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
for_each_console(c) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!c->device)
|
|
|
|
continue;
|
|
|
|
driver = c->device(c, index);
|
|
|
|
if (driver)
|
|
|
|
break;
|
|
|
|
}
|
2011-01-25 16:07:35 -07:00
|
|
|
console_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return driver;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prevent further output on the passed console device so that (for example)
|
|
|
|
* serial drivers can disable console output before suspending a port, and can
|
|
|
|
* re-enable output afterwards.
|
|
|
|
*/
|
|
|
|
void console_stop(struct console *console)
|
|
|
|
{
|
2011-01-25 16:07:35 -07:00
|
|
|
console_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
console->flags &= ~CON_ENABLED;
|
2011-01-25 16:07:35 -07:00
|
|
|
console_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(console_stop);
|
|
|
|
|
|
|
|
void console_start(struct console *console)
|
|
|
|
{
|
2011-01-25 16:07:35 -07:00
|
|
|
console_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
console->flags |= CON_ENABLED;
|
2011-01-25 16:07:35 -07:00
|
|
|
console_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(console_start);
|
|
|
|
|
2011-03-22 17:34:20 -06:00
|
|
|
static int __read_mostly keep_bootcon;
|
|
|
|
|
|
|
|
static int __init keep_bootcon_setup(char *str)
|
|
|
|
{
|
|
|
|
keep_bootcon = 1;
|
|
|
|
printk(KERN_INFO "debug: skip boot console de-registration.\n");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
early_param("keep_bootcon", keep_bootcon_setup);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* The console driver calls this routine during kernel initialization
|
|
|
|
* to register the console printing procedure with printk() and to
|
|
|
|
* print any messages that were printed by the kernel before the
|
|
|
|
* console driver was initialized.
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
*
|
|
|
|
* This can happen pretty early during the boot process (because of
|
|
|
|
* early_printk) - sometimes before setup_arch() completes - be careful
|
|
|
|
* of what kernel features are used - they may not be initialised yet.
|
|
|
|
*
|
|
|
|
* There are two types of consoles - bootconsoles (early_printk) and
|
|
|
|
* "real" consoles (everything which is not a bootconsole) which are
|
|
|
|
* handled differently.
|
|
|
|
* - Any number of bootconsoles can be registered at any time.
|
|
|
|
* - As soon as a "real" console is registered, all bootconsoles
|
|
|
|
* will be unregistered automatically.
|
|
|
|
* - Once a "real" console is registered, any attempt to register a
|
|
|
|
* bootconsoles will be rejected
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
void register_console(struct console *newcon)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-10-30 16:02:46 -07:00
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long flags;
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
struct console *bcon = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
/*
|
|
|
|
* before we register a new CON_BOOT console, make sure we don't
|
|
|
|
* already have a valid console
|
|
|
|
*/
|
|
|
|
if (console_drivers && newcon->flags & CON_BOOT) {
|
|
|
|
/* find the last or real console */
|
|
|
|
for_each_console(bcon) {
|
|
|
|
if (!(bcon->flags & CON_BOOT)) {
|
|
|
|
printk(KERN_INFO "Too late to register bootconsole %s%d\n",
|
|
|
|
newcon->name, newcon->index);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2007-05-08 01:26:49 -06:00
|
|
|
}
|
|
|
|
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
if (console_drivers && console_drivers->flags & CON_BOOT)
|
|
|
|
bcon = console_drivers;
|
|
|
|
|
|
|
|
if (preferred_console < 0 || bcon || !console_drivers)
|
2005-04-16 16:20:36 -06:00
|
|
|
preferred_console = selected_console;
|
|
|
|
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
if (newcon->early_setup)
|
|
|
|
newcon->early_setup();
|
serial: convert early_uart to earlycon for 8250
Beacuse SERIAL_PORT_DFNS is removed from include/asm-i386/serial.h and
include/asm-x86_64/serial.h. the serial8250_ports need to be probed late in
serial initializing stage. the console_init=>serial8250_console_init=>
register_console=>serial8250_console_setup will return -ENDEV, and console
ttyS0 can not be enabled at that time. need to wait till uart_add_one_port in
drivers/serial/serial_core.c to call register_console to get console ttyS0.
that is too late.
Make early_uart to use early_param, so uart console can be used earlier. Make
it to be bootconsole with CON_BOOT flag, so can use console handover feature.
and it will switch to corresponding normal serial console automatically.
new command line will be:
console=uart8250,io,0x3f8,9600n8
console=uart8250,mmio,0xff5e0000,115200n8
or
earlycon=uart8250,io,0x3f8,9600n8
earlycon=uart8250,mmio,0xff5e0000,115200n8
it will print in very early stage:
Early serial console at I/O port 0x3f8 (options '9600n8')
console [uart0] enabled
later for console it will print:
console handover: boot [uart0] -> real [ttyS0]
Signed-off-by: <yinghai.lu@sun.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Bjorn Helgaas <bjorn.helgaas@hp.com>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Gerd Hoffmann <kraxel@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-16 00:37:59 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* See if we want to use this console driver. If we
|
|
|
|
* didn't select a console we take the first one
|
|
|
|
* that registers here.
|
|
|
|
*/
|
|
|
|
if (preferred_console < 0) {
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
if (newcon->index < 0)
|
|
|
|
newcon->index = 0;
|
|
|
|
if (newcon->setup == NULL ||
|
|
|
|
newcon->setup(newcon, NULL) == 0) {
|
|
|
|
newcon->flags |= CON_ENABLED;
|
|
|
|
if (newcon->device) {
|
|
|
|
newcon->flags |= CON_CONSDEV;
|
2008-05-12 13:21:04 -06:00
|
|
|
preferred_console = 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if this console matches one we selected on
|
|
|
|
* the command line.
|
|
|
|
*/
|
2005-10-30 16:02:46 -07:00
|
|
|
for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];
|
|
|
|
i++) {
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
if (strcmp(console_cmdline[i].name, newcon->name) != 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
if (newcon->index >= 0 &&
|
|
|
|
newcon->index != console_cmdline[i].index)
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
if (newcon->index < 0)
|
|
|
|
newcon->index = console_cmdline[i].index;
|
2008-04-30 01:54:51 -06:00
|
|
|
#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
|
|
|
|
if (console_cmdline[i].brl_options) {
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
newcon->flags |= CON_BRL;
|
|
|
|
braille_register_console(newcon,
|
2008-04-30 01:54:51 -06:00
|
|
|
console_cmdline[i].index,
|
|
|
|
console_cmdline[i].options,
|
|
|
|
console_cmdline[i].brl_options);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
if (newcon->setup &&
|
|
|
|
newcon->setup(newcon, console_cmdline[i].options) != 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
newcon->flags |= CON_ENABLED;
|
|
|
|
newcon->index = console_cmdline[i].index;
|
[PATCH] CON_CONSDEV bit not set correctly on last console
According to include/linux/console.h, CON_CONSDEV flag should be set on
the last console specified on the boot command line:
86 #define CON_PRINTBUFFER (1)
87 #define CON_CONSDEV (2) /* Last on the command line */
88 #define CON_ENABLED (4)
89 #define CON_BOOT (8)
This does not currently happen if there is more than one console specified
on the boot commandline. Instead, it gets set on the first console on the
command line. This can cause problems for things like kdb that look for
the CON_CONSDEV flag to see if the console is valid.
Additionaly, it doesn't look like CON_CONSDEV is reassigned to the next
preferred console at unregister time if the console being unregistered
currently has that bit set.
Example (from sn2 ia64):
elilo vmlinuz root=<dev> console=ttyS0 console=ttySG0
in this case, the flags on ttySG console struct will be 0x4 (should be
0x6).
Attached patch against bk fixes both issues for the cases I looked at. It
uses selected_console (which gets incremented for each console specified on
the command line) as the indicator of which console to set CON_CONSDEV on.
When adding the console to the list, if the previous one had CON_CONSDEV
set, it masks it out. Tested on ia64 and x86.
The problem with the current behavior is it breaks overriding the default from
the boot line. In the ia64 case, there may be a global append line defining
console=a in elilo.conf. Then you want to boot your kernel, and want to
override the default by passing console=b on the boot line. elilo constructs
the kernel cmdline by starting with the value of the global append line, then
tacks on whatever else you specify, which puts console=b last.
Signed-off-by: Greg Edwards <edwardsg@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:09:05 -06:00
|
|
|
if (i == selected_console) {
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
newcon->flags |= CON_CONSDEV;
|
[PATCH] CON_CONSDEV bit not set correctly on last console
According to include/linux/console.h, CON_CONSDEV flag should be set on
the last console specified on the boot command line:
86 #define CON_PRINTBUFFER (1)
87 #define CON_CONSDEV (2) /* Last on the command line */
88 #define CON_ENABLED (4)
89 #define CON_BOOT (8)
This does not currently happen if there is more than one console specified
on the boot commandline. Instead, it gets set on the first console on the
command line. This can cause problems for things like kdb that look for
the CON_CONSDEV flag to see if the console is valid.
Additionaly, it doesn't look like CON_CONSDEV is reassigned to the next
preferred console at unregister time if the console being unregistered
currently has that bit set.
Example (from sn2 ia64):
elilo vmlinuz root=<dev> console=ttyS0 console=ttySG0
in this case, the flags on ttySG console struct will be 0x4 (should be
0x6).
Attached patch against bk fixes both issues for the cases I looked at. It
uses selected_console (which gets incremented for each console specified on
the command line) as the indicator of which console to set CON_CONSDEV on.
When adding the console to the list, if the previous one had CON_CONSDEV
set, it masks it out. Tested on ia64 and x86.
The problem with the current behavior is it breaks overriding the default from
the boot line. In the ia64 case, there may be a global append line defining
console=a in elilo.conf. Then you want to boot your kernel, and want to
override the default by passing console=b on the boot line. elilo constructs
the kernel cmdline by starting with the value of the global append line, then
tacks on whatever else you specify, which puts console=b last.
Signed-off-by: Greg Edwards <edwardsg@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:09:05 -06:00
|
|
|
preferred_console = selected_console;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
if (!(newcon->flags & CON_ENABLED))
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
printk: Ensure that "console enabled" messages are printed on the console
Today, when a console is registered without CON_PRINTBUFFER,
end users never see the announcement of it being added, and
never know if they missed something, if the console is really
at the start or not, and just leads to general confusion.
This re-orders existing code, to make sure the console is
added, before the "console [%s%d] enabled" is printed out -
ensuring that this message is _always_ seen.
This has the desired/intended side effect of making sure that
"console enabled:" messages are printed on the bootconsole, and
the real console. This does cause the same line is printed
twice if the bootconsole and real console are the same device,
but if they are on different devices, the message is printed to
both consoles.
Signed-off-by : Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
LKML-Reference: <200907091308.37370.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-09 11:08:37 -06:00
|
|
|
/*
|
|
|
|
* If we have a bootconsole, and are switching to a real console,
|
|
|
|
* don't print everything out again, since when the boot console, and
|
|
|
|
* the real console are the same physical device, it's annoying to
|
|
|
|
* see the beginning boot messages twice
|
|
|
|
*/
|
|
|
|
if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
newcon->flags &= ~CON_PRINTBUFFER;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Put this console in the list - keep the
|
|
|
|
* preferred driver at the head of the list.
|
|
|
|
*/
|
2011-01-25 16:07:35 -07:00
|
|
|
console_lock();
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
|
|
|
|
newcon->next = console_drivers;
|
|
|
|
console_drivers = newcon;
|
|
|
|
if (newcon->next)
|
|
|
|
newcon->next->flags &= ~CON_CONSDEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
newcon->next = console_drivers->next;
|
|
|
|
console_drivers->next = newcon;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
if (newcon->flags & CON_PRINTBUFFER) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2011-01-25 16:07:35 -07:00
|
|
|
* console_unlock(); will print out the buffered messages
|
2005-04-16 16:20:36 -06:00
|
|
|
* for us.
|
|
|
|
*/
|
2009-07-25 09:50:36 -06:00
|
|
|
raw_spin_lock_irqsave(&logbuf_lock, flags);
|
2012-05-02 18:29:13 -06:00
|
|
|
console_seq = syslog_seq;
|
|
|
|
console_idx = syslog_idx;
|
2012-07-09 13:15:42 -06:00
|
|
|
console_prev = syslog_prev;
|
2009-07-25 09:50:36 -06:00
|
|
|
raw_spin_unlock_irqrestore(&logbuf_lock, flags);
|
2011-03-22 17:34:21 -06:00
|
|
|
/*
|
|
|
|
* We're about to replay the log buffer. Only do this to the
|
|
|
|
* just-registered console to avoid excessive message spam to
|
|
|
|
* the already-registered consoles.
|
|
|
|
*/
|
|
|
|
exclusive_console = newcon;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-01-25 16:07:35 -07:00
|
|
|
console_unlock();
|
2010-12-01 10:51:05 -07:00
|
|
|
console_sysfs_notify();
|
printk: Ensure that "console enabled" messages are printed on the console
Today, when a console is registered without CON_PRINTBUFFER,
end users never see the announcement of it being added, and
never know if they missed something, if the console is really
at the start or not, and just leads to general confusion.
This re-orders existing code, to make sure the console is
added, before the "console [%s%d] enabled" is printed out -
ensuring that this message is _always_ seen.
This has the desired/intended side effect of making sure that
"console enabled:" messages are printed on the bootconsole, and
the real console. This does cause the same line is printed
twice if the bootconsole and real console are the same device,
but if they are on different devices, the message is printed to
both consoles.
Signed-off-by : Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
LKML-Reference: <200907091308.37370.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-09 11:08:37 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* By unregistering the bootconsoles after we enable the real console
|
|
|
|
* we get the "console xxx enabled" message on all the consoles -
|
|
|
|
* boot consoles, real consoles, etc - this is to ensure that end
|
|
|
|
* users know there might be something in the kernel's log buffer that
|
|
|
|
* went to the bootconsole (that they do not see on the real console)
|
|
|
|
*/
|
2011-03-22 17:34:20 -06:00
|
|
|
if (bcon &&
|
|
|
|
((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV) &&
|
|
|
|
!keep_bootcon) {
|
printk: Ensure that "console enabled" messages are printed on the console
Today, when a console is registered without CON_PRINTBUFFER,
end users never see the announcement of it being added, and
never know if they missed something, if the console is really
at the start or not, and just leads to general confusion.
This re-orders existing code, to make sure the console is
added, before the "console [%s%d] enabled" is printed out -
ensuring that this message is _always_ seen.
This has the desired/intended side effect of making sure that
"console enabled:" messages are printed on the bootconsole, and
the real console. This does cause the same line is printed
twice if the bootconsole and real console are the same device,
but if they are on different devices, the message is printed to
both consoles.
Signed-off-by : Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
LKML-Reference: <200907091308.37370.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-09 11:08:37 -06:00
|
|
|
/* we need to iterate through twice, to make sure we print
|
|
|
|
* everything out, before we unregister the console(s)
|
|
|
|
*/
|
|
|
|
printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled\n",
|
|
|
|
newcon->name, newcon->index);
|
|
|
|
for_each_console(bcon)
|
|
|
|
if (bcon->flags & CON_BOOT)
|
|
|
|
unregister_console(bcon);
|
|
|
|
} else {
|
|
|
|
printk(KERN_INFO "%sconsole [%s%d] enabled\n",
|
|
|
|
(newcon->flags & CON_BOOT) ? "boot" : "" ,
|
|
|
|
newcon->name, newcon->index);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(register_console);
|
|
|
|
|
2005-10-30 16:02:46 -07:00
|
|
|
int unregister_console(struct console *console)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-10-30 16:02:46 -07:00
|
|
|
struct console *a, *b;
|
2005-04-16 16:20:36 -06:00
|
|
|
int res = 1;
|
|
|
|
|
2008-04-30 01:54:51 -06:00
|
|
|
#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
|
|
|
|
if (console->flags & CON_BRL)
|
|
|
|
return braille_unregister_console(console);
|
|
|
|
#endif
|
|
|
|
|
2011-01-25 16:07:35 -07:00
|
|
|
console_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
if (console_drivers == console) {
|
|
|
|
console_drivers=console->next;
|
|
|
|
res = 0;
|
2005-11-23 14:37:44 -07:00
|
|
|
} else if (console_drivers) {
|
2005-04-16 16:20:36 -06:00
|
|
|
for (a=console_drivers->next, b=console_drivers ;
|
|
|
|
a; b=a, a=b->next) {
|
|
|
|
if (a == console) {
|
|
|
|
b->next = a->next;
|
|
|
|
res = 0;
|
|
|
|
break;
|
2005-10-30 16:02:46 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2005-10-30 16:02:46 -07:00
|
|
|
|
2007-05-08 01:26:49 -06:00
|
|
|
/*
|
[PATCH] CON_CONSDEV bit not set correctly on last console
According to include/linux/console.h, CON_CONSDEV flag should be set on
the last console specified on the boot command line:
86 #define CON_PRINTBUFFER (1)
87 #define CON_CONSDEV (2) /* Last on the command line */
88 #define CON_ENABLED (4)
89 #define CON_BOOT (8)
This does not currently happen if there is more than one console specified
on the boot commandline. Instead, it gets set on the first console on the
command line. This can cause problems for things like kdb that look for
the CON_CONSDEV flag to see if the console is valid.
Additionaly, it doesn't look like CON_CONSDEV is reassigned to the next
preferred console at unregister time if the console being unregistered
currently has that bit set.
Example (from sn2 ia64):
elilo vmlinuz root=<dev> console=ttyS0 console=ttySG0
in this case, the flags on ttySG console struct will be 0x4 (should be
0x6).
Attached patch against bk fixes both issues for the cases I looked at. It
uses selected_console (which gets incremented for each console specified on
the command line) as the indicator of which console to set CON_CONSDEV on.
When adding the console to the list, if the previous one had CON_CONSDEV
set, it masks it out. Tested on ia64 and x86.
The problem with the current behavior is it breaks overriding the default from
the boot line. In the ia64 case, there may be a global append line defining
console=a in elilo.conf. Then you want to boot your kernel, and want to
override the default by passing console=b on the boot line. elilo constructs
the kernel cmdline by starting with the value of the global append line, then
tacks on whatever else you specify, which puts console=b last.
Signed-off-by: Greg Edwards <edwardsg@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:09:05 -06:00
|
|
|
* If this isn't the last console and it has CON_CONSDEV set, we
|
|
|
|
* need to set it on the next preferred console.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-05-08 01:26:49 -06:00
|
|
|
if (console_drivers != NULL && console->flags & CON_CONSDEV)
|
[PATCH] CON_CONSDEV bit not set correctly on last console
According to include/linux/console.h, CON_CONSDEV flag should be set on
the last console specified on the boot command line:
86 #define CON_PRINTBUFFER (1)
87 #define CON_CONSDEV (2) /* Last on the command line */
88 #define CON_ENABLED (4)
89 #define CON_BOOT (8)
This does not currently happen if there is more than one console specified
on the boot commandline. Instead, it gets set on the first console on the
command line. This can cause problems for things like kdb that look for
the CON_CONSDEV flag to see if the console is valid.
Additionaly, it doesn't look like CON_CONSDEV is reassigned to the next
preferred console at unregister time if the console being unregistered
currently has that bit set.
Example (from sn2 ia64):
elilo vmlinuz root=<dev> console=ttyS0 console=ttySG0
in this case, the flags on ttySG console struct will be 0x4 (should be
0x6).
Attached patch against bk fixes both issues for the cases I looked at. It
uses selected_console (which gets incremented for each console specified on
the command line) as the indicator of which console to set CON_CONSDEV on.
When adding the console to the list, if the previous one had CON_CONSDEV
set, it masks it out. Tested on ia64 and x86.
The problem with the current behavior is it breaks overriding the default from
the boot line. In the ia64 case, there may be a global append line defining
console=a in elilo.conf. Then you want to boot your kernel, and want to
override the default by passing console=b on the boot line. elilo constructs
the kernel cmdline by starting with the value of the global append line, then
tacks on whatever else you specify, which puts console=b last.
Signed-off-by: Greg Edwards <edwardsg@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:09:05 -06:00
|
|
|
console_drivers->flags |= CON_CONSDEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-01-25 16:07:35 -07:00
|
|
|
console_unlock();
|
2010-12-01 10:51:05 -07:00
|
|
|
console_sysfs_notify();
|
2005-04-16 16:20:36 -06:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(unregister_console);
|
2005-05-01 09:59:02 -06:00
|
|
|
|
2010-06-03 23:11:25 -06:00
|
|
|
static int __init printk_late_init(void)
|
2007-08-20 13:22:47 -06:00
|
|
|
{
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
struct console *con;
|
|
|
|
|
|
|
|
for_each_console(con) {
|
2011-08-25 16:59:11 -06:00
|
|
|
if (!keep_bootcon && con->flags & CON_BOOT) {
|
2007-08-21 21:14:58 -06:00
|
|
|
printk(KERN_INFO "turn off boot console %s%d\n",
|
printk: Enable the use of more than one CON_BOOT (early console)
Today, register_console() assumes the following usage:
- The first console to register with a flag set to CON_BOOT
is the one and only bootconsole.
- If another register_console() is called with an additional
CON_BOOT, it is silently rejected.
- As soon as a console without the CON_BOOT set calls
registers the bootconsole is automatically unregistered.
- Once there is a "real" console - register_console() will
silently reject any consoles with it's CON_BOOT flag set.
In many systems (alpha, blackfin, microblaze, mips, powerpc,
sh, & x86), there are early_printk implementations, which use
the CON_BOOT which come out serial ports, vga, usb, & memory
buffers.
In many embedded systems, it would be nice to have two
bootconsoles - in case the primary fails, you always have
access to a backup memory buffer - but this requires at least
two CON_BOOT consoles...
This patch enables that functionality.
With the change applied, on boot you get (if you try to
re-enable a boot console after the "real" console has been
registered):
root:/> dmesg | grep console
bootconsole [early_shadow0] enabled
bootconsole [early_BFuart0] enabled
Kernel command line: root=/dev/mtdblock0 rw earlyprintk=serial,uart0,57600 console=ttyBF0,57600 nmi_debug=regs
console handover:boot [early_BFuart0] boot [early_shadow0] -> real [ttyBF0]
Too late to register bootconsole early_shadow0
or:
root:/> dmesg | grep console
Kernel command line: root=/dev/mtdblock0 rw console=ttyBF0,57600
console [ttyBF0] enabled
Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Cc: "Linus Torvalds" <torvalds@linux-foundation.org>
Cc: "Andrew Morton" <akpm@linux-foundation.org>
Cc: "Mike Frysinger" <vapier.adi@gmail.com>
Cc: "Paul Mundt" <lethal@linux-sh.org>
LKML-Reference: <200907012108.38030.rgetz@blackfin.uclinux.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-01 19:08:37 -06:00
|
|
|
con->name, con->index);
|
2009-08-06 16:58:11 -06:00
|
|
|
unregister_console(con);
|
2007-08-21 21:14:58 -06:00
|
|
|
}
|
2007-08-20 13:22:47 -06:00
|
|
|
}
|
2010-06-03 23:11:25 -06:00
|
|
|
hotcpu_notifier(console_cpu_notify, 0);
|
2007-08-20 13:22:47 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2010-06-03 23:11:25 -06:00
|
|
|
late_initcall(printk_late_init);
|
2007-08-20 13:22:47 -06:00
|
|
|
|
2008-02-08 05:21:25 -07:00
|
|
|
#if defined CONFIG_PRINTK
|
2008-07-25 02:45:58 -06:00
|
|
|
|
2012-03-15 05:35:37 -06:00
|
|
|
int printk_sched(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
va_list args;
|
|
|
|
char *buf;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
buf = __get_cpu_var(printk_sched_buf);
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
r = vsnprintf(buf, PRINTK_BUF_SIZE, fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
|
|
|
|
__this_cpu_or(printk_pending, PRINTK_PENDING_SCHED);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* printk rate limiting, lifted from the networking subsystem.
|
|
|
|
*
|
2008-07-29 23:33:38 -06:00
|
|
|
* This enforces a rate limit: not more than 10 kernel messages
|
|
|
|
* every 5s to make a denial-of-service attack impossible.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-07-29 23:33:38 -06:00
|
|
|
DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
|
|
|
|
|
2009-10-23 06:58:11 -06:00
|
|
|
int __printk_ratelimit(const char *func)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-10-23 06:58:11 -06:00
|
|
|
return ___ratelimit(&printk_ratelimit_state, func);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-10-23 06:58:11 -06:00
|
|
|
EXPORT_SYMBOL(__printk_ratelimit);
|
2006-11-02 23:07:16 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* printk_timed_ratelimit - caller-controlled printk ratelimiting
|
|
|
|
* @caller_jiffies: pointer to caller's state
|
|
|
|
* @interval_msecs: minimum interval between prints
|
|
|
|
*
|
|
|
|
* printk_timed_ratelimit() returns true if more than @interval_msecs
|
|
|
|
* milliseconds have elapsed since the last time printk_timed_ratelimit()
|
|
|
|
* returned true.
|
|
|
|
*/
|
|
|
|
bool printk_timed_ratelimit(unsigned long *caller_jiffies,
|
|
|
|
unsigned int interval_msecs)
|
|
|
|
{
|
2009-03-17 09:18:42 -06:00
|
|
|
if (*caller_jiffies == 0
|
|
|
|
|| !time_in_range(jiffies, *caller_jiffies,
|
|
|
|
*caller_jiffies
|
|
|
|
+ msecs_to_jiffies(interval_msecs))) {
|
|
|
|
*caller_jiffies = jiffies;
|
2006-11-02 23:07:16 -07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(printk_timed_ratelimit);
|
2009-10-16 06:09:18 -06:00
|
|
|
|
|
|
|
static DEFINE_SPINLOCK(dump_list_lock);
|
|
|
|
static LIST_HEAD(dump_list);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kmsg_dump_register - register a kernel log dumper.
|
2009-12-17 16:27:27 -07:00
|
|
|
* @dumper: pointer to the kmsg_dumper structure
|
2009-10-16 06:09:18 -06:00
|
|
|
*
|
|
|
|
* 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;
|
2011-01-12 17:59:43 -07:00
|
|
|
list_add_tail_rcu(&dumper->list, &dump_list);
|
2009-10-16 06:09:18 -06:00
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&dump_list_lock, flags);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(kmsg_dump_register);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kmsg_dump_unregister - unregister a kmsg dumper.
|
2009-12-17 16:27:27 -07:00
|
|
|
* @dumper: pointer to the kmsg_dumper structure
|
2009-10-16 06:09:18 -06:00
|
|
|
*
|
|
|
|
* 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;
|
2011-01-12 17:59:43 -07:00
|
|
|
list_del_rcu(&dumper->list);
|
2009-10-16 06:09:18 -06:00
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&dump_list_lock, flags);
|
2011-01-12 17:59:43 -07:00
|
|
|
synchronize_rcu();
|
2009-10-16 06:09:18 -06:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
|
|
|
|
|
2012-05-02 18:29:13 -06:00
|
|
|
static bool always_kmsg_dump;
|
|
|
|
module_param_named(always_kmsg_dump, always_kmsg_dump, bool, S_IRUGO | S_IWUSR);
|
|
|
|
|
2009-10-16 06:09:18 -06:00
|
|
|
/**
|
|
|
|
* kmsg_dump - dump kernel log to kernel message dumpers.
|
|
|
|
* @reason: the reason (oops, panic etc) for dumping
|
|
|
|
*
|
2012-06-15 06:07:51 -06:00
|
|
|
* 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().
|
2009-10-16 06:09:18 -06:00
|
|
|
*/
|
|
|
|
void kmsg_dump(enum kmsg_dump_reason reason)
|
|
|
|
{
|
|
|
|
struct kmsg_dumper *dumper;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2012-03-05 15:59:10 -07:00
|
|
|
if ((reason > KMSG_DUMP_OOPS) && !always_kmsg_dump)
|
|
|
|
return;
|
|
|
|
|
2012-06-15 06:07:51 -06:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-07-20 18:28:07 -06:00
|
|
|
* kmsg_dump_get_line_nolock - retrieve one kmsg log line (unlocked version)
|
2012-06-15 06:07:51 -06:00
|
|
|
* @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.
|
2012-07-20 18:28:07 -06:00
|
|
|
*
|
|
|
|
* The function is similar to kmsg_dump_get_line(), but grabs no locks.
|
2012-06-15 06:07:51 -06:00
|
|
|
*/
|
2012-07-20 18:28:07 -06:00
|
|
|
bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog,
|
|
|
|
char *line, size_t size, size_t *len)
|
2012-06-15 06:07:51 -06:00
|
|
|
{
|
|
|
|
struct log *msg;
|
|
|
|
size_t l = 0;
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
if (!dumper->active)
|
|
|
|
goto out;
|
2012-05-02 18:29:13 -06:00
|
|
|
|
2012-06-15 06:07:51 -06:00
|
|
|
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;
|
|
|
|
}
|
2009-10-16 06:09:18 -06:00
|
|
|
|
2012-06-15 06:07:51 -06:00
|
|
|
/* last entry */
|
2012-07-20 18:28:07 -06:00
|
|
|
if (dumper->cur_seq >= log_next_seq)
|
2012-06-15 06:07:51 -06:00
|
|
|
goto out;
|
2009-10-16 06:09:18 -06:00
|
|
|
|
2012-06-15 06:07:51 -06:00
|
|
|
msg = log_from_idx(dumper->cur_idx);
|
2012-07-09 13:15:42 -06:00
|
|
|
l = msg_print_text(msg, 0, syslog, line, size);
|
2012-06-15 06:07:51 -06:00
|
|
|
|
|
|
|
dumper->cur_idx = log_next(dumper->cur_idx);
|
|
|
|
dumper->cur_seq++;
|
|
|
|
ret = true;
|
|
|
|
out:
|
|
|
|
if (len)
|
|
|
|
*len = l;
|
|
|
|
return ret;
|
|
|
|
}
|
2012-07-20 18:28:07 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
2012-06-15 06:07:51 -06:00
|
|
|
EXPORT_SYMBOL_GPL(kmsg_dump_get_line);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kmsg_dump_get_buffer - copy kmsg log lines
|
|
|
|
* @dumper: registered kmsg dumper
|
|
|
|
* @syslog: include the "<4>" prefixes
|
2012-06-30 16:37:24 -06:00
|
|
|
* @buf: buffer to copy the line to
|
2012-06-15 06:07:51 -06:00
|
|
|
* @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;
|
2012-07-09 13:15:42 -06:00
|
|
|
enum log_flags prev;
|
2012-06-15 06:07:51 -06:00
|
|
|
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;
|
2012-07-09 13:15:42 -06:00
|
|
|
prev = 0;
|
2012-06-15 06:07:51 -06:00
|
|
|
while (seq < dumper->next_seq) {
|
|
|
|
struct log *msg = log_from_idx(idx);
|
|
|
|
|
2012-07-09 13:15:42 -06:00
|
|
|
l += msg_print_text(msg, prev, true, NULL, 0);
|
2012-06-15 06:07:51 -06:00
|
|
|
idx = log_next(idx);
|
|
|
|
seq++;
|
2012-07-09 13:15:42 -06:00
|
|
|
prev = msg->flags;
|
2012-06-15 06:07:51 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* move first record forward until length fits into the buffer */
|
|
|
|
seq = dumper->cur_seq;
|
|
|
|
idx = dumper->cur_idx;
|
2012-07-09 13:15:42 -06:00
|
|
|
prev = 0;
|
2012-06-15 06:07:51 -06:00
|
|
|
while (l > size && seq < dumper->next_seq) {
|
|
|
|
struct log *msg = log_from_idx(idx);
|
2009-10-16 06:09:18 -06:00
|
|
|
|
2012-07-09 13:15:42 -06:00
|
|
|
l -= msg_print_text(msg, prev, true, NULL, 0);
|
2012-06-15 06:07:51 -06:00
|
|
|
idx = log_next(idx);
|
|
|
|
seq++;
|
2012-07-09 13:15:42 -06:00
|
|
|
prev = msg->flags;
|
2009-10-16 06:09:18 -06:00
|
|
|
}
|
2012-06-15 06:07:51 -06:00
|
|
|
|
|
|
|
/* last message in next interation */
|
|
|
|
next_seq = seq;
|
|
|
|
next_idx = idx;
|
|
|
|
|
|
|
|
l = 0;
|
2012-07-09 13:15:42 -06:00
|
|
|
prev = 0;
|
2012-06-15 06:07:51 -06:00
|
|
|
while (seq < dumper->next_seq) {
|
|
|
|
struct log *msg = log_from_idx(idx);
|
|
|
|
|
2012-07-09 13:15:42 -06:00
|
|
|
l += msg_print_text(msg, prev, syslog, buf + l, size - l);
|
2012-06-15 06:07:51 -06:00
|
|
|
idx = log_next(idx);
|
|
|
|
seq++;
|
2012-07-09 13:15:42 -06:00
|
|
|
prev = msg->flags;
|
2012-06-15 06:07:51 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
dumper->next_seq = next_seq;
|
|
|
|
dumper->next_idx = next_idx;
|
|
|
|
ret = true;
|
2012-05-02 18:29:13 -06:00
|
|
|
raw_spin_unlock_irqrestore(&logbuf_lock, flags);
|
2012-06-15 06:07:51 -06:00
|
|
|
out:
|
|
|
|
if (len)
|
|
|
|
*len = l;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
|
2009-10-16 06:09:18 -06:00
|
|
|
|
2012-07-20 18:28:07 -06:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2012-06-15 06:07:51 -06:00
|
|
|
/**
|
|
|
|
* 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);
|
2012-07-20 18:28:07 -06:00
|
|
|
kmsg_dump_rewind_nolock(dumper);
|
2012-06-15 06:07:51 -06:00
|
|
|
raw_spin_unlock_irqrestore(&logbuf_lock, flags);
|
2009-10-16 06:09:18 -06:00
|
|
|
}
|
2012-06-15 06:07:51 -06:00
|
|
|
EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
|
2008-02-08 05:21:25 -07:00
|
|
|
#endif
|