]> www.pilppa.org Git - linux-2.6-omap-h63xx.git/blob - kernel/printk.c
Merge omap-drivers
[linux-2.6-omap-h63xx.git] / 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 <andrewm@uow.edu.au>
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/smp_lock.h>
24 #include <linux/console.h>
25 #include <linux/init.h>
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <linux/interrupt.h>                    /* For in_interrupt() */
29 #include <linux/delay.h>
30 #include <linux/smp.h>
31 #include <linux/security.h>
32 #include <linux/bootmem.h>
33 #include <linux/syscalls.h>
34 #include <linux/jiffies.h>
35
36 #include <asm/uaccess.h>
37
38 #define __LOG_BUF_LEN   (1 << CONFIG_LOG_BUF_SHIFT)
39
40 #ifdef        CONFIG_DEBUG_LL
41 extern void printascii(char *);
42 #endif
43
44 /* printk's without a loglevel use this.. */
45 #define DEFAULT_MESSAGE_LOGLEVEL 4 /* KERN_WARNING */
46
47 /* We show everything that is MORE important than this.. */
48 #define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */
49 #define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG */
50
51 DECLARE_WAIT_QUEUE_HEAD(log_wait);
52
53 int console_printk[4] = {
54         DEFAULT_CONSOLE_LOGLEVEL,       /* console_loglevel */
55         DEFAULT_MESSAGE_LOGLEVEL,       /* default_message_loglevel */
56         MINIMUM_CONSOLE_LOGLEVEL,       /* minimum_console_loglevel */
57         DEFAULT_CONSOLE_LOGLEVEL,       /* default_console_loglevel */
58 };
59
60 /*
61  * Low level drivers may need that to know if they can schedule in
62  * their unblank() callback or not. So let's export it.
63  */
64 int oops_in_progress;
65 EXPORT_SYMBOL(oops_in_progress);
66
67 /*
68  * console_sem protects the console_drivers list, and also
69  * provides serialisation for access to the entire console
70  * driver system.
71  */
72 static DECLARE_MUTEX(console_sem);
73 static DECLARE_MUTEX(secondary_console_sem);
74 struct console *console_drivers;
75 /*
76  * This is used for debugging the mess that is the VT code by
77  * keeping track if we have the console semaphore held. It's
78  * definitely not the perfect debug tool (we don't know if _WE_
79  * hold it are racing, but it helps tracking those weird code
80  * path in the console code where we end up in places I want
81  * locked without the console sempahore held
82  */
83 static int console_locked, console_suspended;
84
85 /*
86  * logbuf_lock protects log_buf, log_start, log_end, con_start and logged_chars
87  * It is also used in interesting ways to provide interlocking in
88  * release_console_sem().
89  */
90 static DEFINE_SPINLOCK(logbuf_lock);
91
92 #define LOG_BUF_MASK    (log_buf_len-1)
93 #define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
94
95 /*
96  * The indices into log_buf are not constrained to log_buf_len - they
97  * must be masked before subscripting
98  */
99 static unsigned long log_start; /* Index into log_buf: next char to be read by syslog() */
100 static unsigned long con_start; /* Index into log_buf: next char to be sent to consoles */
101 static unsigned long log_end;   /* Index into log_buf: most-recently-written-char + 1 */
102
103 /*
104  *      Array of consoles built from command line options (console=)
105  */
106 struct console_cmdline
107 {
108         char    name[8];                        /* Name of the driver       */
109         int     index;                          /* Minor dev. to use        */
110         char    *options;                       /* Options for the driver   */
111 };
112
113 #define MAX_CMDLINECONSOLES 8
114
115 static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
116 static int selected_console = -1;
117 static int preferred_console = -1;
118
119 /* Flag: console code may call schedule() */
120 static int console_may_schedule;
121
122 #ifdef CONFIG_PRINTK
123
124 static char __log_buf[__LOG_BUF_LEN];
125 static char *log_buf = __log_buf;
126 static int log_buf_len = __LOG_BUF_LEN;
127 static unsigned long logged_chars; /* Number of chars produced since last read+clear operation */
128
129 static int __init log_buf_len_setup(char *str)
130 {
131         unsigned long size = memparse(str, &str);
132         unsigned long flags;
133
134         if (size)
135                 size = roundup_pow_of_two(size);
136         if (size > log_buf_len) {
137                 unsigned long start, dest_idx, offset;
138                 char *new_log_buf;
139
140                 new_log_buf = alloc_bootmem(size);
141                 if (!new_log_buf) {
142                         printk(KERN_WARNING "log_buf_len: allocation failed\n");
143                         goto out;
144                 }
145
146                 spin_lock_irqsave(&logbuf_lock, flags);
147                 log_buf_len = size;
148                 log_buf = new_log_buf;
149
150                 offset = start = min(con_start, log_start);
151                 dest_idx = 0;
152                 while (start != log_end) {
153                         log_buf[dest_idx] = __log_buf[start & (__LOG_BUF_LEN - 1)];
154                         start++;
155                         dest_idx++;
156                 }
157                 log_start -= offset;
158                 con_start -= offset;
159                 log_end -= offset;
160                 spin_unlock_irqrestore(&logbuf_lock, flags);
161
162                 printk(KERN_NOTICE "log_buf_len: %d\n", log_buf_len);
163         }
164 out:
165         return 1;
166 }
167
168 __setup("log_buf_len=", log_buf_len_setup);
169
170 /*
171  * Commands to do_syslog:
172  *
173  *      0 -- Close the log.  Currently a NOP.
174  *      1 -- Open the log. Currently a NOP.
175  *      2 -- Read from the log.
176  *      3 -- Read all messages remaining in the ring buffer.
177  *      4 -- Read and clear all messages remaining in the ring buffer
178  *      5 -- Clear ring buffer.
179  *      6 -- Disable printk's to console
180  *      7 -- Enable printk's to console
181  *      8 -- Set level of messages printed to console
182  *      9 -- Return number of unread characters in the log buffer
183  *     10 -- Return size of the log buffer
184  */
185 int do_syslog(int type, char __user *buf, int len)
186 {
187         unsigned long i, j, limit, count;
188         int do_clear = 0;
189         char c;
190         int error = 0;
191
192         error = security_syslog(type);
193         if (error)
194                 return error;
195
196         switch (type) {
197         case 0:         /* Close log */
198                 break;
199         case 1:         /* Open log */
200                 break;
201         case 2:         /* Read from log */
202                 error = -EINVAL;
203                 if (!buf || len < 0)
204                         goto out;
205                 error = 0;
206                 if (!len)
207                         goto out;
208                 if (!access_ok(VERIFY_WRITE, buf, len)) {
209                         error = -EFAULT;
210                         goto out;
211                 }
212                 error = wait_event_interruptible(log_wait,
213                                                         (log_start - log_end));
214                 if (error)
215                         goto out;
216                 i = 0;
217                 spin_lock_irq(&logbuf_lock);
218                 while (!error && (log_start != log_end) && i < len) {
219                         c = LOG_BUF(log_start);
220                         log_start++;
221                         spin_unlock_irq(&logbuf_lock);
222                         error = __put_user(c,buf);
223                         buf++;
224                         i++;
225                         cond_resched();
226                         spin_lock_irq(&logbuf_lock);
227                 }
228                 spin_unlock_irq(&logbuf_lock);
229                 if (!error)
230                         error = i;
231                 break;
232         case 4:         /* Read/clear last kernel messages */
233                 do_clear = 1;
234                 /* FALL THRU */
235         case 3:         /* Read last kernel messages */
236                 error = -EINVAL;
237                 if (!buf || len < 0)
238                         goto out;
239                 error = 0;
240                 if (!len)
241                         goto out;
242                 if (!access_ok(VERIFY_WRITE, buf, len)) {
243                         error = -EFAULT;
244                         goto out;
245                 }
246                 count = len;
247                 if (count > log_buf_len)
248                         count = log_buf_len;
249                 spin_lock_irq(&logbuf_lock);
250                 if (count > logged_chars)
251                         count = logged_chars;
252                 if (do_clear)
253                         logged_chars = 0;
254                 limit = log_end;
255                 /*
256                  * __put_user() could sleep, and while we sleep
257                  * printk() could overwrite the messages
258                  * we try to copy to user space. Therefore
259                  * the messages are copied in reverse. <manfreds>
260                  */
261                 for (i = 0; i < count && !error; i++) {
262                         j = limit-1-i;
263                         if (j + log_buf_len < log_end)
264                                 break;
265                         c = LOG_BUF(j);
266                         spin_unlock_irq(&logbuf_lock);
267                         error = __put_user(c,&buf[count-1-i]);
268                         cond_resched();
269                         spin_lock_irq(&logbuf_lock);
270                 }
271                 spin_unlock_irq(&logbuf_lock);
272                 if (error)
273                         break;
274                 error = i;
275                 if (i != count) {
276                         int offset = count-error;
277                         /* buffer overflow during copy, correct user buffer. */
278                         for (i = 0; i < error; i++) {
279                                 if (__get_user(c,&buf[i+offset]) ||
280                                     __put_user(c,&buf[i])) {
281                                         error = -EFAULT;
282                                         break;
283                                 }
284                                 cond_resched();
285                         }
286                 }
287                 break;
288         case 5:         /* Clear ring buffer */
289                 logged_chars = 0;
290                 break;
291         case 6:         /* Disable logging to console */
292                 console_loglevel = minimum_console_loglevel;
293                 break;
294         case 7:         /* Enable logging to console */
295                 console_loglevel = default_console_loglevel;
296                 break;
297         case 8:         /* Set level of messages printed to console */
298                 error = -EINVAL;
299                 if (len < 1 || len > 8)
300                         goto out;
301                 if (len < minimum_console_loglevel)
302                         len = minimum_console_loglevel;
303                 console_loglevel = len;
304                 error = 0;
305                 break;
306         case 9:         /* Number of chars in the log buffer */
307                 error = log_end - log_start;
308                 break;
309         case 10:        /* Size of the log buffer */
310                 error = log_buf_len;
311                 break;
312         default:
313                 error = -EINVAL;
314                 break;
315         }
316 out:
317         return error;
318 }
319
320 asmlinkage long sys_syslog(int type, char __user *buf, int len)
321 {
322         return do_syslog(type, buf, len);
323 }
324
325 /*
326  * Call the console drivers on a range of log_buf
327  */
328 static void __call_console_drivers(unsigned long start, unsigned long end)
329 {
330         struct console *con;
331
332         for (con = console_drivers; con; con = con->next) {
333                 if ((con->flags & CON_ENABLED) && con->write &&
334                                 (cpu_online(smp_processor_id()) ||
335                                 (con->flags & CON_ANYTIME)))
336                         con->write(con, &LOG_BUF(start), end - start);
337         }
338 }
339
340 static int __read_mostly ignore_loglevel;
341
342 static int __init ignore_loglevel_setup(char *str)
343 {
344         ignore_loglevel = 1;
345         printk(KERN_INFO "debug: ignoring loglevel setting.\n");
346
347         return 1;
348 }
349
350 __setup("ignore_loglevel", ignore_loglevel_setup);
351
352 /*
353  * Write out chars from start to end - 1 inclusive
354  */
355 static void _call_console_drivers(unsigned long start,
356                                 unsigned long end, int msg_log_level)
357 {
358         if ((msg_log_level < console_loglevel || ignore_loglevel) &&
359                         console_drivers && start != end) {
360                 if ((start & LOG_BUF_MASK) > (end & LOG_BUF_MASK)) {
361                         /* wrapped write */
362                         __call_console_drivers(start & LOG_BUF_MASK,
363                                                 log_buf_len);
364                         __call_console_drivers(0, end & LOG_BUF_MASK);
365                 } else {
366                         __call_console_drivers(start, end);
367                 }
368         }
369 }
370
371 /*
372  * Call the console drivers, asking them to write out
373  * log_buf[start] to log_buf[end - 1].
374  * The console_sem must be held.
375  */
376 static void call_console_drivers(unsigned long start, unsigned long end)
377 {
378         unsigned long cur_index, start_print;
379         static int msg_level = -1;
380
381         BUG_ON(((long)(start - end)) > 0);
382
383         cur_index = start;
384         start_print = start;
385         while (cur_index != end) {
386                 if (msg_level < 0 && ((end - cur_index) > 2) &&
387                                 LOG_BUF(cur_index + 0) == '<' &&
388                                 LOG_BUF(cur_index + 1) >= '0' &&
389                                 LOG_BUF(cur_index + 1) <= '7' &&
390                                 LOG_BUF(cur_index + 2) == '>') {
391                         msg_level = LOG_BUF(cur_index + 1) - '0';
392                         cur_index += 3;
393                         start_print = cur_index;
394                 }
395                 while (cur_index != end) {
396                         char c = LOG_BUF(cur_index);
397
398                         cur_index++;
399                         if (c == '\n') {
400                                 if (msg_level < 0) {
401                                         /*
402                                          * printk() has already given us loglevel tags in
403                                          * the buffer.  This code is here in case the
404                                          * log buffer has wrapped right round and scribbled
405                                          * on those tags
406                                          */
407                                         msg_level = default_message_loglevel;
408                                 }
409                                 _call_console_drivers(start_print, cur_index, msg_level);
410                                 msg_level = -1;
411                                 start_print = cur_index;
412                                 break;
413                         }
414                 }
415         }
416         _call_console_drivers(start_print, end, msg_level);
417 }
418
419 static void emit_log_char(char c)
420 {
421         LOG_BUF(log_end) = c;
422         log_end++;
423         if (log_end - log_start > log_buf_len)
424                 log_start = log_end - log_buf_len;
425         if (log_end - con_start > log_buf_len)
426                 con_start = log_end - log_buf_len;
427         if (logged_chars < log_buf_len)
428                 logged_chars++;
429 }
430
431 /*
432  * Zap console related locks when oopsing. Only zap at most once
433  * every 10 seconds, to leave time for slow consoles to print a
434  * full oops.
435  */
436 static void zap_locks(void)
437 {
438         static unsigned long oops_timestamp;
439
440         if (time_after_eq(jiffies, oops_timestamp) &&
441                         !time_after(jiffies, oops_timestamp + 30 * HZ))
442                 return;
443
444         oops_timestamp = jiffies;
445
446         /* If a crash is occurring, make sure we can't deadlock */
447         spin_lock_init(&logbuf_lock);
448         /* And make sure that we print immediately */
449         init_MUTEX(&console_sem);
450 }
451
452 static int printk_time = 0;
453
454 #ifdef CONFIG_PRINTK_TIME
455
456 /*
457  * Initialize printk time. Note that on some systems sched_clock()
458  * does not work until timer is initialized.
459  */
460 static int __init printk_time_init(void)
461 {
462         printk_time = 1;
463
464         return 0;
465 }
466 subsys_initcall(printk_time_init);
467
468 #else
469
470 static int __init printk_time_setup(char *str)
471 {
472         if (*str)
473                 return 0;
474         printk_time = 1;
475         return 1;
476 }
477
478 __setup("time", printk_time_setup);
479
480 #endif
481
482 __attribute__((weak)) unsigned long long printk_clock(void)
483 {
484         return sched_clock();
485 }
486
487 /* Check if we have any console registered that can be called early in boot. */
488 static int have_callable_console(void)
489 {
490         struct console *con;
491
492         for (con = console_drivers; con; con = con->next)
493                 if (con->flags & CON_ANYTIME)
494                         return 1;
495
496         return 0;
497 }
498
499 /**
500  * printk - print a kernel message
501  * @fmt: format string
502  *
503  * This is printk().  It can be called from any context.  We want it to work.
504  *
505  * We try to grab the console_sem.  If we succeed, it's easy - we log the output and
506  * call the console drivers.  If we fail to get the semaphore we place the output
507  * into the log buffer and return.  The current holder of the console_sem will
508  * notice the new output in release_console_sem() and will send it to the
509  * consoles before releasing the semaphore.
510  *
511  * One effect of this deferred printing is that code which calls printk() and
512  * then changes console_loglevel may break. This is because console_loglevel
513  * is inspected when the actual printing occurs.
514  *
515  * See also:
516  * printf(3)
517  */
518
519 asmlinkage int printk(const char *fmt, ...)
520 {
521         va_list args;
522         int r;
523
524         va_start(args, fmt);
525         r = vprintk(fmt, args);
526         va_end(args);
527
528         return r;
529 }
530
531 /* cpu currently holding logbuf_lock */
532 static volatile unsigned int printk_cpu = UINT_MAX;
533
534 asmlinkage int vprintk(const char *fmt, va_list args)
535 {
536         unsigned long flags;
537         int printed_len;
538         char *p;
539         static char printk_buf[1024];
540         static int log_level_unknown = 1;
541
542         preempt_disable();
543         if (unlikely(oops_in_progress) && printk_cpu == smp_processor_id())
544                 /* If a crash is occurring during printk() on this CPU,
545                  * make sure we can't deadlock */
546                 zap_locks();
547
548         /* This stops the holder of console_sem just where we want him */
549         raw_local_irq_save(flags);
550         lockdep_off();
551         spin_lock(&logbuf_lock);
552         printk_cpu = smp_processor_id();
553
554         /* Emit the output into the temporary buffer */
555         printed_len = vscnprintf(printk_buf, sizeof(printk_buf), fmt, args);
556
557 #ifdef  CONFIG_DEBUG_LL
558         printascii(printk_buf);
559 #endif
560
561         /*
562          * Copy the output into log_buf.  If the caller didn't provide
563          * appropriate log level tags, we insert them here
564          */
565         for (p = printk_buf; *p; p++) {
566                 if (log_level_unknown) {
567                         /* log_level_unknown signals the start of a new line */
568                         if (printk_time) {
569                                 int loglev_char;
570                                 char tbuf[50], *tp;
571                                 unsigned tlen;
572                                 unsigned long long t;
573                                 unsigned long nanosec_rem;
574
575                                 /*
576                                  * force the log level token to be
577                                  * before the time output.
578                                  */
579                                 if (p[0] == '<' && p[1] >='0' &&
580                                    p[1] <= '7' && p[2] == '>') {
581                                         loglev_char = p[1];
582                                         p += 3;
583                                         printed_len -= 3;
584                                 } else {
585                                         loglev_char = default_message_loglevel
586                                                 + '0';
587                                 }
588                                 t = printk_clock();
589                                 nanosec_rem = do_div(t, 1000000000);
590                                 tlen = sprintf(tbuf,
591                                                 "<%c>[%5lu.%06lu] ",
592                                                 loglev_char,
593                                                 (unsigned long)t,
594                                                 nanosec_rem/1000);
595
596                                 for (tp = tbuf; tp < tbuf + tlen; tp++)
597                                         emit_log_char(*tp);
598                                 printed_len += tlen;
599                         } else {
600                                 if (p[0] != '<' || p[1] < '0' ||
601                                    p[1] > '7' || p[2] != '>') {
602                                         emit_log_char('<');
603                                         emit_log_char(default_message_loglevel
604                                                 + '0');
605                                         emit_log_char('>');
606                                         printed_len += 3;
607                                 }
608                         }
609                         log_level_unknown = 0;
610                         if (!*p)
611                                 break;
612                 }
613                 emit_log_char(*p);
614                 if (*p == '\n')
615                         log_level_unknown = 1;
616         }
617
618         if (!down_trylock(&console_sem)) {
619                 /*
620                  * We own the drivers.  We can drop the spinlock and
621                  * let release_console_sem() print the text, maybe ...
622                  */
623                 console_locked = 1;
624                 printk_cpu = UINT_MAX;
625                 spin_unlock(&logbuf_lock);
626
627                 /*
628                  * Console drivers may assume that per-cpu resources have
629                  * been allocated. So unless they're explicitly marked as
630                  * being able to cope (CON_ANYTIME) don't call them until
631                  * this CPU is officially up.
632                  */
633                 if (cpu_online(smp_processor_id()) || have_callable_console()) {
634                         console_may_schedule = 0;
635                         release_console_sem();
636                 } else {
637                         /* Release by hand to avoid flushing the buffer. */
638                         console_locked = 0;
639                         up(&console_sem);
640                 }
641                 lockdep_on();
642                 raw_local_irq_restore(flags);
643         } else {
644                 /*
645                  * Someone else owns the drivers.  We drop the spinlock, which
646                  * allows the semaphore holder to proceed and to call the
647                  * console drivers with the output which we just produced.
648                  */
649                 printk_cpu = UINT_MAX;
650                 spin_unlock(&logbuf_lock);
651                 lockdep_on();
652                 raw_local_irq_restore(flags);
653         }
654
655         preempt_enable();
656         return printed_len;
657 }
658 EXPORT_SYMBOL(printk);
659 EXPORT_SYMBOL(vprintk);
660
661 #else
662
663 asmlinkage long sys_syslog(int type, char __user *buf, int len)
664 {
665         return -ENOSYS;
666 }
667
668 static void call_console_drivers(unsigned long start, unsigned long end)
669 {
670 }
671
672 #endif
673
674 /*
675  * Set up a list of consoles.  Called from init/main.c
676  */
677 static int __init console_setup(char *str)
678 {
679         char name[sizeof(console_cmdline[0].name)];
680         char *s, *options;
681         int idx;
682
683         /*
684          * Decode str into name, index, options.
685          */
686         if (str[0] >= '0' && str[0] <= '9') {
687                 strcpy(name, "ttyS");
688                 strncpy(name + 4, str, sizeof(name) - 5);
689         } else {
690                 strncpy(name, str, sizeof(name) - 1);
691         }
692         name[sizeof(name) - 1] = 0;
693         if ((options = strchr(str, ',')) != NULL)
694                 *(options++) = 0;
695 #ifdef __sparc__
696         if (!strcmp(str, "ttya"))
697                 strcpy(name, "ttyS0");
698         if (!strcmp(str, "ttyb"))
699                 strcpy(name, "ttyS1");
700 #endif
701         for (s = name; *s; s++)
702                 if ((*s >= '0' && *s <= '9') || *s == ',')
703                         break;
704         idx = simple_strtoul(s, NULL, 10);
705         *s = 0;
706
707         add_preferred_console(name, idx, options);
708         return 1;
709 }
710 __setup("console=", console_setup);
711
712 /**
713  * add_preferred_console - add a device to the list of preferred consoles.
714  * @name: device name
715  * @idx: device index
716  * @options: options for this console
717  *
718  * The last preferred console added will be used for kernel messages
719  * and stdin/out/err for init.  Normally this is used by console_setup
720  * above to handle user-supplied console arguments; however it can also
721  * be used by arch-specific code either to override the user or more
722  * commonly to provide a default console (ie from PROM variables) when
723  * the user has not supplied one.
724  */
725 int __init add_preferred_console(char *name, int idx, char *options)
726 {
727         struct console_cmdline *c;
728         int i;
729
730         /*
731          *      See if this tty is not yet registered, and
732          *      if we have a slot free.
733          */
734         for(i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
735                 if (strcmp(console_cmdline[i].name, name) == 0 &&
736                           console_cmdline[i].index == idx) {
737                                 selected_console = i;
738                                 return 0;
739                 }
740         if (i == MAX_CMDLINECONSOLES)
741                 return -E2BIG;
742         selected_console = i;
743         c = &console_cmdline[i];
744         memcpy(c->name, name, sizeof(c->name));
745         c->name[sizeof(c->name) - 1] = 0;
746         c->options = options;
747         c->index = idx;
748         return 0;
749 }
750
751 #ifndef CONFIG_DISABLE_CONSOLE_SUSPEND
752 /**
753  * suspend_console - suspend the console subsystem
754  *
755  * This disables printk() while we go into suspend states
756  */
757 void suspend_console(void)
758 {
759         printk("Suspending console(s)\n");
760         acquire_console_sem();
761         console_suspended = 1;
762 }
763
764 void resume_console(void)
765 {
766         console_suspended = 0;
767         release_console_sem();
768 }
769 #endif /* CONFIG_DISABLE_CONSOLE_SUSPEND */
770
771 /**
772  * acquire_console_sem - lock the console system for exclusive use.
773  *
774  * Acquires a semaphore which guarantees that the caller has
775  * exclusive access to the console system and the console_drivers list.
776  *
777  * Can sleep, returns nothing.
778  */
779 void acquire_console_sem(void)
780 {
781         BUG_ON(in_interrupt());
782         if (console_suspended) {
783                 down(&secondary_console_sem);
784                 return;
785         }
786         down(&console_sem);
787         console_locked = 1;
788         console_may_schedule = 1;
789 }
790 EXPORT_SYMBOL(acquire_console_sem);
791
792 int try_acquire_console_sem(void)
793 {
794         if (down_trylock(&console_sem))
795                 return -1;
796         console_locked = 1;
797         console_may_schedule = 0;
798         return 0;
799 }
800 EXPORT_SYMBOL(try_acquire_console_sem);
801
802 int is_console_locked(void)
803 {
804         return console_locked;
805 }
806
807 void wake_up_klogd(void)
808 {
809         if (!oops_in_progress && waitqueue_active(&log_wait))
810                 wake_up_interruptible(&log_wait);
811 }
812
813 /**
814  * release_console_sem - unlock the console system
815  *
816  * Releases the semaphore which the caller holds on the console system
817  * and the console driver list.
818  *
819  * While the semaphore was held, console output may have been buffered
820  * by printk().  If this is the case, release_console_sem() emits
821  * the output prior to releasing the semaphore.
822  *
823  * If there is output waiting for klogd, we wake it up.
824  *
825  * release_console_sem() may be called from any context.
826  */
827 void release_console_sem(void)
828 {
829         unsigned long flags;
830         unsigned long _con_start, _log_end;
831         unsigned long wake_klogd = 0;
832
833         if (console_suspended) {
834                 up(&secondary_console_sem);
835                 return;
836         }
837
838         console_may_schedule = 0;
839
840         for ( ; ; ) {
841                 spin_lock_irqsave(&logbuf_lock, flags);
842                 wake_klogd |= log_start - log_end;
843                 if (con_start == log_end)
844                         break;                  /* Nothing to print */
845                 _con_start = con_start;
846                 _log_end = log_end;
847                 con_start = log_end;            /* Flush */
848                 spin_unlock(&logbuf_lock);
849                 call_console_drivers(_con_start, _log_end);
850                 local_irq_restore(flags);
851         }
852         console_locked = 0;
853         up(&console_sem);
854         spin_unlock_irqrestore(&logbuf_lock, flags);
855         if (wake_klogd)
856                 wake_up_klogd();
857 }
858 EXPORT_SYMBOL(release_console_sem);
859
860 /**
861  * console_conditional_schedule - yield the CPU if required
862  *
863  * If the console code is currently allowed to sleep, and
864  * if this CPU should yield the CPU to another task, do
865  * so here.
866  *
867  * Must be called within acquire_console_sem().
868  */
869 void __sched console_conditional_schedule(void)
870 {
871         if (console_may_schedule)
872                 cond_resched();
873 }
874 EXPORT_SYMBOL(console_conditional_schedule);
875
876 void console_print(const char *s)
877 {
878         printk(KERN_EMERG "%s", s);
879 }
880 EXPORT_SYMBOL(console_print);
881
882 void console_unblank(void)
883 {
884         struct console *c;
885
886         /*
887          * console_unblank can no longer be called in interrupt context unless
888          * oops_in_progress is set to 1..
889          */
890         if (oops_in_progress) {
891                 if (down_trylock(&console_sem) != 0)
892                         return;
893         } else
894                 acquire_console_sem();
895
896         console_locked = 1;
897         console_may_schedule = 0;
898         for (c = console_drivers; c != NULL; c = c->next)
899                 if ((c->flags & CON_ENABLED) && c->unblank)
900                         c->unblank();
901         release_console_sem();
902 }
903
904 /*
905  * Return the console tty driver structure and its associated index
906  */
907 struct tty_driver *console_device(int *index)
908 {
909         struct console *c;
910         struct tty_driver *driver = NULL;
911
912         acquire_console_sem();
913         for (c = console_drivers; c != NULL; c = c->next) {
914                 if (!c->device)
915                         continue;
916                 driver = c->device(c, index);
917                 if (driver)
918                         break;
919         }
920         release_console_sem();
921         return driver;
922 }
923
924 /*
925  * Prevent further output on the passed console device so that (for example)
926  * serial drivers can disable console output before suspending a port, and can
927  * re-enable output afterwards.
928  */
929 void console_stop(struct console *console)
930 {
931         acquire_console_sem();
932         console->flags &= ~CON_ENABLED;
933         release_console_sem();
934 }
935 EXPORT_SYMBOL(console_stop);
936
937 void console_start(struct console *console)
938 {
939         acquire_console_sem();
940         console->flags |= CON_ENABLED;
941         release_console_sem();
942 }
943 EXPORT_SYMBOL(console_start);
944
945 /*
946  * The console driver calls this routine during kernel initialization
947  * to register the console printing procedure with printk() and to
948  * print any messages that were printed by the kernel before the
949  * console driver was initialized.
950  */
951 void register_console(struct console *console)
952 {
953         int i;
954         unsigned long flags;
955
956         if (preferred_console < 0)
957                 preferred_console = selected_console;
958
959         /*
960          *      See if we want to use this console driver. If we
961          *      didn't select a console we take the first one
962          *      that registers here.
963          */
964         if (preferred_console < 0) {
965                 if (console->index < 0)
966                         console->index = 0;
967                 if (console->setup == NULL ||
968                     console->setup(console, NULL) == 0) {
969                         console->flags |= CON_ENABLED | CON_CONSDEV;
970                         preferred_console = 0;
971                 }
972         }
973
974         /*
975          *      See if this console matches one we selected on
976          *      the command line.
977          */
978         for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];
979                         i++) {
980                 if (strcmp(console_cmdline[i].name, console->name) != 0)
981                         continue;
982                 if (console->index >= 0 &&
983                     console->index != console_cmdline[i].index)
984                         continue;
985                 if (console->index < 0)
986                         console->index = console_cmdline[i].index;
987                 if (console->setup &&
988                     console->setup(console, console_cmdline[i].options) != 0)
989                         break;
990                 console->flags |= CON_ENABLED;
991                 console->index = console_cmdline[i].index;
992                 if (i == selected_console) {
993                         console->flags |= CON_CONSDEV;
994                         preferred_console = selected_console;
995                 }
996                 break;
997         }
998
999         if (!(console->flags & CON_ENABLED))
1000                 return;
1001
1002         if (console_drivers && (console_drivers->flags & CON_BOOT)) {
1003                 unregister_console(console_drivers);
1004                 console->flags &= ~CON_PRINTBUFFER;
1005         }
1006
1007         /*
1008          *      Put this console in the list - keep the
1009          *      preferred driver at the head of the list.
1010          */
1011         acquire_console_sem();
1012         if ((console->flags & CON_CONSDEV) || console_drivers == NULL) {
1013                 console->next = console_drivers;
1014                 console_drivers = console;
1015                 if (console->next)
1016                         console->next->flags &= ~CON_CONSDEV;
1017         } else {
1018                 console->next = console_drivers->next;
1019                 console_drivers->next = console;
1020         }
1021         if (console->flags & CON_PRINTBUFFER) {
1022                 /*
1023                  * release_console_sem() will print out the buffered messages
1024                  * for us.
1025                  */
1026                 spin_lock_irqsave(&logbuf_lock, flags);
1027                 con_start = log_start;
1028                 spin_unlock_irqrestore(&logbuf_lock, flags);
1029         }
1030         release_console_sem();
1031 }
1032 EXPORT_SYMBOL(register_console);
1033
1034 int unregister_console(struct console *console)
1035 {
1036         struct console *a, *b;
1037         int res = 1;
1038
1039         acquire_console_sem();
1040         if (console_drivers == console) {
1041                 console_drivers=console->next;
1042                 res = 0;
1043         } else if (console_drivers) {
1044                 for (a=console_drivers->next, b=console_drivers ;
1045                      a; b=a, a=b->next) {
1046                         if (a == console) {
1047                                 b->next = a->next;
1048                                 res = 0;
1049                                 break;
1050                         }
1051                 }
1052         }
1053
1054         /* If last console is removed, we re-enable picking the first
1055          * one that gets registered. Without that, pmac early boot console
1056          * would prevent fbcon from taking over.
1057          *
1058          * If this isn't the last console and it has CON_CONSDEV set, we
1059          * need to set it on the next preferred console.
1060          */
1061         if (console_drivers == NULL)
1062                 preferred_console = selected_console;
1063         else if (console->flags & CON_CONSDEV)
1064                 console_drivers->flags |= CON_CONSDEV;
1065
1066         release_console_sem();
1067         return res;
1068 }
1069 EXPORT_SYMBOL(unregister_console);
1070
1071 /**
1072  * tty_write_message - write a message to a certain tty, not just the console.
1073  * @tty: the destination tty_struct
1074  * @msg: the message to write
1075  *
1076  * This is used for messages that need to be redirected to a specific tty.
1077  * We don't put it into the syslog queue right now maybe in the future if
1078  * really needed.
1079  */
1080 void tty_write_message(struct tty_struct *tty, char *msg)
1081 {
1082         if (tty && tty->driver->write)
1083                 tty->driver->write(tty, msg, strlen(msg));
1084         return;
1085 }
1086
1087 /*
1088  * printk rate limiting, lifted from the networking subsystem.
1089  *
1090  * This enforces a rate limit: not more than one kernel message
1091  * every printk_ratelimit_jiffies to make a denial-of-service
1092  * attack impossible.
1093  */
1094 int __printk_ratelimit(int ratelimit_jiffies, int ratelimit_burst)
1095 {
1096         static DEFINE_SPINLOCK(ratelimit_lock);
1097         static unsigned long toks = 10 * 5 * HZ;
1098         static unsigned long last_msg;
1099         static int missed;
1100         unsigned long flags;
1101         unsigned long now = jiffies;
1102
1103         spin_lock_irqsave(&ratelimit_lock, flags);
1104         toks += now - last_msg;
1105         last_msg = now;
1106         if (toks > (ratelimit_burst * ratelimit_jiffies))
1107                 toks = ratelimit_burst * ratelimit_jiffies;
1108         if (toks >= ratelimit_jiffies) {
1109                 int lost = missed;
1110
1111                 missed = 0;
1112                 toks -= ratelimit_jiffies;
1113                 spin_unlock_irqrestore(&ratelimit_lock, flags);
1114                 if (lost)
1115                         printk(KERN_WARNING "printk: %d messages suppressed.\n", lost);
1116                 return 1;
1117         }
1118         missed++;
1119         spin_unlock_irqrestore(&ratelimit_lock, flags);
1120         return 0;
1121 }
1122 EXPORT_SYMBOL(__printk_ratelimit);
1123
1124 /* minimum time in jiffies between messages */
1125 int printk_ratelimit_jiffies = 5 * HZ;
1126
1127 /* number of messages we send before ratelimiting */
1128 int printk_ratelimit_burst = 10;
1129
1130 int printk_ratelimit(void)
1131 {
1132         return __printk_ratelimit(printk_ratelimit_jiffies,
1133                                 printk_ratelimit_burst);
1134 }
1135 EXPORT_SYMBOL(printk_ratelimit);
1136
1137 /**
1138  * printk_timed_ratelimit - caller-controlled printk ratelimiting
1139  * @caller_jiffies: pointer to caller's state
1140  * @interval_msecs: minimum interval between prints
1141  *
1142  * printk_timed_ratelimit() returns true if more than @interval_msecs
1143  * milliseconds have elapsed since the last time printk_timed_ratelimit()
1144  * returned true.
1145  */
1146 bool printk_timed_ratelimit(unsigned long *caller_jiffies,
1147                         unsigned int interval_msecs)
1148 {
1149         if (*caller_jiffies == 0 || time_after(jiffies, *caller_jiffies)) {
1150                 *caller_jiffies = jiffies + msecs_to_jiffies(interval_msecs);
1151                 return true;
1152         }
1153         return false;
1154 }
1155 EXPORT_SYMBOL(printk_timed_ratelimit);