Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203/* SPDX-License-Identifier: GPL-2.0 */#ifndef _LINUX_TRACE_PRINTK_H#define _LINUX_TRACE_PRINTK_H
#include <linux/compiler_attributes.h>#include <linux/instruction_pointer.h>#include <linux/stddef.h>#include <linux/stringify.h>
/* * General tracing related utility functions - trace_printk(), * tracing_on/tracing_off and tracing_start()/tracing_stop * * Use tracing_on/tracing_off when you want to quickly turn on or off * tracing. It simply enables or disables the recording of the trace events. * This also corresponds to the user space /sys/kernel/tracing/tracing_on * file, which gives a means for the kernel and userspace to interact. * Place a tracing_off() in the kernel where you want tracing to end. * From user space, examine the trace, and then echo 1 > tracing_on * to continue tracing. * * tracing_stop/tracing_start has slightly more overhead. It is used * by things like suspend to ram where disabling the recording of the * trace is not enough, but tracing must actually stop because things * like calling smp_processor_id() may crash the system. * * Most likely, you want to use tracing_on/tracing_off. */
enum ftrace_dump_mode { DUMP_NONE, DUMP_ALL, DUMP_ORIG, DUMP_PARAM,};
#ifdef CONFIG_TRACINGvoid tracing_on(void);void tracing_off(void);int tracing_is_on(void);void tracing_snapshot(void);void tracing_snapshot_alloc(void);
extern void tracing_start(void);extern void tracing_stop(void);
static inline __printf(1, 2)void ____trace_printk_check_format(const char *fmt, ...){}#define __trace_printk_check_format(fmt, args...) \do { \ if (0) \ ____trace_printk_check_format(fmt, ##args); \} while (0)
/** * trace_printk - printf formatting in the ftrace buffer * @fmt: the printf format for printing * * Note: __trace_printk is an internal function for trace_printk() and * the @ip is passed in via the trace_printk() macro. * * This function allows a kernel developer to debug fast path sections * that printk is not appropriate for. By scattering in various * printk like tracing in the code, a developer can quickly see * where problems are occurring. * * This is intended as a debugging tool for the developer only. * Please refrain from leaving trace_printks scattered around in * your code. (Extra memory is used for special buffers that are * allocated when trace_printk() is used.) * * A little optimization trick is done here. If there's only one * argument, there's no need to scan the string for printf formats. * The trace_puts() will suffice. But how can we take advantage of * using trace_puts() when trace_printk() has only one argument? * By stringifying the args and checking the size we can tell * whether or not there are args. __stringify((__VA_ARGS__)) will * turn into "()\0" with a size of 3 when there are no args, anything * else will be bigger. All we need to do is define a string to this, * and then take its size and compare to 3. If it's bigger, use * do_trace_printk() otherwise, optimize it to trace_puts(). Then just * let gcc optimize the rest. */
#define trace_printk(fmt, ...) \do { \ if (sizeof __stringify((__VA_ARGS__)) > 3) \ do_trace_printk(fmt, ##__VA_ARGS__); \ else \ trace_puts(fmt); \} while (0)
#define do_trace_printk(fmt, args...) \do { \ static const char *trace_printk_fmt __used \ __section("__trace_printk_fmt") = \ __builtin_constant_p(fmt) ? fmt : NULL; \ \ __trace_printk_check_format(fmt, ##args); \ \ if (__builtin_constant_p(fmt)) \ __trace_bprintk(_THIS_IP_, trace_printk_fmt, ##args); \ else \ __trace_printk(_THIS_IP_, fmt, ##args); \} while (0)
int __trace_bprintk(unsigned long ip, const char *fmt, ...);
extern __printf(2, 3)int __trace_printk(unsigned long ip, const char *fmt, ...);
/** * trace_puts - write a string into the ftrace buffer * @str: the string to record * * Note: __trace_bputs is an internal function for trace_puts and * the @ip is passed in via the trace_puts macro. * * This is similar to trace_printk() but is made for those really fast * paths that a developer wants the least amount of "Heisenbug" effects, * where the processing of the print format is still too much. * * This function allows a kernel developer to debug fast path sections * that printk is not appropriate for. By scattering in various * printk like tracing in the code, a developer can quickly see * where problems are occurring. * * This is intended as a debugging tool for the developer only. * Please refrain from leaving trace_puts scattered around in * your code. (Extra memory is used for special buffers that are * allocated when trace_puts() is used.) * * Returns: 0 if nothing was written, positive # if string was. * (1 when __trace_bputs is used, strlen(str) when __trace_puts is used) */
#define trace_puts(str) ({ \ static const char *trace_printk_fmt __used \ __section("__trace_printk_fmt") = \ __builtin_constant_p(str) ? str : NULL; \ \ if (__builtin_constant_p(str)) \ __trace_bputs(_THIS_IP_, trace_printk_fmt); \ else \ __trace_puts(_THIS_IP_, str); \})extern int __trace_bputs(unsigned long ip, const char *str);extern int __trace_puts(unsigned long ip, const char *str);
extern void trace_dump_stack(int skip);
/* * The double __builtin_constant_p is because gcc will give us an error * if we try to allocate the static variable to fmt if it is not a * constant. Even with the outer if statement. */#define ftrace_vprintk(fmt, vargs) \do { \ if (__builtin_constant_p(fmt)) { \ static const char *trace_printk_fmt __used \ __section("__trace_printk_fmt") = \ __builtin_constant_p(fmt) ? fmt : NULL; \ \ __ftrace_vbprintk(_THIS_IP_, trace_printk_fmt, vargs); \ } else \ __ftrace_vprintk(_THIS_IP_, fmt, vargs); \} while (0)
extern __printf(2, 0) int__ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);
extern __printf(2, 0) int__ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode);#elsestatic inline void tracing_start(void) { }static inline void tracing_stop(void) { }static inline void trace_dump_stack(int skip) { }
static inline void tracing_on(void) { }static inline void tracing_off(void) { }static inline int tracing_is_on(void) { return 0; }static inline void tracing_snapshot(void) { }static inline void tracing_snapshot_alloc(void) { }
static inline __printf(1, 2)int trace_printk(const char *fmt, ...){ return 0;}static __printf(1, 0) inline intftrace_vprintk(const char *fmt, va_list ap){ return 0;}static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }#endif /* CONFIG_TRACING */
#endif