1#undef TRACE_SYSTEM 2#define TRACE_SYSTEM rcu 3 4#if !defined(_TRACE_RCU_H) || defined(TRACE_HEADER_MULTI_READ) 5#define _TRACE_RCU_H 6 7#include <linux/tracepoint.h> 8 9/* 10 * Tracepoint for start/end markers used for utilization calculations. 11 * By convention, the string is of the following forms: 12 * 13 * "Start <activity>" -- Mark the start of the specified activity, 14 * such as "context switch". Nesting is permitted. 15 * "End <activity>" -- Mark the end of the specified activity. 16 * 17 * An "@" character within "<activity>" is a comment character: Data 18 * reduction scripts will ignore the "@" and the remainder of the line. 19 */ 20TRACE_EVENT(rcu_utilization, 21 22 TP_PROTO(const char *s), 23 24 TP_ARGS(s), 25 26 TP_STRUCT__entry( 27 __field(const char *, s) 28 ), 29 30 TP_fast_assign( 31 __entry->s = s; 32 ), 33 34 TP_printk("%s", __entry->s) 35); 36 37#ifdef CONFIG_RCU_TRACE 38 39#if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU) 40 41/* 42 * Tracepoint for grace-period events. Takes a string identifying the 43 * RCU flavor, the grace-period number, and a string identifying the 44 * grace-period-related event as follows: 45 * 46 * "AccReadyCB": CPU acclerates new callbacks to RCU_NEXT_READY_TAIL. 47 * "AccWaitCB": CPU accelerates new callbacks to RCU_WAIT_TAIL. 48 * "newreq": Request a new grace period. 49 * "start": Start a grace period. 50 * "cpustart": CPU first notices a grace-period start. 51 * "cpuqs": CPU passes through a quiescent state. 52 * "cpuonl": CPU comes online. 53 * "cpuofl": CPU goes offline. 54 * "reqwait": GP kthread sleeps waiting for grace-period request. 55 * "reqwaitsig": GP kthread awakened by signal from reqwait state. 56 * "fqswait": GP kthread waiting until time to force quiescent states. 57 * "fqsstart": GP kthread starts forcing quiescent states. 58 * "fqsend": GP kthread done forcing quiescent states. 59 * "fqswaitsig": GP kthread awakened by signal from fqswait state. 60 * "end": End a grace period. 61 * "cpuend": CPU first notices a grace-period end. 62 */ 63TRACE_EVENT(rcu_grace_period, 64 65 TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent), 66 67 TP_ARGS(rcuname, gpnum, gpevent), 68 69 TP_STRUCT__entry( 70 __field(const char *, rcuname) 71 __field(unsigned long, gpnum) 72 __field(const char *, gpevent) 73 ), 74 75 TP_fast_assign( 76 __entry->rcuname = rcuname; 77 __entry->gpnum = gpnum; 78 __entry->gpevent = gpevent; 79 ), 80 81 TP_printk("%s %lu %s", 82 __entry->rcuname, __entry->gpnum, __entry->gpevent) 83); 84 85/* 86 * Tracepoint for future grace-period events, including those for no-callbacks 87 * CPUs. The caller should pull the data from the rcu_node structure, 88 * other than rcuname, which comes from the rcu_state structure, and event, 89 * which is one of the following: 90 * 91 * "Startleaf": Request a nocb grace period based on leaf-node data. 92 * "Startedleaf": Leaf-node start proved sufficient. 93 * "Startedleafroot": Leaf-node start proved sufficient after checking root. 94 * "Startedroot": Requested a nocb grace period based on root-node data. 95 * "StartWait": Start waiting for the requested grace period. 96 * "ResumeWait": Resume waiting after signal. 97 * "EndWait": Complete wait. 98 * "Cleanup": Clean up rcu_node structure after previous GP. 99 * "CleanupMore": Clean up, and another no-CB GP is needed. 100 */ 101TRACE_EVENT(rcu_future_grace_period, 102 103 TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed, 104 unsigned long c, u8 level, int grplo, int grphi, 105 const char *gpevent), 106 107 TP_ARGS(rcuname, gpnum, completed, c, level, grplo, grphi, gpevent), 108 109 TP_STRUCT__entry( 110 __field(const char *, rcuname) 111 __field(unsigned long, gpnum) 112 __field(unsigned long, completed) 113 __field(unsigned long, c) 114 __field(u8, level) 115 __field(int, grplo) 116 __field(int, grphi) 117 __field(const char *, gpevent) 118 ), 119 120 TP_fast_assign( 121 __entry->rcuname = rcuname; 122 __entry->gpnum = gpnum; 123 __entry->completed = completed; 124 __entry->c = c; 125 __entry->level = level; 126 __entry->grplo = grplo; 127 __entry->grphi = grphi; 128 __entry->gpevent = gpevent; 129 ), 130 131 TP_printk("%s %lu %lu %lu %u %d %d %s", 132 __entry->rcuname, __entry->gpnum, __entry->completed, 133 __entry->c, __entry->level, __entry->grplo, __entry->grphi, 134 __entry->gpevent) 135); 136 137/* 138 * Tracepoint for grace-period-initialization events. These are 139 * distinguished by the type of RCU, the new grace-period number, the 140 * rcu_node structure level, the starting and ending CPU covered by the 141 * rcu_node structure, and the mask of CPUs that will be waited for. 142 * All but the type of RCU are extracted from the rcu_node structure. 143 */ 144TRACE_EVENT(rcu_grace_period_init, 145 146 TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level, 147 int grplo, int grphi, unsigned long qsmask), 148 149 TP_ARGS(rcuname, gpnum, level, grplo, grphi, qsmask), 150 151 TP_STRUCT__entry( 152 __field(const char *, rcuname) 153 __field(unsigned long, gpnum) 154 __field(u8, level) 155 __field(int, grplo) 156 __field(int, grphi) 157 __field(unsigned long, qsmask) 158 ), 159 160 TP_fast_assign( 161 __entry->rcuname = rcuname; 162 __entry->gpnum = gpnum; 163 __entry->level = level; 164 __entry->grplo = grplo; 165 __entry->grphi = grphi; 166 __entry->qsmask = qsmask; 167 ), 168 169 TP_printk("%s %lu %u %d %d %lx", 170 __entry->rcuname, __entry->gpnum, __entry->level, 171 __entry->grplo, __entry->grphi, __entry->qsmask) 172); 173 174/* 175 * Tracepoint for RCU no-CBs CPU callback handoffs. This event is intended 176 * to assist debugging of these handoffs. 177 * 178 * The first argument is the name of the RCU flavor, and the second is 179 * the number of the offloaded CPU are extracted. The third and final 180 * argument is a string as follows: 181 * 182 * "WakeEmpty": Wake rcuo kthread, first CB to empty list. 183 * "WakeEmptyIsDeferred": Wake rcuo kthread later, first CB to empty list. 184 * "WakeOvf": Wake rcuo kthread, CB list is huge. 185 * "WakeOvfIsDeferred": Wake rcuo kthread later, CB list is huge. 186 * "WakeNot": Don't wake rcuo kthread. 187 * "WakeNotPoll": Don't wake rcuo kthread because it is polling. 188 * "DeferredWake": Carried out the "IsDeferred" wakeup. 189 * "Poll": Start of new polling cycle for rcu_nocb_poll. 190 * "Sleep": Sleep waiting for CBs for !rcu_nocb_poll. 191 * "WokeEmpty": rcuo kthread woke to find empty list. 192 * "WokeNonEmpty": rcuo kthread woke to find non-empty list. 193 * "WaitQueue": Enqueue partially done, timed wait for it to complete. 194 * "WokeQueue": Partial enqueue now complete. 195 */ 196TRACE_EVENT(rcu_nocb_wake, 197 198 TP_PROTO(const char *rcuname, int cpu, const char *reason), 199 200 TP_ARGS(rcuname, cpu, reason), 201 202 TP_STRUCT__entry( 203 __field(const char *, rcuname) 204 __field(int, cpu) 205 __field(const char *, reason) 206 ), 207 208 TP_fast_assign( 209 __entry->rcuname = rcuname; 210 __entry->cpu = cpu; 211 __entry->reason = reason; 212 ), 213 214 TP_printk("%s %d %s", __entry->rcuname, __entry->cpu, __entry->reason) 215); 216 217/* 218 * Tracepoint for tasks blocking within preemptible-RCU read-side 219 * critical sections. Track the type of RCU (which one day might 220 * include SRCU), the grace-period number that the task is blocking 221 * (the current or the next), and the task's PID. 222 */ 223TRACE_EVENT(rcu_preempt_task, 224 225 TP_PROTO(const char *rcuname, int pid, unsigned long gpnum), 226 227 TP_ARGS(rcuname, pid, gpnum), 228 229 TP_STRUCT__entry( 230 __field(const char *, rcuname) 231 __field(unsigned long, gpnum) 232 __field(int, pid) 233 ), 234 235 TP_fast_assign( 236 __entry->rcuname = rcuname; 237 __entry->gpnum = gpnum; 238 __entry->pid = pid; 239 ), 240 241 TP_printk("%s %lu %d", 242 __entry->rcuname, __entry->gpnum, __entry->pid) 243); 244 245/* 246 * Tracepoint for tasks that blocked within a given preemptible-RCU 247 * read-side critical section exiting that critical section. Track the 248 * type of RCU (which one day might include SRCU) and the task's PID. 249 */ 250TRACE_EVENT(rcu_unlock_preempted_task, 251 252 TP_PROTO(const char *rcuname, unsigned long gpnum, int pid), 253 254 TP_ARGS(rcuname, gpnum, pid), 255 256 TP_STRUCT__entry( 257 __field(const char *, rcuname) 258 __field(unsigned long, gpnum) 259 __field(int, pid) 260 ), 261 262 TP_fast_assign( 263 __entry->rcuname = rcuname; 264 __entry->gpnum = gpnum; 265 __entry->pid = pid; 266 ), 267 268 TP_printk("%s %lu %d", __entry->rcuname, __entry->gpnum, __entry->pid) 269); 270 271/* 272 * Tracepoint for quiescent-state-reporting events. These are 273 * distinguished by the type of RCU, the grace-period number, the 274 * mask of quiescent lower-level entities, the rcu_node structure level, 275 * the starting and ending CPU covered by the rcu_node structure, and 276 * whether there are any blocked tasks blocking the current grace period. 277 * All but the type of RCU are extracted from the rcu_node structure. 278 */ 279TRACE_EVENT(rcu_quiescent_state_report, 280 281 TP_PROTO(const char *rcuname, unsigned long gpnum, 282 unsigned long mask, unsigned long qsmask, 283 u8 level, int grplo, int grphi, int gp_tasks), 284 285 TP_ARGS(rcuname, gpnum, mask, qsmask, level, grplo, grphi, gp_tasks), 286 287 TP_STRUCT__entry( 288 __field(const char *, rcuname) 289 __field(unsigned long, gpnum) 290 __field(unsigned long, mask) 291 __field(unsigned long, qsmask) 292 __field(u8, level) 293 __field(int, grplo) 294 __field(int, grphi) 295 __field(u8, gp_tasks) 296 ), 297 298 TP_fast_assign( 299 __entry->rcuname = rcuname; 300 __entry->gpnum = gpnum; 301 __entry->mask = mask; 302 __entry->qsmask = qsmask; 303 __entry->level = level; 304 __entry->grplo = grplo; 305 __entry->grphi = grphi; 306 __entry->gp_tasks = gp_tasks; 307 ), 308 309 TP_printk("%s %lu %lx>%lx %u %d %d %u", 310 __entry->rcuname, __entry->gpnum, 311 __entry->mask, __entry->qsmask, __entry->level, 312 __entry->grplo, __entry->grphi, __entry->gp_tasks) 313); 314 315/* 316 * Tracepoint for quiescent states detected by force_quiescent_state(). 317 * These trace events include the type of RCU, the grace-period number 318 * that was blocked by the CPU, the CPU itself, and the type of quiescent 319 * state, which can be "dti" for dyntick-idle mode, "ofl" for CPU offline, 320 * or "kick" when kicking a CPU that has been in dyntick-idle mode for 321 * too long. 322 */ 323TRACE_EVENT(rcu_fqs, 324 325 TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent), 326 327 TP_ARGS(rcuname, gpnum, cpu, qsevent), 328 329 TP_STRUCT__entry( 330 __field(const char *, rcuname) 331 __field(unsigned long, gpnum) 332 __field(int, cpu) 333 __field(const char *, qsevent) 334 ), 335 336 TP_fast_assign( 337 __entry->rcuname = rcuname; 338 __entry->gpnum = gpnum; 339 __entry->cpu = cpu; 340 __entry->qsevent = qsevent; 341 ), 342 343 TP_printk("%s %lu %d %s", 344 __entry->rcuname, __entry->gpnum, 345 __entry->cpu, __entry->qsevent) 346); 347 348#endif /* #if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU) */ 349 350/* 351 * Tracepoint for dyntick-idle entry/exit events. These take a string 352 * as argument: "Start" for entering dyntick-idle mode, "End" for 353 * leaving it, "--=" for events moving towards idle, and "++=" for events 354 * moving away from idle. "Error on entry: not idle task" and "Error on 355 * exit: not idle task" indicate that a non-idle task is erroneously 356 * toying with the idle loop. 357 * 358 * These events also take a pair of numbers, which indicate the nesting 359 * depth before and after the event of interest. Note that task-related 360 * events use the upper bits of each number, while interrupt-related 361 * events use the lower bits. 362 */ 363TRACE_EVENT(rcu_dyntick, 364 365 TP_PROTO(const char *polarity, long long oldnesting, long long newnesting), 366 367 TP_ARGS(polarity, oldnesting, newnesting), 368 369 TP_STRUCT__entry( 370 __field(const char *, polarity) 371 __field(long long, oldnesting) 372 __field(long long, newnesting) 373 ), 374 375 TP_fast_assign( 376 __entry->polarity = polarity; 377 __entry->oldnesting = oldnesting; 378 __entry->newnesting = newnesting; 379 ), 380 381 TP_printk("%s %llx %llx", __entry->polarity, 382 __entry->oldnesting, __entry->newnesting) 383); 384 385/* 386 * Tracepoint for RCU preparation for idle, the goal being to get RCU 387 * processing done so that the current CPU can shut off its scheduling 388 * clock and enter dyntick-idle mode. One way to accomplish this is 389 * to drain all RCU callbacks from this CPU, and the other is to have 390 * done everything RCU requires for the current grace period. In this 391 * latter case, the CPU will be awakened at the end of the current grace 392 * period in order to process the remainder of its callbacks. 393 * 394 * These tracepoints take a string as argument: 395 * 396 * "No callbacks": Nothing to do, no callbacks on this CPU. 397 * "In holdoff": Nothing to do, holding off after unsuccessful attempt. 398 * "Begin holdoff": Attempt failed, don't retry until next jiffy. 399 * "Dyntick with callbacks": Entering dyntick-idle despite callbacks. 400 * "Dyntick with lazy callbacks": Entering dyntick-idle w/lazy callbacks. 401 * "More callbacks": Still more callbacks, try again to clear them out. 402 * "Callbacks drained": All callbacks processed, off to dyntick idle! 403 * "Timer": Timer fired to cause CPU to continue processing callbacks. 404 * "Demigrate": Timer fired on wrong CPU, woke up correct CPU. 405 * "Cleanup after idle": Idle exited, timer canceled. 406 */ 407TRACE_EVENT(rcu_prep_idle, 408 409 TP_PROTO(const char *reason), 410 411 TP_ARGS(reason), 412 413 TP_STRUCT__entry( 414 __field(const char *, reason) 415 ), 416 417 TP_fast_assign( 418 __entry->reason = reason; 419 ), 420 421 TP_printk("%s", __entry->reason) 422); 423 424/* 425 * Tracepoint for the registration of a single RCU callback function. 426 * The first argument is the type of RCU, the second argument is 427 * a pointer to the RCU callback itself, the third element is the 428 * number of lazy callbacks queued, and the fourth element is the 429 * total number of callbacks queued. 430 */ 431TRACE_EVENT(rcu_callback, 432 433 TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy, 434 long qlen), 435 436 TP_ARGS(rcuname, rhp, qlen_lazy, qlen), 437 438 TP_STRUCT__entry( 439 __field(const char *, rcuname) 440 __field(void *, rhp) 441 __field(void *, func) 442 __field(long, qlen_lazy) 443 __field(long, qlen) 444 ), 445 446 TP_fast_assign( 447 __entry->rcuname = rcuname; 448 __entry->rhp = rhp; 449 __entry->func = rhp->func; 450 __entry->qlen_lazy = qlen_lazy; 451 __entry->qlen = qlen; 452 ), 453 454 TP_printk("%s rhp=%p func=%pf %ld/%ld", 455 __entry->rcuname, __entry->rhp, __entry->func, 456 __entry->qlen_lazy, __entry->qlen) 457); 458 459/* 460 * Tracepoint for the registration of a single RCU callback of the special 461 * kfree() form. The first argument is the RCU type, the second argument 462 * is a pointer to the RCU callback, the third argument is the offset 463 * of the callback within the enclosing RCU-protected data structure, 464 * the fourth argument is the number of lazy callbacks queued, and the 465 * fifth argument is the total number of callbacks queued. 466 */ 467TRACE_EVENT(rcu_kfree_callback, 468 469 TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, 470 long qlen_lazy, long qlen), 471 472 TP_ARGS(rcuname, rhp, offset, qlen_lazy, qlen), 473 474 TP_STRUCT__entry( 475 __field(const char *, rcuname) 476 __field(void *, rhp) 477 __field(unsigned long, offset) 478 __field(long, qlen_lazy) 479 __field(long, qlen) 480 ), 481 482 TP_fast_assign( 483 __entry->rcuname = rcuname; 484 __entry->rhp = rhp; 485 __entry->offset = offset; 486 __entry->qlen_lazy = qlen_lazy; 487 __entry->qlen = qlen; 488 ), 489 490 TP_printk("%s rhp=%p func=%ld %ld/%ld", 491 __entry->rcuname, __entry->rhp, __entry->offset, 492 __entry->qlen_lazy, __entry->qlen) 493); 494 495/* 496 * Tracepoint for marking the beginning rcu_do_batch, performed to start 497 * RCU callback invocation. The first argument is the RCU flavor, 498 * the second is the number of lazy callbacks queued, the third is 499 * the total number of callbacks queued, and the fourth argument is 500 * the current RCU-callback batch limit. 501 */ 502TRACE_EVENT(rcu_batch_start, 503 504 TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit), 505 506 TP_ARGS(rcuname, qlen_lazy, qlen, blimit), 507 508 TP_STRUCT__entry( 509 __field(const char *, rcuname) 510 __field(long, qlen_lazy) 511 __field(long, qlen) 512 __field(long, blimit) 513 ), 514 515 TP_fast_assign( 516 __entry->rcuname = rcuname; 517 __entry->qlen_lazy = qlen_lazy; 518 __entry->qlen = qlen; 519 __entry->blimit = blimit; 520 ), 521 522 TP_printk("%s CBs=%ld/%ld bl=%ld", 523 __entry->rcuname, __entry->qlen_lazy, __entry->qlen, 524 __entry->blimit) 525); 526 527/* 528 * Tracepoint for the invocation of a single RCU callback function. 529 * The first argument is the type of RCU, and the second argument is 530 * a pointer to the RCU callback itself. 531 */ 532TRACE_EVENT(rcu_invoke_callback, 533 534 TP_PROTO(const char *rcuname, struct rcu_head *rhp), 535 536 TP_ARGS(rcuname, rhp), 537 538 TP_STRUCT__entry( 539 __field(const char *, rcuname) 540 __field(void *, rhp) 541 __field(void *, func) 542 ), 543 544 TP_fast_assign( 545 __entry->rcuname = rcuname; 546 __entry->rhp = rhp; 547 __entry->func = rhp->func; 548 ), 549 550 TP_printk("%s rhp=%p func=%pf", 551 __entry->rcuname, __entry->rhp, __entry->func) 552); 553 554/* 555 * Tracepoint for the invocation of a single RCU callback of the special 556 * kfree() form. The first argument is the RCU flavor, the second 557 * argument is a pointer to the RCU callback, and the third argument 558 * is the offset of the callback within the enclosing RCU-protected 559 * data structure. 560 */ 561TRACE_EVENT(rcu_invoke_kfree_callback, 562 563 TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), 564 565 TP_ARGS(rcuname, rhp, offset), 566 567 TP_STRUCT__entry( 568 __field(const char *, rcuname) 569 __field(void *, rhp) 570 __field(unsigned long, offset) 571 ), 572 573 TP_fast_assign( 574 __entry->rcuname = rcuname; 575 __entry->rhp = rhp; 576 __entry->offset = offset; 577 ), 578 579 TP_printk("%s rhp=%p func=%ld", 580 __entry->rcuname, __entry->rhp, __entry->offset) 581); 582 583/* 584 * Tracepoint for exiting rcu_do_batch after RCU callbacks have been 585 * invoked. The first argument is the name of the RCU flavor, 586 * the second argument is number of callbacks actually invoked, 587 * the third argument (cb) is whether or not any of the callbacks that 588 * were ready to invoke at the beginning of this batch are still 589 * queued, the fourth argument (nr) is the return value of need_resched(), 590 * the fifth argument (iit) is 1 if the current task is the idle task, 591 * and the sixth argument (risk) is the return value from 592 * rcu_is_callbacks_kthread(). 593 */ 594TRACE_EVENT(rcu_batch_end, 595 596 TP_PROTO(const char *rcuname, int callbacks_invoked, 597 char cb, char nr, char iit, char risk), 598 599 TP_ARGS(rcuname, callbacks_invoked, cb, nr, iit, risk), 600 601 TP_STRUCT__entry( 602 __field(const char *, rcuname) 603 __field(int, callbacks_invoked) 604 __field(char, cb) 605 __field(char, nr) 606 __field(char, iit) 607 __field(char, risk) 608 ), 609 610 TP_fast_assign( 611 __entry->rcuname = rcuname; 612 __entry->callbacks_invoked = callbacks_invoked; 613 __entry->cb = cb; 614 __entry->nr = nr; 615 __entry->iit = iit; 616 __entry->risk = risk; 617 ), 618 619 TP_printk("%s CBs-invoked=%d idle=%c%c%c%c", 620 __entry->rcuname, __entry->callbacks_invoked, 621 __entry->cb ? 'C' : '.', 622 __entry->nr ? 'S' : '.', 623 __entry->iit ? 'I' : '.', 624 __entry->risk ? 'R' : '.') 625); 626 627/* 628 * Tracepoint for rcutorture readers. The first argument is the name 629 * of the RCU flavor from rcutorture's viewpoint and the second argument 630 * is the callback address. 631 */ 632TRACE_EVENT(rcu_torture_read, 633 634 TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, 635 unsigned long secs, unsigned long c_old, unsigned long c), 636 637 TP_ARGS(rcutorturename, rhp, secs, c_old, c), 638 639 TP_STRUCT__entry( 640 __field(const char *, rcutorturename) 641 __field(struct rcu_head *, rhp) 642 __field(unsigned long, secs) 643 __field(unsigned long, c_old) 644 __field(unsigned long, c) 645 ), 646 647 TP_fast_assign( 648 __entry->rcutorturename = rcutorturename; 649 __entry->rhp = rhp; 650 __entry->secs = secs; 651 __entry->c_old = c_old; 652 __entry->c = c; 653 ), 654 655 TP_printk("%s torture read %p %luus c: %lu %lu", 656 __entry->rcutorturename, __entry->rhp, 657 __entry->secs, __entry->c_old, __entry->c) 658); 659 660/* 661 * Tracepoint for _rcu_barrier() execution. The string "s" describes 662 * the _rcu_barrier phase: 663 * "Begin": _rcu_barrier() started. 664 * "EarlyExit": _rcu_barrier() piggybacked, thus early exit. 665 * "Inc1": _rcu_barrier() piggyback check counter incremented. 666 * "OfflineNoCB": _rcu_barrier() found callback on never-online CPU 667 * "OnlineNoCB": _rcu_barrier() found online no-CBs CPU. 668 * "OnlineQ": _rcu_barrier() found online CPU with callbacks. 669 * "OnlineNQ": _rcu_barrier() found online CPU, no callbacks. 670 * "IRQ": An rcu_barrier_callback() callback posted on remote CPU. 671 * "CB": An rcu_barrier_callback() invoked a callback, not the last. 672 * "LastCB": An rcu_barrier_callback() invoked the last callback. 673 * "Inc2": _rcu_barrier() piggyback check counter incremented. 674 * The "cpu" argument is the CPU or -1 if meaningless, the "cnt" argument 675 * is the count of remaining callbacks, and "done" is the piggybacking count. 676 */ 677TRACE_EVENT(rcu_barrier, 678 679 TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), 680 681 TP_ARGS(rcuname, s, cpu, cnt, done), 682 683 TP_STRUCT__entry( 684 __field(const char *, rcuname) 685 __field(const char *, s) 686 __field(int, cpu) 687 __field(int, cnt) 688 __field(unsigned long, done) 689 ), 690 691 TP_fast_assign( 692 __entry->rcuname = rcuname; 693 __entry->s = s; 694 __entry->cpu = cpu; 695 __entry->cnt = cnt; 696 __entry->done = done; 697 ), 698 699 TP_printk("%s %s cpu %d remaining %d # %lu", 700 __entry->rcuname, __entry->s, __entry->cpu, __entry->cnt, 701 __entry->done) 702); 703 704#else /* #ifdef CONFIG_RCU_TRACE */ 705 706#define trace_rcu_grace_period(rcuname, gpnum, gpevent) do { } while (0) 707#define trace_rcu_grace_period_init(rcuname, gpnum, level, grplo, grphi, \ 708 qsmask) do { } while (0) 709#define trace_rcu_future_grace_period(rcuname, gpnum, completed, c, \ 710 level, grplo, grphi, event) \ 711 do { } while (0) 712#define trace_rcu_nocb_wake(rcuname, cpu, reason) do { } while (0) 713#define trace_rcu_preempt_task(rcuname, pid, gpnum) do { } while (0) 714#define trace_rcu_unlock_preempted_task(rcuname, gpnum, pid) do { } while (0) 715#define trace_rcu_quiescent_state_report(rcuname, gpnum, mask, qsmask, level, \ 716 grplo, grphi, gp_tasks) do { } \ 717 while (0) 718#define trace_rcu_fqs(rcuname, gpnum, cpu, qsevent) do { } while (0) 719#define trace_rcu_dyntick(polarity, oldnesting, newnesting) do { } while (0) 720#define trace_rcu_prep_idle(reason) do { } while (0) 721#define trace_rcu_callback(rcuname, rhp, qlen_lazy, qlen) do { } while (0) 722#define trace_rcu_kfree_callback(rcuname, rhp, offset, qlen_lazy, qlen) \ 723 do { } while (0) 724#define trace_rcu_batch_start(rcuname, qlen_lazy, qlen, blimit) \ 725 do { } while (0) 726#define trace_rcu_invoke_callback(rcuname, rhp) do { } while (0) 727#define trace_rcu_invoke_kfree_callback(rcuname, rhp, offset) do { } while (0) 728#define trace_rcu_batch_end(rcuname, callbacks_invoked, cb, nr, iit, risk) \ 729 do { } while (0) 730#define trace_rcu_torture_read(rcutorturename, rhp, secs, c_old, c) \ 731 do { } while (0) 732#define trace_rcu_barrier(name, s, cpu, cnt, done) do { } while (0) 733 734#endif /* #else #ifdef CONFIG_RCU_TRACE */ 735 736#endif /* _TRACE_RCU_H */ 737 738/* This part must be outside protection */ 739#include <trace/define_trace.h> 740