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/ptrace.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 /* 23 * If the arch supports passing the variable contents of 24 * function_trace_op as the third parameter back from the 25 * mcount call, then the arch should define this as 1. 26 */ 27 #ifndef ARCH_SUPPORTS_FTRACE_OPS 28 #define ARCH_SUPPORTS_FTRACE_OPS 0 29 #endif 30 31 /* 32 * If the arch's mcount caller does not support all of ftrace's 33 * features, then it must call an indirect function that 34 * does. Or at least does enough to prevent any unwelcomed side effects. 35 */ 36 #if !ARCH_SUPPORTS_FTRACE_OPS 37 # define FTRACE_FORCE_LIST_FUNC 1 38 #else 39 # define FTRACE_FORCE_LIST_FUNC 0 40 #endif 41 42 /* Main tracing buffer and events set up */ 43 #ifdef CONFIG_TRACING 44 void trace_init(void); 45 #else 46 static inline void trace_init(void) { } 47 #endif 48 49 struct module; 50 struct ftrace_hash; 51 52 #ifdef CONFIG_FUNCTION_TRACER 53 54 extern int ftrace_enabled; 55 extern int 56 ftrace_enable_sysctl(struct ctl_table *table, int write, 57 void __user *buffer, size_t *lenp, 58 loff_t *ppos); 59 60 struct ftrace_ops; 61 62 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip, 63 struct ftrace_ops *op, struct pt_regs *regs); 64 65 ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops); 66 67 /* 68 * FTRACE_OPS_FL_* bits denote the state of ftrace_ops struct and are 69 * set in the flags member. 70 * CONTROL, SAVE_REGS, SAVE_REGS_IF_SUPPORTED, RECURSION_SAFE, STUB and 71 * IPMODIFY are a kind of attribute flags which can be set only before 72 * registering the ftrace_ops, and can not be modified while registered. 73 * Changing those attribute flags after regsitering ftrace_ops will 74 * cause unexpected results. 75 * 76 * ENABLED - set/unset when ftrace_ops is registered/unregistered 77 * DYNAMIC - set when ftrace_ops is registered to denote dynamically 78 * allocated ftrace_ops which need special care 79 * PER_CPU - set manualy by ftrace_ops user to denote the ftrace_ops 80 * could be controlled by following calls: 81 * ftrace_function_local_enable 82 * ftrace_function_local_disable 83 * SAVE_REGS - The ftrace_ops wants regs saved at each function called 84 * and passed to the callback. If this flag is set, but the 85 * architecture does not support passing regs 86 * (CONFIG_DYNAMIC_FTRACE_WITH_REGS is not defined), then the 87 * ftrace_ops will fail to register, unless the next flag 88 * is set. 89 * SAVE_REGS_IF_SUPPORTED - This is the same as SAVE_REGS, but if the 90 * handler can handle an arch that does not save regs 91 * (the handler tests if regs == NULL), then it can set 92 * this flag instead. It will not fail registering the ftrace_ops 93 * but, the regs field will be NULL if the arch does not support 94 * passing regs to the handler. 95 * Note, if this flag is set, the SAVE_REGS flag will automatically 96 * get set upon registering the ftrace_ops, if the arch supports it. 97 * RECURSION_SAFE - The ftrace_ops can set this to tell the ftrace infrastructure 98 * that the call back has its own recursion protection. If it does 99 * not set this, then the ftrace infrastructure will add recursion 100 * protection for the caller. 101 * STUB - The ftrace_ops is just a place holder. 102 * INITIALIZED - The ftrace_ops has already been initialized (first use time 103 * register_ftrace_function() is called, it will initialized the ops) 104 * DELETED - The ops are being deleted, do not let them be registered again. 105 * ADDING - The ops is in the process of being added. 106 * REMOVING - The ops is in the process of being removed. 107 * MODIFYING - The ops is in the process of changing its filter functions. 108 * ALLOC_TRAMP - A dynamic trampoline was allocated by the core code. 109 * The arch specific code sets this flag when it allocated a 110 * trampoline. This lets the arch know that it can update the 111 * trampoline in case the callback function changes. 112 * The ftrace_ops trampoline can be set by the ftrace users, and 113 * in such cases the arch must not modify it. Only the arch ftrace 114 * core code should set this flag. 115 * IPMODIFY - The ops can modify the IP register. This can only be set with 116 * SAVE_REGS. If another ops with this flag set is already registered 117 * for any of the functions that this ops will be registered for, then 118 * this ops will fail to register or set_filter_ip. 119 * PID - Is affected by set_ftrace_pid (allows filtering on those pids) 120 */ 121 enum { 122 FTRACE_OPS_FL_ENABLED = 1 << 0, 123 FTRACE_OPS_FL_DYNAMIC = 1 << 1, 124 FTRACE_OPS_FL_PER_CPU = 1 << 2, 125 FTRACE_OPS_FL_SAVE_REGS = 1 << 3, 126 FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED = 1 << 4, 127 FTRACE_OPS_FL_RECURSION_SAFE = 1 << 5, 128 FTRACE_OPS_FL_STUB = 1 << 6, 129 FTRACE_OPS_FL_INITIALIZED = 1 << 7, 130 FTRACE_OPS_FL_DELETED = 1 << 8, 131 FTRACE_OPS_FL_ADDING = 1 << 9, 132 FTRACE_OPS_FL_REMOVING = 1 << 10, 133 FTRACE_OPS_FL_MODIFYING = 1 << 11, 134 FTRACE_OPS_FL_ALLOC_TRAMP = 1 << 12, 135 FTRACE_OPS_FL_IPMODIFY = 1 << 13, 136 FTRACE_OPS_FL_PID = 1 << 14, 137 FTRACE_OPS_FL_RCU = 1 << 15, 138 }; 139 140 #ifdef CONFIG_DYNAMIC_FTRACE 141 /* The hash used to know what functions callbacks trace */ 142 struct ftrace_ops_hash { 143 struct ftrace_hash *notrace_hash; 144 struct ftrace_hash *filter_hash; 145 struct mutex regex_lock; 146 }; 147 #endif 148 149 /* 150 * Note, ftrace_ops can be referenced outside of RCU protection, unless 151 * the RCU flag is set. If ftrace_ops is allocated and not part of kernel 152 * core data, the unregistering of it will perform a scheduling on all CPUs 153 * to make sure that there are no more users. Depending on the load of the 154 * system that may take a bit of time. 155 * 156 * Any private data added must also take care not to be freed and if private 157 * data is added to a ftrace_ops that is in core code, the user of the 158 * ftrace_ops must perform a schedule_on_each_cpu() before freeing it. 159 */ 160 struct ftrace_ops { 161 ftrace_func_t func; 162 struct ftrace_ops *next; 163 unsigned long flags; 164 void *private; 165 ftrace_func_t saved_func; 166 int __percpu *disabled; 167 #ifdef CONFIG_DYNAMIC_FTRACE 168 int nr_trampolines; 169 struct ftrace_ops_hash local_hash; 170 struct ftrace_ops_hash *func_hash; 171 struct ftrace_ops_hash old_hash; 172 unsigned long trampoline; 173 unsigned long trampoline_size; 174 #endif 175 }; 176 177 /* 178 * Type of the current tracing. 179 */ 180 enum ftrace_tracing_type_t { 181 FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */ 182 FTRACE_TYPE_RETURN, /* Hook the return of the function */ 183 }; 184 185 /* Current tracing type, default is FTRACE_TYPE_ENTER */ 186 extern enum ftrace_tracing_type_t ftrace_tracing_type; 187 188 /* 189 * The ftrace_ops must be a static and should also 190 * be read_mostly. These functions do modify read_mostly variables 191 * so use them sparely. Never free an ftrace_op or modify the 192 * next pointer after it has been registered. Even after unregistering 193 * it, the next pointer may still be used internally. 194 */ 195 int register_ftrace_function(struct ftrace_ops *ops); 196 int unregister_ftrace_function(struct ftrace_ops *ops); 197 void clear_ftrace_function(void); 198 199 /** 200 * ftrace_function_local_enable - enable ftrace_ops on current cpu 201 * 202 * This function enables tracing on current cpu by decreasing 203 * the per cpu control variable. 204 * It must be called with preemption disabled and only on ftrace_ops 205 * registered with FTRACE_OPS_FL_PER_CPU. If called without preemption 206 * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled. 207 */ 208 static inline void ftrace_function_local_enable(struct ftrace_ops *ops) 209 { 210 if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_PER_CPU))) 211 return; 212 213 (*this_cpu_ptr(ops->disabled))--; 214 } 215 216 /** 217 * ftrace_function_local_disable - disable ftrace_ops on current cpu 218 * 219 * This function disables tracing on current cpu by increasing 220 * the per cpu control variable. 221 * It must be called with preemption disabled and only on ftrace_ops 222 * registered with FTRACE_OPS_FL_PER_CPU. If called without preemption 223 * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled. 224 */ 225 static inline void ftrace_function_local_disable(struct ftrace_ops *ops) 226 { 227 if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_PER_CPU))) 228 return; 229 230 (*this_cpu_ptr(ops->disabled))++; 231 } 232 233 /** 234 * ftrace_function_local_disabled - returns ftrace_ops disabled value 235 * on current cpu 236 * 237 * This function returns value of ftrace_ops::disabled on current cpu. 238 * It must be called with preemption disabled and only on ftrace_ops 239 * registered with FTRACE_OPS_FL_PER_CPU. If called without preemption 240 * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled. 241 */ 242 static inline int ftrace_function_local_disabled(struct ftrace_ops *ops) 243 { 244 WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_PER_CPU)); 245 return *this_cpu_ptr(ops->disabled); 246 } 247 248 extern void ftrace_stub(unsigned long a0, unsigned long a1, 249 struct ftrace_ops *op, struct pt_regs *regs); 250 251 #else /* !CONFIG_FUNCTION_TRACER */ 252 /* 253 * (un)register_ftrace_function must be a macro since the ops parameter 254 * must not be evaluated. 255 */ 256 #define register_ftrace_function(ops) ({ 0; }) 257 #define unregister_ftrace_function(ops) ({ 0; }) 258 static inline int ftrace_nr_registered_ops(void) 259 { 260 return 0; 261 } 262 static inline void clear_ftrace_function(void) { } 263 static inline void ftrace_kill(void) { } 264 #endif /* CONFIG_FUNCTION_TRACER */ 265 266 #ifdef CONFIG_STACK_TRACER 267 268 #define STACK_TRACE_ENTRIES 500 269 270 struct stack_trace; 271 272 extern unsigned stack_trace_index[]; 273 extern struct stack_trace stack_trace_max; 274 extern unsigned long stack_trace_max_size; 275 extern arch_spinlock_t stack_trace_max_lock; 276 277 extern int stack_tracer_enabled; 278 void stack_trace_print(void); 279 int 280 stack_trace_sysctl(struct ctl_table *table, int write, 281 void __user *buffer, size_t *lenp, 282 loff_t *ppos); 283 #endif 284 285 struct ftrace_func_command { 286 struct list_head list; 287 char *name; 288 int (*func)(struct ftrace_hash *hash, 289 char *func, char *cmd, 290 char *params, int enable); 291 }; 292 293 #ifdef CONFIG_DYNAMIC_FTRACE 294 295 int ftrace_arch_code_modify_prepare(void); 296 int ftrace_arch_code_modify_post_process(void); 297 298 struct dyn_ftrace; 299 300 enum ftrace_bug_type { 301 FTRACE_BUG_UNKNOWN, 302 FTRACE_BUG_INIT, 303 FTRACE_BUG_NOP, 304 FTRACE_BUG_CALL, 305 FTRACE_BUG_UPDATE, 306 }; 307 extern enum ftrace_bug_type ftrace_bug_type; 308 309 /* 310 * Archs can set this to point to a variable that holds the value that was 311 * expected at the call site before calling ftrace_bug(). 312 */ 313 extern const void *ftrace_expected; 314 315 void ftrace_bug(int err, struct dyn_ftrace *rec); 316 317 struct seq_file; 318 319 struct ftrace_probe_ops { 320 void (*func)(unsigned long ip, 321 unsigned long parent_ip, 322 void **data); 323 int (*init)(struct ftrace_probe_ops *ops, 324 unsigned long ip, void **data); 325 void (*free)(struct ftrace_probe_ops *ops, 326 unsigned long ip, void **data); 327 int (*print)(struct seq_file *m, 328 unsigned long ip, 329 struct ftrace_probe_ops *ops, 330 void *data); 331 }; 332 333 extern int 334 register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, 335 void *data); 336 extern void 337 unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, 338 void *data); 339 extern void 340 unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops); 341 extern void unregister_ftrace_function_probe_all(char *glob); 342 343 extern int ftrace_text_reserved(const void *start, const void *end); 344 345 extern int ftrace_nr_registered_ops(void); 346 347 bool is_ftrace_trampoline(unsigned long addr); 348 349 /* 350 * The dyn_ftrace record's flags field is split into two parts. 351 * the first part which is '0-FTRACE_REF_MAX' is a counter of 352 * the number of callbacks that have registered the function that 353 * the dyn_ftrace descriptor represents. 354 * 355 * The second part is a mask: 356 * ENABLED - the function is being traced 357 * REGS - the record wants the function to save regs 358 * REGS_EN - the function is set up to save regs. 359 * IPMODIFY - the record allows for the IP address to be changed. 360 * DISABLED - the record is not ready to be touched yet 361 * 362 * When a new ftrace_ops is registered and wants a function to save 363 * pt_regs, the rec->flag REGS is set. When the function has been 364 * set up to save regs, the REG_EN flag is set. Once a function 365 * starts saving regs it will do so until all ftrace_ops are removed 366 * from tracing that function. 367 */ 368 enum { 369 FTRACE_FL_ENABLED = (1UL << 31), 370 FTRACE_FL_REGS = (1UL << 30), 371 FTRACE_FL_REGS_EN = (1UL << 29), 372 FTRACE_FL_TRAMP = (1UL << 28), 373 FTRACE_FL_TRAMP_EN = (1UL << 27), 374 FTRACE_FL_IPMODIFY = (1UL << 26), 375 FTRACE_FL_DISABLED = (1UL << 25), 376 }; 377 378 #define FTRACE_REF_MAX_SHIFT 25 379 #define FTRACE_FL_BITS 7 380 #define FTRACE_FL_MASKED_BITS ((1UL << FTRACE_FL_BITS) - 1) 381 #define FTRACE_FL_MASK (FTRACE_FL_MASKED_BITS << FTRACE_REF_MAX_SHIFT) 382 #define FTRACE_REF_MAX ((1UL << FTRACE_REF_MAX_SHIFT) - 1) 383 384 #define ftrace_rec_count(rec) ((rec)->flags & ~FTRACE_FL_MASK) 385 386 struct dyn_ftrace { 387 unsigned long ip; /* address of mcount call-site */ 388 unsigned long flags; 389 struct dyn_arch_ftrace arch; 390 }; 391 392 int ftrace_force_update(void); 393 int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip, 394 int remove, int reset); 395 int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf, 396 int len, int reset); 397 int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf, 398 int len, int reset); 399 void ftrace_set_global_filter(unsigned char *buf, int len, int reset); 400 void ftrace_set_global_notrace(unsigned char *buf, int len, int reset); 401 void ftrace_free_filter(struct ftrace_ops *ops); 402 403 int register_ftrace_command(struct ftrace_func_command *cmd); 404 int unregister_ftrace_command(struct ftrace_func_command *cmd); 405 406 enum { 407 FTRACE_UPDATE_CALLS = (1 << 0), 408 FTRACE_DISABLE_CALLS = (1 << 1), 409 FTRACE_UPDATE_TRACE_FUNC = (1 << 2), 410 FTRACE_START_FUNC_RET = (1 << 3), 411 FTRACE_STOP_FUNC_RET = (1 << 4), 412 }; 413 414 /* 415 * The FTRACE_UPDATE_* enum is used to pass information back 416 * from the ftrace_update_record() and ftrace_test_record() 417 * functions. These are called by the code update routines 418 * to find out what is to be done for a given function. 419 * 420 * IGNORE - The function is already what we want it to be 421 * MAKE_CALL - Start tracing the function 422 * MODIFY_CALL - Stop saving regs for the function 423 * MAKE_NOP - Stop tracing the function 424 */ 425 enum { 426 FTRACE_UPDATE_IGNORE, 427 FTRACE_UPDATE_MAKE_CALL, 428 FTRACE_UPDATE_MODIFY_CALL, 429 FTRACE_UPDATE_MAKE_NOP, 430 }; 431 432 enum { 433 FTRACE_ITER_FILTER = (1 << 0), 434 FTRACE_ITER_NOTRACE = (1 << 1), 435 FTRACE_ITER_PRINTALL = (1 << 2), 436 FTRACE_ITER_DO_HASH = (1 << 3), 437 FTRACE_ITER_HASH = (1 << 4), 438 FTRACE_ITER_ENABLED = (1 << 5), 439 }; 440 441 void arch_ftrace_update_code(int command); 442 443 struct ftrace_rec_iter; 444 445 struct ftrace_rec_iter *ftrace_rec_iter_start(void); 446 struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter); 447 struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter); 448 449 #define for_ftrace_rec_iter(iter) \ 450 for (iter = ftrace_rec_iter_start(); \ 451 iter; \ 452 iter = ftrace_rec_iter_next(iter)) 453 454 455 int ftrace_update_record(struct dyn_ftrace *rec, int enable); 456 int ftrace_test_record(struct dyn_ftrace *rec, int enable); 457 void ftrace_run_stop_machine(int command); 458 unsigned long ftrace_location(unsigned long ip); 459 unsigned long ftrace_get_addr_new(struct dyn_ftrace *rec); 460 unsigned long ftrace_get_addr_curr(struct dyn_ftrace *rec); 461 462 extern ftrace_func_t ftrace_trace_function; 463 464 int ftrace_regex_open(struct ftrace_ops *ops, int flag, 465 struct inode *inode, struct file *file); 466 ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf, 467 size_t cnt, loff_t *ppos); 468 ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf, 469 size_t cnt, loff_t *ppos); 470 int ftrace_regex_release(struct inode *inode, struct file *file); 471 472 void __init 473 ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable); 474 475 /* defined in arch */ 476 extern int ftrace_ip_converted(unsigned long ip); 477 extern int ftrace_dyn_arch_init(void); 478 extern void ftrace_replace_code(int enable); 479 extern int ftrace_update_ftrace_func(ftrace_func_t func); 480 extern void ftrace_caller(void); 481 extern void ftrace_regs_caller(void); 482 extern void ftrace_call(void); 483 extern void ftrace_regs_call(void); 484 extern void mcount_call(void); 485 486 void ftrace_modify_all_code(int command); 487 488 #ifndef FTRACE_ADDR 489 #define FTRACE_ADDR ((unsigned long)ftrace_caller) 490 #endif 491 492 #ifndef FTRACE_GRAPH_ADDR 493 #define FTRACE_GRAPH_ADDR ((unsigned long)ftrace_graph_caller) 494 #endif 495 496 #ifndef FTRACE_REGS_ADDR 497 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS 498 # define FTRACE_REGS_ADDR ((unsigned long)ftrace_regs_caller) 499 #else 500 # define FTRACE_REGS_ADDR FTRACE_ADDR 501 #endif 502 #endif 503 504 /* 505 * If an arch would like functions that are only traced 506 * by the function graph tracer to jump directly to its own 507 * trampoline, then they can define FTRACE_GRAPH_TRAMP_ADDR 508 * to be that address to jump to. 509 */ 510 #ifndef FTRACE_GRAPH_TRAMP_ADDR 511 #define FTRACE_GRAPH_TRAMP_ADDR ((unsigned long) 0) 512 #endif 513 514 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 515 extern void ftrace_graph_caller(void); 516 extern int ftrace_enable_ftrace_graph_caller(void); 517 extern int ftrace_disable_ftrace_graph_caller(void); 518 #else 519 static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; } 520 static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; } 521 #endif 522 523 /** 524 * ftrace_make_nop - convert code into nop 525 * @mod: module structure if called by module load initialization 526 * @rec: the mcount call site record 527 * @addr: the address that the call site should be calling 528 * 529 * This is a very sensitive operation and great care needs 530 * to be taken by the arch. The operation should carefully 531 * read the location, check to see if what is read is indeed 532 * what we expect it to be, and then on success of the compare, 533 * it should write to the location. 534 * 535 * The code segment at @rec->ip should be a caller to @addr 536 * 537 * Return must be: 538 * 0 on success 539 * -EFAULT on error reading the location 540 * -EINVAL on a failed compare of the contents 541 * -EPERM on error writing to the location 542 * Any other value will be considered a failure. 543 */ 544 extern int ftrace_make_nop(struct module *mod, 545 struct dyn_ftrace *rec, unsigned long addr); 546 547 /** 548 * ftrace_make_call - convert a nop call site into a call to addr 549 * @rec: the mcount call site record 550 * @addr: the address that the call site should call 551 * 552 * This is a very sensitive operation and great care needs 553 * to be taken by the arch. The operation should carefully 554 * read the location, check to see if what is read is indeed 555 * what we expect it to be, and then on success of the compare, 556 * it should write to the location. 557 * 558 * The code segment at @rec->ip should be a nop 559 * 560 * Return must be: 561 * 0 on success 562 * -EFAULT on error reading the location 563 * -EINVAL on a failed compare of the contents 564 * -EPERM on error writing to the location 565 * Any other value will be considered a failure. 566 */ 567 extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr); 568 569 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS 570 /** 571 * ftrace_modify_call - convert from one addr to another (no nop) 572 * @rec: the mcount call site record 573 * @old_addr: the address expected to be currently called to 574 * @addr: the address to change to 575 * 576 * This is a very sensitive operation and great care needs 577 * to be taken by the arch. The operation should carefully 578 * read the location, check to see if what is read is indeed 579 * what we expect it to be, and then on success of the compare, 580 * it should write to the location. 581 * 582 * The code segment at @rec->ip should be a caller to @old_addr 583 * 584 * Return must be: 585 * 0 on success 586 * -EFAULT on error reading the location 587 * -EINVAL on a failed compare of the contents 588 * -EPERM on error writing to the location 589 * Any other value will be considered a failure. 590 */ 591 extern int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr, 592 unsigned long addr); 593 #else 594 /* Should never be called */ 595 static inline int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr, 596 unsigned long addr) 597 { 598 return -EINVAL; 599 } 600 #endif 601 602 /* May be defined in arch */ 603 extern int ftrace_arch_read_dyn_info(char *buf, int size); 604 605 extern int skip_trace(unsigned long ip); 606 extern void ftrace_module_init(struct module *mod); 607 extern void ftrace_release_mod(struct module *mod); 608 609 extern void ftrace_disable_daemon(void); 610 extern void ftrace_enable_daemon(void); 611 #else /* CONFIG_DYNAMIC_FTRACE */ 612 static inline int skip_trace(unsigned long ip) { return 0; } 613 static inline int ftrace_force_update(void) { return 0; } 614 static inline void ftrace_disable_daemon(void) { } 615 static inline void ftrace_enable_daemon(void) { } 616 static inline void ftrace_release_mod(struct module *mod) {} 617 static inline void ftrace_module_init(struct module *mod) {} 618 static inline __init int register_ftrace_command(struct ftrace_func_command *cmd) 619 { 620 return -EINVAL; 621 } 622 static inline __init int unregister_ftrace_command(char *cmd_name) 623 { 624 return -EINVAL; 625 } 626 static inline int ftrace_text_reserved(const void *start, const void *end) 627 { 628 return 0; 629 } 630 static inline unsigned long ftrace_location(unsigned long ip) 631 { 632 return 0; 633 } 634 635 /* 636 * Again users of functions that have ftrace_ops may not 637 * have them defined when ftrace is not enabled, but these 638 * functions may still be called. Use a macro instead of inline. 639 */ 640 #define ftrace_regex_open(ops, flag, inod, file) ({ -ENODEV; }) 641 #define ftrace_set_early_filter(ops, buf, enable) do { } while (0) 642 #define ftrace_set_filter_ip(ops, ip, remove, reset) ({ -ENODEV; }) 643 #define ftrace_set_filter(ops, buf, len, reset) ({ -ENODEV; }) 644 #define ftrace_set_notrace(ops, buf, len, reset) ({ -ENODEV; }) 645 #define ftrace_free_filter(ops) do { } while (0) 646 647 static inline ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf, 648 size_t cnt, loff_t *ppos) { return -ENODEV; } 649 static inline ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf, 650 size_t cnt, loff_t *ppos) { return -ENODEV; } 651 static inline int 652 ftrace_regex_release(struct inode *inode, struct file *file) { return -ENODEV; } 653 654 static inline bool is_ftrace_trampoline(unsigned long addr) 655 { 656 return false; 657 } 658 #endif /* CONFIG_DYNAMIC_FTRACE */ 659 660 /* totally disable ftrace - can not re-enable after this */ 661 void ftrace_kill(void); 662 663 static inline void tracer_disable(void) 664 { 665 #ifdef CONFIG_FUNCTION_TRACER 666 ftrace_enabled = 0; 667 #endif 668 } 669 670 /* 671 * Ftrace disable/restore without lock. Some synchronization mechanism 672 * must be used to prevent ftrace_enabled to be changed between 673 * disable/restore. 674 */ 675 static inline int __ftrace_enabled_save(void) 676 { 677 #ifdef CONFIG_FUNCTION_TRACER 678 int saved_ftrace_enabled = ftrace_enabled; 679 ftrace_enabled = 0; 680 return saved_ftrace_enabled; 681 #else 682 return 0; 683 #endif 684 } 685 686 static inline void __ftrace_enabled_restore(int enabled) 687 { 688 #ifdef CONFIG_FUNCTION_TRACER 689 ftrace_enabled = enabled; 690 #endif 691 } 692 693 /* All archs should have this, but we define it for consistency */ 694 #ifndef ftrace_return_address0 695 # define ftrace_return_address0 __builtin_return_address(0) 696 #endif 697 698 /* Archs may use other ways for ADDR1 and beyond */ 699 #ifndef ftrace_return_address 700 # ifdef CONFIG_FRAME_POINTER 701 # define ftrace_return_address(n) __builtin_return_address(n) 702 # else 703 # define ftrace_return_address(n) 0UL 704 # endif 705 #endif 706 707 #define CALLER_ADDR0 ((unsigned long)ftrace_return_address0) 708 #define CALLER_ADDR1 ((unsigned long)ftrace_return_address(1)) 709 #define CALLER_ADDR2 ((unsigned long)ftrace_return_address(2)) 710 #define CALLER_ADDR3 ((unsigned long)ftrace_return_address(3)) 711 #define CALLER_ADDR4 ((unsigned long)ftrace_return_address(4)) 712 #define CALLER_ADDR5 ((unsigned long)ftrace_return_address(5)) 713 #define CALLER_ADDR6 ((unsigned long)ftrace_return_address(6)) 714 715 #ifdef CONFIG_IRQSOFF_TRACER 716 extern void time_hardirqs_on(unsigned long a0, unsigned long a1); 717 extern void time_hardirqs_off(unsigned long a0, unsigned long a1); 718 #else 719 static inline void time_hardirqs_on(unsigned long a0, unsigned long a1) { } 720 static inline void time_hardirqs_off(unsigned long a0, unsigned long a1) { } 721 #endif 722 723 #ifdef CONFIG_PREEMPT_TRACER 724 extern void trace_preempt_on(unsigned long a0, unsigned long a1); 725 extern void trace_preempt_off(unsigned long a0, unsigned long a1); 726 #else 727 /* 728 * Use defines instead of static inlines because some arches will make code out 729 * of the CALLER_ADDR, when we really want these to be a real nop. 730 */ 731 # define trace_preempt_on(a0, a1) do { } while (0) 732 # define trace_preempt_off(a0, a1) do { } while (0) 733 #endif 734 735 #ifdef CONFIG_FTRACE_MCOUNT_RECORD 736 extern void ftrace_init(void); 737 #else 738 static inline void ftrace_init(void) { } 739 #endif 740 741 /* 742 * Structure that defines an entry function trace. 743 */ 744 struct ftrace_graph_ent { 745 unsigned long func; /* Current function */ 746 int depth; 747 }; 748 749 /* 750 * Structure that defines a return function trace. 751 */ 752 struct ftrace_graph_ret { 753 unsigned long func; /* Current function */ 754 unsigned long long calltime; 755 unsigned long long rettime; 756 /* Number of functions that overran the depth limit for current task */ 757 unsigned long overrun; 758 int depth; 759 }; 760 761 /* Type of the callback handlers for tracing function graph*/ 762 typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */ 763 typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */ 764 765 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 766 767 /* for init task */ 768 #define INIT_FTRACE_GRAPH .ret_stack = NULL, 769 770 /* 771 * Stack of return addresses for functions 772 * of a thread. 773 * Used in struct thread_info 774 */ 775 struct ftrace_ret_stack { 776 unsigned long ret; 777 unsigned long func; 778 unsigned long long calltime; 779 unsigned long long subtime; 780 unsigned long fp; 781 }; 782 783 /* 784 * Primary handler of a function return. 785 * It relays on ftrace_return_to_handler. 786 * Defined in entry_32/64.S 787 */ 788 extern void return_to_handler(void); 789 790 extern int 791 ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth, 792 unsigned long frame_pointer); 793 794 /* 795 * Sometimes we don't want to trace a function with the function 796 * graph tracer but we want them to keep traced by the usual function 797 * tracer if the function graph tracer is not configured. 798 */ 799 #define __notrace_funcgraph notrace 800 801 /* 802 * We want to which function is an entrypoint of a hardirq. 803 * That will help us to put a signal on output. 804 */ 805 #define __irq_entry __attribute__((__section__(".irqentry.text"))) 806 807 /* Limits of hardirq entrypoints */ 808 extern char __irqentry_text_start[]; 809 extern char __irqentry_text_end[]; 810 811 #define FTRACE_NOTRACE_DEPTH 65536 812 #define FTRACE_RETFUNC_DEPTH 50 813 #define FTRACE_RETSTACK_ALLOC_SIZE 32 814 extern int register_ftrace_graph(trace_func_graph_ret_t retfunc, 815 trace_func_graph_ent_t entryfunc); 816 817 extern bool ftrace_graph_is_dead(void); 818 extern void ftrace_graph_stop(void); 819 820 /* The current handlers in use */ 821 extern trace_func_graph_ret_t ftrace_graph_return; 822 extern trace_func_graph_ent_t ftrace_graph_entry; 823 824 extern void unregister_ftrace_graph(void); 825 826 extern void ftrace_graph_init_task(struct task_struct *t); 827 extern void ftrace_graph_exit_task(struct task_struct *t); 828 extern void ftrace_graph_init_idle_task(struct task_struct *t, int cpu); 829 830 static inline int task_curr_ret_stack(struct task_struct *t) 831 { 832 return t->curr_ret_stack; 833 } 834 835 static inline void pause_graph_tracing(void) 836 { 837 atomic_inc(¤t->tracing_graph_pause); 838 } 839 840 static inline void unpause_graph_tracing(void) 841 { 842 atomic_dec(¤t->tracing_graph_pause); 843 } 844 #else /* !CONFIG_FUNCTION_GRAPH_TRACER */ 845 846 #define __notrace_funcgraph 847 #define __irq_entry 848 #define INIT_FTRACE_GRAPH 849 850 static inline void ftrace_graph_init_task(struct task_struct *t) { } 851 static inline void ftrace_graph_exit_task(struct task_struct *t) { } 852 static inline void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) { } 853 854 static inline int register_ftrace_graph(trace_func_graph_ret_t retfunc, 855 trace_func_graph_ent_t entryfunc) 856 { 857 return -1; 858 } 859 static inline void unregister_ftrace_graph(void) { } 860 861 static inline int task_curr_ret_stack(struct task_struct *tsk) 862 { 863 return -1; 864 } 865 866 static inline void pause_graph_tracing(void) { } 867 static inline void unpause_graph_tracing(void) { } 868 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ 869 870 #ifdef CONFIG_TRACING 871 872 /* flags for current->trace */ 873 enum { 874 TSK_TRACE_FL_TRACE_BIT = 0, 875 TSK_TRACE_FL_GRAPH_BIT = 1, 876 }; 877 enum { 878 TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT, 879 TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT, 880 }; 881 882 static inline void set_tsk_trace_trace(struct task_struct *tsk) 883 { 884 set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace); 885 } 886 887 static inline void clear_tsk_trace_trace(struct task_struct *tsk) 888 { 889 clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace); 890 } 891 892 static inline int test_tsk_trace_trace(struct task_struct *tsk) 893 { 894 return tsk->trace & TSK_TRACE_FL_TRACE; 895 } 896 897 static inline void set_tsk_trace_graph(struct task_struct *tsk) 898 { 899 set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace); 900 } 901 902 static inline void clear_tsk_trace_graph(struct task_struct *tsk) 903 { 904 clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace); 905 } 906 907 static inline int test_tsk_trace_graph(struct task_struct *tsk) 908 { 909 return tsk->trace & TSK_TRACE_FL_GRAPH; 910 } 911 912 enum ftrace_dump_mode; 913 914 extern enum ftrace_dump_mode ftrace_dump_on_oops; 915 extern int tracepoint_printk; 916 917 extern void disable_trace_on_warning(void); 918 extern int __disable_trace_on_warning; 919 920 #ifdef CONFIG_PREEMPT 921 #define INIT_TRACE_RECURSION .trace_recursion = 0, 922 #endif 923 924 #else /* CONFIG_TRACING */ 925 static inline void disable_trace_on_warning(void) { } 926 #endif /* CONFIG_TRACING */ 927 928 #ifndef INIT_TRACE_RECURSION 929 #define INIT_TRACE_RECURSION 930 #endif 931 932 #ifdef CONFIG_FTRACE_SYSCALLS 933 934 unsigned long arch_syscall_addr(int nr); 935 936 #endif /* CONFIG_FTRACE_SYSCALLS */ 937 938 #endif /* _LINUX_FTRACE_H */ 939