Pileus Git - ~andy/linux/blob - include/linux/ftrace.h

   1 /*
   2  * Ftrace header.  For implementation details beyond the random comments
   3  * scattered below, see: Documentation/trace/ftrace-design.txt
   4  */
   5
   6 #ifndef _LINUX_FTRACE_H
   7 #define _LINUX_FTRACE_H
   8
   9 #include <linux/trace_clock.h>
  10 #include <linux/kallsyms.h>
  11 #include <linux/linkage.h>
  12 #include <linux/bitops.h>
  13 #include <linux/module.h>
  14 #include <linux/ktime.h>
  15 #include <linux/sched.h>
  16 #include <linux/types.h>
  17 #include <linux/init.h>
  18 #include <linux/fs.h>
  19
  20 #include <asm/ftrace.h>
  21
  22 #ifdef CONFIG_FUNCTION_TRACER
  23
  24 extern int ftrace_enabled;
  25 extern int
  26 ftrace_enable_sysctl(struct ctl_table *table, int write,
  27                      void __user *buffer, size_t *lenp,
  28                      loff_t *ppos);
  29
  30 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip);
  31
  32 struct ftrace_hash;
  33
  34 enum {
  35         FTRACE_OPS_FL_ENABLED           = 1 << 0,
  36         FTRACE_OPS_FL_GLOBAL            = 1 << 1,
  37 };
  38
  39 struct ftrace_ops {
  40         ftrace_func_t                   func;
  41         struct ftrace_ops               *next;
  42         unsigned long                   flags;
  43 #ifdef CONFIG_DYNAMIC_FTRACE
  44         struct ftrace_hash              *notrace_hash;
  45         struct ftrace_hash              *filter_hash;
  46 #endif
  47 };
  48
  49 extern int function_trace_stop;
  50
  51 /*
  52  * Type of the current tracing.
  53  */
  54 enum ftrace_tracing_type_t {
  55         FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */
  56         FTRACE_TYPE_RETURN,     /* Hook the return of the function */
  57 };
  58
  59 /* Current tracing type, default is FTRACE_TYPE_ENTER */
  60 extern enum ftrace_tracing_type_t ftrace_tracing_type;
  61
  62 /**
  63  * ftrace_stop - stop function tracer.
  64  *
  65  * A quick way to stop the function tracer. Note this an on off switch,
  66  * it is not something that is recursive like preempt_disable.
  67  * This does not disable the calling of mcount, it only stops the
  68  * calling of functions from mcount.
  69  */
  70 static inline void ftrace_stop(void)
  71 {
  72         function_trace_stop = 1;
  73 }
  74
  75 /**
  76  * ftrace_start - start the function tracer.
  77  *
  78  * This function is the inverse of ftrace_stop. This does not enable
  79  * the function tracing if the function tracer is disabled. This only
  80  * sets the function tracer flag to continue calling the functions
  81  * from mcount.
  82  */
  83 static inline void ftrace_start(void)
  84 {
  85         function_trace_stop = 0;
  86 }
  87
  88 /*
  89  * The ftrace_ops must be a static and should also
  90  * be read_mostly.  These functions do modify read_mostly variables
  91  * so use them sparely. Never free an ftrace_op or modify the
  92  * next pointer after it has been registered. Even after unregistering
  93  * it, the next pointer may still be used internally.
  94  */
  95 int register_ftrace_function(struct ftrace_ops *ops);
  96 int unregister_ftrace_function(struct ftrace_ops *ops);
  97 void clear_ftrace_function(void);
  98
  99 extern void ftrace_stub(unsigned long a0, unsigned long a1);
 100
 101 #else /* !CONFIG_FUNCTION_TRACER */
 102 /*
 103  * (un)register_ftrace_function must be a macro since the ops parameter
 104  * must not be evaluated.
 105  */
 106 #define register_ftrace_function(ops) ({ 0; })
 107 #define unregister_ftrace_function(ops) ({ 0; })
 108 static inline void clear_ftrace_function(void) { }
 109 static inline void ftrace_kill(void) { }
 110 static inline void ftrace_stop(void) { }
 111 static inline void ftrace_start(void) { }
 112 #endif /* CONFIG_FUNCTION_TRACER */
 113
 114 #ifdef CONFIG_STACK_TRACER
 115 extern int stack_tracer_enabled;
 116 int
 117 stack_trace_sysctl(struct ctl_table *table, int write,
 118                    void __user *buffer, size_t *lenp,
 119                    loff_t *ppos);
 120 #endif
 121
 122 struct ftrace_func_command {
 123         struct list_head        list;
 124         char                    *name;
 125         int                     (*func)(char *func, char *cmd,
 126                                         char *params, int enable);
 127 };
 128
 129 #ifdef CONFIG_DYNAMIC_FTRACE
 130
 131 int ftrace_arch_code_modify_prepare(void);
 132 int ftrace_arch_code_modify_post_process(void);
 133
 134 struct seq_file;
 135
 136 struct ftrace_probe_ops {
 137         void                    (*func)(unsigned long ip,
 138                                         unsigned long parent_ip,
 139                                         void **data);
 140         int                     (*callback)(unsigned long ip, void **data);
 141         void                    (*free)(void **data);
 142         int                     (*print)(struct seq_file *m,
 143                                          unsigned long ip,
 144                                          struct ftrace_probe_ops *ops,
 145                                          void *data);
 146 };
 147
 148 extern int
 149 register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
 150                               void *data);
 151 extern void
 152 unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
 153                                 void *data);
 154 extern void
 155 unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
 156 extern void unregister_ftrace_function_probe_all(char *glob);
 157
 158 extern int ftrace_text_reserved(void *start, void *end);
 159
 160 enum {
 161         FTRACE_FL_ENABLED       = (1 << 30),
 162         FTRACE_FL_FREE          = (1 << 31),
 163 };
 164
 165 #define FTRACE_FL_MASK          (0x3UL << 30)
 166 #define FTRACE_REF_MAX          ((1 << 30) - 1)
 167
 168 struct dyn_ftrace {
 169         union {
 170                 unsigned long           ip; /* address of mcount call-site */
 171                 struct dyn_ftrace       *freelist;
 172         };
 173         union {
 174                 unsigned long           flags;
 175                 struct dyn_ftrace       *newlist;
 176         };
 177         struct dyn_arch_ftrace          arch;
 178 };
 179
 180 int ftrace_force_update(void);
 181 void ftrace_set_filter(unsigned char *buf, int len, int reset);
 182
 183 int register_ftrace_command(struct ftrace_func_command *cmd);
 184 int unregister_ftrace_command(struct ftrace_func_command *cmd);
 185
 186 /* defined in arch */
 187 extern int ftrace_ip_converted(unsigned long ip);
 188 extern int ftrace_dyn_arch_init(void *data);
 189 extern int ftrace_update_ftrace_func(ftrace_func_t func);
 190 extern void ftrace_caller(void);
 191 extern void ftrace_call(void);
 192 extern void mcount_call(void);
 193
 194 #ifndef FTRACE_ADDR
 195 #define FTRACE_ADDR ((unsigned long)ftrace_caller)
 196 #endif
 197 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 198 extern void ftrace_graph_caller(void);
 199 extern int ftrace_enable_ftrace_graph_caller(void);
 200 extern int ftrace_disable_ftrace_graph_caller(void);
 201 #else
 202 static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
 203 static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
 204 #endif
 205
 206 /**
 207  * ftrace_make_nop - convert code into nop
 208  * @mod: module structure if called by module load initialization
 209  * @rec: the mcount call site record
 210  * @addr: the address that the call site should be calling
 211  *
 212  * This is a very sensitive operation and great care needs
 213  * to be taken by the arch.  The operation should carefully
 214  * read the location, check to see if what is read is indeed
 215  * what we expect it to be, and then on success of the compare,
 216  * it should write to the location.
 217  *
 218  * The code segment at @rec->ip should be a caller to @addr
 219  *
 220  * Return must be:
 221  *  0 on success
 222  *  -EFAULT on error reading the location
 223  *  -EINVAL on a failed compare of the contents
 224  *  -EPERM  on error writing to the location
 225  * Any other value will be considered a failure.
 226  */
 227 extern int ftrace_make_nop(struct module *mod,
 228                            struct dyn_ftrace *rec, unsigned long addr);
 229
 230 /**
 231  * ftrace_make_call - convert a nop call site into a call to addr
 232  * @rec: the mcount call site record
 233  * @addr: the address that the call site should call
 234  *
 235  * This is a very sensitive operation and great care needs
 236  * to be taken by the arch.  The operation should carefully
 237  * read the location, check to see if what is read is indeed
 238  * what we expect it to be, and then on success of the compare,
 239  * it should write to the location.
 240  *
 241  * The code segment at @rec->ip should be a nop
 242  *
 243  * Return must be:
 244  *  0 on success
 245  *  -EFAULT on error reading the location
 246  *  -EINVAL on a failed compare of the contents
 247  *  -EPERM  on error writing to the location
 248  * Any other value will be considered a failure.
 249  */
 250 extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
 251
 252 /* May be defined in arch */
 253 extern int ftrace_arch_read_dyn_info(char *buf, int size);
 254
 255 extern int skip_trace(unsigned long ip);
 256
 257 extern void ftrace_disable_daemon(void);
 258 extern void ftrace_enable_daemon(void);
 259 #else
 260 static inline int skip_trace(unsigned long ip) { return 0; }
 261 static inline int ftrace_force_update(void) { return 0; }
 262 static inline void ftrace_set_filter(unsigned char *buf, int len, int reset)
 263 {
 264 }
 265 static inline void ftrace_disable_daemon(void) { }
 266 static inline void ftrace_enable_daemon(void) { }
 267 static inline void ftrace_release_mod(struct module *mod) {}
 268 static inline int register_ftrace_command(struct ftrace_func_command *cmd)
 269 {
 270         return -EINVAL;
 271 }
 272 static inline int unregister_ftrace_command(char *cmd_name)
 273 {
 274         return -EINVAL;
 275 }
 276 static inline int ftrace_text_reserved(void *start, void *end)
 277 {
 278         return 0;
 279 }
 280 #endif /* CONFIG_DYNAMIC_FTRACE */
 281
 282 /* totally disable ftrace - can not re-enable after this */
 283 void ftrace_kill(void);
 284
 285 static inline void tracer_disable(void)
 286 {
 287 #ifdef CONFIG_FUNCTION_TRACER
 288         ftrace_enabled = 0;
 289 #endif
 290 }
 291
 292 /*
 293  * Ftrace disable/restore without lock. Some synchronization mechanism
 294  * must be used to prevent ftrace_enabled to be changed between
 295  * disable/restore.
 296  */
 297 static inline int __ftrace_enabled_save(void)
 298 {
 299 #ifdef CONFIG_FUNCTION_TRACER
 300         int saved_ftrace_enabled = ftrace_enabled;
 301         ftrace_enabled = 0;
 302         return saved_ftrace_enabled;
 303 #else
 304         return 0;
 305 #endif
 306 }
 307
 308 static inline void __ftrace_enabled_restore(int enabled)
 309 {
 310 #ifdef CONFIG_FUNCTION_TRACER
 311         ftrace_enabled = enabled;
 312 #endif
 313 }
 314
 315 #ifndef HAVE_ARCH_CALLER_ADDR
 316 # ifdef CONFIG_FRAME_POINTER
 317 #  define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
 318 #  define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
 319 #  define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
 320 #  define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
 321 #  define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
 322 #  define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
 323 #  define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
 324 # else
 325 #  define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
 326 #  define CALLER_ADDR1 0UL
 327 #  define CALLER_ADDR2 0UL
 328 #  define CALLER_ADDR3 0UL
 329 #  define CALLER_ADDR4 0UL
 330 #  define CALLER_ADDR5 0UL
 331 #  define CALLER_ADDR6 0UL
 332 # endif
 333 #endif /* ifndef HAVE_ARCH_CALLER_ADDR */
 334
 335 #ifdef CONFIG_IRQSOFF_TRACER
 336   extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
 337   extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
 338 #else
 339   static inline void time_hardirqs_on(unsigned long a0, unsigned long a1) { }
 340   static inline void time_hardirqs_off(unsigned long a0, unsigned long a1) { }
 341 #endif
 342
 343 #ifdef CONFIG_PREEMPT_TRACER
 344   extern void trace_preempt_on(unsigned long a0, unsigned long a1);
 345   extern void trace_preempt_off(unsigned long a0, unsigned long a1);
 346 #else
 347   static inline void trace_preempt_on(unsigned long a0, unsigned long a1) { }
 348   static inline void trace_preempt_off(unsigned long a0, unsigned long a1) { }
 349 #endif
 350
 351 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
 352 extern void ftrace_init(void);
 353 #else
 354 static inline void ftrace_init(void) { }
 355 #endif
 356
 357 /*
 358  * Structure that defines an entry function trace.
 359  */
 360 struct ftrace_graph_ent {
 361         unsigned long func; /* Current function */
 362         int depth;
 363 };
 364
 365 /*
 366  * Structure that defines a return function trace.
 367  */
 368 struct ftrace_graph_ret {
 369         unsigned long func; /* Current function */
 370         unsigned long long calltime;
 371         unsigned long long rettime;
 372         /* Number of functions that overran the depth limit for current task */
 373         unsigned long overrun;
 374         int depth;
 375 };
 376
 377 /* Type of the callback handlers for tracing function graph*/
 378 typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
 379 typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
 380
 381 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 382
 383 /* for init task */
 384 #define INIT_FTRACE_GRAPH               .ret_stack = NULL,
 385
 386 /*
 387  * Stack of return addresses for functions
 388  * of a thread.
 389  * Used in struct thread_info
 390  */
 391 struct ftrace_ret_stack {
 392         unsigned long ret;
 393         unsigned long func;
 394         unsigned long long calltime;
 395         unsigned long long subtime;
 396         unsigned long fp;
 397 };
 398
 399 /*
 400  * Primary handler of a function return.
 401  * It relays on ftrace_return_to_handler.
 402  * Defined in entry_32/64.S
 403  */
 404 extern void return_to_handler(void);
 405
 406 extern int
 407 ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,
 408                          unsigned long frame_pointer);
 409
 410 /*
 411  * Sometimes we don't want to trace a function with the function
 412  * graph tracer but we want them to keep traced by the usual function
 413  * tracer if the function graph tracer is not configured.
 414  */
 415 #define __notrace_funcgraph             notrace
 416
 417 /*
 418  * We want to which function is an entrypoint of a hardirq.
 419  * That will help us to put a signal on output.
 420  */
 421 #define __irq_entry              __attribute__((__section__(".irqentry.text")))
 422
 423 /* Limits of hardirq entrypoints */
 424 extern char __irqentry_text_start[];
 425 extern char __irqentry_text_end[];
 426
 427 #define FTRACE_RETFUNC_DEPTH 50
 428 #define FTRACE_RETSTACK_ALLOC_SIZE 32
 429 extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
 430                                 trace_func_graph_ent_t entryfunc);
 431
 432 extern void ftrace_graph_stop(void);
 433
 434 /* The current handlers in use */
 435 extern trace_func_graph_ret_t ftrace_graph_return;
 436 extern trace_func_graph_ent_t ftrace_graph_entry;
 437
 438 extern void unregister_ftrace_graph(void);
 439
 440 extern void ftrace_graph_init_task(struct task_struct *t);
 441 extern void ftrace_graph_exit_task(struct task_struct *t);
 442 extern void ftrace_graph_init_idle_task(struct task_struct *t, int cpu);
 443
 444 static inline int task_curr_ret_stack(struct task_struct *t)
 445 {
 446         return t->curr_ret_stack;
 447 }
 448
 449 static inline void pause_graph_tracing(void)
 450 {
 451         atomic_inc(&current->tracing_graph_pause);
 452 }
 453
 454 static inline void unpause_graph_tracing(void)
 455 {
 456         atomic_dec(&current->tracing_graph_pause);
 457 }
 458 #else /* !CONFIG_FUNCTION_GRAPH_TRACER */
 459
 460 #define __notrace_funcgraph
 461 #define __irq_entry
 462 #define INIT_FTRACE_GRAPH
 463
 464 static inline void ftrace_graph_init_task(struct task_struct *t) { }
 465 static inline void ftrace_graph_exit_task(struct task_struct *t) { }
 466 static inline void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) { }
 467
 468 static inline int register_ftrace_graph(trace_func_graph_ret_t retfunc,
 469                           trace_func_graph_ent_t entryfunc)
 470 {
 471         return -1;
 472 }
 473 static inline void unregister_ftrace_graph(void) { }
 474
 475 static inline int task_curr_ret_stack(struct task_struct *tsk)
 476 {
 477         return -1;
 478 }
 479
 480 static inline void pause_graph_tracing(void) { }
 481 static inline void unpause_graph_tracing(void) { }
 482 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 483
 484 #ifdef CONFIG_TRACING
 485
 486 /* flags for current->trace */
 487 enum {
 488         TSK_TRACE_FL_TRACE_BIT  = 0,
 489         TSK_TRACE_FL_GRAPH_BIT  = 1,
 490 };
 491 enum {
 492         TSK_TRACE_FL_TRACE      = 1 << TSK_TRACE_FL_TRACE_BIT,
 493         TSK_TRACE_FL_GRAPH      = 1 << TSK_TRACE_FL_GRAPH_BIT,
 494 };
 495
 496 static inline void set_tsk_trace_trace(struct task_struct *tsk)
 497 {
 498         set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
 499 }
 500
 501 static inline void clear_tsk_trace_trace(struct task_struct *tsk)
 502 {
 503         clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
 504 }
 505
 506 static inline int test_tsk_trace_trace(struct task_struct *tsk)
 507 {
 508         return tsk->trace & TSK_TRACE_FL_TRACE;
 509 }
 510
 511 static inline void set_tsk_trace_graph(struct task_struct *tsk)
 512 {
 513         set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
 514 }
 515
 516 static inline void clear_tsk_trace_graph(struct task_struct *tsk)
 517 {
 518         clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
 519 }
 520
 521 static inline int test_tsk_trace_graph(struct task_struct *tsk)
 522 {
 523         return tsk->trace & TSK_TRACE_FL_GRAPH;
 524 }
 525
 526 enum ftrace_dump_mode;
 527
 528 extern enum ftrace_dump_mode ftrace_dump_on_oops;
 529
 530 #ifdef CONFIG_PREEMPT
 531 #define INIT_TRACE_RECURSION            .trace_recursion = 0,
 532 #endif
 533
 534 #endif /* CONFIG_TRACING */
 535
 536 #ifndef INIT_TRACE_RECURSION
 537 #define INIT_TRACE_RECURSION
 538 #endif
 539
 540 #ifdef CONFIG_FTRACE_SYSCALLS
 541
 542 unsigned long arch_syscall_addr(int nr);
 543
 544 #endif /* CONFIG_FTRACE_SYSCALLS */
 545
 546 #endif /* _LINUX_FTRACE_H */