2005-04-16 22:20:36 +00: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 23:02:46 +00:00
|
|
|
* Fixed SMP synchronization, 08/08/99, Manfred Spraul
|
2006-01-15 01:43:54 +00:00
|
|
|
* manfred@colorfullife.com
|
2005-04-16 22:20:36 +00:00
|
|
|
* Rewrote bits to get rid of console_lock
|
2008-10-16 05:01:59 +00:00
|
|
|
* 01Mar01 Andrew Morton
|
2005-04-16 22:20:36 +00: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 08:23:46 +00:00
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/nmi.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/module.h>
|
2006-06-25 12:48:15 +00:00
|
|
|
#include <linux/moduleparam.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/interrupt.h> /* For in_interrupt() */
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/security.h>
|
|
|
|
#include <linux/bootmem.h>
|
|
|
|
#include <linux/syscalls.h>
|
2009-04-02 23:58:57 +00:00
|
|
|
#include <linux/kexec.h>
|
2009-09-22 14:18:09 +00:00
|
|
|
#include <linux/ratelimit.h>
|
2009-10-16 12:09:18 +00:00
|
|
|
#include <linux/kmsg_dump.h>
|
2010-02-03 23:36:43 +00:00
|
|
|
#include <linux/syslog.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
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-02 01:08:37 +00:00
|
|
|
/*
|
|
|
|
* for_each_console() allows you to iterate on each console
|
|
|
|
*/
|
|
|
|
#define for_each_console(con) \
|
|
|
|
for (con = console_drivers; con != NULL; con = con->next)
|
|
|
|
|
2008-01-30 12:33:06 +00:00
|
|
|
/*
|
|
|
|
* Architectures can override it:
|
|
|
|
*/
|
2008-05-12 13:44:40 +00:00
|
|
|
void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
|
2008-01-30 12:33:06 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
|
|
|
|
|
|
|
|
/* printk's without a loglevel use this.. */
|
|
|
|
#define DEFAULT_MESSAGE_LOGLEVEL 4 /* KERN_WARNING */
|
|
|
|
|
|
|
|
/* 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 */
|
|
|
|
};
|
|
|
|
|
2009-07-06 11:31:48 +00:00
|
|
|
static int saved_console_loglevel = -1;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2007-02-17 19:10:16 +00:00
|
|
|
* Low level drivers may need that to know if they can schedule in
|
2005-04-16 22:20:36 +00: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.
|
|
|
|
*/
|
|
|
|
static DECLARE_MUTEX(console_sem);
|
|
|
|
struct console *console_drivers;
|
2008-06-02 11:19:08 +00:00
|
|
|
EXPORT_SYMBOL_GPL(console_drivers);
|
|
|
|
|
2005-04-16 22:20:36 +00: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-20 01:16:01 +00:00
|
|
|
static int console_locked, console_suspended;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* logbuf_lock protects log_buf, log_start, log_end, con_start and logged_chars
|
|
|
|
* It is also used in interesting ways to provide interlocking in
|
|
|
|
* release_console_sem().
|
|
|
|
*/
|
|
|
|
static DEFINE_SPINLOCK(logbuf_lock);
|
|
|
|
|
2008-02-06 09:37:02 +00:00
|
|
|
#define LOG_BUF_MASK (log_buf_len-1)
|
2005-04-16 22:20:36 +00:00
|
|
|
#define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The indices into log_buf are not constrained to log_buf_len - they
|
|
|
|
* must be masked before subscripting
|
|
|
|
*/
|
2008-02-06 09:37:02 +00:00
|
|
|
static unsigned log_start; /* Index into log_buf: next char to be read by syslog() */
|
|
|
|
static unsigned con_start; /* Index into log_buf: next char to be sent to consoles */
|
|
|
|
static unsigned log_end; /* Index into log_buf: most-recently-written-char + 1 */
|
2005-04-16 22:20:36 +00: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 07:54:51 +00:00
|
|
|
#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
|
|
|
|
char *brl_options; /* Options for braille driver */
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00: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 22:31:07 +00:00
|
|
|
int console_set_on_cmdline;
|
|
|
|
EXPORT_SYMBOL(console_set_on_cmdline);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Flag: console code may call schedule() */
|
|
|
|
static int console_may_schedule;
|
|
|
|
|
2005-05-01 15:59:02 +00:00
|
|
|
#ifdef CONFIG_PRINTK
|
|
|
|
|
|
|
|
static char __log_buf[__LOG_BUF_LEN];
|
|
|
|
static char *log_buf = __log_buf;
|
|
|
|
static int log_buf_len = __LOG_BUF_LEN;
|
2008-02-06 09:37:02 +00:00
|
|
|
static unsigned logged_chars; /* Number of chars produced since last read+clear operation */
|
2005-05-01 15:59:02 +00:00
|
|
|
|
2009-04-02 23:58:57 +00: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_end);
|
|
|
|
VMCOREINFO_SYMBOL(log_buf_len);
|
|
|
|
VMCOREINFO_SYMBOL(logged_chars);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int __init log_buf_len_setup(char *str)
|
|
|
|
{
|
2008-02-06 09:37:02 +00:00
|
|
|
unsigned size = memparse(str, &str);
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (size)
|
|
|
|
size = roundup_pow_of_two(size);
|
|
|
|
if (size > log_buf_len) {
|
2008-02-06 09:37:02 +00:00
|
|
|
unsigned start, dest_idx, offset;
|
2005-10-30 23:02:46 +00:00
|
|
|
char *new_log_buf;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
new_log_buf = alloc_bootmem(size);
|
|
|
|
if (!new_log_buf) {
|
2005-10-30 23:02:46 +00:00
|
|
|
printk(KERN_WARNING "log_buf_len: allocation failed\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&logbuf_lock, flags);
|
|
|
|
log_buf_len = size;
|
|
|
|
log_buf = new_log_buf;
|
|
|
|
|
|
|
|
offset = start = min(con_start, log_start);
|
|
|
|
dest_idx = 0;
|
|
|
|
while (start != log_end) {
|
|
|
|
log_buf[dest_idx] = __log_buf[start & (__LOG_BUF_LEN - 1)];
|
|
|
|
start++;
|
|
|
|
dest_idx++;
|
|
|
|
}
|
|
|
|
log_start -= offset;
|
|
|
|
con_start -= offset;
|
|
|
|
log_end -= offset;
|
|
|
|
spin_unlock_irqrestore(&logbuf_lock, flags);
|
|
|
|
|
2005-10-30 23:02:46 +00:00
|
|
|
printk(KERN_NOTICE "log_buf_len: %d\n", log_buf_len);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("log_buf_len=", log_buf_len_setup);
|
|
|
|
|
2007-10-16 08:23:46 +00:00
|
|
|
#ifdef CONFIG_BOOT_PRINTK_DELAY
|
|
|
|
|
|
|
|
static unsigned int boot_delay; /* msecs delay after each printk during bootup */
|
2009-09-22 23:43:31 +00:00
|
|
|
static unsigned long long loops_per_msec; /* based on boot_delay */
|
2007-10-16 08:23:46 +00: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 23:43:31 +00: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 08:23:46 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("boot_delay=", boot_delay_setup);
|
|
|
|
|
|
|
|
static void boot_delay_msec(void)
|
|
|
|
{
|
|
|
|
unsigned long long k;
|
|
|
|
unsigned long timeout;
|
|
|
|
|
|
|
|
if (boot_delay == 0 || system_state != SYSTEM_BOOTING)
|
|
|
|
return;
|
|
|
|
|
2009-09-22 23:43:31 +00:00
|
|
|
k = (unsigned long long)loops_per_msec * boot_delay;
|
2007-10-16 08:23:46 +00: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
|
|
|
|
static inline void boot_delay_msec(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-02-03 23:36:43 +00:00
|
|
|
int do_syslog(int type, char __user *buf, int len, bool from_file)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-02-06 09:37:02 +00:00
|
|
|
unsigned i, j, limit, count;
|
2005-04-16 22:20:36 +00:00
|
|
|
int do_clear = 0;
|
|
|
|
char c;
|
|
|
|
int error = 0;
|
|
|
|
|
2010-02-03 23:36:43 +00:00
|
|
|
error = security_syslog(type, from_file);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
switch (type) {
|
2010-02-03 23:37:13 +00:00
|
|
|
case SYSLOG_ACTION_CLOSE: /* Close log */
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2010-02-03 23:37:13 +00:00
|
|
|
case SYSLOG_ACTION_OPEN: /* Open log */
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2010-02-03 23:37:13 +00:00
|
|
|
case SYSLOG_ACTION_READ: /* Read from log */
|
2005-04-16 22:20:36 +00: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 23:02:46 +00:00
|
|
|
error = wait_event_interruptible(log_wait,
|
|
|
|
(log_start - log_end));
|
2005-04-16 22:20:36 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
i = 0;
|
|
|
|
spin_lock_irq(&logbuf_lock);
|
|
|
|
while (!error && (log_start != log_end) && i < len) {
|
|
|
|
c = LOG_BUF(log_start);
|
|
|
|
log_start++;
|
|
|
|
spin_unlock_irq(&logbuf_lock);
|
|
|
|
error = __put_user(c,buf);
|
|
|
|
buf++;
|
|
|
|
i++;
|
|
|
|
cond_resched();
|
|
|
|
spin_lock_irq(&logbuf_lock);
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&logbuf_lock);
|
|
|
|
if (!error)
|
|
|
|
error = i;
|
|
|
|
break;
|
2010-02-03 23:37:13 +00:00
|
|
|
/* Read/clear last kernel messages */
|
|
|
|
case SYSLOG_ACTION_READ_CLEAR:
|
2005-10-30 23:02:46 +00:00
|
|
|
do_clear = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
/* FALL THRU */
|
2010-02-03 23:37:13 +00:00
|
|
|
/* Read last kernel messages */
|
|
|
|
case SYSLOG_ACTION_READ_ALL:
|
2005-04-16 22:20:36 +00: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;
|
|
|
|
}
|
|
|
|
count = len;
|
|
|
|
if (count > log_buf_len)
|
|
|
|
count = log_buf_len;
|
|
|
|
spin_lock_irq(&logbuf_lock);
|
|
|
|
if (count > logged_chars)
|
|
|
|
count = logged_chars;
|
|
|
|
if (do_clear)
|
|
|
|
logged_chars = 0;
|
|
|
|
limit = log_end;
|
|
|
|
/*
|
|
|
|
* __put_user() could sleep, and while we sleep
|
2005-10-30 23:02:46 +00:00
|
|
|
* printk() could overwrite the messages
|
2005-04-16 22:20:36 +00:00
|
|
|
* we try to copy to user space. Therefore
|
|
|
|
* the messages are copied in reverse. <manfreds>
|
|
|
|
*/
|
2005-10-30 23:02:46 +00:00
|
|
|
for (i = 0; i < count && !error; i++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
j = limit-1-i;
|
|
|
|
if (j + log_buf_len < log_end)
|
|
|
|
break;
|
|
|
|
c = LOG_BUF(j);
|
|
|
|
spin_unlock_irq(&logbuf_lock);
|
|
|
|
error = __put_user(c,&buf[count-1-i]);
|
|
|
|
cond_resched();
|
|
|
|
spin_lock_irq(&logbuf_lock);
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&logbuf_lock);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
error = i;
|
2005-10-30 23:02:46 +00:00
|
|
|
if (i != count) {
|
2005-04-16 22:20:36 +00:00
|
|
|
int offset = count-error;
|
|
|
|
/* buffer overflow during copy, correct user buffer. */
|
2005-10-30 23:02:46 +00:00
|
|
|
for (i = 0; i < error; i++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (__get_user(c,&buf[i+offset]) ||
|
|
|
|
__put_user(c,&buf[i])) {
|
|
|
|
error = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2010-02-03 23:37:13 +00:00
|
|
|
/* Clear ring buffer */
|
|
|
|
case SYSLOG_ACTION_CLEAR:
|
2005-04-16 22:20:36 +00:00
|
|
|
logged_chars = 0;
|
|
|
|
break;
|
2010-02-03 23:37:13 +00:00
|
|
|
/* Disable logging to console */
|
|
|
|
case SYSLOG_ACTION_CONSOLE_OFF:
|
2009-07-06 11:31:48 +00:00
|
|
|
if (saved_console_loglevel == -1)
|
|
|
|
saved_console_loglevel = console_loglevel;
|
2005-04-16 22:20:36 +00:00
|
|
|
console_loglevel = minimum_console_loglevel;
|
|
|
|
break;
|
2010-02-03 23:37:13 +00:00
|
|
|
/* Enable logging to console */
|
|
|
|
case SYSLOG_ACTION_CONSOLE_ON:
|
2009-07-06 11:31:48 +00:00
|
|
|
if (saved_console_loglevel != -1) {
|
|
|
|
console_loglevel = saved_console_loglevel;
|
|
|
|
saved_console_loglevel = -1;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2010-02-03 23:37:13 +00:00
|
|
|
/* Set level of messages printed to console */
|
|
|
|
case SYSLOG_ACTION_CONSOLE_LEVEL:
|
2005-04-16 22:20:36 +00: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 11:31:48 +00:00
|
|
|
/* Implicitly re-enable logging to console */
|
|
|
|
saved_console_loglevel = -1;
|
2005-04-16 22:20:36 +00:00
|
|
|
error = 0;
|
|
|
|
break;
|
2010-02-03 23:37:13 +00:00
|
|
|
/* Number of chars in the log buffer */
|
|
|
|
case SYSLOG_ACTION_SIZE_UNREAD:
|
2005-04-16 22:20:36 +00:00
|
|
|
error = log_end - log_start;
|
|
|
|
break;
|
2010-02-03 23:37:13 +00:00
|
|
|
/* Size of the log buffer */
|
|
|
|
case SYSLOG_ACTION_SIZE_BUFFER:
|
2005-04-16 22:20:36 +00:00
|
|
|
error = log_buf_len;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
error = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2009-01-14 13:14:29 +00:00
|
|
|
SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-02-03 23:36:43 +00:00
|
|
|
return do_syslog(type, buf, len, SYSLOG_FROM_CALL);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Call the console drivers on a range of log_buf
|
|
|
|
*/
|
2008-02-06 09:37:02 +00:00
|
|
|
static void __call_console_drivers(unsigned start, unsigned end)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
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-02 01:08:37 +00:00
|
|
|
for_each_console(con) {
|
2006-06-25 12:47:40 +00:00
|
|
|
if ((con->flags & CON_ENABLED) && con->write &&
|
|
|
|
(cpu_online(smp_processor_id()) ||
|
|
|
|
(con->flags & CON_ANYTIME)))
|
2005-04-16 22:20:36 +00:00
|
|
|
con->write(con, &LOG_BUF(start), end - start);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-07 04:40:51 +00:00
|
|
|
static int __read_mostly ignore_loglevel;
|
|
|
|
|
2006-12-22 09:07:00 +00:00
|
|
|
static int __init ignore_loglevel_setup(char *str)
|
2006-12-07 04:40:51 +00:00
|
|
|
{
|
|
|
|
ignore_loglevel = 1;
|
|
|
|
printk(KERN_INFO "debug: ignoring loglevel setting.\n");
|
|
|
|
|
2008-01-31 21:45:23 +00:00
|
|
|
return 0;
|
2006-12-07 04:40:51 +00:00
|
|
|
}
|
|
|
|
|
2008-01-31 21:45:23 +00:00
|
|
|
early_param("ignore_loglevel", ignore_loglevel_setup);
|
2006-12-07 04:40:51 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Write out chars from start to end - 1 inclusive
|
|
|
|
*/
|
2008-02-06 09:37:02 +00:00
|
|
|
static void _call_console_drivers(unsigned start,
|
|
|
|
unsigned end, int msg_log_level)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-12-07 04:40:51 +00:00
|
|
|
if ((msg_log_level < console_loglevel || ignore_loglevel) &&
|
2005-04-16 22:20:36 +00:00
|
|
|
console_drivers && start != end) {
|
|
|
|
if ((start & LOG_BUF_MASK) > (end & LOG_BUF_MASK)) {
|
|
|
|
/* wrapped write */
|
|
|
|
__call_console_drivers(start & LOG_BUF_MASK,
|
|
|
|
log_buf_len);
|
|
|
|
__call_console_drivers(0, end & LOG_BUF_MASK);
|
|
|
|
} else {
|
|
|
|
__call_console_drivers(start, end);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Call the console drivers, asking them to write out
|
|
|
|
* log_buf[start] to log_buf[end - 1].
|
|
|
|
* The console_sem must be held.
|
|
|
|
*/
|
2008-02-06 09:37:02 +00:00
|
|
|
static void call_console_drivers(unsigned start, unsigned end)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-02-06 09:37:02 +00:00
|
|
|
unsigned cur_index, start_print;
|
2005-04-16 22:20:36 +00:00
|
|
|
static int msg_level = -1;
|
|
|
|
|
2008-02-06 09:37:02 +00:00
|
|
|
BUG_ON(((int)(start - end)) > 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
cur_index = start;
|
|
|
|
start_print = start;
|
|
|
|
while (cur_index != end) {
|
2005-10-30 23:02:46 +00:00
|
|
|
if (msg_level < 0 && ((end - cur_index) > 2) &&
|
|
|
|
LOG_BUF(cur_index + 0) == '<' &&
|
|
|
|
LOG_BUF(cur_index + 1) >= '0' &&
|
|
|
|
LOG_BUF(cur_index + 1) <= '7' &&
|
|
|
|
LOG_BUF(cur_index + 2) == '>') {
|
2005-04-16 22:20:36 +00:00
|
|
|
msg_level = LOG_BUF(cur_index + 1) - '0';
|
|
|
|
cur_index += 3;
|
|
|
|
start_print = cur_index;
|
|
|
|
}
|
|
|
|
while (cur_index != end) {
|
|
|
|
char c = LOG_BUF(cur_index);
|
|
|
|
|
2005-10-30 23:02:46 +00:00
|
|
|
cur_index++;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (c == '\n') {
|
|
|
|
if (msg_level < 0) {
|
|
|
|
/*
|
|
|
|
* printk() has already given us loglevel tags in
|
|
|
|
* the buffer. This code is here in case the
|
|
|
|
* log buffer has wrapped right round and scribbled
|
|
|
|
* on those tags
|
|
|
|
*/
|
|
|
|
msg_level = default_message_loglevel;
|
|
|
|
}
|
|
|
|
_call_console_drivers(start_print, cur_index, msg_level);
|
|
|
|
msg_level = -1;
|
|
|
|
start_print = cur_index;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_call_console_drivers(start_print, end, msg_level);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void emit_log_char(char c)
|
|
|
|
{
|
|
|
|
LOG_BUF(log_end) = c;
|
|
|
|
log_end++;
|
|
|
|
if (log_end - log_start > log_buf_len)
|
|
|
|
log_start = log_end - log_buf_len;
|
|
|
|
if (log_end - con_start > log_buf_len)
|
|
|
|
con_start = log_end - log_buf_len;
|
|
|
|
if (logged_chars < log_buf_len)
|
|
|
|
logged_chars++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 23:02:46 +00:00
|
|
|
!time_after(jiffies, oops_timestamp + 30 * HZ))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
oops_timestamp = jiffies;
|
|
|
|
|
|
|
|
/* If a crash is occurring, make sure we can't deadlock */
|
|
|
|
spin_lock_init(&logbuf_lock);
|
|
|
|
/* And make sure that we print immediately */
|
|
|
|
init_MUTEX(&console_sem);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(CONFIG_PRINTK_TIME)
|
|
|
|
static int printk_time = 1;
|
|
|
|
#else
|
|
|
|
static int printk_time = 0;
|
|
|
|
#endif
|
2007-07-16 06:40:25 +00:00
|
|
|
module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-25 12:47:40 +00: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-02 01:08:37 +00:00
|
|
|
for_each_console(con)
|
2006-06-25 12:47:40 +00:00
|
|
|
if (con->flags & CON_ANYTIME)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-14 00:08:14 +00:00
|
|
|
/**
|
|
|
|
* printk - print a kernel message
|
|
|
|
* @fmt: format string
|
|
|
|
*
|
2007-02-10 09:45:59 +00:00
|
|
|
* This is printk(). It can be called from any context. We want it to work.
|
2005-10-30 23:02:46 +00:00
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* We try to grab the console_sem. 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 release_console_sem() and will send it to the
|
|
|
|
* consoles before releasing the semaphore.
|
|
|
|
*
|
|
|
|
* 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.
|
2005-11-14 00:08:14 +00:00
|
|
|
*
|
|
|
|
* See also:
|
|
|
|
* printf(3)
|
2008-10-16 05:02:02 +00:00
|
|
|
*
|
|
|
|
* See the vsnprintf() documentation for format string extensions over C99.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2005-05-01 15:59:02 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
asmlinkage int printk(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
r = vprintk(fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2005-09-06 22:16:34 +00:00
|
|
|
/* cpu currently holding logbuf_lock */
|
|
|
|
static volatile unsigned int printk_cpu = UINT_MAX;
|
|
|
|
|
2008-03-25 02:25:08 +00: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
|
|
|
|
* console_semaphore held, and 'console_locked' set) if it
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
static int acquire_console_semaphore_for_printk(unsigned int cpu)
|
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
|
2008-04-15 20:09:54 +00:00
|
|
|
if (!try_acquire_console_sem()) {
|
|
|
|
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;
|
|
|
|
up(&console_sem);
|
|
|
|
retval = 0;
|
|
|
|
}
|
|
|
|
}
|
2008-03-25 02:25:08 +00:00
|
|
|
printk_cpu = UINT_MAX;
|
|
|
|
spin_unlock(&logbuf_lock);
|
|
|
|
return retval;
|
|
|
|
}
|
2008-05-12 19:21:04 +00:00
|
|
|
static const char recursion_bug_msg [] =
|
|
|
|
KERN_CRIT "BUG: recent printk recursion!\n";
|
|
|
|
static int recursion_bug;
|
2008-12-04 11:39:49 +00:00
|
|
|
static int new_text_line = 1;
|
2008-05-12 19:21:04 +00:00
|
|
|
static char printk_buf[1024];
|
2008-01-25 20:07:58 +00:00
|
|
|
|
2009-09-22 23:43:33 +00: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();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
asmlinkage int vprintk(const char *fmt, va_list args)
|
|
|
|
{
|
2008-01-25 20:07:58 +00:00
|
|
|
int printed_len = 0;
|
2008-05-12 19:21:04 +00:00
|
|
|
int current_log_level = default_message_loglevel;
|
2008-05-12 19:21:04 +00:00
|
|
|
unsigned long flags;
|
2008-01-25 20:07:58 +00:00
|
|
|
int this_cpu;
|
2005-04-16 22:20:36 +00:00
|
|
|
char *p;
|
|
|
|
|
2007-10-16 08:23:46 +00:00
|
|
|
boot_delay_msec();
|
2009-09-22 23:43:33 +00:00
|
|
|
printk_delay();
|
2007-10-16 08:23:46 +00:00
|
|
|
|
2005-09-06 22:16:34 +00:00
|
|
|
preempt_disable();
|
2005-04-16 22:20:36 +00:00
|
|
|
/* This stops the holder of console_sem just where we want him */
|
2007-02-10 09:46:29 +00:00
|
|
|
raw_local_irq_save(flags);
|
2008-01-25 20:07:58 +00:00
|
|
|
this_cpu = smp_processor_id();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ouch, printk recursed into itself!
|
|
|
|
*/
|
|
|
|
if (unlikely(printk_cpu == this_cpu)) {
|
|
|
|
/*
|
|
|
|
* 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:
|
|
|
|
*/
|
|
|
|
if (!oops_in_progress) {
|
2008-05-12 19:21:04 +00:00
|
|
|
recursion_bug = 1;
|
2008-01-25 20:07:58 +00:00
|
|
|
goto out_restore_irqs;
|
|
|
|
}
|
|
|
|
zap_locks();
|
|
|
|
}
|
|
|
|
|
2006-07-03 07:24:58 +00:00
|
|
|
lockdep_off();
|
|
|
|
spin_lock(&logbuf_lock);
|
2008-01-25 20:07:58 +00:00
|
|
|
printk_cpu = this_cpu;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-05-12 19:21:04 +00:00
|
|
|
if (recursion_bug) {
|
|
|
|
recursion_bug = 0;
|
|
|
|
strcpy(printk_buf, recursion_bug_msg);
|
2008-12-19 18:23:03 +00:00
|
|
|
printed_len = strlen(recursion_bug_msg);
|
2008-01-25 20:07:58 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Emit the output into the temporary buffer */
|
2008-01-25 20:07:58 +00:00
|
|
|
printed_len += vscnprintf(printk_buf + printed_len,
|
2008-02-14 01:32:07 +00:00
|
|
|
sizeof(printk_buf) - printed_len, fmt, args);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-05-12 19:21:04 +00:00
|
|
|
|
2009-06-16 17:57:02 +00:00
|
|
|
p = printk_buf;
|
|
|
|
|
|
|
|
/* Do we have a loglevel in the string? */
|
|
|
|
if (p[0] == '<') {
|
|
|
|
unsigned char c = p[1];
|
|
|
|
if (c && p[2] == '>') {
|
|
|
|
switch (c) {
|
|
|
|
case '0' ... '7': /* loglevel */
|
|
|
|
current_log_level = c - '0';
|
2009-06-16 18:02:28 +00:00
|
|
|
/* Fallthrough - make sure we're on a new line */
|
|
|
|
case 'd': /* KERN_DEFAULT */
|
2009-06-16 17:57:02 +00:00
|
|
|
if (!new_text_line) {
|
|
|
|
emit_log_char('\n');
|
|
|
|
new_text_line = 1;
|
|
|
|
}
|
|
|
|
/* Fallthrough - skip the loglevel */
|
|
|
|
case 'c': /* KERN_CONT */
|
|
|
|
p += 3;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Copy the output into log_buf. If the caller didn't provide
|
|
|
|
* appropriate log level tags, we insert them here
|
|
|
|
*/
|
2009-06-16 17:57:02 +00:00
|
|
|
for ( ; *p; p++) {
|
2008-05-12 19:21:04 +00:00
|
|
|
if (new_text_line) {
|
|
|
|
/* Always output the token */
|
|
|
|
emit_log_char('<');
|
|
|
|
emit_log_char(current_log_level + '0');
|
|
|
|
emit_log_char('>');
|
|
|
|
printed_len += 3;
|
|
|
|
new_text_line = 0;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (printk_time) {
|
2008-05-12 19:21:04 +00:00
|
|
|
/* Follow the token with the time */
|
2005-04-16 22:20:36 +00:00
|
|
|
char tbuf[50], *tp;
|
|
|
|
unsigned tlen;
|
|
|
|
unsigned long long t;
|
|
|
|
unsigned long nanosec_rem;
|
|
|
|
|
2008-01-27 07:03:54 +00:00
|
|
|
t = cpu_clock(printk_cpu);
|
2005-04-16 22:20:36 +00:00
|
|
|
nanosec_rem = do_div(t, 1000000000);
|
2008-05-12 19:21:04 +00:00
|
|
|
tlen = sprintf(tbuf, "[%5lu.%06lu] ",
|
|
|
|
(unsigned long) t,
|
|
|
|
nanosec_rem / 1000);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
for (tp = tbuf; tp < tbuf + tlen; tp++)
|
|
|
|
emit_log_char(*tp);
|
2006-01-08 09:02:41 +00:00
|
|
|
printed_len += tlen;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-05-12 19:21:04 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!*p)
|
|
|
|
break;
|
|
|
|
}
|
2008-05-12 19:21:04 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
emit_log_char(*p);
|
|
|
|
if (*p == '\n')
|
2008-05-12 19:21:04 +00:00
|
|
|
new_text_line = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-03-25 02:25:08 +00:00
|
|
|
/*
|
|
|
|
* Try to acquire and then immediately release the
|
|
|
|
* console semaphore. The release will do all the
|
|
|
|
* actual magic (print out buffers, wake up klogd,
|
|
|
|
* etc).
|
|
|
|
*
|
|
|
|
* The acquire_console_semaphore_for_printk() function
|
|
|
|
* will release 'logbuf_lock' regardless of whether it
|
|
|
|
* actually gets the semaphore or not.
|
|
|
|
*/
|
|
|
|
if (acquire_console_semaphore_for_printk(this_cpu))
|
|
|
|
release_console_sem();
|
2006-06-25 12:47:40 +00:00
|
|
|
|
2008-03-25 02:25:08 +00:00
|
|
|
lockdep_on();
|
2008-01-25 20:07:58 +00:00
|
|
|
out_restore_irqs:
|
2008-03-25 02:25:08 +00:00
|
|
|
raw_local_irq_restore(flags);
|
2006-06-25 12:47:40 +00:00
|
|
|
|
2005-09-06 22:16:34 +00:00
|
|
|
preempt_enable();
|
2005-04-16 22:20:36 +00:00
|
|
|
return printed_len;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(printk);
|
|
|
|
EXPORT_SYMBOL(vprintk);
|
|
|
|
|
2005-05-01 15:59:02 +00:00
|
|
|
#else
|
|
|
|
|
2008-02-06 09:37:02 +00:00
|
|
|
static void call_console_drivers(unsigned start, unsigned end)
|
2005-10-30 23:02:46 +00:00
|
|
|
{
|
|
|
|
}
|
2005-05-01 15:59:02 +00:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2008-04-30 07:54:51 +00: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 11:18:19 +00:00
|
|
|
/*
|
|
|
|
* Set up a list of consoles. Called from init/main.c
|
|
|
|
*/
|
|
|
|
static int __init console_setup(char *str)
|
|
|
|
{
|
2007-07-16 06:37:27 +00:00
|
|
|
char buf[sizeof(console_cmdline[0].name) + 4]; /* 4 for index */
|
2008-04-30 07:54:51 +00:00
|
|
|
char *s, *options, *brl_options = NULL;
|
2006-03-24 11:18:19 +00:00
|
|
|
int idx;
|
|
|
|
|
2008-04-30 07:54:51 +00: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 11:18:19 +00:00
|
|
|
/*
|
|
|
|
* Decode str into name, index, options.
|
|
|
|
*/
|
|
|
|
if (str[0] >= '0' && str[0] <= '9') {
|
2007-07-16 06:37:27 +00:00
|
|
|
strcpy(buf, "ttyS");
|
|
|
|
strncpy(buf + 4, str, sizeof(buf) - 5);
|
2006-03-24 11:18:19 +00:00
|
|
|
} else {
|
2007-07-16 06:37:27 +00:00
|
|
|
strncpy(buf, str, sizeof(buf) - 1);
|
2006-03-24 11:18:19 +00:00
|
|
|
}
|
2007-07-16 06:37:27 +00:00
|
|
|
buf[sizeof(buf) - 1] = 0;
|
2006-03-24 11:18:19 +00:00
|
|
|
if ((options = strchr(str, ',')) != NULL)
|
|
|
|
*(options++) = 0;
|
|
|
|
#ifdef __sparc__
|
|
|
|
if (!strcmp(str, "ttya"))
|
2007-07-16 06:37:27 +00:00
|
|
|
strcpy(buf, "ttyS0");
|
2006-03-24 11:18:19 +00:00
|
|
|
if (!strcmp(str, "ttyb"))
|
2007-07-16 06:37:27 +00:00
|
|
|
strcpy(buf, "ttyS1");
|
2006-03-24 11:18:19 +00:00
|
|
|
#endif
|
2007-07-16 06:37:27 +00:00
|
|
|
for (s = buf; *s; s++)
|
2006-03-24 11:18:19 +00:00
|
|
|
if ((*s >= '0' && *s <= '9') || *s == ',')
|
|
|
|
break;
|
|
|
|
idx = simple_strtoul(s, NULL, 10);
|
|
|
|
*s = 0;
|
|
|
|
|
2008-04-30 07:54:51 +00: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 22:31:07 +00:00
|
|
|
console_set_on_cmdline = 1;
|
2006-03-24 11:18:19 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("console=", console_setup);
|
|
|
|
|
2005-05-17 04:53:47 +00:00
|
|
|
/**
|
|
|
|
* add_preferred_console - add a device to the list of preferred consoles.
|
2005-11-14 00:08:14 +00:00
|
|
|
* @name: device name
|
|
|
|
* @idx: device index
|
|
|
|
* @options: options for this console
|
2005-05-17 04:53:47 +00: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 09:19:49 +00:00
|
|
|
int add_preferred_console(char *name, int idx, char *options)
|
2005-05-17 04:53:47 +00:00
|
|
|
{
|
2008-04-30 07:54:51 +00:00
|
|
|
return __add_preferred_console(name, idx, options, NULL);
|
2005-05-17 04:53:47 +00:00
|
|
|
}
|
|
|
|
|
2007-08-03 14:07:43 +00: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 06:37:59 +00: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 07:54:52 +00: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 06:37:59 +00:00
|
|
|
c->name[sizeof(c->name) - 1] = 0;
|
|
|
|
c->options = options;
|
|
|
|
c->index = idx_new;
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
/* not found */
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-10-18 10:04:50 +00:00
|
|
|
int console_suspend_enabled = 1;
|
|
|
|
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);
|
|
|
|
|
2006-06-20 01:16:01 +00:00
|
|
|
/**
|
|
|
|
* suspend_console - suspend the console subsystem
|
|
|
|
*
|
|
|
|
* This disables printk() while we go into suspend states
|
|
|
|
*/
|
|
|
|
void suspend_console(void)
|
|
|
|
{
|
2007-10-18 10:04:50 +00:00
|
|
|
if (!console_suspend_enabled)
|
|
|
|
return;
|
2008-07-24 04:28:32 +00:00
|
|
|
printk("Suspending console(s) (use no_console_suspend to debug)\n");
|
2006-06-20 01:16:01 +00:00
|
|
|
acquire_console_sem();
|
|
|
|
console_suspended = 1;
|
2009-02-14 01:07:24 +00:00
|
|
|
up(&console_sem);
|
2006-06-20 01:16:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void resume_console(void)
|
|
|
|
{
|
2007-10-18 10:04:50 +00:00
|
|
|
if (!console_suspend_enabled)
|
|
|
|
return;
|
2009-02-14 01:07:24 +00:00
|
|
|
down(&console_sem);
|
2006-06-20 01:16:01 +00:00
|
|
|
console_suspended = 0;
|
|
|
|
release_console_sem();
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* acquire_console_sem - lock the console system for exclusive use.
|
|
|
|
*
|
|
|
|
* Acquires a semaphore which guarantees that the caller has
|
|
|
|
* exclusive access to the console system and the console_drivers list.
|
|
|
|
*
|
|
|
|
* Can sleep, returns nothing.
|
|
|
|
*/
|
|
|
|
void acquire_console_sem(void)
|
|
|
|
{
|
2006-03-31 23:21:17 +00:00
|
|
|
BUG_ON(in_interrupt());
|
2005-04-16 22:20:36 +00:00
|
|
|
down(&console_sem);
|
2009-02-14 01:07:24 +00:00
|
|
|
if (console_suspended)
|
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
console_locked = 1;
|
|
|
|
console_may_schedule = 1;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acquire_console_sem);
|
|
|
|
|
|
|
|
int try_acquire_console_sem(void)
|
|
|
|
{
|
|
|
|
if (down_trylock(&console_sem))
|
|
|
|
return -1;
|
2009-02-14 01:07:24 +00:00
|
|
|
if (console_suspended) {
|
|
|
|
up(&console_sem);
|
|
|
|
return -1;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
console_locked = 1;
|
|
|
|
console_may_schedule = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(try_acquire_console_sem);
|
|
|
|
|
|
|
|
int is_console_locked(void)
|
|
|
|
{
|
|
|
|
return console_locked;
|
|
|
|
}
|
|
|
|
|
2008-08-08 19:47:09 +00:00
|
|
|
static DEFINE_PER_CPU(int, printk_pending);
|
|
|
|
|
|
|
|
void printk_tick(void)
|
2007-02-10 09:46:19 +00:00
|
|
|
{
|
2008-08-08 19:47:09 +00:00
|
|
|
if (__get_cpu_var(printk_pending)) {
|
|
|
|
__get_cpu_var(printk_pending) = 0;
|
2007-02-10 09:46:19 +00:00
|
|
|
wake_up_interruptible(&log_wait);
|
2008-08-08 19:47:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int printk_needs_cpu(int cpu)
|
|
|
|
{
|
|
|
|
return per_cpu(printk_pending, cpu);
|
|
|
|
}
|
|
|
|
|
|
|
|
void wake_up_klogd(void)
|
|
|
|
{
|
|
|
|
if (waitqueue_active(&log_wait))
|
printk: robustify printk, fix #2
Dmitry Adamushko reported:
> [*] btw., with DEBUG being enabled, pr_debug() generates [1] when
> debug_smp_processor_id() is used (CONFIG_DEBUG_PREEMPT).
>
> the problem seems to be caused by the following commit:
> commit b845b517b5e3706a3729f6ea83b88ab85f0725b0
> Author: Peter Zijlstra <a.p.zijlstra@chello.nl>
> Date: Fri Aug 8 21:47:09 2008 +0200
>
> printk: robustify printk
>
>
> wake_up_klogd() -> __get_cpu_var() -> smp_processor_id()
>
> and that's being called from release_console_sem() which is, in turn,
> said to be "may be called from any context" [2]
>
> and in this case, it seems to be called from some non-preemptible
> context (although, it can't be printk()...
> although, I haven't looked carefully yet).
>
> Provided [2], __get_cpu_var() is perhaps not the right solution there.
>
>
> [1]
>
> [ 7697.942005] BUG: using smp_processor_id() in preemptible [00000000] code: syslogd/3542
> [ 7697.942005] caller is wake_up_klogd+0x1b/0x50
> [ 7697.942005] Pid: 3542, comm: syslogd Not tainted 2.6.27-rc3-tip-git #2
> [ 7697.942005] Call Trace:
> [ 7697.942005] [<ffffffff8036b398>] debug_smp_processor_id+0xe8/0xf0
> [ 7697.942005] [<ffffffff80239d3b>] wake_up_klogd+0x1b/0x50
> [ 7697.942005] [<ffffffff8023a047>] release_console_sem+0x1e7/0x200
> [ 7697.942005] [<ffffffff803c0f17>] do_con_write+0xb7/0x1f30
> [ 7697.942005] [<ffffffff8020d920>] ? show_trace+0x10/0x20
> [ 7697.942005] [<ffffffff8020dc42>] ? dump_stack+0x72/0x80
> [ 7697.942005] [<ffffffff8036392d>] ? __ratelimit+0xbd/0xe0
> [ 7697.942005] [<ffffffff8036b398>] ? debug_smp_processor_id+0xe8/0xf0
> [ 7697.942005] [<ffffffff80239d3b>] ? wake_up_klogd+0x1b/0x50
> [ 7697.942005] [<ffffffff8023a047>] ? release_console_sem+0x1e7/0x200
> [ 7697.942005] [<ffffffff803c2de9>] con_write+0x19/0x30
> [ 7697.942005] [<ffffffff803b37b6>] write_chan+0x276/0x3c0
> [ 7697.942005] [<ffffffff80232b20>] ? default_wake_function+0x0/0x10
> [ 7697.942005] [<ffffffff804cb872>] ? _spin_lock_irqsave+0x22/0x50
> [ 7697.942005] [<ffffffff803b1334>] tty_write+0x194/0x260
> [ 7697.942005] [<ffffffff803b3540>] ? write_chan+0x0/0x3c0
> [ 7697.942005] [<ffffffff803b14a4>] redirected_tty_write+0xa4/0xb0
> [ 7697.942005] [<ffffffff803b1400>] ? redirected_tty_write+0x0/0xb0
> [ 7697.942005] [<ffffffff802a88c2>] do_loop_readv_writev+0x52/0x80
> [ 7697.942005] [<ffffffff802a939d>] do_readv_writev+0x1bd/0x1d0
> [ 7697.942005] [<ffffffff802a93e9>] vfs_writev+0x39/0x60
> [ 7697.942005] [<ffffffff802a9870>] sys_writev+0x50/0x90
> [ 7697.942005] [<ffffffff8020bb3b>] system_call_fastpath+0x16/0x1b
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Reported-by: Dmitry Adamushko <dmitry.adamushko@gmail.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-08-20 07:31:26 +00:00
|
|
|
__raw_get_cpu_var(printk_pending) = 1;
|
2007-02-10 09:46:19 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* release_console_sem - unlock the console system
|
|
|
|
*
|
|
|
|
* Releases the semaphore which the caller holds on the console system
|
|
|
|
* and the console driver list.
|
|
|
|
*
|
|
|
|
* While the semaphore was held, console output may have been buffered
|
|
|
|
* by printk(). If this is the case, release_console_sem() emits
|
|
|
|
* the output prior to releasing the semaphore.
|
|
|
|
*
|
|
|
|
* If there is output waiting for klogd, we wake it up.
|
|
|
|
*
|
|
|
|
* release_console_sem() may be called from any context.
|
|
|
|
*/
|
|
|
|
void release_console_sem(void)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
2008-02-06 09:37:02 +00:00
|
|
|
unsigned _con_start, _log_end;
|
|
|
|
unsigned wake_klogd = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-20 01:16:01 +00:00
|
|
|
if (console_suspended) {
|
2009-02-14 01:07:24 +00:00
|
|
|
up(&console_sem);
|
2006-06-20 01:16:01 +00:00
|
|
|
return;
|
|
|
|
}
|
2006-08-05 19:14:16 +00:00
|
|
|
|
|
|
|
console_may_schedule = 0;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
for ( ; ; ) {
|
|
|
|
spin_lock_irqsave(&logbuf_lock, flags);
|
|
|
|
wake_klogd |= log_start - log_end;
|
|
|
|
if (con_start == log_end)
|
|
|
|
break; /* Nothing to print */
|
|
|
|
_con_start = con_start;
|
|
|
|
_log_end = log_end;
|
|
|
|
con_start = log_end; /* Flush */
|
|
|
|
spin_unlock(&logbuf_lock);
|
2008-05-12 19:20:42 +00:00
|
|
|
stop_critical_timings(); /* don't trace print latency */
|
2005-04-16 22:20:36 +00:00
|
|
|
call_console_drivers(_con_start, _log_end);
|
2008-05-12 19:20:42 +00:00
|
|
|
start_critical_timings();
|
2005-04-16 22:20:36 +00:00
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
console_locked = 0;
|
|
|
|
up(&console_sem);
|
|
|
|
spin_unlock_irqrestore(&logbuf_lock, flags);
|
2007-02-10 09:46:19 +00:00
|
|
|
if (wake_klogd)
|
|
|
|
wake_up_klogd();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(release_console_sem);
|
|
|
|
|
2005-11-14 00:08:14 +00:00
|
|
|
/**
|
|
|
|
* console_conditional_schedule - yield the CPU if required
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* If the console code is currently allowed to sleep, and
|
|
|
|
* if this CPU should yield the CPU to another task, do
|
|
|
|
* so here.
|
|
|
|
*
|
|
|
|
* Must be called within acquire_console_sem().
|
|
|
|
*/
|
|
|
|
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
|
|
|
|
acquire_console_sem();
|
|
|
|
|
|
|
|
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-02 01:08:37 +00:00
|
|
|
for_each_console(c)
|
2005-04-16 22:20:36 +00:00
|
|
|
if ((c->flags & CON_ENABLED) && c->unblank)
|
|
|
|
c->unblank();
|
|
|
|
release_console_sem();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
acquire_console_sem();
|
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-02 01:08:37 +00:00
|
|
|
for_each_console(c) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!c->device)
|
|
|
|
continue;
|
|
|
|
driver = c->device(c, index);
|
|
|
|
if (driver)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
release_console_sem();
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
acquire_console_sem();
|
|
|
|
console->flags &= ~CON_ENABLED;
|
|
|
|
release_console_sem();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(console_stop);
|
|
|
|
|
|
|
|
void console_start(struct console *console)
|
|
|
|
{
|
|
|
|
acquire_console_sem();
|
|
|
|
console->flags |= CON_ENABLED;
|
|
|
|
release_console_sem();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(console_start);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-02 01:08:37 +00: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 22:20:36 +00: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-02 01:08:37 +00:00
|
|
|
void register_console(struct console *newcon)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-10-30 23:02:46 +00:00
|
|
|
int i;
|
2005-04-16 22:20:36 +00: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-02 01:08:37 +00:00
|
|
|
struct console *bcon = NULL;
|
2005-04-16 22:20:36 +00: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-02 01:08:37 +00: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 07:26:49 +00: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-02 01:08:37 +00:00
|
|
|
if (console_drivers && console_drivers->flags & CON_BOOT)
|
|
|
|
bcon = console_drivers;
|
|
|
|
|
|
|
|
if (preferred_console < 0 || bcon || !console_drivers)
|
2005-04-16 22:20:36 +00: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-02 01:08:37 +00: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 06:37:59 +00:00
|
|
|
|
2005-04-16 22:20:36 +00: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-02 01:08:37 +00: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 19:21:04 +00:00
|
|
|
preferred_console = 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if this console matches one we selected on
|
|
|
|
* the command line.
|
|
|
|
*/
|
2005-10-30 23:02:46 +00: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-02 01:08:37 +00:00
|
|
|
if (strcmp(console_cmdline[i].name, newcon->name) != 0)
|
2005-04-16 22:20:36 +00: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-02 01:08:37 +00:00
|
|
|
if (newcon->index >= 0 &&
|
|
|
|
newcon->index != console_cmdline[i].index)
|
2005-04-16 22:20:36 +00: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-02 01:08:37 +00:00
|
|
|
if (newcon->index < 0)
|
|
|
|
newcon->index = console_cmdline[i].index;
|
2008-04-30 07:54:51 +00: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-02 01:08:37 +00:00
|
|
|
newcon->flags |= CON_BRL;
|
|
|
|
braille_register_console(newcon,
|
2008-04-30 07:54:51 +00: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-02 01:08:37 +00:00
|
|
|
if (newcon->setup &&
|
|
|
|
newcon->setup(newcon, console_cmdline[i].options) != 0)
|
2005-04-16 22:20:36 +00: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-02 01:08:37 +00: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 07:09:05 +00: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-02 01:08:37 +00: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 07:09:05 +00:00
|
|
|
preferred_console = selected_console;
|
|
|
|
}
|
2005-04-16 22:20:36 +00: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-02 01:08:37 +00:00
|
|
|
if (!(newcon->flags & CON_ENABLED))
|
2005-04-16 22:20:36 +00: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 17:08:37 +00: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-02 01:08:37 +00:00
|
|
|
newcon->flags &= ~CON_PRINTBUFFER;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Put this console in the list - keep the
|
|
|
|
* preferred driver at the head of the list.
|
|
|
|
*/
|
|
|
|
acquire_console_sem();
|
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-02 01:08:37 +00: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 22:20:36 +00: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-02 01:08:37 +00:00
|
|
|
newcon->next = console_drivers->next;
|
|
|
|
console_drivers->next = newcon;
|
2005-04-16 22:20:36 +00: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-02 01:08:37 +00:00
|
|
|
if (newcon->flags & CON_PRINTBUFFER) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* release_console_sem() will print out the buffered messages
|
|
|
|
* for us.
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&logbuf_lock, flags);
|
|
|
|
con_start = log_start;
|
|
|
|
spin_unlock_irqrestore(&logbuf_lock, flags);
|
|
|
|
}
|
|
|
|
release_console_sem();
|
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 17:08:37 +00: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)
|
|
|
|
*/
|
|
|
|
if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV)) {
|
|
|
|
/* 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 22:20:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(register_console);
|
|
|
|
|
2005-10-30 23:02:46 +00:00
|
|
|
int unregister_console(struct console *console)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-10-30 23:02:46 +00:00
|
|
|
struct console *a, *b;
|
2005-04-16 22:20:36 +00:00
|
|
|
int res = 1;
|
|
|
|
|
2008-04-30 07:54:51 +00:00
|
|
|
#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
|
|
|
|
if (console->flags & CON_BRL)
|
|
|
|
return braille_unregister_console(console);
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
acquire_console_sem();
|
|
|
|
if (console_drivers == console) {
|
|
|
|
console_drivers=console->next;
|
|
|
|
res = 0;
|
2005-11-23 21:37:44 +00:00
|
|
|
} else if (console_drivers) {
|
2005-04-16 22:20:36 +00: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 23:02:46 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2005-10-30 23:02:46 +00:00
|
|
|
|
2007-05-08 07:26:49 +00: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 07:09:05 +00: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 22:20:36 +00:00
|
|
|
*/
|
2007-05-08 07:26:49 +00: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 07:09:05 +00:00
|
|
|
console_drivers->flags |= CON_CONSDEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
release_console_sem();
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(unregister_console);
|
2005-05-01 15:59:02 +00:00
|
|
|
|
2007-08-20 19:22:47 +00:00
|
|
|
static int __init disable_boot_consoles(void)
|
|
|
|
{
|
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-02 01:08:37 +00:00
|
|
|
struct console *con;
|
|
|
|
|
|
|
|
for_each_console(con) {
|
|
|
|
if (con->flags & CON_BOOT) {
|
2007-08-22 03:14:58 +00: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-02 01:08:37 +00:00
|
|
|
con->name, con->index);
|
2009-08-06 22:58:11 +00:00
|
|
|
unregister_console(con);
|
2007-08-22 03:14:58 +00:00
|
|
|
}
|
2007-08-20 19:22:47 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
late_initcall(disable_boot_consoles);
|
|
|
|
|
2008-02-08 12:21:25 +00:00
|
|
|
#if defined CONFIG_PRINTK
|
2008-07-25 08:45:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* printk rate limiting, lifted from the networking subsystem.
|
|
|
|
*
|
2008-07-30 05:33:38 +00: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 22:20:36 +00:00
|
|
|
*/
|
2008-07-30 05:33:38 +00:00
|
|
|
DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
|
|
|
|
|
2009-10-23 12:58:11 +00:00
|
|
|
int __printk_ratelimit(const char *func)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-10-23 12:58:11 +00:00
|
|
|
return ___ratelimit(&printk_ratelimit_state, func);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-10-23 12:58:11 +00:00
|
|
|
EXPORT_SYMBOL(__printk_ratelimit);
|
2006-11-03 06:07:16 +00: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 15:18:42 +00:00
|
|
|
if (*caller_jiffies == 0
|
|
|
|
|| !time_in_range(jiffies, *caller_jiffies,
|
|
|
|
*caller_jiffies
|
|
|
|
+ msecs_to_jiffies(interval_msecs))) {
|
|
|
|
*caller_jiffies = jiffies;
|
2006-11-03 06:07:16 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(printk_timed_ratelimit);
|
2009-10-16 12:09:18 +00:00
|
|
|
|
|
|
|
static DEFINE_SPINLOCK(dump_list_lock);
|
|
|
|
static LIST_HEAD(dump_list);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kmsg_dump_register - register a kernel log dumper.
|
2009-12-17 23:27:27 +00:00
|
|
|
* @dumper: pointer to the kmsg_dumper structure
|
2009-10-16 12:09:18 +00: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;
|
|
|
|
list_add_tail(&dumper->list, &dump_list);
|
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&dump_list_lock, flags);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(kmsg_dump_register);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kmsg_dump_unregister - unregister a kmsg dumper.
|
2009-12-17 23:27:27 +00:00
|
|
|
* @dumper: pointer to the kmsg_dumper structure
|
2009-10-16 12:09:18 +00: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;
|
|
|
|
list_del(&dumper->list);
|
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&dump_list_lock, flags);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
|
|
|
|
|
|
|
|
static const char const *kmsg_reasons[] = {
|
|
|
|
[KMSG_DUMP_OOPS] = "oops",
|
|
|
|
[KMSG_DUMP_PANIC] = "panic",
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char *kmsg_to_str(enum kmsg_dump_reason reason)
|
|
|
|
{
|
|
|
|
if (reason >= ARRAY_SIZE(kmsg_reasons) || reason < 0)
|
|
|
|
return "unknown";
|
|
|
|
|
|
|
|
return kmsg_reasons[reason];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kmsg_dump - dump kernel log to kernel message dumpers.
|
|
|
|
* @reason: the reason (oops, panic etc) for dumping
|
|
|
|
*
|
|
|
|
* Iterate through each of the dump devices and call the oops/panic
|
|
|
|
* callbacks with the log buffer.
|
|
|
|
*/
|
|
|
|
void kmsg_dump(enum kmsg_dump_reason reason)
|
|
|
|
{
|
|
|
|
unsigned long end;
|
|
|
|
unsigned chars;
|
|
|
|
struct kmsg_dumper *dumper;
|
|
|
|
const char *s1, *s2;
|
|
|
|
unsigned long l1, l2;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/* Theoretically, the log could move on after we do this, but
|
|
|
|
there's not a lot we can do about that. The new messages
|
|
|
|
will overwrite the start of what we dump. */
|
|
|
|
spin_lock_irqsave(&logbuf_lock, flags);
|
|
|
|
end = log_end & LOG_BUF_MASK;
|
|
|
|
chars = logged_chars;
|
|
|
|
spin_unlock_irqrestore(&logbuf_lock, flags);
|
|
|
|
|
|
|
|
if (logged_chars > end) {
|
|
|
|
s1 = log_buf + log_buf_len - logged_chars + end;
|
|
|
|
l1 = logged_chars - end;
|
|
|
|
|
|
|
|
s2 = log_buf;
|
|
|
|
l2 = end;
|
|
|
|
} else {
|
|
|
|
s1 = "";
|
|
|
|
l1 = 0;
|
|
|
|
|
|
|
|
s2 = log_buf + end - logged_chars;
|
|
|
|
l2 = logged_chars;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!spin_trylock_irqsave(&dump_list_lock, flags)) {
|
|
|
|
printk(KERN_ERR "dump_kmsg: dump list lock is held during %s, skipping dump\n",
|
|
|
|
kmsg_to_str(reason));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
list_for_each_entry(dumper, &dump_list, list)
|
|
|
|
dumper->dump(dumper, reason, s1, l1, s2, l2);
|
|
|
|
spin_unlock_irqrestore(&dump_list_lock, flags);
|
|
|
|
}
|
2008-02-08 12:21:25 +00:00
|
|
|
#endif
|