1 // SPDX-FileCopyrightText: 2012 Andrew Gabbasov <andrew_gabbasov@mentor.com>
3 // SPDX-License-Identifier: GPL-2.0-only
6 #define TRACE_SYSTEM rcu
8 #if !defined(LTTNG_TRACE_RCU_H) || defined(TRACE_HEADER_MULTI_READ)
9 #define LTTNG_TRACE_RCU_H
11 #include <lttng/tracepoint-event.h>
12 #include <lttng/kernel-version.h>
15 * Tracepoint for start/end markers used for utilization calculations.
16 * By convention, the string is of the following forms:
18 * "Start <activity>" -- Mark the start of the specified activity,
19 * such as "context switch". Nesting is permitted.
20 * "End <activity>" -- Mark the end of the specified activity.
22 * An "@" character within "<activity>" is a comment character: Data
23 * reduction scripts will ignore the "@" and the remainder of the line.
25 LTTNG_TRACEPOINT_EVENT(rcu_utilization
,
27 TP_PROTO(const char *s
),
36 #ifdef CONFIG_RCU_TRACE
38 #if defined(CONFIG_TREE_RCU) \
39 || defined(CONFIG_PREEMPT_RCU) \
40 || defined(CONFIG_TREE_PREEMPT_RCU)
43 * Tracepoint for grace-period events: starting and ending a grace
44 * period ("start" and "end", respectively), a CPU noting the start
45 * of a new grace period or the end of an old grace period ("cpustart"
46 * and "cpuend", respectively), a CPU passing through a quiescent
47 * state ("cpuqs"), a CPU coming online or going offline ("cpuonl"
48 * and "cpuofl", respectively), and a CPU being kicked for being too
49 * long in dyntick-idle mode ("kick").
51 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,19,0) || \
52 LTTNG_RHEL_KERNEL_RANGE(4,18,0,80,0,0, 4,19,0,0,0,0))
53 LTTNG_TRACEPOINT_EVENT(rcu_grace_period
,
55 TP_PROTO(const char *rcuname
, unsigned long gp_seq
, const char *gpevent
),
57 TP_ARGS(rcuname
, gp_seq
, gpevent
),
60 ctf_string(rcuname
, rcuname
)
61 ctf_integer(unsigned long, gp_seq
, gp_seq
)
62 ctf_string(gpevent
, gpevent
)
66 LTTNG_TRACEPOINT_EVENT(rcu_grace_period
,
68 TP_PROTO(const char *rcuname
, unsigned long gpnum
, const char *gpevent
),
70 TP_ARGS(rcuname
, gpnum
, gpevent
),
73 ctf_string(rcuname
, rcuname
)
74 ctf_integer(unsigned long, gpnum
, gpnum
)
75 ctf_string(gpevent
, gpevent
)
81 * Tracepoint for grace-period-initialization events. These are
82 * distinguished by the type of RCU, the new grace-period number, the
83 * rcu_node structure level, the starting and ending CPU covered by the
84 * rcu_node structure, and the mask of CPUs that will be waited for.
85 * All but the type of RCU are extracted from the rcu_node structure.
87 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,19,0) || \
88 LTTNG_RHEL_KERNEL_RANGE(4,18,0,80,0,0, 4,19,0,0,0,0))
89 LTTNG_TRACEPOINT_EVENT(rcu_grace_period_init
,
91 TP_PROTO(const char *rcuname
, unsigned long gp_seq
, u8 level
,
92 int grplo
, int grphi
, unsigned long qsmask
),
94 TP_ARGS(rcuname
, gp_seq
, level
, grplo
, grphi
, qsmask
),
97 ctf_string(rcuname
, rcuname
)
98 ctf_integer(unsigned long, gp_seq
, gp_seq
)
99 ctf_integer(u8
, level
, level
)
100 ctf_integer(int, grplo
, grplo
)
101 ctf_integer(int, grphi
, grphi
)
102 ctf_integer(unsigned long, qsmask
, qsmask
)
106 LTTNG_TRACEPOINT_EVENT(rcu_grace_period_init
,
108 TP_PROTO(const char *rcuname
, unsigned long gpnum
, u8 level
,
109 int grplo
, int grphi
, unsigned long qsmask
),
111 TP_ARGS(rcuname
, gpnum
, level
, grplo
, grphi
, qsmask
),
114 ctf_string(rcuname
, rcuname
)
115 ctf_integer(unsigned long, gpnum
, gpnum
)
116 ctf_integer(u8
, level
, level
)
117 ctf_integer(int, grplo
, grplo
)
118 ctf_integer(int, grphi
, grphi
)
119 ctf_integer(unsigned long, qsmask
, qsmask
)
125 * Tracepoint for tasks blocking within preemptible-RCU read-side
126 * critical sections. Track the type of RCU (which one day might
127 * include SRCU), the grace-period number that the task is blocking
128 * (the current or the next), and the task's PID.
130 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,19,0) || \
131 LTTNG_RHEL_KERNEL_RANGE(4,18,0,80,0,0, 4,19,0,0,0,0))
132 LTTNG_TRACEPOINT_EVENT(rcu_preempt_task
,
134 TP_PROTO(const char *rcuname
, int pid
, unsigned long gp_seq
),
136 TP_ARGS(rcuname
, pid
, gp_seq
),
139 ctf_string(rcuname
, rcuname
)
140 ctf_integer(unsigned long, gp_seq
, gp_seq
)
141 ctf_integer(int, pid
, pid
)
145 LTTNG_TRACEPOINT_EVENT(rcu_preempt_task
,
147 TP_PROTO(const char *rcuname
, int pid
, unsigned long gpnum
),
149 TP_ARGS(rcuname
, pid
, gpnum
),
152 ctf_string(rcuname
, rcuname
)
153 ctf_integer(unsigned long, gpnum
, gpnum
)
154 ctf_integer(int, pid
, pid
)
160 * Tracepoint for tasks that blocked within a given preemptible-RCU
161 * read-side critical section exiting that critical section. Track the
162 * type of RCU (which one day might include SRCU) and the task's PID.
164 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,19,0) || \
165 LTTNG_RHEL_KERNEL_RANGE(4,18,0,80,0,0, 4,19,0,0,0,0))
166 LTTNG_TRACEPOINT_EVENT(rcu_unlock_preempted_task
,
168 TP_PROTO(const char *rcuname
, unsigned long gp_seq
, int pid
),
170 TP_ARGS(rcuname
, gp_seq
, pid
),
173 ctf_string(rcuname
, rcuname
)
174 ctf_integer(unsigned long, gp_seq
, gp_seq
)
175 ctf_integer(int, pid
, pid
)
179 LTTNG_TRACEPOINT_EVENT(rcu_unlock_preempted_task
,
181 TP_PROTO(const char *rcuname
, unsigned long gpnum
, int pid
),
183 TP_ARGS(rcuname
, gpnum
, pid
),
186 ctf_string(rcuname
, rcuname
)
187 ctf_integer(unsigned long, gpnum
, gpnum
)
188 ctf_integer(int, pid
, pid
)
194 * Tracepoint for quiescent-state-reporting events. These are
195 * distinguished by the type of RCU, the grace-period number, the
196 * mask of quiescent lower-level entities, the rcu_node structure level,
197 * the starting and ending CPU covered by the rcu_node structure, and
198 * whether there are any blocked tasks blocking the current grace period.
199 * All but the type of RCU are extracted from the rcu_node structure.
201 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,19,0) || \
202 LTTNG_RHEL_KERNEL_RANGE(4,18,0,80,0,0, 4,19,0,0,0,0))
203 LTTNG_TRACEPOINT_EVENT(rcu_quiescent_state_report
,
205 TP_PROTO(const char *rcuname
, unsigned long gp_seq
,
206 unsigned long mask
, unsigned long qsmask
,
207 u8 level
, int grplo
, int grphi
, int gp_tasks
),
209 TP_ARGS(rcuname
, gp_seq
, mask
, qsmask
, level
, grplo
, grphi
, gp_tasks
),
212 ctf_string(rcuname
, rcuname
)
213 ctf_integer(unsigned long, gp_seq
, gp_seq
)
214 ctf_integer(unsigned long, mask
, mask
)
215 ctf_integer(unsigned long, qsmask
, qsmask
)
216 ctf_integer(u8
, level
, level
)
217 ctf_integer(int, grplo
, grplo
)
218 ctf_integer(int, grphi
, grphi
)
219 ctf_integer(u8
, gp_tasks
, gp_tasks
)
223 LTTNG_TRACEPOINT_EVENT(rcu_quiescent_state_report
,
225 TP_PROTO(const char *rcuname
, unsigned long gpnum
,
226 unsigned long mask
, unsigned long qsmask
,
227 u8 level
, int grplo
, int grphi
, int gp_tasks
),
229 TP_ARGS(rcuname
, gpnum
, mask
, qsmask
, level
, grplo
, grphi
, gp_tasks
),
232 ctf_string(rcuname
, rcuname
)
233 ctf_integer(unsigned long, gpnum
, gpnum
)
234 ctf_integer(unsigned long, mask
, mask
)
235 ctf_integer(unsigned long, qsmask
, qsmask
)
236 ctf_integer(u8
, level
, level
)
237 ctf_integer(int, grplo
, grplo
)
238 ctf_integer(int, grphi
, grphi
)
239 ctf_integer(u8
, gp_tasks
, gp_tasks
)
245 * Tracepoint for quiescent states detected by force_quiescent_state().
246 * These trace events include the type of RCU, the grace-period number
247 * that was blocked by the CPU, the CPU itself, and the type of quiescent
248 * state, which can be "dti" for dyntick-idle mode, "ofl" for CPU offline,
249 * or "kick" when kicking a CPU that has been in dyntick-idle mode for
252 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,19,0) || \
253 LTTNG_RHEL_KERNEL_RANGE(4,18,0,80,0,0, 4,19,0,0,0,0))
254 LTTNG_TRACEPOINT_EVENT(rcu_fqs
,
256 TP_PROTO(const char *rcuname
, unsigned long gp_seq
, int cpu
, const char *qsevent
),
258 TP_ARGS(rcuname
, gp_seq
, cpu
, qsevent
),
261 ctf_integer(unsigned long, gp_seq
, gp_seq
)
262 ctf_integer(int, cpu
, cpu
)
263 ctf_string(rcuname
, rcuname
)
264 ctf_string(qsevent
, qsevent
)
268 LTTNG_TRACEPOINT_EVENT(rcu_fqs
,
270 TP_PROTO(const char *rcuname
, unsigned long gpnum
, int cpu
, const char *qsevent
),
272 TP_ARGS(rcuname
, gpnum
, cpu
, qsevent
),
275 ctf_integer(unsigned long, gpnum
, gpnum
)
276 ctf_integer(int, cpu
, cpu
)
277 ctf_string(rcuname
, rcuname
)
278 ctf_string(qsevent
, qsevent
)
284 * #if defined(CONFIG_TREE_RCU)
285 * || (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,19,0)
286 * && defined(CONFIG_PREEMPT_RCU))
287 * || defined(CONFIG_TREE_PREEMPT_RCU)
291 * Tracepoint for dyntick-idle entry/exit events. These take a string
292 * as argument: "Start" for entering dyntick-idle mode, "End" for
293 * leaving it, "--=" for events moving towards idle, and "++=" for events
294 * moving away from idle. "Error on entry: not idle task" and "Error on
295 * exit: not idle task" indicate that a non-idle task is erroneously
296 * toying with the idle loop.
298 * These events also take a pair of numbers, which indicate the nesting
299 * depth before and after the event of interest. Note that task-related
300 * events use the upper bits of each number, while interrupt-related
301 * events use the lower bits.
303 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0)) \
304 || LTTNG_KERNEL_RANGE(5,5,6, 5,6,0) \
305 || LTTNG_KERNEL_RANGE(5,4,22, 5,5,0) \
306 || LTTNG_UBUNTU_KERNEL_RANGE(5,0,21,46, 5,1,0,0)
307 LTTNG_TRACEPOINT_EVENT(rcu_dyntick
,
309 TP_PROTO(const char *polarity
, long oldnesting
, long newnesting
, int dynticks
),
311 TP_ARGS(polarity
, oldnesting
, newnesting
, dynticks
),
314 ctf_string(polarity
, polarity
)
315 ctf_integer(long, oldnesting
, oldnesting
)
316 ctf_integer(long, newnesting
, newnesting
)
317 ctf_integer(int, dynticks
, dynticks
)
321 #elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,16,0))
322 LTTNG_TRACEPOINT_EVENT(rcu_dyntick
,
324 TP_PROTO(const char *polarity
, long oldnesting
, long newnesting
, atomic_t dynticks
),
326 TP_ARGS(polarity
, oldnesting
, newnesting
, dynticks
),
329 ctf_string(polarity
, polarity
)
330 ctf_integer(long, oldnesting
, oldnesting
)
331 ctf_integer(long, newnesting
, newnesting
)
332 ctf_integer(int, dynticks
, atomic_read(&dynticks
))
337 LTTNG_TRACEPOINT_EVENT(rcu_dyntick
,
339 TP_PROTO(const char *polarity
, long long oldnesting
, long long newnesting
),
341 TP_ARGS(polarity
, oldnesting
, newnesting
),
344 ctf_string(polarity
, polarity
)
345 ctf_integer(long long, oldnesting
, oldnesting
)
346 ctf_integer(long long, newnesting
, newnesting
)
353 * Tracepoint for RCU preparation for idle, the goal being to get RCU
354 * processing done so that the current CPU can shut off its scheduling
355 * clock and enter dyntick-idle mode. One way to accomplish this is
356 * to drain all RCU callbacks from this CPU, and the other is to have
357 * done everything RCU requires for the current grace period. In this
358 * latter case, the CPU will be awakened at the end of the current grace
359 * period in order to process the remainder of its callbacks.
361 * These tracepoints take a string as argument:
363 * "No callbacks": Nothing to do, no callbacks on this CPU.
364 * "In holdoff": Nothing to do, holding off after unsuccessful attempt.
365 * "Begin holdoff": Attempt failed, don't retry until next jiffy.
366 * "Dyntick with callbacks": Entering dyntick-idle despite callbacks.
367 * "Dyntick with lazy callbacks": Entering dyntick-idle w/lazy callbacks.
368 * "More callbacks": Still more callbacks, try again to clear them out.
369 * "Callbacks drained": All callbacks processed, off to dyntick idle!
370 * "Timer": Timer fired to cause CPU to continue processing callbacks.
371 * "Demigrate": Timer fired on wrong CPU, woke up correct CPU.
372 * "Cleanup after idle": Idle exited, timer canceled.
374 LTTNG_TRACEPOINT_EVENT(rcu_prep_idle
,
376 TP_PROTO(const char *reason
),
381 ctf_string(reason
, reason
)
386 * Tracepoint for the registration of a single RCU callback function.
387 * The first argument is the type of RCU, the second argument is
388 * a pointer to the RCU callback itself, the third element is the
389 * number of lazy callbacks queued, and the fourth element is the
390 * total number of callbacks queued.
392 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0))
393 LTTNG_TRACEPOINT_EVENT(rcu_callback
,
395 TP_PROTO(const char *rcuname
, struct rcu_head
*rhp
, long qlen
),
397 TP_ARGS(rcuname
, rhp
, qlen
),
400 ctf_string(rcuname
, rcuname
)
401 ctf_integer_hex(void *, rhp
, rhp
)
402 ctf_integer_hex(void *, func
, rhp
->func
)
403 ctf_integer(long, qlen
, qlen
)
407 LTTNG_TRACEPOINT_EVENT(rcu_callback
,
409 TP_PROTO(const char *rcuname
, struct rcu_head
*rhp
, long qlen_lazy
,
412 TP_ARGS(rcuname
, rhp
, qlen_lazy
, qlen
),
415 ctf_string(rcuname
, rcuname
)
416 ctf_integer_hex(void *, rhp
, rhp
)
417 ctf_integer_hex(void *, func
, rhp
->func
)
418 ctf_integer(long, qlen_lazy
, qlen_lazy
)
419 ctf_integer(long, qlen
, qlen
)
426 * Tracepoint for the registration of a single RCU callback of the special
427 * kfree() form. The first argument is the RCU type, the second argument
428 * is a pointer to the RCU callback, the third argument is the offset
429 * of the callback within the enclosing RCU-protected data structure,
430 * the fourth argument is the number of lazy callbacks queued, and the
431 * fifth argument is the total number of callbacks queued.
433 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0))
434 LTTNG_TRACEPOINT_EVENT(rcu_kfree_callback
,
436 TP_PROTO(const char *rcuname
, struct rcu_head
*rhp
, unsigned long offset
,
439 TP_ARGS(rcuname
, rhp
, offset
, qlen
),
442 ctf_string(rcuname
, rcuname
)
443 ctf_integer_hex(void *, rhp
, rhp
)
444 ctf_integer_hex(unsigned long, offset
, offset
)
445 ctf_integer(long, qlen
, qlen
)
449 LTTNG_TRACEPOINT_EVENT(rcu_kfree_callback
,
451 TP_PROTO(const char *rcuname
, struct rcu_head
*rhp
, unsigned long offset
,
452 long qlen_lazy
, long qlen
),
454 TP_ARGS(rcuname
, rhp
, offset
, qlen_lazy
, qlen
),
457 ctf_string(rcuname
, rcuname
)
458 ctf_integer_hex(void *, rhp
, rhp
)
459 ctf_integer_hex(unsigned long, offset
, offset
)
460 ctf_integer(long, qlen_lazy
, qlen_lazy
)
461 ctf_integer(long, qlen
, qlen
)
467 * Tracepoint for marking the beginning rcu_do_batch, performed to start
468 * RCU callback invocation. The first argument is the RCU flavor,
469 * the second is the number of lazy callbacks queued, the third is
470 * the total number of callbacks queued, and the fourth argument is
471 * the current RCU-callback batch limit.
473 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0))
474 LTTNG_TRACEPOINT_EVENT(rcu_batch_start
,
476 TP_PROTO(const char *rcuname
, long qlen
, long blimit
),
478 TP_ARGS(rcuname
, qlen
, blimit
),
481 ctf_string(rcuname
, rcuname
)
482 ctf_integer(long, qlen
, qlen
)
483 ctf_integer(long, blimit
, blimit
)
487 LTTNG_TRACEPOINT_EVENT(rcu_batch_start
,
489 TP_PROTO(const char *rcuname
, long qlen_lazy
, long qlen
, long blimit
),
491 TP_ARGS(rcuname
, qlen_lazy
, qlen
, blimit
),
494 ctf_string(rcuname
, rcuname
)
495 ctf_integer(long, qlen_lazy
, qlen_lazy
)
496 ctf_integer(long, qlen
, qlen
)
497 ctf_integer(long, blimit
, blimit
)
503 * Tracepoint for the invocation of a single RCU callback function.
504 * The first argument is the type of RCU, and the second argument is
505 * a pointer to the RCU callback itself.
507 LTTNG_TRACEPOINT_EVENT(rcu_invoke_callback
,
509 TP_PROTO(const char *rcuname
, struct rcu_head
*rhp
),
511 TP_ARGS(rcuname
, rhp
),
514 ctf_string(rcuname
, rcuname
)
515 ctf_integer_hex(void *, rhp
, rhp
)
516 ctf_integer_hex(void *, func
, rhp
->func
)
521 * Tracepoint for the invocation of a single RCU callback of the special
522 * kfree() form. The first argument is the RCU flavor, the second
523 * argument is a pointer to the RCU callback, and the third argument
524 * is the offset of the callback within the enclosing RCU-protected
527 LTTNG_TRACEPOINT_EVENT(rcu_invoke_kfree_callback
,
529 TP_PROTO(const char *rcuname
, struct rcu_head
*rhp
, unsigned long offset
),
531 TP_ARGS(rcuname
, rhp
, offset
),
534 ctf_string(rcuname
, rcuname
)
535 ctf_integer_hex(void *, rhp
, rhp
)
536 ctf_integer(unsigned long, offset
, offset
)
541 * Tracepoint for exiting rcu_do_batch after RCU callbacks have been
542 * invoked. The first argument is the name of the RCU flavor,
543 * the second argument is number of callbacks actually invoked,
544 * the third argument (cb) is whether or not any of the callbacks that
545 * were ready to invoke at the beginning of this batch are still
546 * queued, the fourth argument (nr) is the return value of need_resched(),
547 * the fifth argument (iit) is 1 if the current task is the idle task,
548 * and the sixth argument (risk) is the return value from
549 * rcu_is_callbacks_kthread().
551 LTTNG_TRACEPOINT_EVENT(rcu_batch_end
,
553 TP_PROTO(const char *rcuname
, int callbacks_invoked
,
554 char cb
, char nr
, char iit
, char risk
),
556 TP_ARGS(rcuname
, callbacks_invoked
, cb
, nr
, iit
, risk
),
559 ctf_string(rcuname
, rcuname
)
560 ctf_integer(int, callbacks_invoked
, callbacks_invoked
)
561 ctf_integer(char, cb
, cb
)
562 ctf_integer(char, nr
, nr
)
563 ctf_integer(char, iit
, iit
)
564 ctf_integer(char, risk
, risk
)
569 * Tracepoint for rcutorture readers. The first argument is the name
570 * of the RCU flavor from rcutorture's viewpoint and the second argument
571 * is the callback address.
573 LTTNG_TRACEPOINT_EVENT(rcu_torture_read
,
575 TP_PROTO(const char *rcutorturename
, struct rcu_head
*rhp
,
576 unsigned long secs
, unsigned long c_old
, unsigned long c
),
578 TP_ARGS(rcutorturename
, rhp
, secs
, c_old
, c
),
581 ctf_string(rcutorturename
, rcutorturename
)
582 ctf_integer_hex(struct rcu_head
*, rhp
, rhp
)
583 ctf_integer(unsigned long, secs
, secs
)
584 ctf_integer(unsigned long, c_old
, c_old
)
585 ctf_integer(unsigned long, c
, c
)
590 * Tracepoint for _rcu_barrier() execution. The string "s" describes
591 * the _rcu_barrier phase:
592 * "Begin": rcu_barrier_callback() started.
593 * "Check": rcu_barrier_callback() checking for piggybacking.
594 * "EarlyExit": rcu_barrier_callback() piggybacked, thus early exit.
595 * "Inc1": rcu_barrier_callback() piggyback check counter incremented.
596 * "Offline": rcu_barrier_callback() found offline CPU
597 * "OnlineQ": rcu_barrier_callback() found online CPU with callbacks.
598 * "OnlineNQ": rcu_barrier_callback() found online CPU, no callbacks.
599 * "IRQ": An rcu_barrier_callback() callback posted on remote CPU.
600 * "CB": An rcu_barrier_callback() invoked a callback, not the last.
601 * "LastCB": An rcu_barrier_callback() invoked the last callback.
602 * "Inc2": rcu_barrier_callback() piggyback check counter incremented.
603 * The "cpu" argument is the CPU or -1 if meaningless, the "cnt" argument
604 * is the count of remaining callbacks, and "done" is the piggybacking count.
606 LTTNG_TRACEPOINT_EVENT(rcu_barrier
,
608 TP_PROTO(const char *rcuname
, const char *s
, int cpu
, int cnt
, unsigned long done
),
610 TP_ARGS(rcuname
, s
, cpu
, cnt
, done
),
613 ctf_string(rcuname
, rcuname
)
615 ctf_integer(int, cpu
, cpu
)
616 ctf_integer(int, cnt
, cnt
)
617 ctf_integer(unsigned long, done
, done
)
621 #else /* #ifdef CONFIG_RCU_TRACE */
623 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,19,0) || \
624 LTTNG_RHEL_KERNEL_RANGE(4,18,0,80,0,0, 4,19,0,0,0,0))
625 #define trace_rcu_grace_period(rcuname, gp_seq, gpevent) do { } while (0)
626 #define trace_rcu_grace_period_init(rcuname, gp_seq, level, grplo, grphi, \
627 qsmask) do { } while (0)
628 #define trace_rcu_preempt_task(rcuname, pid, gp_seq) do { } while (0)
629 #define trace_rcu_unlock_preempted_task(rcuname, gp_seq, pid) do { } while (0)
630 #define trace_rcu_quiescent_state_report(rcuname, gp_seq, mask, qsmask, level, \
631 grplo, grphi, gp_tasks) do { } \
633 #define trace_rcu_fqs(rcuname, gp_seq, cpu, qsevent) do { } while (0)
635 #define trace_rcu_grace_period(rcuname, gpnum, gpevent) do { } while (0)
636 #define trace_rcu_grace_period_init(rcuname, gpnum, level, grplo, grphi, \
637 qsmask) do { } while (0)
638 #define trace_rcu_preempt_task(rcuname, pid, gpnum) do { } while (0)
639 #define trace_rcu_unlock_preempted_task(rcuname, gpnum, pid) do { } while (0)
640 #define trace_rcu_quiescent_state_report(rcuname, gpnum, mask, qsmask, level, \
641 grplo, grphi, gp_tasks) do { } \
643 #define trace_rcu_fqs(rcuname, gpnum, cpu, qsevent) do { } while (0)
646 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,16,0))
647 #define trace_rcu_dyntick(polarity, oldnesting, newnesting, dyntick) do { } while (0)
649 #define trace_rcu_dyntick(polarity, oldnesting, newnesting) do { } while (0)
652 #define trace_rcu_prep_idle(reason) do { } while (0)
653 #define trace_rcu_callback(rcuname, rhp, qlen_lazy, qlen) do { } while (0)
654 #define trace_rcu_kfree_callback(rcuname, rhp, offset, qlen_lazy, qlen) \
656 #define trace_rcu_batch_start(rcuname, qlen_lazy, qlen, blimit) \
658 #define trace_rcu_invoke_callback(rcuname, rhp) do { } while (0)
659 #define trace_rcu_invoke_kfree_callback(rcuname, rhp, offset) do { } while (0)
660 #define trace_rcu_batch_end(rcuname, callbacks_invoked, cb, nr, iit, risk) \
662 #define trace_rcu_torture_read(rcutorturename, rhp, secs, c_old, c) \
664 #define trace_rcu_barrier(name, s, cpu, cnt, done) do { } while (0)
665 #endif /* #else #ifdef CONFIG_RCU_TRACE */
667 #endif /* LTTNG_TRACE_RCU_H */
669 /* This part must be outside protection */
670 #include <lttng/define_trace.h>