printk.h 9.2 KB
Newer Older
1 2 3
#ifndef __KERNEL_PRINTK__
#define __KERNEL_PRINTK__

4
#include <linux/init.h>
5
#include <linux/kern_levels.h>
6

7 8 9
extern const char linux_banner[];
extern const char linux_proc_banner[];

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
static inline int printk_get_level(const char *buffer)
{
	if (buffer[0] == '<' && buffer[1] && buffer[2] == '>') {
		switch (buffer[1]) {
		case '0' ... '7':
		case 'd':	/* KERN_DEFAULT */
		case 'c':	/* KERN_CONT */
			return buffer[1];
		}
	}
	return 0;
}

static inline const char *printk_skip_level(const char *buffer)
{
	if (printk_get_level(buffer)) {
		switch (buffer[1]) {
		case '0' ... '7':
		case 'd':	/* KERN_DEFAULT */
		case 'c':	/* KERN_CONT */
			return buffer + 3;
		}
	}
	return buffer;
}

36 37 38 39 40 41 42
extern int console_printk[];

#define console_loglevel (console_printk[0])
#define default_message_loglevel (console_printk[1])
#define minimum_console_loglevel (console_printk[2])
#define default_console_loglevel (console_printk[3])

43 44 45 46 47 48 49 50 51 52 53
static inline void console_silent(void)
{
	console_loglevel = 0;
}

static inline void console_verbose(void)
{
	if (console_loglevel)
		console_loglevel = 15;
}

54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
struct va_format {
	const char *fmt;
	va_list *va;
};

/*
 * FW_BUG
 * Add this to a message where you are sure the firmware is buggy or behaves
 * really stupid or out of spec. Be aware that the responsible BIOS developer
 * should be able to fix this issue or at least get a concrete idea of the
 * problem by reading your message without the need of looking at the kernel
 * code.
 *
 * Use it for definite and high priority BIOS bugs.
 *
 * FW_WARN
 * Use it for not that clear (e.g. could the kernel messed up things already?)
 * and medium priority BIOS bugs.
 *
 * FW_INFO
 * Use this one if you want to tell the user or vendor about something
 * suspicious, but generally harmless related to the firmware.
 *
 * Use it for information or very low priority BIOS bugs.
 */
#define FW_BUG		"[Firmware Bug]: "
#define FW_WARN		"[Firmware Warn]: "
#define FW_INFO		"[Firmware Info]: "

/*
 * HW_ERR
 * Add this to a message for hardware errors, so that user can report
 * it to hardware vendor instead of LKML or software vendor.
 */
#define HW_ERR		"[Hardware Error]: "

90 91 92 93
/*
 * Dummy printk for disabled debugging statements to use whilst maintaining
 * gcc's format and side-effect checking.
 */
94
static inline __printf(1, 2)
95 96 97 98 99
int no_printk(const char *fmt, ...)
{
	return 0;
}

100
extern asmlinkage __printf(1, 2)
101 102 103 104 105
void early_printk(const char *fmt, ...);

extern int printk_needs_cpu(int cpu);
extern void printk_tick(void);

106
#ifdef CONFIG_PRINTK
107 108 109 110 111
asmlinkage __printf(5, 0)
int vprintk_emit(int facility, int level,
		 const char *dict, size_t dictlen,
		 const char *fmt, va_list args);

112
asmlinkage __printf(1, 0)
113
int vprintk(const char *fmt, va_list args);
114 115 116 117 118 119

asmlinkage __printf(5, 6) __cold
asmlinkage int printk_emit(int facility, int level,
			   const char *dict, size_t dictlen,
			   const char *fmt, ...);

120
asmlinkage __printf(1, 2) __cold
121
int printk(const char *fmt, ...);
122

123 124 125 126 127
/*
 * Special printk facility for scheduler use only, _DO_NOT_USE_ !
 */
__printf(1, 2) __cold int printk_sched(const char *fmt, ...);

128 129 130 131 132 133 134 135 136 137 138 139
/*
 * Please don't use printk_ratelimit(), because it shares ratelimiting state
 * with all other unrelated printk_ratelimit() callsites.  Instead use
 * printk_ratelimited() or plain old __ratelimit().
 */
extern int __printk_ratelimit(const char *func);
#define printk_ratelimit() __printk_ratelimit(__func__)
extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
				   unsigned int interval_msec);

extern int printk_delay_msec;
extern int dmesg_restrict;
140
extern int kptr_restrict;
141 142

void log_buf_kexec_setup(void);
143
void __init setup_log_buf(int early);
144
#else
145
static inline __printf(1, 0)
146 147 148 149
int vprintk(const char *s, va_list args)
{
	return 0;
}
150
static inline __printf(1, 2) __cold
151 152 153 154
int printk(const char *s, ...)
{
	return 0;
}
155 156 157 158 159
static inline __printf(1, 2) __cold
int printk_sched(const char *s, ...)
{
	return 0;
}
160 161 162 163 164 165 166 167 168
static inline int printk_ratelimit(void)
{
	return 0;
}
static inline bool printk_timed_ratelimit(unsigned long *caller_jiffies,
					  unsigned int interval_msec)
{
	return false;
}
169 170 171 172

static inline void log_buf_kexec_setup(void)
{
}
173 174 175 176

static inline void setup_log_buf(int early)
{
}
177 178 179 180 181 182 183 184 185
#endif

extern void dump_stack(void) __cold;

#ifndef pr_fmt
#define pr_fmt(fmt) fmt
#endif

