6 * Copyright(C) 2007, Red Hat, Inc., Ingo Molnar
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/proc_fs.h>
14 #include <linux/sched.h>
15 #include <linux/seq_file.h>
16 #include <linux/kallsyms.h>
17 #include <linux/utsname.h>
21 static DEFINE_SPINLOCK(sched_debug_lock
);
24 * This allows printing both to /proc/sched_debug and
27 #define SEQ_printf(m, x...) \
36 * Ease the printing of nsec fields:
38 static long long nsec_high(unsigned long long nsec
)
40 if ((long long)nsec
< 0) {
42 do_div(nsec
, 1000000);
45 do_div(nsec
, 1000000);
50 static unsigned long nsec_low(unsigned long long nsec
)
52 if ((long long)nsec
< 0)
55 return do_div(nsec
, 1000000);
58 #define SPLIT_NS(x) nsec_high(x), nsec_low(x)
60 #ifdef CONFIG_FAIR_GROUP_SCHED
61 static void print_cfs_group_stats(struct seq_file
*m
, int cpu
, struct task_group
*tg
)
63 struct sched_entity
*se
= tg
->se
[cpu
];
66 SEQ_printf(m, " .%-30s: %lld\n", #F, (long long)F)
68 SEQ_printf(m, " .%-30s: %lld.%06ld\n", #F, SPLIT_NS((long long)F))
71 struct sched_avg
*avg
= &cpu_rq(cpu
)->avg
;
72 P(avg
->runnable_avg_sum
);
73 P(avg
->runnable_avg_period
);
80 PN(se
->sum_exec_runtime
);
81 #ifdef CONFIG_SCHEDSTATS
82 PN(se
->statistics
.wait_start
);
83 PN(se
->statistics
.sleep_start
);
84 PN(se
->statistics
.block_start
);
85 PN(se
->statistics
.sleep_max
);
86 PN(se
->statistics
.block_max
);
87 PN(se
->statistics
.exec_max
);
88 PN(se
->statistics
.slice_max
);
89 PN(se
->statistics
.wait_max
);
90 PN(se
->statistics
.wait_sum
);
91 P(se
->statistics
.wait_count
);
95 P(se
->avg
.runnable_avg_sum
);
96 P(se
->avg
.runnable_avg_period
);
97 P(se
->avg
.load_avg_contrib
);
98 P(se
->avg
.decay_count
);
105 #ifdef CONFIG_CGROUP_SCHED
106 static char group_path
[PATH_MAX
];
108 static char *task_group_path(struct task_group
*tg
)
110 if (autogroup_path(tg
, group_path
, PATH_MAX
))
113 cgroup_path(tg
->css
.cgroup
, group_path
, PATH_MAX
);
119 print_task(struct seq_file
*m
, struct rq
*rq
, struct task_struct
*p
)
126 SEQ_printf(m
, "%15s %5d %9Ld.%06ld %9Ld %5d ",
128 SPLIT_NS(p
->se
.vruntime
),
129 (long long)(p
->nvcsw
+ p
->nivcsw
),
131 #ifdef CONFIG_SCHEDSTATS
132 SEQ_printf(m
, "%9Ld.%06ld %9Ld.%06ld %9Ld.%06ld",
133 SPLIT_NS(p
->se
.vruntime
),
134 SPLIT_NS(p
->se
.sum_exec_runtime
),
135 SPLIT_NS(p
->se
.statistics
.sum_sleep_runtime
));
137 SEQ_printf(m
, "%15Ld %15Ld %15Ld.%06ld %15Ld.%06ld %15Ld.%06ld",
138 0LL, 0LL, 0LL, 0L, 0LL, 0L, 0LL, 0L);
140 #ifdef CONFIG_CGROUP_SCHED
141 SEQ_printf(m
, " %s", task_group_path(task_group(p
)));
147 static void print_rq(struct seq_file
*m
, struct rq
*rq
, int rq_cpu
)
149 struct task_struct
*g
, *p
;
153 "\nrunnable tasks:\n"
154 " task PID tree-key switches prio"
155 " exec-runtime sum-exec sum-sleep\n"
156 "------------------------------------------------------"
157 "----------------------------------------------------\n");
159 read_lock_irqsave(&tasklist_lock
, flags
);
161 do_each_thread(g
, p
) {
162 if (!p
->on_rq
|| task_cpu(p
) != rq_cpu
)
165 print_task(m
, rq
, p
);
166 } while_each_thread(g
, p
);
168 read_unlock_irqrestore(&tasklist_lock
, flags
);
171 void print_cfs_rq(struct seq_file
*m
, int cpu
, struct cfs_rq
*cfs_rq
)
173 s64 MIN_vruntime
= -1, min_vruntime
, max_vruntime
= -1,
174 spread
, rq0_min_vruntime
, spread0
;
175 struct rq
*rq
= cpu_rq(cpu
);
176 struct sched_entity
*last
;
179 #ifdef CONFIG_FAIR_GROUP_SCHED
180 SEQ_printf(m
, "\ncfs_rq[%d]:%s\n", cpu
, task_group_path(cfs_rq
->tg
));
182 SEQ_printf(m
, "\ncfs_rq[%d]:\n", cpu
);
184 SEQ_printf(m
, " .%-30s: %Ld.%06ld\n", "exec_clock",
185 SPLIT_NS(cfs_rq
->exec_clock
));
187 raw_spin_lock_irqsave(&rq
->lock
, flags
);
188 if (cfs_rq
->rb_leftmost
)
189 MIN_vruntime
= (__pick_first_entity(cfs_rq
))->vruntime
;
190 last
= __pick_last_entity(cfs_rq
);
192 max_vruntime
= last
->vruntime
;
193 min_vruntime
= cfs_rq
->min_vruntime
;
194 rq0_min_vruntime
= cpu_rq(0)->cfs
.min_vruntime
;
195 raw_spin_unlock_irqrestore(&rq
->lock
, flags
);
196 SEQ_printf(m
, " .%-30s: %Ld.%06ld\n", "MIN_vruntime",
197 SPLIT_NS(MIN_vruntime
));
198 SEQ_printf(m
, " .%-30s: %Ld.%06ld\n", "min_vruntime",
199 SPLIT_NS(min_vruntime
));
200 SEQ_printf(m
, " .%-30s: %Ld.%06ld\n", "max_vruntime",
201 SPLIT_NS(max_vruntime
));
202 spread
= max_vruntime
- MIN_vruntime
;
203 SEQ_printf(m
, " .%-30s: %Ld.%06ld\n", "spread",
205 spread0
= min_vruntime
- rq0_min_vruntime
;
206 SEQ_printf(m
, " .%-30s: %Ld.%06ld\n", "spread0",
208 SEQ_printf(m
, " .%-30s: %d\n", "nr_spread_over",
209 cfs_rq
->nr_spread_over
);
210 SEQ_printf(m
, " .%-30s: %d\n", "nr_running", cfs_rq
->nr_running
);
211 SEQ_printf(m
, " .%-30s: %ld\n", "load", cfs_rq
->load
.weight
);
212 #ifdef CONFIG_FAIR_GROUP_SCHED
214 SEQ_printf(m
, " .%-30s: %lld\n", "runnable_load_avg",
215 cfs_rq
->runnable_load_avg
);
216 SEQ_printf(m
, " .%-30s: %lld\n", "blocked_load_avg",
217 cfs_rq
->blocked_load_avg
);
218 SEQ_printf(m
, " .%-30s: %lld\n", "tg_load_avg",
219 (unsigned long long)atomic64_read(&cfs_rq
->tg
->load_avg
));
220 SEQ_printf(m
, " .%-30s: %lld\n", "tg_load_contrib",
221 cfs_rq
->tg_load_contrib
);
222 SEQ_printf(m
, " .%-30s: %d\n", "tg_runnable_contrib",
223 cfs_rq
->tg_runnable_contrib
);
224 SEQ_printf(m
, " .%-30s: %d\n", "tg->runnable_avg",
225 atomic_read(&cfs_rq
->tg
->runnable_avg
));
228 print_cfs_group_stats(m
, cpu
, cfs_rq
->tg
);
232 void print_rt_rq(struct seq_file
*m
, int cpu
, struct rt_rq
*rt_rq
)
234 #ifdef CONFIG_RT_GROUP_SCHED
235 SEQ_printf(m
, "\nrt_rq[%d]:%s\n", cpu
, task_group_path(rt_rq
->tg
));
237 SEQ_printf(m
, "\nrt_rq[%d]:\n", cpu
);
241 SEQ_printf(m, " .%-30s: %Ld\n", #x, (long long)(rt_rq->x))
243 SEQ_printf(m, " .%-30s: %Ld.%06ld\n", #x, SPLIT_NS(rt_rq->x))
254 extern __read_mostly
int sched_clock_running
;
256 static void print_cpu(struct seq_file
*m
, int cpu
)
258 struct rq
*rq
= cpu_rq(cpu
);
263 unsigned int freq
= cpu_khz
? : 1;
265 SEQ_printf(m
, "cpu#%d, %u.%03u MHz\n",
266 cpu
, freq
/ 1000, (freq
% 1000));
269 SEQ_printf(m
, "cpu#%d\n", cpu
);
274 if (sizeof(rq->x) == 4) \
275 SEQ_printf(m, " .%-30s: %ld\n", #x, (long)(rq->x)); \
277 SEQ_printf(m, " .%-30s: %Ld\n", #x, (long long)(rq->x));\
281 SEQ_printf(m, " .%-30s: %Ld.%06ld\n", #x, SPLIT_NS(rq->x))
284 SEQ_printf(m
, " .%-30s: %lu\n", "load",
288 P(nr_uninterruptible
);
300 #ifdef CONFIG_SCHEDSTATS
301 #define P(n) SEQ_printf(m, " .%-30s: %d\n", #n, rq->n);
302 #define P64(n) SEQ_printf(m, " .%-30s: %Ld\n", #n, rq->n);
318 spin_lock_irqsave(&sched_debug_lock
, flags
);
319 print_cfs_stats(m
, cpu
);
320 print_rt_stats(m
, cpu
);
323 print_rq(m
, rq
, cpu
);
325 spin_unlock_irqrestore(&sched_debug_lock
, flags
);
329 static const char *sched_tunable_scaling_names
[] = {
335 static void sched_debug_header(struct seq_file
*m
)
337 u64 ktime
, sched_clk
, cpu_clk
;
340 local_irq_save(flags
);
341 ktime
= ktime_to_ns(ktime_get());
342 sched_clk
= sched_clock();
343 cpu_clk
= local_clock();
344 local_irq_restore(flags
);
346 SEQ_printf(m
, "Sched Debug Version: v0.10, %s %.*s\n",
347 init_utsname()->release
,
348 (int)strcspn(init_utsname()->version
, " "),
349 init_utsname()->version
);
352 SEQ_printf(m, "%-40s: %Ld\n", #x, (long long)(x))
354 SEQ_printf(m, "%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
359 #ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
360 P(sched_clock_stable
);
366 SEQ_printf(m
, "sysctl_sched\n");
369 SEQ_printf(m, " .%-40s: %Ld\n", #x, (long long)(x))
371 SEQ_printf(m, " .%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
372 PN(sysctl_sched_latency
);
373 PN(sysctl_sched_min_granularity
);
374 PN(sysctl_sched_wakeup_granularity
);
375 P(sysctl_sched_child_runs_first
);
376 P(sysctl_sched_features
);
380 SEQ_printf(m
, " .%-40s: %d (%s)\n",
381 "sysctl_sched_tunable_scaling",
382 sysctl_sched_tunable_scaling
,
383 sched_tunable_scaling_names
[sysctl_sched_tunable_scaling
]);
387 static int sched_debug_show(struct seq_file
*m
, void *v
)
389 int cpu
= (unsigned long)(v
- 2);
394 sched_debug_header(m
);
399 void sysrq_sched_debug_show(void)
403 sched_debug_header(NULL
);
404 for_each_online_cpu(cpu
)
405 print_cpu(NULL
, cpu
);
410 * This itererator needs some explanation.
411 * It returns 1 for the header position.
412 * This means 2 is cpu 0.
413 * In a hotplugged system some cpus, including cpu 0, may be missing so we have
414 * to use cpumask_* to iterate over the cpus.
416 static void *sched_debug_start(struct seq_file
*file
, loff_t
*offset
)
418 unsigned long n
= *offset
;
426 n
= cpumask_next(n
- 1, cpu_online_mask
);
428 n
= cpumask_first(cpu_online_mask
);
433 return (void *)(unsigned long)(n
+ 2);
437 static void *sched_debug_next(struct seq_file
*file
, void *data
, loff_t
*offset
)
440 return sched_debug_start(file
, offset
);
443 static void sched_debug_stop(struct seq_file
*file
, void *data
)
447 static const struct seq_operations sched_debug_sops
= {
448 .start
= sched_debug_start
,
449 .next
= sched_debug_next
,
450 .stop
= sched_debug_stop
,
451 .show
= sched_debug_show
,
454 static int sched_debug_release(struct inode
*inode
, struct file
*file
)
456 seq_release(inode
, file
);
461 static int sched_debug_open(struct inode
*inode
, struct file
*filp
)
465 ret
= seq_open(filp
, &sched_debug_sops
);
470 static const struct file_operations sched_debug_fops
= {
471 .open
= sched_debug_open
,
474 .release
= sched_debug_release
,
477 static int __init
init_sched_debug_procfs(void)
479 struct proc_dir_entry
*pe
;
481 pe
= proc_create("sched_debug", 0444, NULL
, &sched_debug_fops
);
487 __initcall(init_sched_debug_procfs
);
489 void proc_sched_show_task(struct task_struct
*p
, struct seq_file
*m
)
491 unsigned long nr_switches
;
493 SEQ_printf(m
, "%s (%d, #threads: %d)\n", p
->comm
, p
->pid
,
496 "---------------------------------------------------------\n");
498 SEQ_printf(m, "%-35s:%21Ld\n", #F, (long long)F)
500 SEQ_printf(m, "%-35s:%21Ld\n", #F, (long long)p->F)
502 SEQ_printf(m, "%-35s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)F))
504 SEQ_printf(m, "%-35s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)p->F))
508 PN(se
.sum_exec_runtime
);
510 nr_switches
= p
->nvcsw
+ p
->nivcsw
;
512 #ifdef CONFIG_SCHEDSTATS
513 PN(se
.statistics
.wait_start
);
514 PN(se
.statistics
.sleep_start
);
515 PN(se
.statistics
.block_start
);
516 PN(se
.statistics
.sleep_max
);
517 PN(se
.statistics
.block_max
);
518 PN(se
.statistics
.exec_max
);
519 PN(se
.statistics
.slice_max
);
520 PN(se
.statistics
.wait_max
);
521 PN(se
.statistics
.wait_sum
);
522 P(se
.statistics
.wait_count
);
523 PN(se
.statistics
.iowait_sum
);
524 P(se
.statistics
.iowait_count
);
526 P(se
.statistics
.nr_migrations_cold
);
527 P(se
.statistics
.nr_failed_migrations_affine
);
528 P(se
.statistics
.nr_failed_migrations_running
);
529 P(se
.statistics
.nr_failed_migrations_hot
);
530 P(se
.statistics
.nr_forced_migrations
);
531 P(se
.statistics
.nr_wakeups
);
532 P(se
.statistics
.nr_wakeups_sync
);
533 P(se
.statistics
.nr_wakeups_migrate
);
534 P(se
.statistics
.nr_wakeups_local
);
535 P(se
.statistics
.nr_wakeups_remote
);
536 P(se
.statistics
.nr_wakeups_affine
);
537 P(se
.statistics
.nr_wakeups_affine_attempts
);
538 P(se
.statistics
.nr_wakeups_passive
);
539 P(se
.statistics
.nr_wakeups_idle
);
542 u64 avg_atom
, avg_per_cpu
;
544 avg_atom
= p
->se
.sum_exec_runtime
;
546 do_div(avg_atom
, nr_switches
);
550 avg_per_cpu
= p
->se
.sum_exec_runtime
;
551 if (p
->se
.nr_migrations
) {
552 avg_per_cpu
= div64_u64(avg_per_cpu
,
553 p
->se
.nr_migrations
);
563 SEQ_printf(m
, "%-35s:%21Ld\n",
564 "nr_voluntary_switches", (long long)p
->nvcsw
);
565 SEQ_printf(m
, "%-35s:%21Ld\n",
566 "nr_involuntary_switches", (long long)p
->nivcsw
);
577 unsigned int this_cpu
= raw_smp_processor_id();
580 t0
= cpu_clock(this_cpu
);
581 t1
= cpu_clock(this_cpu
);
582 SEQ_printf(m
, "%-35s:%21Ld\n",
583 "clock-delta", (long long)(t1
-t0
));
587 void proc_sched_set_task(struct task_struct
*p
)
589 #ifdef CONFIG_SCHEDSTATS
590 memset(&p
->se
.statistics
, 0, sizeof(p
->se
.statistics
));