~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/trace/events/rcu.h

Version: ~ [ linux-5.14-rc3 ] ~ [ linux-5.13.5 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.53 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.135 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.198 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.240 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.276 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.276 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp