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