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