1 /* Include in trace.c */ 2 3 #include <linux/kthread.h> 4 #include <linux/delay.h> 5 6 static inline int trace_valid_entry(struct trace_entry *entry) 7 { 8 switch (entry->type) { 9 case TRACE_FN: 10 case TRACE_CTX: 11 case TRACE_WAKE: 12 case TRACE_CONT: 13 case TRACE_STACK: 14 case TRACE_PRINT: 15 case TRACE_SPECIAL: 16 case TRACE_BRANCH: 17 return 1; 18 } 19 return 0; 20 } 21 22 static int trace_test_buffer_cpu(struct trace_array *tr, int cpu) 23 { 24 struct ring_buffer_event *event; 25 struct trace_entry *entry; 26 unsigned int loops = 0; 27 28 while ((event = ring_buffer_consume(tr->buffer, cpu, NULL))) { 29 entry = ring_buffer_event_data(event); 30 31 /* 32 * The ring buffer is a size of trace_buf_size, if 33 * we loop more than the size, there's something wrong 34 * with the ring buffer. 35 */ 36 if (loops++ > trace_buf_size) { 37 printk(KERN_CONT ".. bad ring buffer "); 38 goto failed; 39 } 40 if (!trace_valid_entry(entry)) { 41 printk(KERN_CONT ".. invalid entry %d ", 42 entry->type); 43 goto failed; 44 } 45 } 46 return 0; 47 48 failed: 49 /* disable tracing */ 50 tracing_disabled = 1; 51 printk(KERN_CONT ".. corrupted trace buffer .. "); 52 return -1; 53 } 54 55 /* 56 * Test the trace buffer to see if all the elements 57 * are still sane. 58 */ 59 static int trace_test_buffer(struct trace_array *tr, unsigned long *count) 60 { 61 unsigned long flags, cnt = 0; 62 int cpu, ret = 0; 63 64 /* Don't allow flipping of max traces now */ 65 local_irq_save(flags); 66 __raw_spin_lock(&ftrace_max_lock); 67 68 cnt = ring_buffer_entries(tr->buffer); 69 70 /* 71 * The trace_test_buffer_cpu runs a while loop to consume all data. 72 * If the calling tracer is broken, and is constantly filling 73 * the buffer, this will run forever, and hard lock the box. 74 * We disable the ring buffer while we do this test to prevent 75 * a hard lock up. 76 */ 77 tracing_off(); 78 for_each_possible_cpu(cpu) { 79 ret = trace_test_buffer_cpu(tr, cpu); 80 if (ret) 81 break; 82 } 83 tracing_on(); 84 __raw_spin_unlock(&ftrace_max_lock); 85 local_irq_restore(flags); 86 87 if (count) 88 *count = cnt; 89 90 return ret; 91 } 92 93 static inline void warn_failed_init_tracer(struct tracer *trace, int init_ret) 94 { 95 printk(KERN_WARNING "Failed to init %s tracer, init returned %d\n", 96 trace->name, init_ret); 97 } 98 #ifdef CONFIG_FUNCTION_TRACER 99 100 #ifdef CONFIG_DYNAMIC_FTRACE 101 102 #define __STR(x) #x 103 #define STR(x) __STR(x) 104 105 /* Test dynamic code modification and ftrace filters */ 106 int trace_selftest_startup_dynamic_tracing(struct tracer *trace, 107 struct trace_array *tr, 108 int (*func)(void)) 109 { 110 int save_ftrace_enabled = ftrace_enabled; 111 int save_tracer_enabled = tracer_enabled; 112 unsigned long count; 113 char *func_name; 114 int ret; 115 116 /* The ftrace test PASSED */ 117 printk(KERN_CONT "PASSED\n"); 118 pr_info("Testing dynamic ftrace: "); 119 120 /* enable tracing, and record the filter function */ 121 ftrace_enabled = 1; 122 tracer_enabled = 1; 123 124 /* passed in by parameter to fool gcc from optimizing */ 125 func(); 126 127 /* 128 * Some archs *cough*PowerPC*cough* add charachters to the 129 * start of the function names. We simply put a '*' to 130 * accomodate them. 131 */ 132 func_name = "*" STR(DYN_FTRACE_TEST_NAME); 133 134 /* filter only on our function */ 135 ftrace_set_filter(func_name, strlen(func_name), 1); 136 137 /* enable tracing */ 138 ret = trace->init(tr); 139 if (ret) { 140 warn_failed_init_tracer(trace, ret); 141 goto out; 142 } 143 144 /* Sleep for a 1/10 of a second */ 145 msleep(100); 146 147 /* we should have nothing in the buffer */ 148 ret = trace_test_buffer(tr, &count); 149 if (ret) 150 goto out; 151 152 if (count) { 153 ret = -1; 154 printk(KERN_CONT ".. filter did not filter .. "); 155 goto out; 156 } 157 158 /* call our function again */ 159 func(); 160 161 /* sleep again */ 162 msleep(100); 163 164 /* stop the tracing. */ 165 tracing_stop(); 166 ftrace_enabled = 0; 167 168 /* check the trace buffer */ 169 ret = trace_test_buffer(tr, &count); 170 trace->reset(tr); 171 tracing_start(); 172 173 /* we should only have one item */ 174 if (!ret && count != 1) { 175 printk(KERN_CONT ".. filter failed count=%ld ..", count); 176 ret = -1; 177 goto out; 178 } 179 180 out: 181 ftrace_enabled = save_ftrace_enabled; 182 tracer_enabled = save_tracer_enabled; 183 184 /* Enable tracing on all functions again */ 185 ftrace_set_filter(NULL, 0, 1); 186 187 return ret; 188 } 189 #else 190 # define trace_selftest_startup_dynamic_tracing(trace, tr, func) ({ 0; }) 191 #endif /* CONFIG_DYNAMIC_FTRACE */ 192 /* 193 * Simple verification test of ftrace function tracer. 194 * Enable ftrace, sleep 1/10 second, and then read the trace 195 * buffer to see if all is in order. 196 */ 197 int 198 trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr) 199 { 200 int save_ftrace_enabled = ftrace_enabled; 201 int save_tracer_enabled = tracer_enabled; 202 unsigned long count; 203 int ret; 204 205 /* make sure msleep has been recorded */ 206 msleep(1); 207 208 /* start the tracing */ 209 ftrace_enabled = 1; 210 tracer_enabled = 1; 211 212 ret = trace->init(tr); 213 if (ret) { 214 warn_failed_init_tracer(trace, ret); 215 goto out; 216 } 217 218 /* Sleep for a 1/10 of a second */ 219 msleep(100); 220 /* stop the tracing. */ 221 tracing_stop(); 222 ftrace_enabled = 0; 223 224 /* check the trace buffer */ 225 ret = trace_test_buffer(tr, &count); 226 trace->reset(tr); 227 tracing_start(); 228 229 if (!ret && !count) { 230 printk(KERN_CONT ".. no entries found .."); 231 ret = -1; 232 goto out; 233 } 234 235 ret = trace_selftest_startup_dynamic_tracing(trace, tr, 236 DYN_FTRACE_TEST_NAME); 237 238 out: 239 ftrace_enabled = save_ftrace_enabled; 240 tracer_enabled = save_tracer_enabled; 241 242 /* kill ftrace totally if we failed */ 243 if (ret) 244 ftrace_kill(); 245 246 return ret; 247 } 248 #endif /* CONFIG_FUNCTION_TRACER */ 249 250 #ifdef CONFIG_IRQSOFF_TRACER 251 int 252 trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr) 253 { 254 unsigned long save_max = tracing_max_latency; 255 unsigned long count; 256 int ret; 257 258 /* start the tracing */ 259 ret = trace->init(tr); 260 if (ret) { 261 warn_failed_init_tracer(trace, ret); 262 return ret; 263 } 264 265 /* reset the max latency */ 266 tracing_max_latency = 0; 267 /* disable interrupts for a bit */ 268 local_irq_disable(); 269 udelay(100); 270 local_irq_enable(); 271 /* stop the tracing. */ 272 tracing_stop(); 273 /* check both trace buffers */ 274 ret = trace_test_buffer(tr, NULL); 275 if (!ret) 276 ret = trace_test_buffer(&max_tr, &count); 277 trace->reset(tr); 278 tracing_start(); 279 280 if (!ret && !count) { 281 printk(KERN_CONT ".. no entries found .."); 282 ret = -1; 283 } 284 285 tracing_max_latency = save_max; 286 287 return ret; 288 } 289 #endif /* CONFIG_IRQSOFF_TRACER */ 290 291 #ifdef CONFIG_PREEMPT_TRACER 292 int 293 trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr) 294 { 295 unsigned long save_max = tracing_max_latency; 296 unsigned long count; 297 int ret; 298 299 /* 300 * Now that the big kernel lock is no longer preemptable, 301 * and this is called with the BKL held, it will always 302 * fail. If preemption is already disabled, simply 303 * pass the test. When the BKL is removed, or becomes 304 * preemptible again, we will once again test this, 305 * so keep it in. 306 */ 307 if (preempt_count()) { 308 printk(KERN_CONT "can not test ... force "); 309 return 0; 310 } 311 312 /* start the tracing */ 313 ret = trace->init(tr); 314 if (ret) { 315 warn_failed_init_tracer(trace, ret); 316 return ret; 317 } 318 319 /* reset the max latency */ 320 tracing_max_latency = 0; 321 /* disable preemption for a bit */ 322 preempt_disable(); 323 udelay(100); 324 preempt_enable(); 325 /* stop the tracing. */ 326 tracing_stop(); 327 /* check both trace buffers */ 328 ret = trace_test_buffer(tr, NULL); 329 if (!ret) 330 ret = trace_test_buffer(&max_tr, &count); 331 trace->reset(tr); 332 tracing_start(); 333 334 if (!ret && !count) { 335 printk(KERN_CONT ".. no entries found .."); 336 ret = -1; 337 } 338 339 tracing_max_latency = save_max; 340 341 return ret; 342 } 343 #endif /* CONFIG_PREEMPT_TRACER */ 344 345 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER) 346 int 347 trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr) 348 { 349 unsigned long save_max = tracing_max_latency; 350 unsigned long count; 351 int ret; 352 353 /* 354 * Now that the big kernel lock is no longer preemptable, 355 * and this is called with the BKL held, it will always 356 * fail. If preemption is already disabled, simply 357 * pass the test. When the BKL is removed, or becomes 358 * preemptible again, we will once again test this, 359 * so keep it in. 360 */ 361 if (preempt_count()) { 362 printk(KERN_CONT "can not test ... force "); 363 return 0; 364 } 365 366 /* start the tracing */ 367 ret = trace->init(tr); 368 if (ret) { 369 warn_failed_init_tracer(trace, ret); 370 goto out; 371 } 372 373 /* reset the max latency */ 374 tracing_max_latency = 0; 375 376 /* disable preemption and interrupts for a bit */ 377 preempt_disable(); 378 local_irq_disable(); 379 udelay(100); 380 preempt_enable(); 381 /* reverse the order of preempt vs irqs */ 382 local_irq_enable(); 383 384 /* stop the tracing. */ 385 tracing_stop(); 386 /* check both trace buffers */ 387 ret = trace_test_buffer(tr, NULL); 388 if (ret) { 389 tracing_start(); 390 goto out; 391 } 392 393 ret = trace_test_buffer(&max_tr, &count); 394 if (ret) { 395 tracing_start(); 396 goto out; 397 } 398 399 if (!ret && !count) { 400 printk(KERN_CONT ".. no entries found .."); 401 ret = -1; 402 tracing_start(); 403 goto out; 404 } 405 406 /* do the test by disabling interrupts first this time */ 407 tracing_max_latency = 0; 408 tracing_start(); 409 preempt_disable(); 410 local_irq_disable(); 411 udelay(100); 412 preempt_enable(); 413 /* reverse the order of preempt vs irqs */ 414 local_irq_enable(); 415 416 /* stop the tracing. */ 417 tracing_stop(); 418 /* check both trace buffers */ 419 ret = trace_test_buffer(tr, NULL); 420 if (ret) 421 goto out; 422 423 ret = trace_test_buffer(&max_tr, &count); 424 425 if (!ret && !count) { 426 printk(KERN_CONT ".. no entries found .."); 427 ret = -1; 428 goto out; 429 } 430 431 out: 432 trace->reset(tr); 433 tracing_start(); 434 tracing_max_latency = save_max; 435 436 return ret; 437 } 438 #endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */ 439 440 #ifdef CONFIG_NOP_TRACER 441 int 442 trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr) 443 { 444 /* What could possibly go wrong? */ 445 return 0; 446 } 447 #endif 448 449 #ifdef CONFIG_SCHED_TRACER 450 static int trace_wakeup_test_thread(void *data) 451 { 452 /* Make this a RT thread, doesn't need to be too high */ 453 struct sched_param param = { .sched_priority = 5 }; 454 struct completion *x = data; 455 456 sched_setscheduler(current, SCHED_FIFO, ¶m); 457 458 /* Make it know we have a new prio */ 459 complete(x); 460 461 /* now go to sleep and let the test wake us up */ 462 set_current_state(TASK_INTERRUPTIBLE); 463 schedule(); 464 465 /* we are awake, now wait to disappear */ 466 while (!kthread_should_stop()) { 467 /* 468 * This is an RT task, do short sleeps to let 469 * others run. 470 */ 471 msleep(100); 472 } 473 474 return 0; 475 } 476 477 int 478 trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr) 479 { 480 unsigned long save_max = tracing_max_latency; 481 struct task_struct *p; 482 struct completion isrt; 483 unsigned long count; 484 int ret; 485 486 init_completion(&isrt); 487 488 /* create a high prio thread */ 489 p = kthread_run(trace_wakeup_test_thread, &isrt, "ftrace-test"); 490 if (IS_ERR(p)) { 491 printk(KERN_CONT "Failed to create ftrace wakeup test thread "); 492 return -1; 493 } 494 495 /* make sure the thread is running at an RT prio */ 496 wait_for_completion(&isrt); 497 498 /* start the tracing */ 499 ret = trace->init(tr); 500 if (ret) { 501 warn_failed_init_tracer(trace, ret); 502 return ret; 503 } 504 505 /* reset the max latency */ 506 tracing_max_latency = 0; 507 508 /* sleep to let the RT thread sleep too */ 509 msleep(100); 510 511 /* 512 * Yes this is slightly racy. It is possible that for some 513 * strange reason that the RT thread we created, did not 514 * call schedule for 100ms after doing the completion, 515 * and we do a wakeup on a task that already is awake. 516 * But that is extremely unlikely, and the worst thing that 517 * happens in such a case, is that we disable tracing. 518 * Honestly, if this race does happen something is horrible 519 * wrong with the system. 520 */ 521 522 wake_up_process(p); 523 524 /* give a little time to let the thread wake up */ 525 msleep(100); 526 527 /* stop the tracing. */ 528 tracing_stop(); 529 /* check both trace buffers */ 530 ret = trace_test_buffer(tr, NULL); 531 if (!ret) 532 ret = trace_test_buffer(&max_tr, &count); 533 534 535 trace->reset(tr); 536 tracing_start(); 537 538 tracing_max_latency = save_max; 539 540 /* kill the thread */ 541 kthread_stop(p); 542 543 if (!ret && !count) { 544 printk(KERN_CONT ".. no entries found .."); 545 ret = -1; 546 } 547 548 return ret; 549 } 550 #endif /* CONFIG_SCHED_TRACER */ 551 552 #ifdef CONFIG_CONTEXT_SWITCH_TRACER 553 int 554 trace_selftest_startup_sched_switch(struct tracer *trace, struct trace_array *tr) 555 { 556 unsigned long count; 557 int ret; 558 559 /* start the tracing */ 560 ret = trace->init(tr); 561 if (ret) { 562 warn_failed_init_tracer(trace, ret); 563 return ret; 564 } 565 566 /* Sleep for a 1/10 of a second */ 567 msleep(100); 568 /* stop the tracing. */ 569 tracing_stop(); 570 /* check the trace buffer */ 571 ret = trace_test_buffer(tr, &count); 572 trace->reset(tr); 573 tracing_start(); 574 575 if (!ret && !count) { 576 printk(KERN_CONT ".. no entries found .."); 577 ret = -1; 578 } 579 580 return ret; 581 } 582 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */ 583 584 #ifdef CONFIG_SYSPROF_TRACER 585 int 586 trace_selftest_startup_sysprof(struct tracer *trace, struct trace_array *tr) 587 { 588 unsigned long count; 589 int ret; 590 591 /* start the tracing */ 592 ret = trace->init(tr); 593 if (ret) { 594 warn_failed_init_tracer(trace, ret); 595 return 0; 596 } 597 598 /* Sleep for a 1/10 of a second */ 599 msleep(100); 600 /* stop the tracing. */ 601 tracing_stop(); 602 /* check the trace buffer */ 603 ret = trace_test_buffer(tr, &count); 604 trace->reset(tr); 605 tracing_start(); 606 607 return ret; 608 } 609 #endif /* CONFIG_SYSPROF_TRACER */ 610 611 #ifdef CONFIG_BRANCH_TRACER 612 int 613 trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr) 614 { 615 unsigned long count; 616 int ret; 617 618 /* start the tracing */ 619 ret = trace->init(tr); 620 if (ret) { 621 warn_failed_init_tracer(trace, ret); 622 return ret; 623 } 624 625 /* Sleep for a 1/10 of a second */ 626 msleep(100); 627 /* stop the tracing. */ 628 tracing_stop(); 629 /* check the trace buffer */ 630 ret = trace_test_buffer(tr, &count); 631 trace->reset(tr); 632 tracing_start(); 633 634 return ret; 635 } 636 #endif /* CONFIG_BRANCH_TRACER */ 637