#define pr_emerg(fmt, ...) \
186
	printk(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
187
#define pr_alert(fmt, ...) \
188
	printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
189
#define pr_crit(fmt, ...) \
190
	printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
191
#define pr_err(fmt, ...) \
192
	printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
193
#define pr_warning(fmt, ...) \
194
	printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
195 196
#define pr_warn pr_warning
#define pr_notice(fmt, ...) \
197
	printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
198
#define pr_info(fmt, ...) \
199
	printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
200 201 202 203 204 205 206 207 208
#define pr_cont(fmt, ...) \
	printk(KERN_CONT fmt, ##__VA_ARGS__)

/* pr_devel() should produce zero code unless DEBUG is defined */
#ifdef DEBUG
#define pr_devel(fmt, ...) \
	printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
#else
#define pr_devel(fmt, ...) \
209
	no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
210 211 212
#endif

/* If you are writing a driver, please use dev_dbg instead */
213
#if defined(CONFIG_DYNAMIC_DEBUG)
214 215 216
/* dynamic_pr_debug() uses pr_fmt() internally so we don't need it here */
#define pr_debug(fmt, ...) \
	dynamic_pr_debug(fmt, ##__VA_ARGS__)
217 218 219
#elif defined(DEBUG)
#define pr_debug(fmt, ...) \
	printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
220 221
#else
#define pr_debug(fmt, ...) \
222
	no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
223 224
#endif

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
/*
 * Print a one-time message (analogous to WARN_ONCE() et al):
 */

#ifdef CONFIG_PRINTK
#define printk_once(fmt, ...)			\
({						\
	static bool __print_once;		\
						\
	if (!__print_once) {			\
		__print_once = true;		\
		printk(fmt, ##__VA_ARGS__);	\
	}					\
})
#else
#define printk_once(fmt, ...)			\
	no_printk(fmt, ##__VA_ARGS__)
#endif

#define pr_emerg_once(fmt, ...)					\
	printk_once(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
#define pr_alert_once(fmt, ...)					\
	printk_once(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
#define pr_crit_once(fmt, ...)					\
	printk_once(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
#define pr_err_once(fmt, ...)					\
	printk_once(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
#define pr_warn_once(fmt, ...)					\
	printk_once(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
#define pr_notice_once(fmt, ...)				\
	printk_once(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
#define pr_info_once(fmt, ...)					\
	printk_once(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
#define pr_cont_once(fmt, ...)					\
	printk_once(KERN_CONT pr_fmt(fmt), ##__VA_ARGS__)
/* If you are writing a driver, please use dev_dbg instead */
#if defined(DEBUG)
#define pr_debug_once(fmt, ...)					\
	printk_once(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
#else
#define pr_debug_once(fmt, ...)					\
	no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
#endif

269 270 271 272 273
/*
 * ratelimited messages with local ratelimit_state,
 * no local ratelimit_state used in the !PRINTK case
 */
#ifdef CONFIG_PRINTK
274 275
#define printk_ratelimited(fmt, ...)					\
({									\
276 277 278 279 280 281 282 283
	static DEFINE_RATELIMIT_STATE(_rs,				\
				      DEFAULT_RATELIMIT_INTERVAL,	\
				      DEFAULT_RATELIMIT_BURST);		\
									\
	if (__ratelimit(&_rs))						\
		printk(fmt, ##__VA_ARGS__);				\
})
#else
284 285
#define printk_ratelimited(fmt, ...)					\
	no_printk(fmt, ##__VA_ARGS__)
286 287
#endif

288
#define pr_emerg_ratelimited(fmt, ...)					\
289
	printk_ratelimited(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
290
#define pr_alert_ratelimited(fmt, ...)					\
291
	printk_ratelimited(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
292
#define pr_crit_ratelimited(fmt, ...)					\
293
	printk_ratelimited(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
294
#define pr_err_ratelimited(fmt, ...)					\
295
	printk_ratelimited(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
296
#define pr_warn_ratelimited(fmt, ...)					\
297
	printk_ratelimited(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
298
#define pr_notice_ratelimited(fmt, ...)					\
299
	printk_ratelimited(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
300
#define pr_info_ratelimited(fmt, ...)					\
301 302 303 304
	printk_ratelimited(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
/* no pr_cont_ratelimited, don't do that... */
/* If you are writing a driver, please use dev_dbg instead */
#if defined(DEBUG)
305
#define pr_debug_ratelimited(fmt, ...)					\
306 307 308
	printk_ratelimited(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
#else
#define pr_debug_ratelimited(fmt, ...) \
309
	no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
310 311
#endif

312 313
extern const struct file_operations kmsg_fops;

314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
enum {
	DUMP_PREFIX_NONE,
	DUMP_PREFIX_ADDRESS,
	DUMP_PREFIX_OFFSET
};
extern void hex_dump_to_buffer(const void *buf, size_t len,
			       int rowsize, int groupsize,
			       char *linebuf, size_t linebuflen, bool ascii);
#ifdef CONFIG_PRINTK
extern void print_hex_dump(const char *level, const char *prefix_str,
			   int prefix_type, int rowsize, int groupsize,
			   const void *buf, size_t len, bool ascii);
extern void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
				 const void *buf, size_t len);
#else
static inline void print_hex_dump(const char *level, const char *prefix_str,
				  int prefix_type, int rowsize, int groupsize,
				  const void *buf, size_t len, bool ascii)
{
}
static inline void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
					const void *buf, size_t len)
{
}

#endif

341
#endif