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  *     manfreds@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/interrupt.h>                    /* For in_interrupt() */
  28 #include <linux/config.h>
  29 #include <linux/delay.h>
  30 #include <linux/smp.h>
  31 #include <linux/security.h>
  32
  33 #include <asm/uaccess.h>
  34
  35 #define LOG_BUF_LEN     (1 << CONFIG_LOG_BUF_SHIFT)
  36 #define LOG_BUF_MASK    (LOG_BUF_LEN-1)
  37
  38 /* printk's without a loglevel use this.. */
  39 #define DEFAULT_MESSAGE_LOGLEVEL 4 /* KERN_WARNING */
  40
  41 /* We show everything that is MORE important than this.. */
  42 #define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */
  43 #define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG */
  44
  45 DECLARE_WAIT_QUEUE_HEAD(log_wait);
  46
  47 int console_printk[4] = {
  48         DEFAULT_CONSOLE_LOGLEVEL,       /* console_loglevel */
  49         DEFAULT_MESSAGE_LOGLEVEL,       /* default_message_loglevel */
  50         MINIMUM_CONSOLE_LOGLEVEL,       /* minimum_console_loglevel */
  51         DEFAULT_CONSOLE_LOGLEVEL,       /* default_console_loglevel */
  52 };
  53
  54 int oops_in_progress;
  55
  56 /*
  57  * console_sem protects the console_drivers list, and also
  58  * provides serialisation for access to the entire console
  59  * driver system.
  60  */
  61 static DECLARE_MUTEX(console_sem);
  62 struct console *console_drivers;
  63
  64 /*
  65  * logbuf_lock protects log_buf, log_start, log_end, con_start and logged_chars
  66  * It is also used in interesting ways to provide interlocking in
  67  * release_console_sem().
  68  */
  69 static spinlock_t logbuf_lock = SPIN_LOCK_UNLOCKED;
  70
  71 static char log_buf[LOG_BUF_LEN];
  72 #define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
  73
  74 /*
  75  * The indices into log_buf are not constrained to LOG_BUF_LEN - they
  76  * must be masked before subscripting
  77  */
  78 static unsigned long log_start;                 /* Index into log_buf: next char to be read by syslog() */
  79 static unsigned long con_start;                 /* Index into log_buf: next char to be sent to consoles */
  80 static unsigned long log_end;                   /* Index into log_buf: most-recently-written-char + 1 */
  81 static unsigned long logged_chars;              /* Number of chars produced since last read+clear operation */
  82
  83 struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
  84 static int preferred_console = -1;
  85
  86 /* Flag: console code may call schedule() */
  87 static int console_may_schedule;
  88
  89 /*
  90  *      Setup a list of consoles. Called from init/main.c
  91  */
  92 static int __init console_setup(char *str)
  93 {
  94         struct console_cmdline *c;
  95         char name[sizeof(c->name)];
  96         char *s, *options;
  97         int i, idx;
  98
  99         /*
 100          *      Decode str into name, index, options.
 101          */
 102         if (str[0] >= '0' && str[0] <= '9') {
 103                 strcpy(name, "ttyS");
 104                 strncpy(name + 4, str, sizeof(name) - 5);
 105         } else
 106                 strncpy(name, str, sizeof(name) - 1);
 107         name[sizeof(name) - 1] = 0;
 108         if ((options = strchr(str, ',')) != NULL)
 109                 *(options++) = 0;
 110 #ifdef __sparc__
 111         if (!strcmp(str, "ttya"))
 112                 strcpy(name, "ttyS0");
 113         if (!strcmp(str, "ttyb"))
 114                 strcpy(name, "ttyS1");
 115 #endif
 116         for(s = name; *s; s++)
 117                 if (*s >= '0' && *s <= '9')
 118                         break;
 119         idx = simple_strtoul(s, NULL, 10);
 120         *s = 0;
 121
 122         /*
 123          *      See if this tty is not yet registered, and
 124          *      if we have a slot free.
 125          */
 126         for(i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
 127                 if (strcmp(console_cmdline[i].name, name) == 0 &&
 128                           console_cmdline[i].index == idx) {
 129                                 preferred_console = i;
 130                                 return 1;
 131                 }
 132         if (i == MAX_CMDLINECONSOLES)
 133                 return 1;
 134         preferred_console = i;
 135         c = &console_cmdline[i];
 136         memcpy(c->name, name, sizeof(c->name));
 137         c->options = options;
 138         c->index = idx;
 139         return 1;
 140 }
 141
 142 __setup("console=", console_setup);
 143
 144 /*
 145  * Commands to do_syslog:
 146  *
 147  *      0 -- Close the log.  Currently a NOP.
 148  *      1 -- Open the log. Currently a NOP.
 149  *      2 -- Read from the log.
 150  *      3 -- Read all messages remaining in the ring buffer.
 151  *      4 -- Read and clear all messages remaining in the ring buffer
 152  *      5 -- Clear ring buffer.
 153  *      6 -- Disable printk's to console
 154  *      7 -- Enable printk's to console
 155  *      8 -- Set level of messages printed to console
 156  *      9 -- Return number of unread characters in the log buffer
 157  */
 158 int do_syslog(int type, char __user * buf, int len)
 159 {
 160         unsigned long i, j, limit, count;
 161         int do_clear = 0;
 162         char c;
 163         int error = 0;
 164
 165         error = security_syslog(type);
 166         if (error)
 167                 return error;
 168
 169         switch (type) {
 170         case 0:         /* Close log */
 171                 break;
 172         case 1:         /* Open log */
 173                 break;
 174         case 2:         /* Read from log */
 175                 error = -EINVAL;
 176                 if (!buf || len < 0)
 177                         goto out;
 178                 error = 0;
 179                 if (!len)
 180                         goto out;
 181                 error = verify_area(VERIFY_WRITE,buf,len);
 182                 if (error)
 183                         goto out;
 184                 error = wait_event_interruptible(log_wait, (log_start - log_end));
 185                 if (error)
 186                         goto out;
 187                 i = 0;
 188                 spin_lock_irq(&logbuf_lock);
 189                 while ((log_start != log_end) && i < len) {
 190                         c = LOG_BUF(log_start);
 191                         log_start++;
 192                         spin_unlock_irq(&logbuf_lock);
 193                         __put_user(c,buf);
 194                         buf++;
 195                         i++;
 196                         spin_lock_irq(&logbuf_lock);
 197                 }
 198                 spin_unlock_irq(&logbuf_lock);
 199                 error = i;
 200                 break;
 201         case 4:         /* Read/clear last kernel messages */
 202                 do_clear = 1;
 203                 /* FALL THRU */
 204         case 3:         /* Read last kernel messages */
 205                 error = -EINVAL;
 206                 if (!buf || len < 0)
 207                         goto out;
 208                 error = 0;
 209                 if (!len)
 210                         goto out;
 211                 error = verify_area(VERIFY_WRITE,buf,len);
 212                 if (error)
 213                         goto out;
 214                 count = len;
 215                 if (count > LOG_BUF_LEN)
 216                         count = LOG_BUF_LEN;
 217                 spin_lock_irq(&logbuf_lock);
 218                 if (count > logged_chars)
 219                         count = logged_chars;
 220                 if (do_clear)
 221                         logged_chars = 0;
 222                 limit = log_end;
 223                 /*
 224                  * __put_user() could sleep, and while we sleep
 225                  * printk() could overwrite the messages
 226                  * we try to copy to user space. Therefore
 227                  * the messages are copied in reverse. <manfreds>
 228                  */
 229                 for(i=0;i < count;i++) {
 230                         j = limit-1-i;
 231                         if (j+LOG_BUF_LEN < log_end)
 232                                 break;
 233                         c = LOG_BUF(j);
 234                         spin_unlock_irq(&logbuf_lock);
 235                         __put_user(c,&buf[count-1-i]);
 236                         spin_lock_irq(&logbuf_lock);
 237                 }
 238                 spin_unlock_irq(&logbuf_lock);
 239                 error = i;
 240                 if(i != count) {
 241                         int offset = count-error;
 242                         /* buffer overflow during copy, correct user buffer. */
 243                         for(i=0;i<error;i++) {
 244                                 __get_user(c,&buf[i+offset]);
 245                                 __put_user(c,&buf[i]);
 246                         }
 247                 }
 248
 249                 break;
 250         case 5:         /* Clear ring buffer */
 251                 logged_chars = 0;
 252                 break;
 253         case 6:         /* Disable logging to console */
 254                 console_loglevel = minimum_console_loglevel;
 255                 break;
 256         case 7:         /* Enable logging to console */
 257                 console_loglevel = default_console_loglevel;
 258                 break;
 259         case 8:         /* Set level of messages printed to console */
 260                 error = -EINVAL;
 261                 if (len < 1 || len > 8)
 262                         goto out;
 263                 if (len < minimum_console_loglevel)
 264                         len = minimum_console_loglevel;
 265                 console_loglevel = len;
 266                 error = 0;
 267                 break;
 268         case 9:         /* Number of chars in the log buffer */
 269                 error = log_end - log_start;
 270                 break;
 271         default:
 272                 error = -EINVAL;
 273                 break;
 274         }
 275 out:
 276         return error;
 277 }
 278
 279 asmlinkage long sys_syslog(int type, char __user * buf, int len)
 280 {
 281         return do_syslog(type, buf, len);
 282 }
 283
 284 /*
 285  * Call the console drivers on a range of log_buf
 286  */
 287 static void __call_console_drivers(unsigned long start, unsigned long end)
 288 {
 289         struct console *con;
 290
 291         for (con = console_drivers; con; con = con->next) {
 292                 if ((con->flags & CON_ENABLED) && con->write)
 293                         con->write(con, &LOG_BUF(start), end - start);
 294         }
 295 }
 296
 297 /*
 298  * Write out chars from start to end - 1 inclusive
 299  */
 300 static void _call_console_drivers(unsigned long start, unsigned long end, int msg_log_level)
 301 {
 302         if (msg_log_level < console_loglevel && console_drivers && start != end) {
 303                 if ((start & LOG_BUF_MASK) > (end & LOG_BUF_MASK)) {
 304                         /* wrapped write */
 305                         __call_console_drivers(start & LOG_BUF_MASK, LOG_BUF_LEN);
 306                         __call_console_drivers(0, end & LOG_BUF_MASK);
 307                 } else {
 308                         __call_console_drivers(start, end);
 309                 }
 310         }
 311 }
 312
 313 /*
 314  * Call the console drivers, asking them to write out
 315  * log_buf[start] to log_buf[end - 1].
 316  * The console_sem must be held.
 317  */
 318 static void call_console_drivers(unsigned long start, unsigned long end)
 319 {
 320         unsigned long cur_index, start_print;
 321         static int msg_level = -1;
 322
 323         if (((long)(start - end)) > 0)
 324                 BUG();
 325
 326         cur_index = start;
 327         start_print = start;
 328         while (cur_index != end) {
 329                 if (    msg_level < 0 &&
 330                         ((end - cur_index) > 2) &&
 331                         LOG_BUF(cur_index + 0) == '<' &&
 332                         LOG_BUF(cur_index + 1) >= '0' &&
 333                         LOG_BUF(cur_index + 1) <= '7' &&
 334                         LOG_BUF(cur_index + 2) == '>')
 335                 {
 336                         msg_level = LOG_BUF(cur_index + 1) - '0';
 337                         cur_index += 3;
 338                         start_print = cur_index;
 339                 }
 340                 while (cur_index != end) {
 341                         char c = LOG_BUF(cur_index);
 342                         cur_index++;
 343
 344                         if (c == '\n') {
 345                                 if (msg_level < 0) {
 346                                         /*
 347                                          * printk() has already given us loglevel tags in
 348                                          * the buffer.  This code is here in case the
 349                                          * log buffer has wrapped right round and scribbled
 350                                          * on those tags
 351                                          */
 352                                         msg_level = default_message_loglevel;
 353                                 }
 354                                 _call_console_drivers(start_print, cur_index, msg_level);
 355                                 msg_level = -1;
 356                                 start_print = cur_index;
 357                                 break;
 358                         }
 359                 }
 360         }
 361         _call_console_drivers(start_print, end, msg_level);
 362 }
 363
 364 static void emit_log_char(char c)
 365 {
 366         LOG_BUF(log_end) = c;
 367         log_end++;
 368         if (log_end - log_start > LOG_BUF_LEN)
 369                 log_start = log_end - LOG_BUF_LEN;
 370         if (log_end - con_start > LOG_BUF_LEN)
 371                 con_start = log_end - LOG_BUF_LEN;
 372         if (logged_chars < LOG_BUF_LEN)
 373                 logged_chars++;
 374 }
 375
 376 /*
 377  * This is printk.  It can be called from any context.  We want it to work.
 378  *
 379  * We try to grab the console_sem.  If we succeed, it's easy - we log the output and
 380  * call the console drivers.  If we fail to get the semaphore we place the output
 381  * into the log buffer and return.  The current holder of the console_sem will
 382  * notice the new output in release_console_sem() and will send it to the
 383  * consoles before releasing the semaphore.
 384  *
 385  * One effect of this deferred printing is that code which calls printk() and
 386  * then changes console_loglevel may break. This is because console_loglevel
 387  * is inspected when the actual printing occurs.
 388  */
 389 asmlinkage int printk(const char *fmt, ...)
 390 {
 391         va_list args;
 392         unsigned long flags;
 393         int printed_len;
 394         char *p;
 395         static char printk_buf[1024];
 396         static int log_level_unknown = 1;
 397
 398         if (oops_in_progress) {
 399                 /* If a crash is occurring, make sure we can't deadlock */
 400                 spin_lock_init(&logbuf_lock);
 401                 /* And make sure that we print immediately */
 402                 init_MUTEX(&console_sem);
 403         }
 404
 405         /* This stops the holder of console_sem just where we want him */
 406         spin_lock_irqsave(&logbuf_lock, flags);
 407
 408         /* Emit the output into the temporary buffer */
 409         va_start(args, fmt);
 410         printed_len = vsnprintf(printk_buf, sizeof(printk_buf), fmt, args);
 411         va_end(args);
 412
 413         /*
 414          * Copy the output into log_buf.  If the caller didn't provide
 415          * appropriate log level tags, we insert them here
 416          */
 417         for (p = printk_buf; *p; p++) {
 418                 if (log_level_unknown) {
 419                         if (p[0] != '<' || p[1] < '0' || p[1] > '7' || p[2] != '>') {
 420                                 emit_log_char('<');
 421                                 emit_log_char(default_message_loglevel + '0');
 422                                 emit_log_char('>');
 423                         }
 424                         log_level_unknown = 0;
 425                 }
 426                 emit_log_char(*p);
 427                 if (*p == '\n')
 428                         log_level_unknown = 1;
 429         }
 430
 431         if (!cpu_online(smp_processor_id())) {
 432                 /*
 433                  * Some console drivers may assume that per-cpu resources have
 434                  * been allocated.  So don't allow them to be called by this
 435                  * CPU until it is officially up.  We shouldn't be calling into
 436                  * random console drivers on a CPU which doesn't exist yet..
 437                  */
 438                 spin_unlock_irqrestore(&logbuf_lock, flags);
 439                 goto out;
 440         }
 441         if (!down_trylock(&console_sem)) {
 442                 /*
 443                  * We own the drivers.  We can drop the spinlock and let
 444                  * release_console_sem() print the text
 445                  */
 446                 spin_unlock_irqrestore(&logbuf_lock, flags);
 447                 console_may_schedule = 0;
 448                 release_console_sem();
 449         } else {
 450                 /*
 451                  * Someone else owns the drivers.  We drop the spinlock, which
 452                  * allows the semaphore holder to proceed and to call the
 453                  * console drivers with the output which we just produced.
 454                  */
 455                 spin_unlock_irqrestore(&logbuf_lock, flags);
 456         }
 457 out:
 458         return printed_len;
 459 }
 460 EXPORT_SYMBOL(printk);
 461
 462 /**
 463  * acquire_console_sem - lock the console system for exclusive use.
 464  *
 465  * Acquires a semaphore which guarantees that the caller has
 466  * exclusive access to the console system and the console_drivers list.
 467  *
 468  * Can sleep, returns nothing.
 469  */
 470 void acquire_console_sem(void)
 471 {
 472         if (in_interrupt())
 473                 BUG();
 474         down(&console_sem);
 475         console_may_schedule = 1;
 476 }
 477 EXPORT_SYMBOL(acquire_console_sem);
 478
 479 /**
 480  * release_console_sem - unlock the console system
 481  *
 482  * Releases the semaphore which the caller holds on the console system
 483  * and the console driver list.
 484  *
 485  * While the semaphore was held, console output may have been buffered
 486  * by printk().  If this is the case, release_console_sem() emits
 487  * the output prior to releasing the semaphore.
 488  *
 489  * If there is output waiting for klogd, we wake it up.
 490  *
 491  * release_console_sem() may be called from any context.
 492  */
 493 void release_console_sem(void)
 494 {
 495         unsigned long flags;
 496         unsigned long _con_start, _log_end;
 497         unsigned long wake_klogd = 0;
 498
 499         for ( ; ; ) {
 500                 spin_lock_irqsave(&logbuf_lock, flags);
 501                 wake_klogd |= log_start - log_end;
 502                 if (con_start == log_end)
 503                         break;                  /* Nothing to print */
 504                 _con_start = con_start;
 505                 _log_end = log_end;
 506                 con_start = log_end;            /* Flush */
 507                 spin_unlock_irqrestore(&logbuf_lock, flags);
 508                 call_console_drivers(_con_start, _log_end);
 509         }
 510         console_may_schedule = 0;
 511         up(&console_sem);
 512         spin_unlock_irqrestore(&logbuf_lock, flags);
 513         if (wake_klogd && !oops_in_progress && waitqueue_active(&log_wait))
 514                 wake_up_interruptible(&log_wait);
 515 }
 516
 517 /** console_conditional_schedule - yield the CPU if required
 518  *
 519  * If the console code is currently allowed to sleep, and
 520  * if this CPU should yield the CPU to another task, do
 521  * so here.
 522  *
 523  * Must be called within acquire_console_sem().
 524  */
 525 void console_conditional_schedule(void)
 526 {
 527         if (console_may_schedule && need_resched()) {
 528                 set_current_state(TASK_RUNNING);
 529                 schedule();
 530         }
 531 }
 532 EXPORT_SYMBOL(console_conditional_schedule);
 533
 534 void console_print(const char *s)
 535 {
 536         printk(KERN_EMERG "%s", s);
 537 }
 538 EXPORT_SYMBOL(console_print);
 539
 540 void console_unblank(void)
 541 {
 542         struct console *c;
 543
 544         /*
 545          * Try to get the console semaphore. If someone else owns it
 546          * we have to return without unblanking because console_unblank
 547          * may be called in interrupt context.
 548          */
 549         if (down_trylock(&console_sem) != 0)
 550                 return;
 551         console_may_schedule = 0;
 552         for (c = console_drivers; c != NULL; c = c->next)
 553                 if ((c->flags & CON_ENABLED) && c->unblank)
 554                         c->unblank();
 555         release_console_sem();
 556 }
 557 EXPORT_SYMBOL(console_unblank);
 558
 559 /*
 560  * The console driver calls this routine during kernel initialization
 561  * to register the console printing procedure with printk() and to
 562  * print any messages that were printed by the kernel before the
 563  * console driver was initialized.
 564  */
 565 void register_console(struct console * console)
 566 {
 567         int     i;
 568         unsigned long flags;
 569
 570         /*
 571          *      See if we want to use this console driver. If we
 572          *      didn't select a console we take the first one
 573          *      that registers here.
 574          */
 575         if (preferred_console < 0) {
 576                 if (console->index < 0)
 577                         console->index = 0;
 578                 if (console->setup == NULL ||
 579                     console->setup(console, NULL) == 0) {
 580                         console->flags |= CON_ENABLED | CON_CONSDEV;
 581                         preferred_console = 0;
 582                 }
 583         }
 584
 585         /*
 586          *      See if this console matches one we selected on
 587          *      the command line.
 588          */
 589         for(i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++) {
 590                 if (strcmp(console_cmdline[i].name, console->name) != 0)
 591                         continue;
 592                 if (console->index >= 0 &&
 593                     console->index != console_cmdline[i].index)
 594                         continue;
 595                 if (console->index < 0)
 596                         console->index = console_cmdline[i].index;
 597                 if (console->setup &&
 598                     console->setup(console, console_cmdline[i].options) != 0)
 599                         break;
 600                 console->flags |= CON_ENABLED;
 601                 console->index = console_cmdline[i].index;
 602                 if (i == preferred_console)
 603                         console->flags |= CON_CONSDEV;
 604                 break;
 605         }
 606
 607         if (!(console->flags & CON_ENABLED))
 608                 return;
 609
 610         /*
 611          *      Put this console in the list - keep the
 612          *      preferred driver at the head of the list.
 613          */
 614         acquire_console_sem();
 615         if ((console->flags & CON_CONSDEV) || console_drivers == NULL) {
 616                 console->next = console_drivers;
 617                 console_drivers = console;
 618         } else {
 619                 console->next = console_drivers->next;
 620                 console_drivers->next = console;
 621         }
 622         if (console->flags & CON_PRINTBUFFER) {
 623                 /*
 624                  * release_console_sem() will print out the buffered messages
 625                  * for us.
 626                  */
 627                 spin_lock_irqsave(&logbuf_lock, flags);
 628                 con_start = log_start;
 629                 spin_unlock_irqrestore(&logbuf_lock, flags);
 630         }
 631         release_console_sem();
 632 }
 633 EXPORT_SYMBOL(register_console);
 634
 635 int unregister_console(struct console * console)
 636 {
 637         struct console *a,*b;
 638         int res = 1;
 639
 640         acquire_console_sem();
 641         if (console_drivers == console) {
 642                 console_drivers=console->next;
 643                 res = 0;
 644         } else {
 645                 for (a=console_drivers->next, b=console_drivers ;
 646                      a; b=a, a=b->next) {
 647                         if (a == console) {
 648                                 b->next = a->next;
 649                                 res = 0;
 650                                 break;
 651                         }
 652                 }
 653         }
 654
 655         /* If last console is removed, we re-enable picking the first
 656          * one that gets registered. Without that, pmac early boot console
 657          * would prevent fbcon from taking over.
 658          */
 659         if (console_drivers == NULL)
 660                 preferred_console = -1;
 661
 662
 663         release_console_sem();
 664         return res;
 665 }
 666 EXPORT_SYMBOL(unregister_console);
 667
 668 /**
 669  * tty_write_message - write a message to a certain tty, not just the console.
 670  *
 671  * This is used for messages that need to be redirected to a specific tty.
 672  * We don't put it into the syslog queue right now maybe in the future if
 673  * really needed.
 674  */
 675 void tty_write_message(struct tty_struct *tty, char *msg)
 676 {
 677         if (tty && tty->driver->write)
 678                 tty->driver->write(tty, 0, msg, strlen(msg));
 679         return;
 680 }