include/linux/ftrace.h

   1 #ifndef _LINUX_FTRACE_H
   2 #define _LINUX_FTRACE_H
   3
   4 #include <linux/linkage.h>
   5 #include <linux/fs.h>
   6 #include <linux/ktime.h>
   7 #include <linux/init.h>
   8 #include <linux/types.h>
   9 #include <linux/module.h>
  10 #include <linux/kallsyms.h>
  11 #include <linux/bitops.h>
  12 #include <linux/sched.h>
  13
  14 #ifdef CONFIG_FUNCTION_TRACER
  15
  16 extern int ftrace_enabled;
  17 extern int
  18 ftrace_enable_sysctl(struct ctl_table *table, int write,
  19                      struct file *filp, void __user *buffer, size_t *lenp,
  20                      loff_t *ppos);
  21
  22 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip);
  23
  24 struct ftrace_ops {
  25         ftrace_func_t     func;
  26         struct ftrace_ops *next;
  27 };
  28
  29 extern int function_trace_stop;
  30
  31 /*
  32  * Type of the current tracing.
  33  */
  34 enum ftrace_tracing_type_t {
  35         FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */
  36         FTRACE_TYPE_RETURN,     /* Hook the return of the function */
  37 };
  38
  39 /* Current tracing type, default is FTRACE_TYPE_ENTER */
  40 extern enum ftrace_tracing_type_t ftrace_tracing_type;
  41
  42 /**
  43  * ftrace_stop - stop function tracer.
  44  *
  45  * A quick way to stop the function tracer. Note this an on off switch,
  46  * it is not something that is recursive like preempt_disable.
  47  * This does not disable the calling of mcount, it only stops the
  48  * calling of functions from mcount.
  49  */
  50 static inline void ftrace_stop(void)
  51 {
  52         function_trace_stop = 1;
  53 }
  54
  55 /**
  56  * ftrace_start - start the function tracer.
  57  *
  58  * This function is the inverse of ftrace_stop. This does not enable
  59  * the function tracing if the function tracer is disabled. This only
  60  * sets the function tracer flag to continue calling the functions
  61  * from mcount.
  62  */
  63 static inline void ftrace_start(void)
  64 {
  65         function_trace_stop = 0;
  66 }
  67
  68 /*
  69  * The ftrace_ops must be a static and should also
  70  * be read_mostly.  These functions do modify read_mostly variables
  71  * so use them sparely. Never free an ftrace_op or modify the
  72  * next pointer after it has been registered. Even after unregistering
  73  * it, the next pointer may still be used internally.
  74  */
  75 int register_ftrace_function(struct ftrace_ops *ops);
  76 int unregister_ftrace_function(struct ftrace_ops *ops);
  77 void clear_ftrace_function(void);
  78
  79 extern void ftrace_stub(unsigned long a0, unsigned long a1);
  80
  81 #else /* !CONFIG_FUNCTION_TRACER */
  82 # define register_ftrace_function(ops) do { } while (0)
  83 # define unregister_ftrace_function(ops) do { } while (0)
  84 # define clear_ftrace_function(ops) do { } while (0)
  85 static inline void ftrace_kill(void) { }
  86 static inline void ftrace_stop(void) { }
  87 static inline void ftrace_start(void) { }
  88 #endif /* CONFIG_FUNCTION_TRACER */
  89
  90 #ifdef CONFIG_DYNAMIC_FTRACE
  91 /* asm/ftrace.h must be defined for archs supporting dynamic ftrace */
  92 #include <asm/ftrace.h>
  93
  94 enum {
  95         FTRACE_FL_FREE          = (1 << 0),
  96         FTRACE_FL_FAILED        = (1 << 1),
  97         FTRACE_FL_FILTER        = (1 << 2),
  98         FTRACE_FL_ENABLED       = (1 << 3),
  99         FTRACE_FL_NOTRACE       = (1 << 4),
 100         FTRACE_FL_CONVERTED     = (1 << 5),
 101         FTRACE_FL_FROZEN        = (1 << 6),
 102 };
 103
 104 struct dyn_ftrace {
 105         struct list_head        list;
 106         unsigned long           ip; /* address of mcount call-site */
 107         unsigned long           flags;
 108         struct dyn_arch_ftrace  arch;
 109 };
 110
 111 int ftrace_force_update(void);
 112 void ftrace_set_filter(unsigned char *buf, int len, int reset);
 113
 114 /* defined in arch */
 115 extern int ftrace_ip_converted(unsigned long ip);
 116 extern int ftrace_dyn_arch_init(void *data);
 117 extern int ftrace_update_ftrace_func(ftrace_func_t func);
 118 extern void ftrace_caller(void);
 119 extern void ftrace_call(void);
 120 extern void mcount_call(void);
 121 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 122 extern void ftrace_graph_caller(void);
 123 extern int ftrace_enable_ftrace_graph_caller(void);
 124 extern int ftrace_disable_ftrace_graph_caller(void);
 125 #else
 126 static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
 127 static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
 128 #endif
 129
 130 /**
 131  * ftrace_make_nop - convert code into top
 132  * @mod: module structure if called by module load initialization
 133  * @rec: the mcount call site record
 134  * @addr: the address that the call site should be calling
 135  *
 136  * This is a very sensitive operation and great care needs
 137  * to be taken by the arch.  The operation should carefully
 138  * read the location, check to see if what is read is indeed
 139  * what we expect it to be, and then on success of the compare,
 140  * it should write to the location.
 141  *
 142  * The code segment at @rec->ip should be a caller to @addr
 143  *
 144  * Return must be:
 145  *  0 on success
 146  *  -EFAULT on error reading the location
 147  *  -EINVAL on a failed compare of the contents
 148  *  -EPERM  on error writing to the location
 149  * Any other value will be considered a failure.
 150  */
 151 extern int ftrace_make_nop(struct module *mod,
 152                            struct dyn_ftrace *rec, unsigned long addr);
 153
 154 /**
 155  * ftrace_make_call - convert a nop call site into a call to addr
 156  * @rec: the mcount call site record
 157  * @addr: the address that the call site should call
 158  *
 159  * This is a very sensitive operation and great care needs
 160  * to be taken by the arch.  The operation should carefully
 161  * read the location, check to see if what is read is indeed
 162  * what we expect it to be, and then on success of the compare,
 163  * it should write to the location.
 164  *
 165  * The code segment at @rec->ip should be a nop
 166  *
 167  * Return must be:
 168  *  0 on success
 169  *  -EFAULT on error reading the location
 170  *  -EINVAL on a failed compare of the contents
 171  *  -EPERM  on error writing to the location
 172  * Any other value will be considered a failure.
 173  */
 174 extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
 175
 176
 177 /* May be defined in arch */
 178 extern int ftrace_arch_read_dyn_info(char *buf, int size);
 179
 180 extern int skip_trace(unsigned long ip);
 181
 182 extern void ftrace_release(void *start, unsigned long size);
 183
 184 extern void ftrace_disable_daemon(void);
 185 extern void ftrace_enable_daemon(void);
 186 #else
 187 # define skip_trace(ip)                         ({ 0; })
 188 # define ftrace_force_update()                  ({ 0; })
 189 # define ftrace_set_filter(buf, len, reset)     do { } while (0)
 190 # define ftrace_disable_daemon()                do { } while (0)
 191 # define ftrace_enable_daemon()                 do { } while (0)
 192 static inline void ftrace_release(void *start, unsigned long size) { }
 193 #endif /* CONFIG_DYNAMIC_FTRACE */
 194
 195 /* totally disable ftrace - can not re-enable after this */
 196 void ftrace_kill(void);
 197
 198 static inline void tracer_disable(void)
 199 {
 200 #ifdef CONFIG_FUNCTION_TRACER
 201         ftrace_enabled = 0;
 202 #endif
 203 }
 204
 205 /*
 206  * Ftrace disable/restore without lock. Some synchronization mechanism
 207  * must be used to prevent ftrace_enabled to be changed between
 208  * disable/restore.
 209  */
 210 static inline int __ftrace_enabled_save(void)
 211 {
 212 #ifdef CONFIG_FUNCTION_TRACER
 213         int saved_ftrace_enabled = ftrace_enabled;
 214         ftrace_enabled = 0;
 215         return saved_ftrace_enabled;
 216 #else
 217         return 0;
 218 #endif
 219 }
 220
 221 static inline void __ftrace_enabled_restore(int enabled)
 222 {
 223 #ifdef CONFIG_FUNCTION_TRACER
 224         ftrace_enabled = enabled;
 225 #endif
 226 }
 227
 228 #ifdef CONFIG_FRAME_POINTER
 229 /* TODO: need to fix this for ARM */
 230 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
 231 # define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
 232 # define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
 233 # define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
 234 # define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
 235 # define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
 236 # define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
 237 #else
 238 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
 239 # define CALLER_ADDR1 0UL
 240 # define CALLER_ADDR2 0UL
 241 # define CALLER_ADDR3 0UL
 242 # define CALLER_ADDR4 0UL
 243 # define CALLER_ADDR5 0UL
 244 # define CALLER_ADDR6 0UL
 245 #endif
 246
 247 #ifdef CONFIG_IRQSOFF_TRACER
 248   extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
 249   extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
 250 #else
 251 # define time_hardirqs_on(a0, a1)               do { } while (0)
 252 # define time_hardirqs_off(a0, a1)              do { } while (0)
 253 #endif
 254
 255 #ifdef CONFIG_PREEMPT_TRACER
 256   extern void trace_preempt_on(unsigned long a0, unsigned long a1);
 257   extern void trace_preempt_off(unsigned long a0, unsigned long a1);
 258 #else
 259 # define trace_preempt_on(a0, a1)               do { } while (0)
 260 # define trace_preempt_off(a0, a1)              do { } while (0)
 261 #endif
 262
 263 #ifdef CONFIG_TRACING
 264 extern int ftrace_dump_on_oops;
 265
 266 extern void tracing_start(void);
 267 extern void tracing_stop(void);
 268 extern void ftrace_off_permanent(void);
 269
 270 extern void
 271 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
 272
 273 /**
 274  * ftrace_printk - printf formatting in the ftrace buffer
 275  * @fmt: the printf format for printing
 276  *
 277  * Note: __ftrace_printk is an internal function for ftrace_printk and
 278  *       the @ip is passed in via the ftrace_printk macro.
 279  *
 280  * This function allows a kernel developer to debug fast path sections
 281  * that printk is not appropriate for. By scattering in various
 282  * printk like tracing in the code, a developer can quickly see
 283  * where problems are occurring.
 284  *
 285  * This is intended as a debugging tool for the developer only.
 286  * Please refrain from leaving ftrace_printks scattered around in
 287  * your code.
 288  */
 289 # define ftrace_printk(fmt...) __ftrace_printk(_THIS_IP_, fmt)
 290 extern int
 291 __ftrace_printk(unsigned long ip, const char *fmt, ...)
 292         __attribute__ ((format (printf, 2, 3)));
 293 extern void ftrace_dump(void);
 294 #else
 295 static inline void
 296 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
 297 static inline int
 298 ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 0)));
 299
 300 static inline void tracing_start(void) { }
 301 static inline void tracing_stop(void) { }
 302 static inline void ftrace_off_permanent(void) { }
 303 static inline int
 304 ftrace_printk(const char *fmt, ...)
 305 {
 306         return 0;
 307 }
 308 static inline void ftrace_dump(void) { }
 309 #endif
 310
 311 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
 312 extern void ftrace_init(void);
 313 extern void ftrace_init_module(struct module *mod,
 314                                unsigned long *start, unsigned long *end);
 315 #else
 316 static inline void ftrace_init(void) { }
 317 static inline void
 318 ftrace_init_module(struct module *mod,
 319                    unsigned long *start, unsigned long *end) { }
 320 #endif
 321
 322 enum {
 323         POWER_NONE = 0,
 324         POWER_CSTATE = 1,
 325         POWER_PSTATE = 2,
 326 };
 327
 328 struct power_trace {
 329 #ifdef CONFIG_POWER_TRACER
 330         ktime_t                 stamp;
 331         ktime_t                 end;
 332         int                     type;
 333         int                     state;
 334 #endif
 335 };
 336
 337 #ifdef CONFIG_POWER_TRACER
 338 extern void trace_power_start(struct power_trace *it, unsigned int type,
 339                                         unsigned int state);
 340 extern void trace_power_mark(struct power_trace *it, unsigned int type,
 341                                         unsigned int state);
 342 extern void trace_power_end(struct power_trace *it);
 343 #else
 344 static inline void trace_power_start(struct power_trace *it, unsigned int type,
 345                                         unsigned int state) { }
 346 static inline void trace_power_mark(struct power_trace *it, unsigned int type,
 347                                         unsigned int state) { }
 348 static inline void trace_power_end(struct power_trace *it) { }
 349 #endif
 350
 351
 352 /*
 353  * Structure that defines an entry function trace.
 354  */
 355 struct ftrace_graph_ent {
 356         unsigned long func; /* Current function */
 357         int depth;
 358 };
 359
 360 /*
 361  * Structure that defines a return function trace.
 362  */
 363 struct ftrace_graph_ret {
 364         unsigned long func; /* Current function */
 365         unsigned long long calltime;
 366         unsigned long long rettime;
 367         /* Number of functions that overran the depth limit for current task */
 368         unsigned long overrun;
 369         int depth;
 370 };
 371
 372 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 373
 374 /*
 375  * Sometimes we don't want to trace a function with the function
 376  * graph tracer but we want them to keep traced by the usual function
 377  * tracer if the function graph tracer is not configured.
 378  */
 379 #define __notrace_funcgraph             notrace
 380
 381 #define FTRACE_RETFUNC_DEPTH 50
 382 #define FTRACE_RETSTACK_ALLOC_SIZE 32
 383 /* Type of the callback handlers for tracing function graph*/
 384 typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
 385 typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
 386
 387 extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
 388                                 trace_func_graph_ent_t entryfunc);
 389
 390 extern void ftrace_graph_stop(void);
 391
 392 /* The current handlers in use */
 393 extern trace_func_graph_ret_t ftrace_graph_return;
 394 extern trace_func_graph_ent_t ftrace_graph_entry;
 395
 396 extern void unregister_ftrace_graph(void);
 397
 398 extern void ftrace_graph_init_task(struct task_struct *t);
 399 extern void ftrace_graph_exit_task(struct task_struct *t);
 400
 401 static inline int task_curr_ret_stack(struct task_struct *t)
 402 {
 403         return t->curr_ret_stack;
 404 }
 405
 406 static inline void pause_graph_tracing(void)
 407 {
 408         atomic_inc(&current->tracing_graph_pause);
 409 }
 410
 411 static inline void unpause_graph_tracing(void)
 412 {
 413         atomic_dec(&current->tracing_graph_pause);
 414 }
 415 #else
 416
 417 #define __notrace_funcgraph
 418
 419 static inline void ftrace_graph_init_task(struct task_struct *t) { }
 420 static inline void ftrace_graph_exit_task(struct task_struct *t) { }
 421
 422 static inline int task_curr_ret_stack(struct task_struct *tsk)
 423 {
 424         return -1;
 425 }
 426
 427 static inline void pause_graph_tracing(void) { }
 428 static inline void unpause_graph_tracing(void) { }
 429 #endif
 430
 431 #ifdef CONFIG_TRACING
 432 #include <linux/sched.h>
 433
 434 /* flags for current->trace */
 435 enum {
 436         TSK_TRACE_FL_TRACE_BIT  = 0,
 437         TSK_TRACE_FL_GRAPH_BIT  = 1,
 438 };
 439 enum {
 440         TSK_TRACE_FL_TRACE      = 1 << TSK_TRACE_FL_TRACE_BIT,
 441         TSK_TRACE_FL_GRAPH      = 1 << TSK_TRACE_FL_GRAPH_BIT,
 442 };
 443
 444 static inline void set_tsk_trace_trace(struct task_struct *tsk)
 445 {
 446         set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
 447 }
 448
 449 static inline void clear_tsk_trace_trace(struct task_struct *tsk)
 450 {
 451         clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
 452 }
 453
 454 static inline int test_tsk_trace_trace(struct task_struct *tsk)
 455 {
 456         return tsk->trace & TSK_TRACE_FL_TRACE;
 457 }
 458
 459 static inline void set_tsk_trace_graph(struct task_struct *tsk)
 460 {
 461         set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
 462 }
 463
 464 static inline void clear_tsk_trace_graph(struct task_struct *tsk)
 465 {
 466         clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
 467 }
 468
 469 static inline int test_tsk_trace_graph(struct task_struct *tsk)
 470 {
 471         return tsk->trace & TSK_TRACE_FL_GRAPH;
 472 }
 473
 474 #endif /* CONFIG_TRACING */
 475
 476 #endif /* _LINUX_FTRACE_H */