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>
18 #include <linux/mempolicy.h>
22 static DEFINE_SPINLOCK(sched_debug_lock
);
25 * This allows printing both to /proc/sched_debug and
28 #define SEQ_printf(m, x...) \
37 * Ease the printing of nsec fields:
39 static long long nsec_high(unsigned long long nsec
)
41 if ((long long)nsec
< 0) {
43 do_div(nsec
, 1000000);
46 do_div(nsec
, 1000000);
51 static unsigned long nsec_low(unsigned long long nsec
)
53 if ((long long)nsec
< 0)
56 return do_div(nsec
, 1000000);
59 #define SPLIT_NS(x) nsec_high(x), nsec_low(x)
61 #ifdef CONFIG_FAIR_GROUP_SCHED
62 static void print_cfs_group_stats(struct seq_file
*m
, int cpu
, struct task_group
*tg
)
64 struct sched_entity
*se
= tg
->se
[cpu
];
67 SEQ_printf(m, " .%-30s: %lld\n", #F, (long long)F)
69 SEQ_printf(m, " .%-30s: %lld.%06ld\n", #F, SPLIT_NS((long long)F))
72 struct sched_avg
*avg
= &cpu_rq(cpu
)->avg
;
73 P(avg
->runnable_avg_sum
);
74 P(avg
->runnable_avg_period
);
81 PN(se
->sum_exec_runtime
);
82 #ifdef CONFIG_SCHEDSTATS
83 PN(se
->statistics
.wait_start
);
84 PN(se
->statistics
.sleep_start
);
85 PN(se
->statistics
.block_start
);
86 PN(se
->statistics
.sleep_max
);
87 PN(se
->statistics
.block_max
);
88 PN(se
->statistics
.exec_max
);
89 PN(se
->statistics
.slice_max
);
90 PN(se
->statistics
.wait_max
);
91 PN(se
->statistics
.wait_sum
);
92 P(se
->statistics
.wait_count
);
96 P(se
->avg
.runnable_avg_sum
);
97 P(se
->avg
.runnable_avg_period
);
98 P(se
->avg
.load_avg_contrib
);
99 P(se
->avg
.decay_count
);
106 #ifdef CONFIG_CGROUP_SCHED
107 static char group_path
[PATH_MAX
];
109 static char *task_group_path(struct task_group
*tg
)
111 if (autogroup_path(tg
, group_path
, PATH_MAX
))
114 return 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 ",
127 p
->comm
, task_pid_nr(p
),
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_NUMA_BALANCING
141 SEQ_printf(m
, " %d", task_node(p
));
143 #ifdef CONFIG_CGROUP_SCHED
144 SEQ_printf(m
, " %s", task_group_path(task_group(p
)));
150 static void print_rq(struct seq_file
*m
, struct rq
*rq
, int rq_cpu
)
152 struct task_struct
*g
, *p
;
155 "\nrunnable tasks:\n"
156 " task PID tree-key switches prio"
157 " exec-runtime sum-exec sum-sleep\n"
158 "------------------------------------------------------"
159 "----------------------------------------------------\n");
162 for_each_process_thread(g
, p
) {
163 if (task_cpu(p
) != rq_cpu
)
166 print_task(m
, rq
, p
);
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
);
213 SEQ_printf(m
, " .%-30s: %ld\n", "runnable_load_avg",
214 cfs_rq
->runnable_load_avg
);
215 SEQ_printf(m
, " .%-30s: %ld\n", "blocked_load_avg",
216 cfs_rq
->blocked_load_avg
);
217 #ifdef CONFIG_FAIR_GROUP_SCHED
218 SEQ_printf(m
, " .%-30s: %ld\n", "tg_load_contrib",
219 cfs_rq
->tg_load_contrib
);
220 SEQ_printf(m
, " .%-30s: %d\n", "tg_runnable_contrib",
221 cfs_rq
->tg_runnable_contrib
);
222 SEQ_printf(m
, " .%-30s: %ld\n", "tg_load_avg",
223 atomic_long_read(&cfs_rq
->tg
->load_avg
));
224 SEQ_printf(m
, " .%-30s: %d\n", "tg->runnable_avg",
225 atomic_read(&cfs_rq
->tg
->runnable_avg
));
228 #ifdef CONFIG_CFS_BANDWIDTH
229 SEQ_printf(m
, " .%-30s: %d\n", "tg->cfs_bandwidth.timer_active",
230 cfs_rq
->tg
->cfs_bandwidth
.timer_active
);
231 SEQ_printf(m
, " .%-30s: %d\n", "throttled",
233 SEQ_printf(m
, " .%-30s: %d\n", "throttle_count",
234 cfs_rq
->throttle_count
);
237 #ifdef CONFIG_FAIR_GROUP_SCHED
238 print_cfs_group_stats(m
, cpu
, cfs_rq
->tg
);
242 void print_rt_rq(struct seq_file
*m
, int cpu
, struct rt_rq
*rt_rq
)
244 #ifdef CONFIG_RT_GROUP_SCHED
245 SEQ_printf(m
, "\nrt_rq[%d]:%s\n", cpu
, task_group_path(rt_rq
->tg
));
247 SEQ_printf(m
, "\nrt_rq[%d]:\n", cpu
);
251 SEQ_printf(m, " .%-30s: %Ld\n", #x, (long long)(rt_rq->x))
253 SEQ_printf(m, " .%-30s: %Ld.%06ld\n", #x, SPLIT_NS(rt_rq->x))
264 void print_dl_rq(struct seq_file
*m
, int cpu
, struct dl_rq
*dl_rq
)
266 SEQ_printf(m
, "\ndl_rq[%d]:\n", cpu
);
267 SEQ_printf(m
, " .%-30s: %ld\n", "dl_nr_running", dl_rq
->dl_nr_running
);
270 extern __read_mostly
int sched_clock_running
;
272 static void print_cpu(struct seq_file
*m
, int cpu
)
274 struct rq
*rq
= cpu_rq(cpu
);
279 unsigned int freq
= cpu_khz
? : 1;
281 SEQ_printf(m
, "cpu#%d, %u.%03u MHz\n",
282 cpu
, freq
/ 1000, (freq
% 1000));
285 SEQ_printf(m
, "cpu#%d\n", cpu
);
290 if (sizeof(rq->x) == 4) \
291 SEQ_printf(m, " .%-30s: %ld\n", #x, (long)(rq->x)); \
293 SEQ_printf(m, " .%-30s: %Ld\n", #x, (long long)(rq->x));\
297 SEQ_printf(m, " .%-30s: %Ld.%06ld\n", #x, SPLIT_NS(rq->x))
300 SEQ_printf(m
, " .%-30s: %lu\n", "load",
304 P(nr_uninterruptible
);
306 SEQ_printf(m
, " .%-30s: %ld\n", "curr->pid", (long)(task_pid_nr(rq
->curr
)));
316 #ifdef CONFIG_SCHEDSTATS
317 #define P(n) SEQ_printf(m, " .%-30s: %d\n", #n, rq->n);
318 #define P64(n) SEQ_printf(m, " .%-30s: %Ld\n", #n, rq->n);
326 P64(max_idle_balance_cost
);
335 spin_lock_irqsave(&sched_debug_lock
, flags
);
336 print_cfs_stats(m
, cpu
);
337 print_rt_stats(m
, cpu
);
338 print_dl_stats(m
, cpu
);
340 print_rq(m
, rq
, cpu
);
341 spin_unlock_irqrestore(&sched_debug_lock
, flags
);
345 static const char *sched_tunable_scaling_names
[] = {
351 static void sched_debug_header(struct seq_file
*m
)
353 u64 ktime
, sched_clk
, cpu_clk
;
356 local_irq_save(flags
);
357 ktime
= ktime_to_ns(ktime_get());
358 sched_clk
= sched_clock();
359 cpu_clk
= local_clock();
360 local_irq_restore(flags
);
362 SEQ_printf(m
, "Sched Debug Version: v0.11, %s %.*s\n",
363 init_utsname()->release
,
364 (int)strcspn(init_utsname()->version
, " "),
365 init_utsname()->version
);
368 SEQ_printf(m, "%-40s: %Ld\n", #x, (long long)(x))
370 SEQ_printf(m, "%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
375 #ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
376 P(sched_clock_stable());
382 SEQ_printf(m
, "sysctl_sched\n");
385 SEQ_printf(m, " .%-40s: %Ld\n", #x, (long long)(x))
387 SEQ_printf(m, " .%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
388 PN(sysctl_sched_latency
);
389 PN(sysctl_sched_min_granularity
);
390 PN(sysctl_sched_wakeup_granularity
);
391 P(sysctl_sched_child_runs_first
);
392 P(sysctl_sched_features
);
396 SEQ_printf(m
, " .%-40s: %d (%s)\n",
397 "sysctl_sched_tunable_scaling",
398 sysctl_sched_tunable_scaling
,
399 sched_tunable_scaling_names
[sysctl_sched_tunable_scaling
]);
403 static int sched_debug_show(struct seq_file
*m
, void *v
)
405 int cpu
= (unsigned long)(v
- 2);
410 sched_debug_header(m
);
415 void sysrq_sched_debug_show(void)
419 sched_debug_header(NULL
);
420 for_each_online_cpu(cpu
)
421 print_cpu(NULL
, cpu
);
426 * This itererator needs some explanation.
427 * It returns 1 for the header position.
428 * This means 2 is cpu 0.
429 * In a hotplugged system some cpus, including cpu 0, may be missing so we have
430 * to use cpumask_* to iterate over the cpus.
432 static void *sched_debug_start(struct seq_file
*file
, loff_t
*offset
)
434 unsigned long n
= *offset
;
442 n
= cpumask_next(n
- 1, cpu_online_mask
);
444 n
= cpumask_first(cpu_online_mask
);
449 return (void *)(unsigned long)(n
+ 2);
453 static void *sched_debug_next(struct seq_file
*file
, void *data
, loff_t
*offset
)
456 return sched_debug_start(file
, offset
);
459 static void sched_debug_stop(struct seq_file
*file
, void *data
)
463 static const struct seq_operations sched_debug_sops
= {
464 .start
= sched_debug_start
,
465 .next
= sched_debug_next
,
466 .stop
= sched_debug_stop
,
467 .show
= sched_debug_show
,
470 static int sched_debug_release(struct inode
*inode
, struct file
*file
)
472 seq_release(inode
, file
);
477 static int sched_debug_open(struct inode
*inode
, struct file
*filp
)
481 ret
= seq_open(filp
, &sched_debug_sops
);
486 static const struct file_operations sched_debug_fops
= {
487 .open
= sched_debug_open
,
490 .release
= sched_debug_release
,
493 static int __init
init_sched_debug_procfs(void)
495 struct proc_dir_entry
*pe
;
497 pe
= proc_create("sched_debug", 0444, NULL
, &sched_debug_fops
);
503 __initcall(init_sched_debug_procfs
);
506 SEQ_printf(m, "%-45s:%21Ld\n", #F, (long long)F)
508 SEQ_printf(m, "%-45s:%21Ld\n", #F, (long long)p->F)
510 SEQ_printf(m, "%-45s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)F))
512 SEQ_printf(m, "%-45s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)p->F))
515 static void sched_show_numa(struct task_struct
*p
, struct seq_file
*m
)
517 #ifdef CONFIG_NUMA_BALANCING
518 struct mempolicy
*pol
;
522 P(mm
->numa_scan_seq
);
526 if (pol
&& !(pol
->flags
& MPOL_F_MORON
))
531 SEQ_printf(m
, "numa_migrations, %ld\n", xchg(&p
->numa_pages_migrated
, 0));
533 for_each_online_node(node
) {
534 for (i
= 0; i
< 2; i
++) {
535 unsigned long nr_faults
= -1;
536 int cpu_current
, home_node
;
539 nr_faults
= p
->numa_faults
[2*node
+ i
];
541 cpu_current
= !i
? (task_node(p
) == node
) :
542 (pol
&& node_isset(node
, pol
->v
.nodes
));
544 home_node
= (p
->numa_preferred_nid
== node
);
546 SEQ_printf(m
, "numa_faults_memory, %d, %d, %d, %d, %ld\n",
547 i
, node
, cpu_current
, home_node
, nr_faults
);
555 void proc_sched_show_task(struct task_struct
*p
, struct seq_file
*m
)
557 unsigned long nr_switches
;
559 SEQ_printf(m
, "%s (%d, #threads: %d)\n", p
->comm
, task_pid_nr(p
),
562 "---------------------------------------------------------"
565 SEQ_printf(m, "%-45s:%21Ld\n", #F, (long long)F)
567 SEQ_printf(m, "%-45s:%21Ld\n", #F, (long long)p->F)
569 SEQ_printf(m, "%-45s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)F))
571 SEQ_printf(m, "%-45s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)p->F))
575 PN(se
.sum_exec_runtime
);
577 nr_switches
= p
->nvcsw
+ p
->nivcsw
;
579 #ifdef CONFIG_SCHEDSTATS
580 PN(se
.statistics
.wait_start
);
581 PN(se
.statistics
.sleep_start
);
582 PN(se
.statistics
.block_start
);
583 PN(se
.statistics
.sleep_max
);
584 PN(se
.statistics
.block_max
);
585 PN(se
.statistics
.exec_max
);
586 PN(se
.statistics
.slice_max
);
587 PN(se
.statistics
.wait_max
);
588 PN(se
.statistics
.wait_sum
);
589 P(se
.statistics
.wait_count
);
590 PN(se
.statistics
.iowait_sum
);
591 P(se
.statistics
.iowait_count
);
593 P(se
.statistics
.nr_migrations_cold
);
594 P(se
.statistics
.nr_failed_migrations_affine
);
595 P(se
.statistics
.nr_failed_migrations_running
);
596 P(se
.statistics
.nr_failed_migrations_hot
);
597 P(se
.statistics
.nr_forced_migrations
);
598 P(se
.statistics
.nr_wakeups
);
599 P(se
.statistics
.nr_wakeups_sync
);
600 P(se
.statistics
.nr_wakeups_migrate
);
601 P(se
.statistics
.nr_wakeups_local
);
602 P(se
.statistics
.nr_wakeups_remote
);
603 P(se
.statistics
.nr_wakeups_affine
);
604 P(se
.statistics
.nr_wakeups_affine_attempts
);
605 P(se
.statistics
.nr_wakeups_passive
);
606 P(se
.statistics
.nr_wakeups_idle
);
609 u64 avg_atom
, avg_per_cpu
;
611 avg_atom
= p
->se
.sum_exec_runtime
;
613 avg_atom
= div64_ul(avg_atom
, nr_switches
);
617 avg_per_cpu
= p
->se
.sum_exec_runtime
;
618 if (p
->se
.nr_migrations
) {
619 avg_per_cpu
= div64_u64(avg_per_cpu
,
620 p
->se
.nr_migrations
);
630 SEQ_printf(m
, "%-45s:%21Ld\n",
631 "nr_voluntary_switches", (long long)p
->nvcsw
);
632 SEQ_printf(m
, "%-45s:%21Ld\n",
633 "nr_involuntary_switches", (long long)p
->nivcsw
);
637 P(se
.avg
.runnable_avg_sum
);
638 P(se
.avg
.runnable_avg_period
);
639 P(se
.avg
.load_avg_contrib
);
640 P(se
.avg
.decay_count
);
650 unsigned int this_cpu
= raw_smp_processor_id();
653 t0
= cpu_clock(this_cpu
);
654 t1
= cpu_clock(this_cpu
);
655 SEQ_printf(m
, "%-45s:%21Ld\n",
656 "clock-delta", (long long)(t1
-t0
));
659 sched_show_numa(p
, m
);
662 void proc_sched_set_task(struct task_struct
*p
)
664 #ifdef CONFIG_SCHEDSTATS
665 memset(&p
->se
.statistics
, 0, sizeof(p
->se
.statistics
));