2 * Read-Copy Update tracing for classic implementation
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 * Copyright IBM Corporation, 2008
20 * Papers: http://www.rdrop.com/users/paulmck/RCU
22 * For detailed explanation of Read-Copy Update mechanism see -
26 #include <linux/types.h>
27 #include <linux/kernel.h>
28 #include <linux/init.h>
29 #include <linux/spinlock.h>
30 #include <linux/smp.h>
31 #include <linux/rcupdate.h>
32 #include <linux/interrupt.h>
33 #include <linux/sched.h>
34 #include <linux/atomic.h>
35 #include <linux/bitops.h>
36 #include <linux/module.h>
37 #include <linux/completion.h>
38 #include <linux/moduleparam.h>
39 #include <linux/percpu.h>
40 #include <linux/notifier.h>
41 #include <linux/cpu.h>
42 #include <linux/mutex.h>
43 #include <linux/debugfs.h>
44 #include <linux/seq_file.h>
46 #define RCU_TREE_NONCORE
49 static int show_rcubarrier(struct seq_file
*m
, void *unused
)
51 struct rcu_state
*rsp
;
53 for_each_rcu_flavor(rsp
)
54 seq_printf(m
, "%s: bcc: %d nbd: %lu\n",
56 atomic_read(&rsp
->barrier_cpu_count
),
61 static int rcubarrier_open(struct inode
*inode
, struct file
*file
)
63 return single_open(file
, show_rcubarrier
, NULL
);
66 static const struct file_operations rcubarrier_fops
= {
68 .open
= rcubarrier_open
,
71 .release
= single_release
,
74 #ifdef CONFIG_RCU_BOOST
76 static char convert_kthread_status(unsigned int kthread_status
)
78 if (kthread_status
> RCU_KTHREAD_MAX
)
80 return "SRWOY"[kthread_status
];
83 #endif /* #ifdef CONFIG_RCU_BOOST */
85 static void print_one_rcu_data(struct seq_file
*m
, struct rcu_data
*rdp
)
89 seq_printf(m
, "%3d%cc=%lu g=%lu pq=%d qp=%d",
91 cpu_is_offline(rdp
->cpu
) ? '!' : ' ',
92 rdp
->completed
, rdp
->gpnum
,
93 rdp
->passed_quiesce
, rdp
->qs_pending
);
94 seq_printf(m
, " dt=%d/%llx/%d df=%lu",
95 atomic_read(&rdp
->dynticks
->dynticks
),
96 rdp
->dynticks
->dynticks_nesting
,
97 rdp
->dynticks
->dynticks_nmi_nesting
,
99 seq_printf(m
, " of=%lu", rdp
->offline_fqs
);
100 seq_printf(m
, " ql=%ld/%ld qs=%c%c%c%c",
101 rdp
->qlen_lazy
, rdp
->qlen
,
102 ".N"[rdp
->nxttail
[RCU_NEXT_READY_TAIL
] !=
103 rdp
->nxttail
[RCU_NEXT_TAIL
]],
104 ".R"[rdp
->nxttail
[RCU_WAIT_TAIL
] !=
105 rdp
->nxttail
[RCU_NEXT_READY_TAIL
]],
106 ".W"[rdp
->nxttail
[RCU_DONE_TAIL
] !=
107 rdp
->nxttail
[RCU_WAIT_TAIL
]],
108 ".D"[&rdp
->nxtlist
!= rdp
->nxttail
[RCU_DONE_TAIL
]]);
109 #ifdef CONFIG_RCU_BOOST
110 seq_printf(m
, " kt=%d/%c/%d ktl=%x",
111 per_cpu(rcu_cpu_has_work
, rdp
->cpu
),
112 convert_kthread_status(per_cpu(rcu_cpu_kthread_status
,
114 per_cpu(rcu_cpu_kthread_cpu
, rdp
->cpu
),
115 per_cpu(rcu_cpu_kthread_loops
, rdp
->cpu
) & 0xffff);
116 #endif /* #ifdef CONFIG_RCU_BOOST */
117 seq_printf(m
, " b=%ld", rdp
->blimit
);
118 seq_printf(m
, " ci=%lu co=%lu ca=%lu\n",
119 rdp
->n_cbs_invoked
, rdp
->n_cbs_orphaned
, rdp
->n_cbs_adopted
);
122 static int show_rcudata(struct seq_file
*m
, void *unused
)
125 struct rcu_state
*rsp
;
127 for_each_rcu_flavor(rsp
) {
128 seq_printf(m
, "%s:\n", rsp
->name
);
129 for_each_possible_cpu(cpu
)
130 print_one_rcu_data(m
, per_cpu_ptr(rsp
->rda
, cpu
));
135 static int rcudata_open(struct inode
*inode
, struct file
*file
)
137 return single_open(file
, show_rcudata
, NULL
);
140 static const struct file_operations rcudata_fops
= {
141 .owner
= THIS_MODULE
,
142 .open
= rcudata_open
,
145 .release
= single_release
,
148 static void print_one_rcu_data_csv(struct seq_file
*m
, struct rcu_data
*rdp
)
150 if (!rdp
->beenonline
)
152 seq_printf(m
, "%d,%s,%lu,%lu,%d,%d",
154 cpu_is_offline(rdp
->cpu
) ? "\"N\"" : "\"Y\"",
155 rdp
->completed
, rdp
->gpnum
,
156 rdp
->passed_quiesce
, rdp
->qs_pending
);
157 seq_printf(m
, ",%d,%llx,%d,%lu",
158 atomic_read(&rdp
->dynticks
->dynticks
),
159 rdp
->dynticks
->dynticks_nesting
,
160 rdp
->dynticks
->dynticks_nmi_nesting
,
162 seq_printf(m
, ",%lu", rdp
->offline_fqs
);
163 seq_printf(m
, ",%ld,%ld,\"%c%c%c%c\"", rdp
->qlen_lazy
, rdp
->qlen
,
164 ".N"[rdp
->nxttail
[RCU_NEXT_READY_TAIL
] !=
165 rdp
->nxttail
[RCU_NEXT_TAIL
]],
166 ".R"[rdp
->nxttail
[RCU_WAIT_TAIL
] !=
167 rdp
->nxttail
[RCU_NEXT_READY_TAIL
]],
168 ".W"[rdp
->nxttail
[RCU_DONE_TAIL
] !=
169 rdp
->nxttail
[RCU_WAIT_TAIL
]],
170 ".D"[&rdp
->nxtlist
!= rdp
->nxttail
[RCU_DONE_TAIL
]]);
171 #ifdef CONFIG_RCU_BOOST
172 seq_printf(m
, ",%d,\"%c\"",
173 per_cpu(rcu_cpu_has_work
, rdp
->cpu
),
174 convert_kthread_status(per_cpu(rcu_cpu_kthread_status
,
176 #endif /* #ifdef CONFIG_RCU_BOOST */
177 seq_printf(m
, ",%ld", rdp
->blimit
);
178 seq_printf(m
, ",%lu,%lu,%lu\n",
179 rdp
->n_cbs_invoked
, rdp
->n_cbs_orphaned
, rdp
->n_cbs_adopted
);
182 static int show_rcudata_csv(struct seq_file
*m
, void *unused
)
185 struct rcu_state
*rsp
;
187 seq_puts(m
, "\"CPU\",\"Online?\",\"c\",\"g\",\"pq\",\"pq\",");
188 seq_puts(m
, "\"dt\",\"dt nesting\",\"dt NMI nesting\",\"df\",");
189 seq_puts(m
, "\"of\",\"qll\",\"ql\",\"qs\"");
190 #ifdef CONFIG_RCU_BOOST
191 seq_puts(m
, "\"kt\",\"ktl\"");
192 #endif /* #ifdef CONFIG_RCU_BOOST */
193 seq_puts(m
, ",\"b\",\"ci\",\"co\",\"ca\"\n");
194 for_each_rcu_flavor(rsp
) {
195 seq_printf(m
, "\"%s:\"\n", rsp
->name
);
196 for_each_possible_cpu(cpu
)
197 print_one_rcu_data_csv(m
, per_cpu_ptr(rsp
->rda
, cpu
));
202 static int rcudata_csv_open(struct inode
*inode
, struct file
*file
)
204 return single_open(file
, show_rcudata_csv
, NULL
);
207 static const struct file_operations rcudata_csv_fops
= {
208 .owner
= THIS_MODULE
,
209 .open
= rcudata_csv_open
,
212 .release
= single_release
,
215 #ifdef CONFIG_RCU_BOOST
217 static void print_one_rcu_node_boost(struct seq_file
*m
, struct rcu_node
*rnp
)
219 seq_printf(m
, "%d:%d tasks=%c%c%c%c kt=%c ntb=%lu neb=%lu nnb=%lu ",
220 rnp
->grplo
, rnp
->grphi
,
221 "T."[list_empty(&rnp
->blkd_tasks
)],
222 "N."[!rnp
->gp_tasks
],
223 "E."[!rnp
->exp_tasks
],
224 "B."[!rnp
->boost_tasks
],
225 convert_kthread_status(rnp
->boost_kthread_status
),
226 rnp
->n_tasks_boosted
, rnp
->n_exp_boosts
,
227 rnp
->n_normal_boosts
);
228 seq_printf(m
, "j=%04x bt=%04x\n",
229 (int)(jiffies
& 0xffff),
230 (int)(rnp
->boost_time
& 0xffff));
231 seq_printf(m
, " balk: nt=%lu egt=%lu bt=%lu nb=%lu ny=%lu nos=%lu\n",
232 rnp
->n_balk_blkd_tasks
,
233 rnp
->n_balk_exp_gp_tasks
,
234 rnp
->n_balk_boost_tasks
,
235 rnp
->n_balk_notblocked
,
240 static int show_rcu_node_boost(struct seq_file
*m
, void *unused
)
242 struct rcu_node
*rnp
;
244 rcu_for_each_leaf_node(&rcu_preempt_state
, rnp
)
245 print_one_rcu_node_boost(m
, rnp
);
249 static int rcu_node_boost_open(struct inode
*inode
, struct file
*file
)
251 return single_open(file
, show_rcu_node_boost
, NULL
);
254 static const struct file_operations rcu_node_boost_fops
= {
255 .owner
= THIS_MODULE
,
256 .open
= rcu_node_boost_open
,
259 .release
= single_release
,
263 * Create the rcuboost debugfs entry. Standard error return.
265 static int rcu_boost_trace_create_file(struct dentry
*rcudir
)
267 return !debugfs_create_file("rcuboost", 0444, rcudir
, NULL
,
268 &rcu_node_boost_fops
);
271 #else /* #ifdef CONFIG_RCU_BOOST */
273 static int rcu_boost_trace_create_file(struct dentry
*rcudir
)
275 return 0; /* There cannot be an error if we didn't create it! */
278 #endif /* #else #ifdef CONFIG_RCU_BOOST */
280 static void print_one_rcu_state(struct seq_file
*m
, struct rcu_state
*rsp
)
284 struct rcu_node
*rnp
;
287 seq_printf(m
, "%s: c=%lu g=%lu s=%d jfq=%ld j=%x ",
288 rsp
->name
, rsp
->completed
, gpnum
, rsp
->fqs_state
,
289 (long)(rsp
->jiffies_force_qs
- jiffies
),
290 (int)(jiffies
& 0xffff));
291 seq_printf(m
, "nfqs=%lu/nfqsng=%lu(%lu) fqlh=%lu oqlen=%ld/%ld\n",
292 rsp
->n_force_qs
, rsp
->n_force_qs_ngp
,
293 rsp
->n_force_qs
- rsp
->n_force_qs_ngp
,
294 rsp
->n_force_qs_lh
, rsp
->qlen_lazy
, rsp
->qlen
);
295 for (rnp
= &rsp
->node
[0]; rnp
- &rsp
->node
[0] < rcu_num_nodes
; rnp
++) {
296 if (rnp
->level
!= level
) {
300 seq_printf(m
, "%lx/%lx %c%c>%c %d:%d ^%d ",
301 rnp
->qsmask
, rnp
->qsmaskinit
,
302 ".G"[rnp
->gp_tasks
!= NULL
],
303 ".E"[rnp
->exp_tasks
!= NULL
],
304 ".T"[!list_empty(&rnp
->blkd_tasks
)],
305 rnp
->grplo
, rnp
->grphi
, rnp
->grpnum
);
310 static int show_rcuhier(struct seq_file
*m
, void *unused
)
312 struct rcu_state
*rsp
;
314 for_each_rcu_flavor(rsp
)
315 print_one_rcu_state(m
, rsp
);
319 static int rcuhier_open(struct inode
*inode
, struct file
*file
)
321 return single_open(file
, show_rcuhier
, NULL
);
324 static const struct file_operations rcuhier_fops
= {
325 .owner
= THIS_MODULE
,
326 .open
= rcuhier_open
,
329 .release
= single_release
,
332 static void show_one_rcugp(struct seq_file
*m
, struct rcu_state
*rsp
)
335 unsigned long completed
;
339 struct rcu_node
*rnp
= &rsp
->node
[0];
341 raw_spin_lock_irqsave(&rnp
->lock
, flags
);
342 completed
= rsp
->completed
;
344 if (rsp
->completed
== rsp
->gpnum
)
347 gpage
= jiffies
- rsp
->gp_start
;
349 raw_spin_unlock_irqrestore(&rnp
->lock
, flags
);
350 seq_printf(m
, "%s: completed=%ld gpnum=%lu age=%ld max=%ld\n",
351 rsp
->name
, completed
, gpnum
, gpage
, gpmax
);
354 static int show_rcugp(struct seq_file
*m
, void *unused
)
356 struct rcu_state
*rsp
;
358 for_each_rcu_flavor(rsp
)
359 show_one_rcugp(m
, rsp
);
363 static int rcugp_open(struct inode
*inode
, struct file
*file
)
365 return single_open(file
, show_rcugp
, NULL
);
368 static const struct file_operations rcugp_fops
= {
369 .owner
= THIS_MODULE
,
373 .release
= single_release
,
376 static void print_one_rcu_pending(struct seq_file
*m
, struct rcu_data
*rdp
)
378 seq_printf(m
, "%3d%cnp=%ld ",
380 cpu_is_offline(rdp
->cpu
) ? '!' : ' ',
382 seq_printf(m
, "qsp=%ld rpq=%ld cbr=%ld cng=%ld ",
383 rdp
->n_rp_qs_pending
,
386 rdp
->n_rp_cpu_needs_gp
);
387 seq_printf(m
, "gpc=%ld gps=%ld nn=%ld\n",
388 rdp
->n_rp_gp_completed
,
389 rdp
->n_rp_gp_started
,
390 rdp
->n_rp_need_nothing
);
393 static int show_rcu_pending(struct seq_file
*m
, void *unused
)
396 struct rcu_data
*rdp
;
397 struct rcu_state
*rsp
;
399 for_each_rcu_flavor(rsp
) {
400 seq_printf(m
, "%s:\n", rsp
->name
);
401 for_each_possible_cpu(cpu
) {
402 rdp
= per_cpu_ptr(rsp
->rda
, cpu
);
404 print_one_rcu_pending(m
, rdp
);
410 static int rcu_pending_open(struct inode
*inode
, struct file
*file
)
412 return single_open(file
, show_rcu_pending
, NULL
);
415 static const struct file_operations rcu_pending_fops
= {
416 .owner
= THIS_MODULE
,
417 .open
= rcu_pending_open
,
420 .release
= single_release
,
423 static int show_rcutorture(struct seq_file
*m
, void *unused
)
425 seq_printf(m
, "rcutorture test sequence: %lu %s\n",
426 rcutorture_testseq
>> 1,
427 (rcutorture_testseq
& 0x1) ? "(test in progress)" : "");
428 seq_printf(m
, "rcutorture update version number: %lu\n",
433 static int rcutorture_open(struct inode
*inode
, struct file
*file
)
435 return single_open(file
, show_rcutorture
, NULL
);
438 static const struct file_operations rcutorture_fops
= {
439 .owner
= THIS_MODULE
,
440 .open
= rcutorture_open
,
443 .release
= single_release
,
446 static struct dentry
*rcudir
;
448 static int __init
rcutree_trace_init(void)
450 struct dentry
*retval
;
452 rcudir
= debugfs_create_dir("rcu", NULL
);
456 retval
= debugfs_create_file("rcubarrier", 0444, rcudir
,
457 NULL
, &rcubarrier_fops
);
461 retval
= debugfs_create_file("rcudata", 0444, rcudir
,
462 NULL
, &rcudata_fops
);
466 retval
= debugfs_create_file("rcudata.csv", 0444, rcudir
,
467 NULL
, &rcudata_csv_fops
);
471 if (rcu_boost_trace_create_file(rcudir
))
474 retval
= debugfs_create_file("rcugp", 0444, rcudir
, NULL
, &rcugp_fops
);
478 retval
= debugfs_create_file("rcuhier", 0444, rcudir
,
479 NULL
, &rcuhier_fops
);
483 retval
= debugfs_create_file("rcu_pending", 0444, rcudir
,
484 NULL
, &rcu_pending_fops
);
488 retval
= debugfs_create_file("rcutorture", 0444, rcudir
,
489 NULL
, &rcutorture_fops
);
494 debugfs_remove_recursive(rcudir
);
498 static void __exit
rcutree_trace_cleanup(void)
500 debugfs_remove_recursive(rcudir
);
504 module_init(rcutree_trace_init
);
505 module_exit(rcutree_trace_cleanup
);
507 MODULE_AUTHOR("Paul E. McKenney");
508 MODULE_DESCRIPTION("Read-Copy Update tracing for hierarchical implementation");
509 MODULE_LICENSE("GPL");