Branch data Line data Source code
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 : : */
20 [ # # # # ]: 210912886 : TRACE_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_TREE_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 : : */
63 : : TRACE_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 : : */
101 : : TRACE_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 : : */
144 : : TRACE_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 : : * "WakeOvf": Wake rcuo kthread, CB list is huge.
184 : : * "WakeNot": Don't wake rcuo kthread.
185 : : * "WakeNotPoll": Don't wake rcuo kthread because it is polling.
186 : : * "Poll": Start of new polling cycle for rcu_nocb_poll.
187 : : * "Sleep": Sleep waiting for CBs for !rcu_nocb_poll.
188 : : * "WokeEmpty": rcuo kthread woke to find empty list.
189 : : * "WokeNonEmpty": rcuo kthread woke to find non-empty list.
190 : : * "WaitQueue": Enqueue partially done, timed wait for it to complete.
191 : : * "WokeQueue": Partial enqueue now complete.
192 : : */
193 : : TRACE_EVENT(rcu_nocb_wake,
194 : :
195 : : TP_PROTO(const char *rcuname, int cpu, const char *reason),
196 : :
197 : : TP_ARGS(rcuname, cpu, reason),
198 : :
199 : : TP_STRUCT__entry(
200 : : __field(const char *, rcuname)
201 : : __field(int, cpu)
202 : : __field(const char *, reason)
203 : : ),
204 : :
205 : : TP_fast_assign(
206 : : __entry->rcuname = rcuname;
207 : : __entry->cpu = cpu;
208 : : __entry->reason = reason;
209 : : ),
210 : :
211 : : TP_printk("%s %d %s", __entry->rcuname, __entry->cpu, __entry->reason)
212 : : );
213 : :
214 : : /*
215 : : * Tracepoint for tasks blocking within preemptible-RCU read-side
216 : : * critical sections. Track the type of RCU (which one day might
217 : : * include SRCU), the grace-period number that the task is blocking
218 : : * (the current or the next), and the task's PID.
219 : : */
220 : : TRACE_EVENT(rcu_preempt_task,
221 : :
222 : : TP_PROTO(const char *rcuname, int pid, unsigned long gpnum),
223 : :
224 : : TP_ARGS(rcuname, pid, gpnum),
225 : :
226 : : TP_STRUCT__entry(
227 : : __field(const char *, rcuname)
228 : : __field(unsigned long, gpnum)
229 : : __field(int, pid)
230 : : ),
231 : :
232 : : TP_fast_assign(
233 : : __entry->rcuname = rcuname;
234 : : __entry->gpnum = gpnum;
235 : : __entry->pid = pid;
236 : : ),
237 : :
238 : : TP_printk("%s %lu %d",
239 : : __entry->rcuname, __entry->gpnum, __entry->pid)
240 : : );
241 : :
242 : : /*
243 : : * Tracepoint for tasks that blocked within a given preemptible-RCU
244 : : * read-side critical section exiting that critical section. Track the
245 : : * type of RCU (which one day might include SRCU) and the task's PID.
246 : : */
247 : : TRACE_EVENT(rcu_unlock_preempted_task,
248 : :
249 : : TP_PROTO(const char *rcuname, unsigned long gpnum, int pid),
250 : :
251 : : TP_ARGS(rcuname, gpnum, pid),
252 : :
253 : : TP_STRUCT__entry(
254 : : __field(const char *, rcuname)
255 : : __field(unsigned long, gpnum)
256 : : __field(int, pid)
257 : : ),
258 : :
259 : : TP_fast_assign(
260 : : __entry->rcuname = rcuname;
261 : : __entry->gpnum = gpnum;
262 : : __entry->pid = pid;
263 : : ),
264 : :
265 : : TP_printk("%s %lu %d", __entry->rcuname, __entry->gpnum, __entry->pid)
266 : : );
267 : :
268 : : /*
269 : : * Tracepoint for quiescent-state-reporting events. These are
270 : : * distinguished by the type of RCU, the grace-period number, the
271 : : * mask of quiescent lower-level entities, the rcu_node structure level,
272 : : * the starting and ending CPU covered by the rcu_node structure, and
273 : : * whether there are any blocked tasks blocking the current grace period.
274 : : * All but the type of RCU are extracted from the rcu_node structure.
275 : : */
276 : : TRACE_EVENT(rcu_quiescent_state_report,
277 : :
278 : : TP_PROTO(const char *rcuname, unsigned long gpnum,
279 : : unsigned long mask, unsigned long qsmask,
280 : : u8 level, int grplo, int grphi, int gp_tasks),
281 : :
282 : : TP_ARGS(rcuname, gpnum, mask, qsmask, level, grplo, grphi, gp_tasks),
283 : :
284 : : TP_STRUCT__entry(
285 : : __field(const char *, rcuname)
286 : : __field(unsigned long, gpnum)
287 : : __field(unsigned long, mask)
288 : : __field(unsigned long, qsmask)
289 : : __field(u8, level)
290 : : __field(int, grplo)
291 : : __field(int, grphi)
292 : : __field(u8, gp_tasks)
293 : : ),
294 : :
295 : : TP_fast_assign(
296 : : __entry->rcuname = rcuname;
297 : : __entry->gpnum = gpnum;
298 : : __entry->mask = mask;
299 : : __entry->qsmask = qsmask;
300 : : __entry->level = level;
301 : : __entry->grplo = grplo;
302 : : __entry->grphi = grphi;
303 : : __entry->gp_tasks = gp_tasks;
304 : : ),
305 : :
306 : : TP_printk("%s %lu %lx>%lx %u %d %d %u",
307 : : __entry->rcuname, __entry->gpnum,
308 : : __entry->mask, __entry->qsmask, __entry->level,
309 : : __entry->grplo, __entry->grphi, __entry->gp_tasks)
310 : : );
311 : :
312 : : /*
313 : : * Tracepoint for quiescent states detected by force_quiescent_state().
314 : : * These trace events include the type of RCU, the grace-period number
315 : : * that was blocked by the CPU, the CPU itself, and the type of quiescent
316 : : * state, which can be "dti" for dyntick-idle mode, "ofl" for CPU offline,
317 : : * or "kick" when kicking a CPU that has been in dyntick-idle mode for
318 : : * too long.
319 : : */
320 : : TRACE_EVENT(rcu_fqs,
321 : :
322 : : TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent),
323 : :
324 : : TP_ARGS(rcuname, gpnum, cpu, qsevent),
325 : :
326 : : TP_STRUCT__entry(
327 : : __field(const char *, rcuname)
328 : : __field(unsigned long, gpnum)
329 : : __field(int, cpu)
330 : : __field(const char *, qsevent)
331 : : ),
332 : :
333 : : TP_fast_assign(
334 : : __entry->rcuname = rcuname;
335 : : __entry->gpnum = gpnum;
336 : : __entry->cpu = cpu;
337 : : __entry->qsevent = qsevent;
338 : : ),
339 : :
340 : : TP_printk("%s %lu %d %s",
341 : : __entry->rcuname, __entry->gpnum,
342 : : __entry->cpu, __entry->qsevent)
343 : : );
344 : :
345 : : #endif /* #if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU) */
346 : :
347 : : /*
348 : : * Tracepoint for dyntick-idle entry/exit events. These take a string
349 : : * as argument: "Start" for entering dyntick-idle mode, "End" for
350 : : * leaving it, "--=" for events moving towards idle, and "++=" for events
351 : : * moving away from idle. "Error on entry: not idle task" and "Error on
352 : : * exit: not idle task" indicate that a non-idle task is erroneously
353 : : * toying with the idle loop.
354 : : *
355 : : * These events also take a pair of numbers, which indicate the nesting
356 : : * depth before and after the event of interest. Note that task-related
357 : : * events use the upper bits of each number, while interrupt-related
358 : : * events use the lower bits.
359 : : */
360 : : TRACE_EVENT(rcu_dyntick,
361 : :
362 : : TP_PROTO(const char *polarity, long long oldnesting, long long newnesting),
363 : :
364 : : TP_ARGS(polarity, oldnesting, newnesting),
365 : :
366 : : TP_STRUCT__entry(
367 : : __field(const char *, polarity)
368 : : __field(long long, oldnesting)
369 : : __field(long long, newnesting)
370 : : ),
371 : :
372 : : TP_fast_assign(
373 : : __entry->polarity = polarity;
374 : : __entry->oldnesting = oldnesting;
375 : : __entry->newnesting = newnesting;
376 : : ),
377 : :
378 : : TP_printk("%s %llx %llx", __entry->polarity,
379 : : __entry->oldnesting, __entry->newnesting)
380 : : );
381 : :
382 : : /*
383 : : * Tracepoint for RCU preparation for idle, the goal being to get RCU
384 : : * processing done so that the current CPU can shut off its scheduling
385 : : * clock and enter dyntick-idle mode. One way to accomplish this is
386 : : * to drain all RCU callbacks from this CPU, and the other is to have
387 : : * done everything RCU requires for the current grace period. In this
388 : : * latter case, the CPU will be awakened at the end of the current grace
389 : : * period in order to process the remainder of its callbacks.
390 : : *
391 : : * These tracepoints take a string as argument:
392 : : *
393 : : * "No callbacks": Nothing to do, no callbacks on this CPU.
394 : : * "In holdoff": Nothing to do, holding off after unsuccessful attempt.
395 : : * "Begin holdoff": Attempt failed, don't retry until next jiffy.
396 : : * "Dyntick with callbacks": Entering dyntick-idle despite callbacks.
397 : : * "Dyntick with lazy callbacks": Entering dyntick-idle w/lazy callbacks.
398 : : * "More callbacks": Still more callbacks, try again to clear them out.
399 : : * "Callbacks drained": All callbacks processed, off to dyntick idle!
400 : : * "Timer": Timer fired to cause CPU to continue processing callbacks.
401 : : * "Demigrate": Timer fired on wrong CPU, woke up correct CPU.
402 : : * "Cleanup after idle": Idle exited, timer canceled.
403 : : */
404 : : TRACE_EVENT(rcu_prep_idle,
405 : :
406 : : TP_PROTO(const char *reason),
407 : :
408 : : TP_ARGS(reason),
409 : :
410 : : TP_STRUCT__entry(
411 : : __field(const char *, reason)
412 : : ),
413 : :
414 : : TP_fast_assign(
415 : : __entry->reason = reason;
416 : : ),
417 : :
418 : : TP_printk("%s", __entry->reason)
419 : : );
420 : :
421 : : /*
422 : : * Tracepoint for the registration of a single RCU callback function.
423 : : * The first argument is the type of RCU, the second argument is
424 : : * a pointer to the RCU callback itself, the third element is the
425 : : * number of lazy callbacks queued, and the fourth element is the
426 : : * total number of callbacks queued.
427 : : */
428 : : TRACE_EVENT(rcu_callback,
429 : :
430 : : TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy,
431 : : long qlen),
432 : :
433 : : TP_ARGS(rcuname, rhp, qlen_lazy, qlen),
434 : :
435 : : TP_STRUCT__entry(
436 : : __field(const char *, rcuname)
437 : : __field(void *, rhp)
438 : : __field(void *, func)
439 : : __field(long, qlen_lazy)
440 : : __field(long, qlen)
441 : : ),
442 : :
443 : : TP_fast_assign(
444 : : __entry->rcuname = rcuname;
445 : : __entry->rhp = rhp;
446 : : __entry->func = rhp->func;
447 : : __entry->qlen_lazy = qlen_lazy;
448 : : __entry->qlen = qlen;
449 : : ),
450 : :
451 : : TP_printk("%s rhp=%p func=%pf %ld/%ld",
452 : : __entry->rcuname, __entry->rhp, __entry->func,
453 : : __entry->qlen_lazy, __entry->qlen)
454 : : );
455 : :
456 : : /*
457 : : * Tracepoint for the registration of a single RCU callback of the special
458 : : * kfree() form. The first argument is the RCU type, the second argument
459 : : * is a pointer to the RCU callback, the third argument is the offset
460 : : * of the callback within the enclosing RCU-protected data structure,
461 : : * the fourth argument is the number of lazy callbacks queued, and the
462 : : * fifth argument is the total number of callbacks queued.
463 : : */
464 : : TRACE_EVENT(rcu_kfree_callback,
465 : :
466 : : TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset,
467 : : long qlen_lazy, long qlen),
468 : :
469 : : TP_ARGS(rcuname, rhp, offset, qlen_lazy, qlen),
470 : :
471 : : TP_STRUCT__entry(
472 : : __field(const char *, rcuname)
473 : : __field(void *, rhp)
474 : : __field(unsigned long, offset)
475 : : __field(long, qlen_lazy)
476 : : __field(long, qlen)
477 : : ),
478 : :
479 : : TP_fast_assign(
480 : : __entry->rcuname = rcuname;
481 : : __entry->rhp = rhp;
482 : : __entry->offset = offset;
483 : : __entry->qlen_lazy = qlen_lazy;
484 : : __entry->qlen = qlen;
485 : : ),
486 : :
487 : : TP_printk("%s rhp=%p func=%ld %ld/%ld",
488 : : __entry->rcuname, __entry->rhp, __entry->offset,
489 : : __entry->qlen_lazy, __entry->qlen)
490 : : );
491 : :
492 : : /*
493 : : * Tracepoint for marking the beginning rcu_do_batch, performed to start
494 : : * RCU callback invocation. The first argument is the RCU flavor,
495 : : * the second is the number of lazy callbacks queued, the third is
496 : : * the total number of callbacks queued, and the fourth argument is
497 : : * the current RCU-callback batch limit.
498 : : */
499 : : TRACE_EVENT(rcu_batch_start,
500 : :
501 : : TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit),
502 : :
503 : : TP_ARGS(rcuname, qlen_lazy, qlen, blimit),
504 : :
505 : : TP_STRUCT__entry(
506 : : __field(const char *, rcuname)
507 : : __field(long, qlen_lazy)
508 : : __field(long, qlen)
509 : : __field(long, blimit)
510 : : ),
511 : :
512 : : TP_fast_assign(
513 : : __entry->rcuname = rcuname;
514 : : __entry->qlen_lazy = qlen_lazy;
515 : : __entry->qlen = qlen;
516 : : __entry->blimit = blimit;
517 : : ),
518 : :
519 : : TP_printk("%s CBs=%ld/%ld bl=%ld",
520 : : __entry->rcuname, __entry->qlen_lazy, __entry->qlen,
521 : : __entry->blimit)
522 : : );
523 : :
524 : : /*
525 : : * Tracepoint for the invocation of a single RCU callback function.
526 : : * The first argument is the type of RCU, and the second argument is
527 : : * a pointer to the RCU callback itself.
528 : : */
529 : : TRACE_EVENT(rcu_invoke_callback,
530 : :
531 : : TP_PROTO(const char *rcuname, struct rcu_head *rhp),
532 : :
533 : : TP_ARGS(rcuname, rhp),
534 : :
535 : : TP_STRUCT__entry(
536 : : __field(const char *, rcuname)
537 : : __field(void *, rhp)
538 : : __field(void *, func)
539 : : ),
540 : :
541 : : TP_fast_assign(
542 : : __entry->rcuname = rcuname;
543 : : __entry->rhp = rhp;
544 : : __entry->func = rhp->func;
545 : : ),
546 : :
547 : : TP_printk("%s rhp=%p func=%pf",
548 : : __entry->rcuname, __entry->rhp, __entry->func)
549 : : );
550 : :
551 : : /*
552 : : * Tracepoint for the invocation of a single RCU callback of the special
553 : : * kfree() form. The first argument is the RCU flavor, the second
554 : : * argument is a pointer to the RCU callback, and the third argument
555 : : * is the offset of the callback within the enclosing RCU-protected
556 : : * data structure.
557 : : */
558 : : TRACE_EVENT(rcu_invoke_kfree_callback,
559 : :
560 : : TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset),
561 : :
562 : : TP_ARGS(rcuname, rhp, offset),
563 : :
564 : : TP_STRUCT__entry(
565 : : __field(const char *, rcuname)
566 : : __field(void *, rhp)
567 : : __field(unsigned long, offset)
568 : : ),
569 : :
570 : : TP_fast_assign(
571 : : __entry->rcuname = rcuname;
572 : : __entry->rhp = rhp;
573 : : __entry->offset = offset;
574 : : ),
575 : :
576 : : TP_printk("%s rhp=%p func=%ld",
577 : : __entry->rcuname, __entry->rhp, __entry->offset)
578 : : );
579 : :
580 : : /*
581 : : * Tracepoint for exiting rcu_do_batch after RCU callbacks have been
582 : : * invoked. The first argument is the name of the RCU flavor,
583 : : * the second argument is number of callbacks actually invoked,
584 : : * the third argument (cb) is whether or not any of the callbacks that
585 : : * were ready to invoke at the beginning of this batch are still
586 : : * queued, the fourth argument (nr) is the return value of need_resched(),
587 : : * the fifth argument (iit) is 1 if the current task is the idle task,
588 : : * and the sixth argument (risk) is the return value from
589 : : * rcu_is_callbacks_kthread().
590 : : */
591 : : TRACE_EVENT(rcu_batch_end,
592 : :
593 : : TP_PROTO(const char *rcuname, int callbacks_invoked,
594 : : char cb, char nr, char iit, char risk),
595 : :
596 : : TP_ARGS(rcuname, callbacks_invoked, cb, nr, iit, risk),
597 : :
598 : : TP_STRUCT__entry(
599 : : __field(const char *, rcuname)
600 : : __field(int, callbacks_invoked)
601 : : __field(char, cb)
602 : : __field(char, nr)
603 : : __field(char, iit)
604 : : __field(char, risk)
605 : : ),
606 : :
607 : : TP_fast_assign(
608 : : __entry->rcuname = rcuname;
609 : : __entry->callbacks_invoked = callbacks_invoked;
610 : : __entry->cb = cb;
611 : : __entry->nr = nr;
612 : : __entry->iit = iit;
613 : : __entry->risk = risk;
614 : : ),
615 : :
616 : : TP_printk("%s CBs-invoked=%d idle=%c%c%c%c",
617 : : __entry->rcuname, __entry->callbacks_invoked,
618 : : __entry->cb ? 'C' : '.',
619 : : __entry->nr ? 'S' : '.',
620 : : __entry->iit ? 'I' : '.',
621 : : __entry->risk ? 'R' : '.')
622 : : );
623 : :
624 : : /*
625 : : * Tracepoint for rcutorture readers. The first argument is the name
626 : : * of the RCU flavor from rcutorture's viewpoint and the second argument
627 : : * is the callback address.
628 : : */
629 : : TRACE_EVENT(rcu_torture_read,
630 : :
631 : : TP_PROTO(const char *rcutorturename, struct rcu_head *rhp,
632 : : unsigned long secs, unsigned long c_old, unsigned long c),
633 : :
634 : : TP_ARGS(rcutorturename, rhp, secs, c_old, c),
635 : :
636 : : TP_STRUCT__entry(
637 : : __field(const char *, rcutorturename)
638 : : __field(struct rcu_head *, rhp)
639 : : __field(unsigned long, secs)
640 : : __field(unsigned long, c_old)
641 : : __field(unsigned long, c)
642 : : ),
643 : :
644 : : TP_fast_assign(
645 : : __entry->rcutorturename = rcutorturename;
646 : : __entry->rhp = rhp;
647 : : __entry->secs = secs;
648 : : __entry->c_old = c_old;
649 : : __entry->c = c;
650 : : ),
651 : :
652 : : TP_printk("%s torture read %p %luus c: %lu %lu",
653 : : __entry->rcutorturename, __entry->rhp,
654 : : __entry->secs, __entry->c_old, __entry->c)
655 : : );
656 : :
657 : : /*
658 : : * Tracepoint for _rcu_barrier() execution. The string "s" describes
659 : : * the _rcu_barrier phase:
660 : : * "Begin": rcu_barrier_callback() started.
661 : : * "Check": rcu_barrier_callback() checking for piggybacking.
662 : : * "EarlyExit": rcu_barrier_callback() piggybacked, thus early exit.
663 : : * "Inc1": rcu_barrier_callback() piggyback check counter incremented.
664 : : * "Offline": rcu_barrier_callback() found offline CPU
665 : : * "OnlineNoCB": rcu_barrier_callback() found online no-CBs CPU.
666 : : * "OnlineQ": rcu_barrier_callback() found online CPU with callbacks.
667 : : * "OnlineNQ": rcu_barrier_callback() found online CPU, no callbacks.
668 : : * "IRQ": An rcu_barrier_callback() callback posted on remote CPU.
669 : : * "CB": An rcu_barrier_callback() invoked a callback, not the last.
670 : : * "LastCB": An rcu_barrier_callback() invoked the last callback.
671 : : * "Inc2": rcu_barrier_callback() piggyback check counter incremented.
672 : : * The "cpu" argument is the CPU or -1 if meaningless, the "cnt" argument
673 : : * is the count of remaining callbacks, and "done" is the piggybacking count.
674 : : */
675 : : TRACE_EVENT(rcu_barrier,
676 : :
677 : : TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done),
678 : :
679 : : TP_ARGS(rcuname, s, cpu, cnt, done),
680 : :
681 : : TP_STRUCT__entry(
682 : : __field(const char *, rcuname)
683 : : __field(const char *, s)
684 : : __field(int, cpu)
685 : : __field(int, cnt)
686 : : __field(unsigned long, done)
687 : : ),
688 : :
689 : : TP_fast_assign(
690 : : __entry->rcuname = rcuname;
691 : : __entry->s = s;
692 : : __entry->cpu = cpu;
693 : : __entry->cnt = cnt;
694 : : __entry->done = done;
695 : : ),
696 : :
697 : : TP_printk("%s %s cpu %d remaining %d # %lu",
698 : : __entry->rcuname, __entry->s, __entry->cpu, __entry->cnt,
699 : : __entry->done)
700 : : );
701 : :
702 : : #else /* #ifdef CONFIG_RCU_TRACE */
703 : :
704 : : #define trace_rcu_grace_period(rcuname, gpnum, gpevent) do { } while (0)
705 : : #define trace_rcu_grace_period_init(rcuname, gpnum, level, grplo, grphi, \
706 : : qsmask) do { } while (0)
707 : : #define trace_rcu_future_grace_period(rcuname, gpnum, completed, c, \
708 : : level, grplo, grphi, event) \
709 : : do { } while (0)
710 : : #define trace_rcu_nocb_wake(rcuname, cpu, reason) do { } while (0)
711 : : #define trace_rcu_preempt_task(rcuname, pid, gpnum) do { } while (0)
712 : : #define trace_rcu_unlock_preempted_task(rcuname, gpnum, pid) do { } while (0)
713 : : #define trace_rcu_quiescent_state_report(rcuname, gpnum, mask, qsmask, level, \
714 : : grplo, grphi, gp_tasks) do { } \
715 : : while (0)
716 : : #define trace_rcu_fqs(rcuname, gpnum, cpu, qsevent) do { } while (0)
717 : : #define trace_rcu_dyntick(polarity, oldnesting, newnesting) do { } while (0)
718 : : #define trace_rcu_prep_idle(reason) do { } while (0)
719 : : #define trace_rcu_callback(rcuname, rhp, qlen_lazy, qlen) do { } while (0)
720 : : #define trace_rcu_kfree_callback(rcuname, rhp, offset, qlen_lazy, qlen) \
721 : : do { } while (0)
722 : : #define trace_rcu_batch_start(rcuname, qlen_lazy, qlen, blimit) \
723 : : do { } while (0)
724 : : #define trace_rcu_invoke_callback(rcuname, rhp) do { } while (0)
725 : : #define trace_rcu_invoke_kfree_callback(rcuname, rhp, offset) do { } while (0)
726 : : #define trace_rcu_batch_end(rcuname, callbacks_invoked, cb, nr, iit, risk) \
727 : : do { } while (0)
728 : : #define trace_rcu_torture_read(rcutorturename, rhp, secs, c_old, c) \
729 : : do { } while (0)
730 : : #define trace_rcu_barrier(name, s, cpu, cnt, done) do { } while (0)
731 : :
732 : : #endif /* #else #ifdef CONFIG_RCU_TRACE */
733 : :
734 : : #endif /* _TRACE_RCU_H */
735 : :
736 : : /* This part must be outside protection */
737 : : #include <trace/define_trace.h>
|
