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