Kernel

Kernel Git Source Tree

Root/kernel/printk.c

1	/*
2	* linux/kernel/printk.c
3	*
4	* Copyright (C) 1991, 1992 Linus Torvalds
5	*
6	* Modified to make sys_syslog() more flexible: added commands to
7	* return the last 4k of kernel messages, regardless of whether
8	* they've been read or not. Added option to suppress kernel printk's
9	* to the console. Added hook for sending the console messages
10	* elsewhere, in preparation for a serial line console (someday).
11	* Ted Ts'o, 2/11/93.
12	* Modified for sysctl support, 1/8/97, Chris Horn.
13	* Fixed SMP synchronization, 08/08/99, Manfred Spraul
14	* manfred@colorfullife.com
15	* Rewrote bits to get rid of console_lock
16	* 01Mar01 Andrew Morton
17	*/
18
19	#include <linux/kernel.h>
20	#include <linux/mm.h>
21	#include <linux/tty.h>
22	#include <linux/tty_driver.h>
23	#include <linux/console.h>
24	#include <linux/init.h>
25	#include <linux/jiffies.h>
26	#include <linux/nmi.h>
27	#include <linux/module.h>
28	#include <linux/moduleparam.h>
29	#include <linux/interrupt.h> /* For in_interrupt() */
30	#include <linux/delay.h>
31	#include <linux/smp.h>
32	#include <linux/security.h>
33	#include <linux/bootmem.h>
34	#include <linux/syscalls.h>
35	#include <linux/kexec.h>
36	#include <linux/ratelimit.h>
37	#include <linux/kmsg_dump.h>
38	#include <linux/syslog.h>
39
40	#include <asm/uaccess.h>
41
42	/*
43	* for_each_console() allows you to iterate on each console
44	*/
45	#define for_each_console(con) \
46	for (con = console_drivers; con != NULL; con = con->next)
47
48	/*
49	* Architectures can override it:
50	*/
51	void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
52	{
53	}
54
55	#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
56
57	/* printk's without a loglevel use this.. */
58	#define DEFAULT_MESSAGE_LOGLEVEL 4 /* KERN_WARNING */
59
60	/* We show everything that is MORE important than this.. */
61	#define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */
62	#define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG */
63
64	DECLARE_WAIT_QUEUE_HEAD(log_wait);
65
66	int console_printk[4] = {
67	DEFAULT_CONSOLE_LOGLEVEL, /* console_loglevel */
68	DEFAULT_MESSAGE_LOGLEVEL, /* default_message_loglevel */
69	MINIMUM_CONSOLE_LOGLEVEL, /* minimum_console_loglevel */
70	DEFAULT_CONSOLE_LOGLEVEL, /* default_console_loglevel */
71	};
72
73	/*
74	* Low level drivers may need that to know if they can schedule in
75	* their unblank() callback or not. So let's export it.
76	*/
77	int oops_in_progress;
78	EXPORT_SYMBOL(oops_in_progress);
79
80	/*
81	* console_sem protects the console_drivers list, and also
82	* provides serialisation for access to the entire console
83	* driver system.
84	*/
85	static DECLARE_MUTEX(console_sem);
86	struct console *console_drivers;
87	EXPORT_SYMBOL_GPL(console_drivers);
88
89	/*
90	* This is used for debugging the mess that is the VT code by
91	* keeping track if we have the console semaphore held. It's
92	* definitely not the perfect debug tool (we don't know if _WE_
93	* hold it are racing, but it helps tracking those weird code
94	* path in the console code where we end up in places I want
95	* locked without the console sempahore held
96	*/
97	static int console_locked, console_suspended;
98
99	/*
100	* logbuf_lock protects log_buf, log_start, log_end, con_start and logged_chars
101	* It is also used in interesting ways to provide interlocking in
102	* release_console_sem().
103	*/
104	static DEFINE_SPINLOCK(logbuf_lock);
105
106	#define LOG_BUF_MASK (log_buf_len-1)
107	#define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
108
109	/*
110	* The indices into log_buf are not constrained to log_buf_len - they
111	* must be masked before subscripting
112	*/
113	static unsigned log_start; /* Index into log_buf: next char to be read by syslog() */
114	static unsigned con_start; /* Index into log_buf: next char to be sent to consoles */
115	static unsigned log_end; /* Index into log_buf: most-recently-written-char + 1 */
116
117	/*
118	* Array of consoles built from command line options (console=)
119	*/
120	struct console_cmdline
121	{
122	char name[8]; /* Name of the driver */
123	int index; /* Minor dev. to use */
124	char options; / Options for the driver */
125	#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
126	char brl_options; / Options for braille driver */
127	#endif
128	};
129
130	#define MAX_CMDLINECONSOLES 8
131
132	static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
133	static int selected_console = -1;
134	static int preferred_console = -1;
135	int console_set_on_cmdline;
136	EXPORT_SYMBOL(console_set_on_cmdline);
137
138	/* Flag: console code may call schedule() */
139	static int console_may_schedule;
140
141	#ifdef CONFIG_PRINTK
142
143	static char __log_buf[__LOG_BUF_LEN];
144	static char *log_buf = __log_buf;
145	static int log_buf_len = __LOG_BUF_LEN;
146	static unsigned logged_chars; /* Number of chars produced since last read+clear operation */
147	static int saved_console_loglevel = -1;
148
149	#ifdef CONFIG_KEXEC
150	/*
151	* This appends the listed symbols to /proc/vmcoreinfo
152	*
153	* /proc/vmcoreinfo is used by various utiilties, like crash and makedumpfile to
154	* obtain access to symbols that are otherwise very difficult to locate. These
155	* symbols are specifically used so that utilities can access and extract the
156	* dmesg log from a vmcore file after a crash.
157	*/
158	void log_buf_kexec_setup(void)
159	{
160	VMCOREINFO_SYMBOL(log_buf);
161	VMCOREINFO_SYMBOL(log_end);
162	VMCOREINFO_SYMBOL(log_buf_len);
163	VMCOREINFO_SYMBOL(logged_chars);
164	}
165	#endif
166
167	static int __init log_buf_len_setup(char *str)
168	{
169	unsigned size = memparse(str, &str);
170	unsigned long flags;
171
172	if (size)
173	size = roundup_pow_of_two(size);
174	if (size > log_buf_len) {
175	unsigned start, dest_idx, offset;
176	char *new_log_buf;
177
178	new_log_buf = alloc_bootmem(size);
179	if (!new_log_buf) {
180	printk(KERN_WARNING "log_buf_len: allocation failed\n");
181	goto out;
182	}
183
184	spin_lock_irqsave(&logbuf_lock, flags);
185	log_buf_len = size;
186	log_buf = new_log_buf;
187
188	offset = start = min(con_start, log_start);
189	dest_idx = 0;
190	while (start != log_end) {
191	log_buf[dest_idx] = __log_buf[start & (__LOG_BUF_LEN - 1)];
192	start++;
193	dest_idx++;
194	}
195	log_start -= offset;
196	con_start -= offset;
197	log_end -= offset;
198	spin_unlock_irqrestore(&logbuf_lock, flags);
199
200	printk(KERN_NOTICE "log_buf_len: %d\n", log_buf_len);
201	}
202	out:
203	return 1;
204	}
205
206	__setup("log_buf_len=", log_buf_len_setup);
207
208	#ifdef CONFIG_BOOT_PRINTK_DELAY
209
210	static unsigned int boot_delay; /* msecs delay after each printk during bootup */
211	static unsigned long long loops_per_msec; /* based on boot_delay */
212
213	static int __init boot_delay_setup(char *str)
214	{
215	unsigned long lpj;
216
217	lpj = preset_lpj ? preset_lpj : 1000000; /* some guess */
218	loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
219
220	get_option(&str, &boot_delay);
221	if (boot_delay > 10 * 1000)
222	boot_delay = 0;
223
224	pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
225	"HZ: %d, loops_per_msec: %llu\n",
226	boot_delay, preset_lpj, lpj, HZ, loops_per_msec);
227	return 1;
228	}
229	__setup("boot_delay=", boot_delay_setup);
230
231	static void boot_delay_msec(void)
232	{
233	unsigned long long k;
234	unsigned long timeout;
235
236	if (boot_delay == 0 \|\| system_state != SYSTEM_BOOTING)
237	return;
238
239	k = (unsigned long long)loops_per_msec * boot_delay;
240
241	timeout = jiffies + msecs_to_jiffies(boot_delay);
242	while (k) {
243	k--;
244	cpu_relax();
245	/*
246	* use (volatile) jiffies to prevent
247	* compiler reduction; loop termination via jiffies
248	* is secondary and may or may not happen.
249	*/
250	if (time_after(jiffies, timeout))
251	break;
252	touch_nmi_watchdog();
253	}
254	}
255	#else
256	static inline void boot_delay_msec(void)
257	{
258	}
259	#endif
260
261	int do_syslog(int type, char __user *buf, int len, bool from_file)
262	{
263	unsigned i, j, limit, count;
264	int do_clear = 0;
265	char c;
266	int error = 0;
267
268	error = security_syslog(type, from_file);
269	if (error)
270	return error;
271
272	switch (type) {
273	case SYSLOG_ACTION_CLOSE: /* Close log */
274	break;
275	case SYSLOG_ACTION_OPEN: /* Open log */
276	break;
277	case SYSLOG_ACTION_READ: /* Read from log */
278	error = -EINVAL;
279	if (!buf \|\| len < 0)
280	goto out;
281	error = 0;
282	if (!len)
283	goto out;
284	if (!access_ok(VERIFY_WRITE, buf, len)) {
285	error = -EFAULT;
286	goto out;
287	}
288	error = wait_event_interruptible(log_wait,
289	(log_start - log_end));
290	if (error)
291	goto out;
292	i = 0;
293	spin_lock_irq(&logbuf_lock);
294	while (!error && (log_start != log_end) && i < len) {
295	c = LOG_BUF(log_start);
296	log_start++;
297	spin_unlock_irq(&logbuf_lock);
298	error = __put_user(c,buf);
299	buf++;
300	i++;
301	cond_resched();
302	spin_lock_irq(&logbuf_lock);
303	}
304	spin_unlock_irq(&logbuf_lock);
305	if (!error)
306	error = i;
307	break;
308	/* Read/clear last kernel messages */
309	case SYSLOG_ACTION_READ_CLEAR:
310	do_clear = 1;
311	/* FALL THRU */
312	/* Read last kernel messages */
313	case SYSLOG_ACTION_READ_ALL:
314	error = -EINVAL;
315	if (!buf \|\| len < 0)
316	goto out;
317	error = 0;
318	if (!len)
319	goto out;
320	if (!access_ok(VERIFY_WRITE, buf, len)) {
321	error = -EFAULT;
322	goto out;
323	}
324	count = len;
325	if (count > log_buf_len)
326	count = log_buf_len;
327	spin_lock_irq(&logbuf_lock);
328	if (count > logged_chars)
329	count = logged_chars;
330	if (do_clear)
331	logged_chars = 0;
332	limit = log_end;
333	/*
334	* __put_user() could sleep, and while we sleep
335	* printk() could overwrite the messages
336	* we try to copy to user space. Therefore
337	* the messages are copied in reverse. <manfreds>
338	*/
339	for (i = 0; i < count && !error; i++) {
340	j = limit-1-i;
341	if (j + log_buf_len < log_end)
342	break;
343	c = LOG_BUF(j);
344	spin_unlock_irq(&logbuf_lock);
345	error = __put_user(c,&buf[count-1-i]);
346	cond_resched();
347	spin_lock_irq(&logbuf_lock);
348	}
349	spin_unlock_irq(&logbuf_lock);
350	if (error)
351	break;
352	error = i;
353	if (i != count) {
354	int offset = count-error;
355	/* buffer overflow during copy, correct user buffer. */
356	for (i = 0; i < error; i++) {
357	if (__get_user(c,&buf[i+offset]) \|\|
358	__put_user(c,&buf[i])) {
359	error = -EFAULT;
360	break;
361	}
362	cond_resched();
363	}
364	}
365	break;
366	/* Clear ring buffer */
367	case SYSLOG_ACTION_CLEAR:
368	logged_chars = 0;
369	break;
370	/* Disable logging to console */
371	case SYSLOG_ACTION_CONSOLE_OFF:
372	if (saved_console_loglevel == -1)
373	saved_console_loglevel = console_loglevel;
374	console_loglevel = minimum_console_loglevel;
375	break;
376	/* Enable logging to console */
377	case SYSLOG_ACTION_CONSOLE_ON:
378	if (saved_console_loglevel != -1) {
379	console_loglevel = saved_console_loglevel;
380	saved_console_loglevel = -1;
381	}
382	break;
383	/* Set level of messages printed to console */
384	case SYSLOG_ACTION_CONSOLE_LEVEL:
385	error = -EINVAL;
386	if (len < 1 \|\| len > 8)
387	goto out;
388	if (len < minimum_console_loglevel)
389	len = minimum_console_loglevel;
390	console_loglevel = len;
391	/* Implicitly re-enable logging to console */
392	saved_console_loglevel = -1;
393	error = 0;
394	break;
395	/* Number of chars in the log buffer */
396	case SYSLOG_ACTION_SIZE_UNREAD:
397	error = log_end - log_start;
398	break;
399	/* Size of the log buffer */
400	case SYSLOG_ACTION_SIZE_BUFFER:
401	error = log_buf_len;
402	break;
403	default:
404	error = -EINVAL;
405	break;
406	}
407	out:
408	return error;
409	}
410
411	SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
412	{
413	return do_syslog(type, buf, len, SYSLOG_FROM_CALL);
414	}
415
416	/*
417	* Call the console drivers on a range of log_buf
418	*/
419	static void __call_console_drivers(unsigned start, unsigned end)
420	{
421	struct console *con;
422
423	for_each_console(con) {
424	if ((con->flags & CON_ENABLED) && con->write &&
425	(cpu_online(smp_processor_id()) \|\|
426	(con->flags & CON_ANYTIME)))
427	con->write(con, &LOG_BUF(start), end - start);
428	}
429	}
430
431	static int __read_mostly ignore_loglevel;
432
433	static int __init ignore_loglevel_setup(char *str)
434	{
435	ignore_loglevel = 1;
436	printk(KERN_INFO "debug: ignoring loglevel setting.\n");
437
438	return 0;
439	}
440
441	early_param("ignore_loglevel", ignore_loglevel_setup);
442
443	/*
444	* Write out chars from start to end - 1 inclusive
445	*/
446	static void _call_console_drivers(unsigned start,
447	unsigned end, int msg_log_level)
448	{
449	if ((msg_log_level < console_loglevel \|\| ignore_loglevel) &&
450	console_drivers && start != end) {
451	if ((start & LOG_BUF_MASK) > (end & LOG_BUF_MASK)) {
452	/* wrapped write */
453	__call_console_drivers(start & LOG_BUF_MASK,
454	log_buf_len);
455	__call_console_drivers(0, end & LOG_BUF_MASK);
456	} else {
457	__call_console_drivers(start, end);
458	}
459	}
460	}
461
462	/*
463	* Call the console drivers, asking them to write out
464	* log_buf[start] to log_buf[end - 1].
465	* The console_sem must be held.
466	*/
467	static void call_console_drivers(unsigned start, unsigned end)
468	{
469	unsigned cur_index, start_print;
470	static int msg_level = -1;
471
472	BUG_ON(((int)(start - end)) > 0);
473
474	cur_index = start;
475	start_print = start;
476	while (cur_index != end) {
477	if (msg_level < 0 && ((end - cur_index) > 2) &&
478	LOG_BUF(cur_index + 0) == '<' &&
479	LOG_BUF(cur_index + 1) >= '0' &&
480	LOG_BUF(cur_index + 1) <= '7' &&
481	LOG_BUF(cur_index + 2) == '>') {
482	msg_level = LOG_BUF(cur_index + 1) - '0';
483	cur_index += 3;
484	start_print = cur_index;
485	}
486	while (cur_index != end) {
487	char c = LOG_BUF(cur_index);
488
489	cur_index++;
490	if (c == '\n') {
491	if (msg_level < 0) {
492	/*
493	* printk() has already given us loglevel tags in
494	* the buffer. This code is here in case the
495	* log buffer has wrapped right round and scribbled
496	* on those tags
497	*/
498	msg_level = default_message_loglevel;
499	}
500	_call_console_drivers(start_print, cur_index, msg_level);
501	msg_level = -1;
502	start_print = cur_index;
503	break;
504	}
505	}
506	}
507	_call_console_drivers(start_print, end, msg_level);
508	}
509
510	static void emit_log_char(char c)
511	{
512	LOG_BUF(log_end) = c;
513	log_end++;
514	if (log_end - log_start > log_buf_len)
515	log_start = log_end - log_buf_len;
516	if (log_end - con_start > log_buf_len)
517	con_start = log_end - log_buf_len;
518	if (logged_chars < log_buf_len)
519	logged_chars++;
520	}
521
522	/*
523	* Zap console related locks when oopsing. Only zap at most once
524	* every 10 seconds, to leave time for slow consoles to print a
525	* full oops.
526	*/
527	static void zap_locks(void)
528	{
529	static unsigned long oops_timestamp;
530
531	if (time_after_eq(jiffies, oops_timestamp) &&
532	!time_after(jiffies, oops_timestamp + 30 * HZ))
533	return;
534
535	oops_timestamp = jiffies;
536
537	/* If a crash is occurring, make sure we can't deadlock */
538	spin_lock_init(&logbuf_lock);
539	/* And make sure that we print immediately */
540	init_MUTEX(&console_sem);
541	}
542
543	#if defined(CONFIG_PRINTK_TIME)
544	static int printk_time = 1;
545	#else
546	static int printk_time = 0;
547	#endif
548	module_param_named(time, printk_time, bool, S_IRUGO \| S_IWUSR);
549
550	/* Check if we have any console registered that can be called early in boot. */
551	static int have_callable_console(void)
552	{
553	struct console *con;
554
555	for_each_console(con)
556	if (con->flags & CON_ANYTIME)
557	return 1;
558
559	return 0;
560	}
561
562	/**
563	* printk - print a kernel message
564	* @fmt: format string
565	*
566	* This is printk(). It can be called from any context. We want it to work.
567	*
568	* We try to grab the console_sem. If we succeed, it's easy - we log the output and
569	* call the console drivers. If we fail to get the semaphore we place the output
570	* into the log buffer and return. The current holder of the console_sem will
571	* notice the new output in release_console_sem() and will send it to the
572	* consoles before releasing the semaphore.
573	*
574	* One effect of this deferred printing is that code which calls printk() and
575	* then changes console_loglevel may break. This is because console_loglevel
576	* is inspected when the actual printing occurs.
577	*
578	* See also:
579	* printf(3)
580	*
581	* See the vsnprintf() documentation for format string extensions over C99.
582	*/
583
584	asmlinkage int printk(const char *fmt, ...)
585	{
586	va_list args;
587	int r;
588
589	va_start(args, fmt);
590	r = vprintk(fmt, args);
591	va_end(args);
592
593	return r;
594	}
595
596	/* cpu currently holding logbuf_lock */
597	static volatile unsigned int printk_cpu = UINT_MAX;
598
599	/*
600	* Can we actually use the console at this time on this cpu?
601	*
602	* Console drivers may assume that per-cpu resources have
603	* been allocated. So unless they're explicitly marked as
604	* being able to cope (CON_ANYTIME) don't call them until
605	* this CPU is officially up.
606	*/
607	static inline int can_use_console(unsigned int cpu)
608	{
609	return cpu_online(cpu) \|\| have_callable_console();
610	}
611
612	/*
613	* Try to get console ownership to actually show the kernel
614	* messages from a 'printk'. Return true (and with the
615	* console_semaphore held, and 'console_locked' set) if it
616	* is successful, false otherwise.
617	*
618	* This gets called with the 'logbuf_lock' spinlock held and
619	* interrupts disabled. It should return with 'lockbuf_lock'
620	* released but interrupts still disabled.
621	*/
622	static int acquire_console_semaphore_for_printk(unsigned int cpu)
623	{
624	int retval = 0;
625
626	if (!try_acquire_console_sem()) {
627	retval = 1;
628
629	/*
630	* If we can't use the console, we need to release
631	* the console semaphore by hand to avoid flushing
632	* the buffer. We need to hold the console semaphore
633	* in order to do this test safely.
634	*/
635	if (!can_use_console(cpu)) {
636	console_locked = 0;
637	up(&console_sem);
638	retval = 0;
639	}
640	}
641	printk_cpu = UINT_MAX;
642	spin_unlock(&logbuf_lock);
643	return retval;
644	}
645	static const char recursion_bug_msg [] =
646	KERN_CRIT "BUG: recent printk recursion!\n";
647	static int recursion_bug;
648	static int new_text_line = 1;
649	static char printk_buf[1024];
650
651	int printk_delay_msec __read_mostly;
652
653	static inline void printk_delay(void)
654	{
655	if (unlikely(printk_delay_msec)) {
656	int m = printk_delay_msec;
657
658	while (m--) {
659	mdelay(1);
660	touch_nmi_watchdog();
661	}
662	}
663	}
664
665	asmlinkage int vprintk(const char *fmt, va_list args)
666	{
667	int printed_len = 0;
668	int current_log_level = default_message_loglevel;
669	unsigned long flags;
670	int this_cpu;
671	char *p;
672
673	boot_delay_msec();
674	printk_delay();
675
676	preempt_disable();
677	/* This stops the holder of console_sem just where we want him */
678	raw_local_irq_save(flags);
679	this_cpu = smp_processor_id();
680
681	/*
682	* Ouch, printk recursed into itself!
683	*/
684	if (unlikely(printk_cpu == this_cpu)) {
685	/*
686	* If a crash is occurring during printk() on this CPU,
687	* then try to get the crash message out but make sure
688	* we can't deadlock. Otherwise just return to avoid the
689	* recursion and return - but flag the recursion so that
690	* it can be printed at the next appropriate moment:
691	*/
692	if (!oops_in_progress) {
693	recursion_bug = 1;
694	goto out_restore_irqs;
695	}
696	zap_locks();
697	}
698
699	lockdep_off();
700	spin_lock(&logbuf_lock);
701	printk_cpu = this_cpu;
702
703	if (recursion_bug) {
704	recursion_bug = 0;
705	strcpy(printk_buf, recursion_bug_msg);
706	printed_len = strlen(recursion_bug_msg);
707	}
708	/* Emit the output into the temporary buffer */
709	printed_len += vscnprintf(printk_buf + printed_len,
710	sizeof(printk_buf) - printed_len, fmt, args);
711
712
713	p = printk_buf;
714
715	/* Do we have a loglevel in the string? */
716	if (p[0] == '<') {
717	unsigned char c = p[1];
718	if (c && p[2] == '>') {
719	switch (c) {
720	case '0' ... '7': /* loglevel */
721	current_log_level = c - '0';
722	/* Fallthrough - make sure we're on a new line */
723	case 'd': /* KERN_DEFAULT */
724	if (!new_text_line) {
725	emit_log_char('\n');
726	new_text_line = 1;
727	}
728	/* Fallthrough - skip the loglevel */
729	case 'c': /* KERN_CONT */
730	p += 3;
731	break;
732	}
733	}
734	}
735
736	/*
737	* Copy the output into log_buf. If the caller didn't provide
738	* appropriate log level tags, we insert them here
739	*/
740	for ( ; *p; p++) {
741	if (new_text_line) {
742	/* Always output the token */
743	emit_log_char('<');
744	emit_log_char(current_log_level + '0');
745	emit_log_char('>');
746	printed_len += 3;
747	new_text_line = 0;
748
749	if (printk_time) {
750	/* Follow the token with the time */
751	char tbuf[50], *tp;
752	unsigned tlen;
753	unsigned long long t;
754	unsigned long nanosec_rem;
755
756	t = cpu_clock(printk_cpu);
757	nanosec_rem = do_div(t, 1000000000);
758	tlen = sprintf(tbuf, "[%5lu.%06lu] ",
759	(unsigned long) t,
760	nanosec_rem / 1000);
761
762	for (tp = tbuf; tp < tbuf + tlen; tp++)
763	emit_log_char(*tp);
764	printed_len += tlen;
765	}
766
767	if (!*p)
768	break;
769	}
770
771	emit_log_char(*p);
772	if (*p == '\n')
773	new_text_line = 1;
774	}
775
776	/*
777	* Try to acquire and then immediately release the
778	* console semaphore. The release will do all the
779	* actual magic (print out buffers, wake up klogd,
780	* etc).
781	*
782	* The acquire_console_semaphore_for_printk() function
783	* will release 'logbuf_lock' regardless of whether it
784	* actually gets the semaphore or not.
785	*/
786	if (acquire_console_semaphore_for_printk(this_cpu))
787	release_console_sem();
788
789	lockdep_on();
790	out_restore_irqs:
791	raw_local_irq_restore(flags);
792
793	preempt_enable();
794	return printed_len;
795	}
796	EXPORT_SYMBOL(printk);
797	EXPORT_SYMBOL(vprintk);
798
799	#else
800
801	static void call_console_drivers(unsigned start, unsigned end)
802	{
803	}
804
805	#endif
806
807	static int __add_preferred_console(char name, int idx, char options,
808	char *brl_options)
809	{
810	struct console_cmdline *c;
811	int i;
812
813	/*
814	* See if this tty is not yet registered, and
815	* if we have a slot free.
816	*/
817	for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
818	if (strcmp(console_cmdline[i].name, name) == 0 &&
819	console_cmdline[i].index == idx) {
820	if (!brl_options)
821	selected_console = i;
822	return 0;
823	}
824	if (i == MAX_CMDLINECONSOLES)
825	return -E2BIG;
826	if (!brl_options)
827	selected_console = i;
828	c = &console_cmdline[i];
829	strlcpy(c->name, name, sizeof(c->name));
830	c->options = options;
831	#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
832	c->brl_options = brl_options;
833	#endif
834	c->index = idx;
835	return 0;
836	}
837	/*
838	* Set up a list of consoles. Called from init/main.c
839	*/
840	static int __init console_setup(char *str)
841	{
842	char buf[sizeof(console_cmdline[0].name) + 4]; /* 4 for index */
843	char s, options, *brl_options = NULL;
844	int idx;
845
846	#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
847	if (!memcmp(str, "brl,", 4)) {
848	brl_options = "";
849	str += 4;
850	} else if (!memcmp(str, "brl=", 4)) {
851	brl_options = str + 4;
852	str = strchr(brl_options, ',');
853	if (!str) {
854	printk(KERN_ERR "need port name after brl=\n");
855	return 1;
856	}
857	*(str++) = 0;
858	}
859	#endif
860
861	/*
862	* Decode str into name, index, options.
863	*/
864	if (str[0] >= '0' && str[0] <= '9') {
865	strcpy(buf, "ttyS");
866	strncpy(buf + 4, str, sizeof(buf) - 5);
867	} else {
868	strncpy(buf, str, sizeof(buf) - 1);
869	}
870	buf[sizeof(buf) - 1] = 0;
871	if ((options = strchr(str, ',')) != NULL)
872	*(options++) = 0;
873	#ifdef __sparc__
874	if (!strcmp(str, "ttya"))
875	strcpy(buf, "ttyS0");
876	if (!strcmp(str, "ttyb"))
877	strcpy(buf, "ttyS1");
878	#endif
879	for (s = buf; *s; s++)
880	if ((s >= '0' && s <= '9') \|\| *s == ',')
881	break;
882	idx = simple_strtoul(s, NULL, 10);
883	*s = 0;
884
885	__add_preferred_console(buf, idx, options, brl_options);
886	console_set_on_cmdline = 1;
887	return 1;
888	}
889	__setup("console=", console_setup);
890
891	/**
892	* add_preferred_console - add a device to the list of preferred consoles.
893	* @name: device name
894	* @idx: device index
895	* @options: options for this console
896	*
897	* The last preferred console added will be used for kernel messages
898	* and stdin/out/err for init. Normally this is used by console_setup
899	* above to handle user-supplied console arguments; however it can also
900	* be used by arch-specific code either to override the user or more
901	* commonly to provide a default console (ie from PROM variables) when
902	* the user has not supplied one.
903	*/
904	int add_preferred_console(char name, int idx, char options)
905	{
906	return __add_preferred_console(name, idx, options, NULL);
907	}
908
909	int update_console_cmdline(char name, int idx, char name_new, int idx_new, char *options)
910	{
911	struct console_cmdline *c;
912	int i;
913
914	for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
915	if (strcmp(console_cmdline[i].name, name) == 0 &&
916	console_cmdline[i].index == idx) {
917	c = &console_cmdline[i];
918	strlcpy(c->name, name_new, sizeof(c->name));
919	c->name[sizeof(c->name) - 1] = 0;
920	c->options = options;
921	c->index = idx_new;
922	return i;
923	}
924	/* not found */
925	return -1;
926	}
927
928	int console_suspend_enabled = 1;
929	EXPORT_SYMBOL(console_suspend_enabled);
930
931	static int __init console_suspend_disable(char *str)
932	{
933	console_suspend_enabled = 0;
934	return 1;
935	}
936	__setup("no_console_suspend", console_suspend_disable);
937
938	/**
939	* suspend_console - suspend the console subsystem
940	*
941	* This disables printk() while we go into suspend states
942	*/
943	void suspend_console(void)
944	{
945	if (!console_suspend_enabled)
946	return;
947	printk("Suspending console(s) (use no_console_suspend to debug)\n");
948	acquire_console_sem();
949	console_suspended = 1;
950	up(&console_sem);
951	}
952
953	void resume_console(void)
954	{
955	if (!console_suspend_enabled)
956	return;
957	down(&console_sem);
958	console_suspended = 0;
959	release_console_sem();
960	}
961
962	/**
963	* acquire_console_sem - lock the console system for exclusive use.
964	*
965	* Acquires a semaphore which guarantees that the caller has
966	* exclusive access to the console system and the console_drivers list.
967	*
968	* Can sleep, returns nothing.
969	*/
970	void acquire_console_sem(void)
971	{
972	BUG_ON(in_interrupt());
973	down(&console_sem);
974	if (console_suspended)
975	return;
976	console_locked = 1;
977	console_may_schedule = 1;
978	}
979	EXPORT_SYMBOL(acquire_console_sem);
980
981	int try_acquire_console_sem(void)
982	{
983	if (down_trylock(&console_sem))
984	return -1;
985	if (console_suspended) {
986	up(&console_sem);
987	return -1;
988	}
989	console_locked = 1;
990	console_may_schedule = 0;
991	return 0;
992	}
993	EXPORT_SYMBOL(try_acquire_console_sem);
994
995	int is_console_locked(void)
996	{
997	return console_locked;
998	}
999
1000	static DEFINE_PER_CPU(int, printk_pending);
1001
1002	void printk_tick(void)
1003	{
1004	if (__get_cpu_var(printk_pending)) {
1005	__get_cpu_var(printk_pending) = 0;
1006	wake_up_interruptible(&log_wait);
1007	}
1008	}
1009
1010	int printk_needs_cpu(int cpu)
1011	{
1012	return per_cpu(printk_pending, cpu);
1013	}
1014
1015	void wake_up_klogd(void)
1016	{
1017	if (waitqueue_active(&log_wait))
1018	__raw_get_cpu_var(printk_pending) = 1;
1019	}
1020
1021	/**
1022	* release_console_sem - unlock the console system
1023	*
1024	* Releases the semaphore which the caller holds on the console system
1025	* and the console driver list.
1026	*
1027	* While the semaphore was held, console output may have been buffered
1028	* by printk(). If this is the case, release_console_sem() emits
1029	* the output prior to releasing the semaphore.
1030	*
1031	* If there is output waiting for klogd, we wake it up.
1032	*
1033	* release_console_sem() may be called from any context.
1034	*/
1035	void release_console_sem(void)
1036	{
1037	unsigned long flags;
1038	unsigned _con_start, _log_end;
1039	unsigned wake_klogd = 0;
1040
1041	if (console_suspended) {
1042	up(&console_sem);
1043	return;
1044	}
1045
1046	console_may_schedule = 0;
1047
1048	for ( ; ; ) {
1049	spin_lock_irqsave(&logbuf_lock, flags);
1050	wake_klogd \|= log_start - log_end;
1051	if (con_start == log_end)
1052	break; /* Nothing to print */
1053	_con_start = con_start;
1054	_log_end = log_end;
1055	con_start = log_end; /* Flush */
1056	spin_unlock(&logbuf_lock);
1057	stop_critical_timings(); /* don't trace print latency */
1058	call_console_drivers(_con_start, _log_end);
1059	start_critical_timings();
1060	local_irq_restore(flags);
1061	}
1062	console_locked = 0;
1063	up(&console_sem);
1064	spin_unlock_irqrestore(&logbuf_lock, flags);
1065	if (wake_klogd)
1066	wake_up_klogd();
1067	}
1068	EXPORT_SYMBOL(release_console_sem);
1069
1070	/**
1071	* console_conditional_schedule - yield the CPU if required
1072	*
1073	* If the console code is currently allowed to sleep, and
1074	* if this CPU should yield the CPU to another task, do
1075	* so here.
1076	*
1077	* Must be called within acquire_console_sem().
1078	*/
1079	void __sched console_conditional_schedule(void)
1080	{
1081	if (console_may_schedule)
1082	cond_resched();
1083	}
1084	EXPORT_SYMBOL(console_conditional_schedule);
1085
1086	void console_unblank(void)
1087	{
1088	struct console *c;
1089
1090	/*
1091	* console_unblank can no longer be called in interrupt context unless
1092	* oops_in_progress is set to 1..
1093	*/
1094	if (oops_in_progress) {
1095	if (down_trylock(&console_sem) != 0)
1096	return;
1097	} else
1098	acquire_console_sem();
1099
1100	console_locked = 1;
1101	console_may_schedule = 0;
1102	for_each_console(c)
1103	if ((c->flags & CON_ENABLED) && c->unblank)
1104	c->unblank();
1105	release_console_sem();
1106	}
1107
1108	/*
1109	* Return the console tty driver structure and its associated index
1110	*/
1111	struct tty_driver console_device(int index)
1112	{
1113	struct console *c;
1114	struct tty_driver *driver = NULL;
1115
1116	acquire_console_sem();
1117	for_each_console(c) {
1118	if (!c->device)
1119	continue;
1120	driver = c->device(c, index);
1121	if (driver)
1122	break;
1123	}
1124	release_console_sem();
1125	return driver;
1126	}
1127
1128	/*
1129	* Prevent further output on the passed console device so that (for example)
1130	* serial drivers can disable console output before suspending a port, and can
1131	* re-enable output afterwards.
1132	*/
1133	void console_stop(struct console *console)
1134	{
1135	acquire_console_sem();
1136	console->flags &= ~CON_ENABLED;
1137	release_console_sem();
1138	}
1139	EXPORT_SYMBOL(console_stop);
1140
1141	void console_start(struct console *console)
1142	{
1143	acquire_console_sem();
1144	console->flags \|= CON_ENABLED;
1145	release_console_sem();
1146	}
1147	EXPORT_SYMBOL(console_start);
1148
1149	/*
1150	* The console driver calls this routine during kernel initialization
1151	* to register the console printing procedure with printk() and to
1152	* print any messages that were printed by the kernel before the
1153	* console driver was initialized.
1154	*
1155	* This can happen pretty early during the boot process (because of
1156	* early_printk) - sometimes before setup_arch() completes - be careful
1157	* of what kernel features are used - they may not be initialised yet.
1158	*
1159	* There are two types of consoles - bootconsoles (early_printk) and
1160	* "real" consoles (everything which is not a bootconsole) which are
1161	* handled differently.
1162	* - Any number of bootconsoles can be registered at any time.
1163	* - As soon as a "real" console is registered, all bootconsoles
1164	* will be unregistered automatically.
1165	* - Once a "real" console is registered, any attempt to register a
1166	* bootconsoles will be rejected
1167	*/
1168	void register_console(struct console *newcon)
1169	{
1170	int i;
1171	unsigned long flags;
1172	struct console *bcon = NULL;
1173
1174	/*
1175	* before we register a new CON_BOOT console, make sure we don't
1176	* already have a valid console
1177	*/
1178	if (console_drivers && newcon->flags & CON_BOOT) {
1179	/* find the last or real console */
1180	for_each_console(bcon) {
1181	if (!(bcon->flags & CON_BOOT)) {
1182	printk(KERN_INFO "Too late to register bootconsole %s%d\n",
1183	newcon->name, newcon->index);
1184	return;
1185	}
1186	}
1187	}
1188
1189	if (console_drivers && console_drivers->flags & CON_BOOT)
1190	bcon = console_drivers;
1191
1192	if (preferred_console < 0 \|\| bcon \|\| !console_drivers)
1193	preferred_console = selected_console;
1194
1195	if (newcon->early_setup)
1196	newcon->early_setup();
1197
1198	/*
1199	* See if we want to use this console driver. If we
1200	* didn't select a console we take the first one
1201	* that registers here.
1202	*/
1203	if (preferred_console < 0) {
1204	if (newcon->index < 0)
1205	newcon->index = 0;
1206	if (newcon->setup == NULL \|\|
1207	newcon->setup(newcon, NULL) == 0) {
1208	newcon->flags \|= CON_ENABLED;
1209	if (newcon->device) {
1210	newcon->flags \|= CON_CONSDEV;
1211	preferred_console = 0;
1212	}
1213	}
1214	}
1215
1216	/*
1217	* See if this console matches one we selected on
1218	* the command line.
1219	*/
1220	for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];
1221	i++) {
1222	if (strcmp(console_cmdline[i].name, newcon->name) != 0)
1223	continue;
1224	if (newcon->index >= 0 &&
1225	newcon->index != console_cmdline[i].index)
1226	continue;
1227	if (newcon->index < 0)
1228	newcon->index = console_cmdline[i].index;
1229	#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1230	if (console_cmdline[i].brl_options) {
1231	newcon->flags \|= CON_BRL;
1232	braille_register_console(newcon,
1233	console_cmdline[i].index,
1234	console_cmdline[i].options,
1235	console_cmdline[i].brl_options);
1236	return;
1237	}
1238	#endif
1239	if (newcon->setup &&
1240	newcon->setup(newcon, console_cmdline[i].options) != 0)
1241	break;
1242	newcon->flags \|= CON_ENABLED;
1243	newcon->index = console_cmdline[i].index;
1244	if (i == selected_console) {
1245	newcon->flags \|= CON_CONSDEV;
1246	preferred_console = selected_console;
1247	}
1248	break;
1249	}
1250
1251	if (!(newcon->flags & CON_ENABLED))
1252	return;
1253
1254	/*
1255	* If we have a bootconsole, and are switching to a real console,
1256	* don't print everything out again, since when the boot console, and
1257	* the real console are the same physical device, it's annoying to
1258	* see the beginning boot messages twice
1259	*/
1260	if (bcon && ((newcon->flags & (CON_CONSDEV \| CON_BOOT)) == CON_CONSDEV))
1261	newcon->flags &= ~CON_PRINTBUFFER;
1262
1263	/*
1264	* Put this console in the list - keep the
1265	* preferred driver at the head of the list.
1266	*/
1267	acquire_console_sem();
1268	if ((newcon->flags & CON_CONSDEV) \|\| console_drivers == NULL) {
1269	newcon->next = console_drivers;
1270	console_drivers = newcon;
1271	if (newcon->next)
1272	newcon->next->flags &= ~CON_CONSDEV;
1273	} else {
1274	newcon->next = console_drivers->next;
1275	console_drivers->next = newcon;
1276	}
1277	if (newcon->flags & CON_PRINTBUFFER) {
1278	/*
1279	* release_console_sem() will print out the buffered messages
1280	* for us.
1281	*/
1282	spin_lock_irqsave(&logbuf_lock, flags);
1283	con_start = log_start;
1284	spin_unlock_irqrestore(&logbuf_lock, flags);
1285	}
1286	release_console_sem();
1287
1288	/*
1289	* By unregistering the bootconsoles after we enable the real console
1290	* we get the "console xxx enabled" message on all the consoles -
1291	* boot consoles, real consoles, etc - this is to ensure that end
1292	* users know there might be something in the kernel's log buffer that
1293	* went to the bootconsole (that they do not see on the real console)
1294	*/
1295	if (bcon && ((newcon->flags & (CON_CONSDEV \| CON_BOOT)) == CON_CONSDEV)) {
1296	/* we need to iterate through twice, to make sure we print
1297	* everything out, before we unregister the console(s)
1298	*/
1299	printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled\n",
1300	newcon->name, newcon->index);
1301	for_each_console(bcon)
1302	if (bcon->flags & CON_BOOT)
1303	unregister_console(bcon);
1304	} else {
1305	printk(KERN_INFO "%sconsole [%s%d] enabled\n",
1306	(newcon->flags & CON_BOOT) ? "boot" : "" ,
1307	newcon->name, newcon->index);
1308	}
1309	}
1310	EXPORT_SYMBOL(register_console);
1311
1312	int unregister_console(struct console *console)
1313	{
1314	struct console a, b;
1315	int res = 1;
1316
1317	#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1318	if (console->flags & CON_BRL)
1319	return braille_unregister_console(console);
1320	#endif
1321
1322	acquire_console_sem();
1323	if (console_drivers == console) {
1324	console_drivers=console->next;
1325	res = 0;
1326	} else if (console_drivers) {
1327	for (a=console_drivers->next, b=console_drivers ;
1328	a; b=a, a=b->next) {
1329	if (a == console) {
1330	b->next = a->next;
1331	res = 0;
1332	break;
1333	}
1334	}
1335	}
1336
1337	/*
1338	* If this isn't the last console and it has CON_CONSDEV set, we
1339	* need to set it on the next preferred console.
1340	*/
1341	if (console_drivers != NULL && console->flags & CON_CONSDEV)
1342	console_drivers->flags \|= CON_CONSDEV;
1343
1344	release_console_sem();
1345	return res;
1346	}
1347	EXPORT_SYMBOL(unregister_console);
1348
1349	static int __init disable_boot_consoles(void)
1350	{
1351	struct console *con;
1352
1353	for_each_console(con) {
1354	if (con->flags & CON_BOOT) {
1355	printk(KERN_INFO "turn off boot console %s%d\n",
1356	con->name, con->index);
1357	unregister_console(con);
1358	}
1359	}
1360	return 0;
1361	}
1362	late_initcall(disable_boot_consoles);
1363
1364	#if defined CONFIG_PRINTK
1365
1366	/*
1367	* printk rate limiting, lifted from the networking subsystem.
1368	*
1369	* This enforces a rate limit: not more than 10 kernel messages
1370	* every 5s to make a denial-of-service attack impossible.
1371	*/
1372	DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
1373
1374	int __printk_ratelimit(const char *func)
1375	{
1376	return ___ratelimit(&printk_ratelimit_state, func);
1377	}
1378	EXPORT_SYMBOL(__printk_ratelimit);
1379
1380	/**
1381	* printk_timed_ratelimit - caller-controlled printk ratelimiting
1382	* @caller_jiffies: pointer to caller's state
1383	* @interval_msecs: minimum interval between prints
1384	*
1385	* printk_timed_ratelimit() returns true if more than @interval_msecs
1386	* milliseconds have elapsed since the last time printk_timed_ratelimit()
1387	* returned true.
1388	*/
1389	bool printk_timed_ratelimit(unsigned long *caller_jiffies,
1390	unsigned int interval_msecs)
1391	{
1392	if (*caller_jiffies == 0
1393	\|\| !time_in_range(jiffies, *caller_jiffies,
1394	*caller_jiffies
1395	+ msecs_to_jiffies(interval_msecs))) {
1396	*caller_jiffies = jiffies;
1397	return true;
1398	}
1399	return false;
1400	}
1401	EXPORT_SYMBOL(printk_timed_ratelimit);
1402
1403	static DEFINE_SPINLOCK(dump_list_lock);
1404	static LIST_HEAD(dump_list);
1405
1406	/**
1407	* kmsg_dump_register - register a kernel log dumper.
1408	* @dumper: pointer to the kmsg_dumper structure
1409	*
1410	* Adds a kernel log dumper to the system. The dump callback in the
1411	* structure will be called when the kernel oopses or panics and must be
1412	* set. Returns zero on success and %-EINVAL or %-EBUSY otherwise.
1413	*/
1414	int kmsg_dump_register(struct kmsg_dumper *dumper)
1415	{
1416	unsigned long flags;
1417	int err = -EBUSY;
1418
1419	/* The dump callback needs to be set */
1420	if (!dumper->dump)
1421	return -EINVAL;
1422
1423	spin_lock_irqsave(&dump_list_lock, flags);
1424	/* Don't allow registering multiple times */
1425	if (!dumper->registered) {
1426	dumper->registered = 1;
1427	list_add_tail(&dumper->list, &dump_list);
1428	err = 0;
1429	}
1430	spin_unlock_irqrestore(&dump_list_lock, flags);
1431
1432	return err;
1433	}
1434	EXPORT_SYMBOL_GPL(kmsg_dump_register);
1435
1436	/**
1437	* kmsg_dump_unregister - unregister a kmsg dumper.
1438	* @dumper: pointer to the kmsg_dumper structure
1439	*
1440	* Removes a dump device from the system. Returns zero on success and
1441	* %-EINVAL otherwise.
1442	*/
1443	int kmsg_dump_unregister(struct kmsg_dumper *dumper)
1444	{
1445	unsigned long flags;
1446	int err = -EINVAL;
1447
1448	spin_lock_irqsave(&dump_list_lock, flags);
1449	if (dumper->registered) {
1450	dumper->registered = 0;
1451	list_del(&dumper->list);
1452	err = 0;
1453	}
1454	spin_unlock_irqrestore(&dump_list_lock, flags);
1455
1456	return err;
1457	}
1458	EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
1459
1460	static const char const *kmsg_reasons[] = {
1461	[KMSG_DUMP_OOPS] = "oops",
1462	[KMSG_DUMP_PANIC] = "panic",
1463	[KMSG_DUMP_KEXEC] = "kexec",
1464	};
1465
1466	static const char *kmsg_to_str(enum kmsg_dump_reason reason)
1467	{
1468	if (reason >= ARRAY_SIZE(kmsg_reasons) \|\| reason < 0)
1469	return "unknown";
1470
1471	return kmsg_reasons[reason];
1472	}
1473
1474	/**
1475	* kmsg_dump - dump kernel log to kernel message dumpers.
1476	* @reason: the reason (oops, panic etc) for dumping
1477	*
1478	* Iterate through each of the dump devices and call the oops/panic
1479	* callbacks with the log buffer.
1480	*/
1481	void kmsg_dump(enum kmsg_dump_reason reason)
1482	{
1483	unsigned long end;
1484	unsigned chars;
1485	struct kmsg_dumper *dumper;
1486	const char s1, s2;
1487	unsigned long l1, l2;
1488	unsigned long flags;
1489
1490	/* Theoretically, the log could move on after we do this, but
1491	there's not a lot we can do about that. The new messages
1492	will overwrite the start of what we dump. */
1493	spin_lock_irqsave(&logbuf_lock, flags);
1494	end = log_end & LOG_BUF_MASK;
1495	chars = logged_chars;
1496	spin_unlock_irqrestore(&logbuf_lock, flags);
1497
1498	if (logged_chars > end) {
1499	s1 = log_buf + log_buf_len - logged_chars + end;
1500	l1 = logged_chars - end;
1501
1502	s2 = log_buf;
1503	l2 = end;
1504	} else {
1505	s1 = "";
1506	l1 = 0;
1507
1508	s2 = log_buf + end - logged_chars;
1509	l2 = logged_chars;
1510	}
1511
1512	if (!spin_trylock_irqsave(&dump_list_lock, flags)) {
1513	printk(KERN_ERR "dump_kmsg: dump list lock is held during %s, skipping dump\n",
1514	kmsg_to_str(reason));
1515	return;
1516	}
1517	list_for_each_entry(dumper, &dump_list, list)
1518	dumper->dump(dumper, reason, s1, l1, s2, l2);
1519	spin_unlock_irqrestore(&dump_list_lock, flags);
1520	}
1521	#endif
1522

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/kernel/printk.c

interactive