File: /Users/paulross/dev/linux/linux-3.13/include/linux/printk.h

Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.

       1: #ifndef __KERNEL_PRINTK__
       2: #define __KERNEL_PRINTK__
       3: 
       4: #include <stdarg.h>
       5: #include <linux/init.h>
       6: #include <linux/kern_levels.h>
       7: #include <linux/linkage.h>
       8: 
       9: extern const char linux_banner[];
      10: extern const char linux_proc_banner[];
      11: 
      12: static inline int printk_get_level(const char *buffer)
      13: {
      14:     if (buffer[0] == KERN_SOH_ASCII && buffer[1]) {
      15:         switch (buffer[1]) {
      16:         case '0' ... '7':
      17:         case 'd':    /* KERN_DEFAULT */
      18:             return buffer[1];
      19:         }
      20:     }
      21:     return 0;
      22: }
      23: 
      24: static inline const char *printk_skip_level(const char *buffer)
      25: {
      26:     if (printk_get_level(buffer)) {
      27:         switch (buffer[1]) {
      28:         case '0' ... '7':
      29:         case 'd':    /* KERN_DEFAULT */
      30:             return buffer + 2;
      31:         }
      32:     }
      33:     return buffer;
      34: }
      35: 
      36: extern int console_printk[];
      37: 
      38: #define console_loglevel (console_printk[0])
      39: #define default_message_loglevel (console_printk[1])
      40: #define minimum_console_loglevel (console_printk[2])
      41: #define default_console_loglevel (console_printk[3])
      42: 
      43: static inline void console_silent(void)
      44: {
      45:     console_loglevel = 0;
      46: }
      47: 
      48: static inline void console_verbose(void)
      49: {
      50:     if (console_loglevel)
      51:         console_loglevel = 15;
      52: }
      53: 
      54: struct va_format {
      55:     const char *fmt;
      56:     va_list *va;
      57: };
      58: 
      59: /*
      60:  * FW_BUG
      61:  * Add this to a message where you are sure the firmware is buggy or behaves
      62:  * really stupid or out of spec. Be aware that the responsible BIOS developer
      63:  * should be able to fix this issue or at least get a concrete idea of the
      64:  * problem by reading your message without the need of looking at the kernel
      65:  * code.
      66:  *
      67:  * Use it for definite and high priority BIOS bugs.
      68:  *
      69:  * FW_WARN
      70:  * Use it for not that clear (e.g. could the kernel messed up things already?)
      71:  * and medium priority BIOS bugs.
      72:  *
      73:  * FW_INFO
      74:  * Use this one if you want to tell the user or vendor about something
      75:  * suspicious, but generally harmless related to the firmware.
      76:  *
      77:  * Use it for information or very low priority BIOS bugs.
      78:  */
      79: #define FW_BUG        "[Firmware Bug]: "
      80: #define FW_WARN        "[Firmware Warn]: "
      81: #define FW_INFO        "[Firmware Info]: "
      82: 
      83: /*
      84:  * HW_ERR
      85:  * Add this to a message for hardware errors, so that user can report
      86:  * it to hardware vendor instead of LKML or software vendor.
      87:  */
      88: #define HW_ERR        "[Hardware Error]: "
      89: 
      90: /*
      91:  * Dummy printk for disabled debugging statements to use whilst maintaining
      92:  * gcc's format and side-effect checking.
      93:  */
      94: static inline __printf(1, 2)
      95: int no_printk(const char *fmt, ...)
      96: {
      97:     return 0;
      98: }
      99: 
     100: #ifdef CONFIG_EARLY_PRINTK
     101: extern asmlinkage __printf(1, 2)
     102: void early_printk(const char *fmt, ...);
     103: void early_vprintk(const char *fmt, va_list ap);
     104: #else
     105: static inline __printf(1, 2) __cold
     106: void early_printk(const char *s, ...) { }
     107: #endif
     108: 
     109: #ifdef CONFIG_PRINTK
     110: asmlinkage __printf(5, 0)
     111: int vprintk_emit(int facility, int level,
     112:          const char *dict, size_t dictlen,
     113:          const char *fmt, va_list args);
     114: 
     115: asmlinkage __printf(1, 0)
     116: int vprintk(const char *fmt, va_list args);
     117: 
     118: asmlinkage __printf(5, 6) __cold
     119: asmlinkage int printk_emit(int facility, int level,
     120:                const char *dict, size_t dictlen,
     121:                const char *fmt, ...);
     122: 
     123: asmlinkage __printf(1, 2) __cold
     124: int printk(const char *fmt, ...);
     125: 
     126: /*
     127:  * Special printk facility for scheduler use only, _DO_NOT_USE_ !
     128:  */
     129: __printf(1, 2) __cold int printk_sched(const char *fmt, ...);
     130: 
     131: /*
     132:  * Please don't use printk_ratelimit(), because it shares ratelimiting state
     133:  * with all other unrelated printk_ratelimit() callsites.  Instead use
     134:  * printk_ratelimited() or plain old __ratelimit().
     135:  */
     136: extern int __printk_ratelimit(const char *func);
     137: #define printk_ratelimit() __printk_ratelimit(__func__)
     138: extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
     139:                    unsigned int interval_msec);
     140: 
     141: extern int printk_delay_msec;
     142: extern int dmesg_restrict;
     143: extern int kptr_restrict;
     144: 
     145: extern void wake_up_klogd(void);
     146: 
     147: void log_buf_kexec_setup(void);
     148: void __init setup_log_buf(int early);
     149: void dump_stack_set_arch_desc(const char *fmt, ...);
     150: void dump_stack_print_info(const char *log_lvl);
     151: void show_regs_print_info(const char *log_lvl);
     152: #else
     153: static inline __printf(1, 0)
     154: int vprintk(const char *s, va_list args)
     155: {
     156:     return 0;
     157: }
     158: static inline __printf(1, 2) __cold
     159: int printk(const char *s, ...)
     160: {
     161:     return 0;
     162: }
     163: static inline __printf(1, 2) __cold
     164: int printk_sched(const char *s, ...)
     165: {
     166:     return 0;
     167: }
     168: static inline int printk_ratelimit(void)
     169: {
     170:     return 0;
     171: }
     172: static inline bool printk_timed_ratelimit(unsigned long *caller_jiffies,
     173:                       unsigned int interval_msec)
     174: {
     175:     return false;
     176: }
     177: 
     178: static inline void wake_up_klogd(void)
     179: {
     180: }
     181: 
     182: static inline void log_buf_kexec_setup(void)
     183: {
     184: }
     185: 
     186: static inline void setup_log_buf(int early)
     187: {
     188: }
     189: 
     190: static inline void dump_stack_set_arch_desc(const char *fmt, ...)
     191: {
     192: }
     193: 
     194: static inline void dump_stack_print_info(const char *log_lvl)
     195: {
     196: }
     197: 
     198: static inline void show_regs_print_info(const char *log_lvl)
     199: {
     200: }
     201: #endif
     202: 
     203: extern asmlinkage void dump_stack(void) __cold;
     204: 
     205: #ifndef pr_fmt
     206: #define pr_fmt(fmt) fmt
     207: #endif
     208: 
     209: #define pr_emerg(fmt, ...) \
     210:     printk(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
     211: #define pr_alert(fmt, ...) \
     212:     printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
     213: #define pr_crit(fmt, ...) \
     214:     printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
     215: #define pr_err(fmt, ...) \
     216:     printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
     217: #define pr_warning(fmt, ...) \
     218:     printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
     219: #define pr_warn pr_warning
     220: #define pr_notice(fmt, ...) \
     221:     printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
     222: #define pr_info(fmt, ...) \
     223:     printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
     224: #define pr_cont(fmt, ...) \
     225:     printk(KERN_CONT fmt, ##__VA_ARGS__)
     226: 
     227: /* pr_devel() should produce zero code unless DEBUG is defined */
     228: #ifdef DEBUG
     229: #define pr_devel(fmt, ...) \
     230:     printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     231: #else
     232: #define pr_devel(fmt, ...) \
     233:     no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     234: #endif
     235: 
     236: #include <linux/dynamic_debug.h>
     237: 
     238: /* If you are writing a driver, please use dev_dbg instead */
     239: #if defined(CONFIG_DYNAMIC_DEBUG)
     240: /* dynamic_pr_debug() uses pr_fmt() internally so we don't need it here */
     241: #define pr_debug(fmt, ...) \
     242:     dynamic_pr_debug(fmt, ##__VA_ARGS__)
     243: #elif defined(DEBUG)
     244: #define pr_debug(fmt, ...) \
     245:     printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     246: #else
     247: #define pr_debug(fmt, ...) \
     248:     no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     249: #endif
     250: 
     251: /*
     252:  * Print a one-time message (analogous to WARN_ONCE() et al):
     253:  */
     254: 
     255: #ifdef CONFIG_PRINTK
     256: #define printk_once(fmt, ...)            \
     257: ({                        \
     258:     static bool __print_once;        \
     259:                         \
     260:     if (!__print_once) {            \
     261:         __print_once = true;        \
     262:         printk(fmt, ##__VA_ARGS__);    \
     263:     }                    \
     264: })
     265: #else
     266: #define printk_once(fmt, ...)            \
     267:     no_printk(fmt, ##__VA_ARGS__)
     268: #endif
     269: 
     270: #define pr_emerg_once(fmt, ...)                    \
     271:     printk_once(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
     272: #define pr_alert_once(fmt, ...)                    \
     273:     printk_once(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
     274: #define pr_crit_once(fmt, ...)                    \
     275:     printk_once(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
     276: #define pr_err_once(fmt, ...)                    \
     277:     printk_once(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
     278: #define pr_warn_once(fmt, ...)                    \
     279:     printk_once(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
     280: #define pr_notice_once(fmt, ...)                \
     281:     printk_once(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
     282: #define pr_info_once(fmt, ...)                    \
     283:     printk_once(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
     284: #define pr_cont_once(fmt, ...)                    \
     285:     printk_once(KERN_CONT pr_fmt(fmt), ##__VA_ARGS__)
     286: 
     287: #if defined(DEBUG)
     288: #define pr_devel_once(fmt, ...)                    \
     289:     printk_once(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     290: #else
     291: #define pr_devel_once(fmt, ...)                    \
     292:     no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     293: #endif
     294: 
     295: /* If you are writing a driver, please use dev_dbg instead */
     296: #if defined(DEBUG)
     297: #define pr_debug_once(fmt, ...)                    \
     298:     printk_once(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     299: #else
     300: #define pr_debug_once(fmt, ...)                    \
     301:     no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     302: #endif
     303: 
     304: /*
     305:  * ratelimited messages with local ratelimit_state,
     306:  * no local ratelimit_state used in the !PRINTK case
     307:  */
     308: #ifdef CONFIG_PRINTK
     309: #define printk_ratelimited(fmt, ...)                    \
     310: ({                                    \
     311:     static DEFINE_RATELIMIT_STATE(_rs,                \
     312:                       DEFAULT_RATELIMIT_INTERVAL,    \
     313:                       DEFAULT_RATELIMIT_BURST);        \
     314:                                     \
     315:     if (__ratelimit(&_rs))                        \
     316:         printk(fmt, ##__VA_ARGS__);                \
     317: })
     318: #else
     319: #define printk_ratelimited(fmt, ...)                    \
     320:     no_printk(fmt, ##__VA_ARGS__)
     321: #endif
     322: 
     323: #define pr_emerg_ratelimited(fmt, ...)                    \
     324:     printk_ratelimited(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
     325: #define pr_alert_ratelimited(fmt, ...)                    \
     326:     printk_ratelimited(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
     327: #define pr_crit_ratelimited(fmt, ...)                    \
     328:     printk_ratelimited(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
     329: #define pr_err_ratelimited(fmt, ...)                    \
     330:     printk_ratelimited(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
     331: #define pr_warn_ratelimited(fmt, ...)                    \
     332:     printk_ratelimited(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
     333: #define pr_notice_ratelimited(fmt, ...)                    \
     334:     printk_ratelimited(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
     335: #define pr_info_ratelimited(fmt, ...)                    \
     336:     printk_ratelimited(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
     337: /* no pr_cont_ratelimited, don't do that... */
     338: 
     339: #if defined(DEBUG)
     340: #define pr_devel_ratelimited(fmt, ...)                    \
     341:     printk_ratelimited(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     342: #else
     343: #define pr_devel_ratelimited(fmt, ...)                    \
     344:     no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     345: #endif
     346: 
     347: /* If you are writing a driver, please use dev_dbg instead */
     348: #if defined(CONFIG_DYNAMIC_DEBUG)
     349: /* descriptor check is first to prevent flooding with "callbacks suppressed" */
     350: #define pr_debug_ratelimited(fmt, ...)                    \
     351: do {                                    \
     352:     static DEFINE_RATELIMIT_STATE(_rs,                \
     353:                       DEFAULT_RATELIMIT_INTERVAL,    \
     354:                       DEFAULT_RATELIMIT_BURST);        \
     355:     DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);            \
     356:     if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) &&    \
     357:         __ratelimit(&_rs))                        \
     358:         __dynamic_pr_debug(&descriptor, fmt, ##__VA_ARGS__);    \
     359: } while (0)
     360: #elif defined(DEBUG)
     361: #define pr_debug_ratelimited(fmt, ...)                    \
     362:     printk_ratelimited(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     363: #else
     364: #define pr_debug_ratelimited(fmt, ...) \
     365:     no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     366: #endif
     367: 
     368: extern const struct file_operations kmsg_fops;
     369: 
     370: enum {
     371:     DUMP_PREFIX_NONE,
     372:     DUMP_PREFIX_ADDRESS,
     373:     DUMP_PREFIX_OFFSET
     374: };
     375: extern void hex_dump_to_buffer(const void *buf, size_t len,
     376:                    int rowsize, int groupsize,
     377:                    char *linebuf, size_t linebuflen, bool ascii);
     378: #ifdef CONFIG_PRINTK
     379: extern void print_hex_dump(const char *level, const char *prefix_str,
     380:                int prefix_type, int rowsize, int groupsize,
     381:                const void *buf, size_t len, bool ascii);
     382: #if defined(CONFIG_DYNAMIC_DEBUG)
     383: #define print_hex_dump_bytes(prefix_str, prefix_type, buf, len)    \
     384:     dynamic_hex_dump(prefix_str, prefix_type, 16, 1, buf, len, true)
     385: #else
     386: extern void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
     387:                  const void *buf, size_t len);
     388: #endif /* defined(CONFIG_DYNAMIC_DEBUG) */
     389: #else
     390: static inline void print_hex_dump(const char *level, const char *prefix_str,
     391:                   int prefix_type, int rowsize, int groupsize,
     392:                   const void *buf, size_t len, bool ascii)
     393: {
     394: }
     395: static inline void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
     396:                     const void *buf, size_t len)
     397: {
     398: }
     399: 
     400: #endif
     401: 
     402: #if defined(CONFIG_DYNAMIC_DEBUG)
     403: #define print_hex_dump_debug(prefix_str, prefix_type, rowsize,    \
     404:                  groupsize, buf, len, ascii)    \
     405:     dynamic_hex_dump(prefix_str, prefix_type, rowsize,    \
     406:              groupsize, buf, len, ascii)
     407: #else
     408: #define print_hex_dump_debug(prefix_str, prefix_type, rowsize,        \
     409:                  groupsize, buf, len, ascii)        \
     410:     print_hex_dump(KERN_DEBUG, prefix_str, prefix_type, rowsize,    \
     411:                groupsize, buf, len, ascii)
     412: #endif /* defined(CONFIG_DYNAMIC_DEBUG) */
     413: 
     414: #endif
     415: