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: