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))
76 PN(se
->sum_exec_runtime
);
77 #ifdef CONFIG_SCHEDSTATS
78 if (schedstat_enabled()) {
79 PN(se
->statistics
.wait_start
);
80 PN(se
->statistics
.sleep_start
);
81 PN(se
->statistics
.block_start
);
82 PN(se
->statistics
.sleep_max
);
83 PN(se
->statistics
.block_max
);
84 PN(se
->statistics
.exec_max
);
85 PN(se
->statistics
.slice_max
);
86 PN(se
->statistics
.wait_max
);
87 PN(se
->statistics
.wait_sum
);
88 P(se
->statistics
.wait_count
);
101 #ifdef CONFIG_CGROUP_SCHED
102 static char group_path
[PATH_MAX
];
104 static char *task_group_path(struct task_group
*tg
)
106 if (autogroup_path(tg
, group_path
, PATH_MAX
))
109 return cgroup_path(tg
->css
.cgroup
, group_path
, PATH_MAX
);
114 print_task(struct seq_file
*m
, struct rq
*rq
, struct task_struct
*p
)
121 SEQ_printf(m
, "%15s %5d %9Ld.%06ld %9Ld %5d ",
122 p
->comm
, task_pid_nr(p
),
123 SPLIT_NS(p
->se
.vruntime
),
124 (long long)(p
->nvcsw
+ p
->nivcsw
),
126 #ifdef CONFIG_SCHEDSTATS
127 if (schedstat_enabled()) {
128 SEQ_printf(m
, "%9Ld.%06ld %9Ld.%06ld %9Ld.%06ld",
129 SPLIT_NS(p
->se
.statistics
.wait_sum
),
130 SPLIT_NS(p
->se
.sum_exec_runtime
),
131 SPLIT_NS(p
->se
.statistics
.sum_sleep_runtime
));
134 SEQ_printf(m
, "%9Ld.%06ld %9Ld.%06ld %9Ld.%06ld",
136 SPLIT_NS(p
->se
.sum_exec_runtime
),
139 #ifdef CONFIG_NUMA_BALANCING
140 SEQ_printf(m
, " %d %d", task_node(p
), task_numa_group_id(p
));
142 #ifdef CONFIG_CGROUP_SCHED
143 SEQ_printf(m
, " %s", task_group_path(task_group(p
)));
149 static void print_rq(struct seq_file
*m
, struct rq
*rq
, int rq_cpu
)
151 struct task_struct
*g
, *p
;
154 "\nrunnable tasks:\n"
155 " task PID tree-key switches prio"
156 " wait-time sum-exec sum-sleep\n"
157 "------------------------------------------------------"
158 "----------------------------------------------------\n");
161 for_each_process_thread(g
, p
) {
162 if (task_cpu(p
) != rq_cpu
)
165 print_task(m
, rq
, p
);
170 void print_cfs_rq(struct seq_file
*m
, int cpu
, struct cfs_rq
*cfs_rq
)
172 s64 MIN_vruntime
= -1, min_vruntime
, max_vruntime
= -1,
173 spread
, rq0_min_vruntime
, spread0
;
174 struct rq
*rq
= cpu_rq(cpu
);
175 struct sched_entity
*last
;
178 #ifdef CONFIG_FAIR_GROUP_SCHED
179 SEQ_printf(m
, "\ncfs_rq[%d]:%s\n", cpu
, task_group_path(cfs_rq
->tg
));
181 SEQ_printf(m
, "\ncfs_rq[%d]:\n", cpu
);
183 SEQ_printf(m
, " .%-30s: %Ld.%06ld\n", "exec_clock",
184 SPLIT_NS(cfs_rq
->exec_clock
));
186 raw_spin_lock_irqsave(&rq
->lock
, flags
);
187 if (cfs_rq
->rb_leftmost
)
188 MIN_vruntime
= (__pick_first_entity(cfs_rq
))->vruntime
;
189 last
= __pick_last_entity(cfs_rq
);
191 max_vruntime
= last
->vruntime
;
192 min_vruntime
= cfs_rq
->min_vruntime
;
193 rq0_min_vruntime
= cpu_rq(0)->cfs
.min_vruntime
;
194 raw_spin_unlock_irqrestore(&rq
->lock
, flags
);
195 SEQ_printf(m
, " .%-30s: %Ld.%06ld\n", "MIN_vruntime",
196 SPLIT_NS(MIN_vruntime
));
197 SEQ_printf(m
, " .%-30s: %Ld.%06ld\n", "min_vruntime",
198 SPLIT_NS(min_vruntime
));
199 SEQ_printf(m
, " .%-30s: %Ld.%06ld\n", "max_vruntime",
200 SPLIT_NS(max_vruntime
));
201 spread
= max_vruntime
- MIN_vruntime
;
202 SEQ_printf(m
, " .%-30s: %Ld.%06ld\n", "spread",
204 spread0
= min_vruntime
- rq0_min_vruntime
;
205 SEQ_printf(m
, " .%-30s: %Ld.%06ld\n", "spread0",
207 SEQ_printf(m
, " .%-30s: %d\n", "nr_spread_over",
208 cfs_rq
->nr_spread_over
);
209 SEQ_printf(m
, " .%-30s: %d\n", "nr_running", cfs_rq
->nr_running
);
210 SEQ_printf(m
, " .%-30s: %ld\n", "load", cfs_rq
->load
.weight
);
212 SEQ_printf(m
, " .%-30s: %lu\n", "load_avg",
213 cfs_rq
->avg
.load_avg
);
214 SEQ_printf(m
, " .%-30s: %lu\n", "runnable_load_avg",
215 cfs_rq
->runnable_load_avg
);
216 SEQ_printf(m
, " .%-30s: %lu\n", "util_avg",
217 cfs_rq
->avg
.util_avg
);
218 SEQ_printf(m
, " .%-30s: %ld\n", "removed_load_avg",
219 atomic_long_read(&cfs_rq
->removed_load_avg
));
220 SEQ_printf(m
, " .%-30s: %ld\n", "removed_util_avg",
221 atomic_long_read(&cfs_rq
->removed_util_avg
));
222 #ifdef CONFIG_FAIR_GROUP_SCHED
223 SEQ_printf(m
, " .%-30s: %lu\n", "tg_load_avg_contrib",
224 cfs_rq
->tg_load_avg_contrib
);
225 SEQ_printf(m
, " .%-30s: %ld\n", "tg_load_avg",
226 atomic_long_read(&cfs_rq
->tg
->load_avg
));
229 #ifdef CONFIG_CFS_BANDWIDTH
230 SEQ_printf(m
, " .%-30s: %d\n", "throttled",
232 SEQ_printf(m
, " .%-30s: %d\n", "throttle_count",
233 cfs_rq
->throttle_count
);
236 #ifdef CONFIG_FAIR_GROUP_SCHED
237 print_cfs_group_stats(m
, cpu
, cfs_rq
->tg
);
241 void print_rt_rq(struct seq_file
*m
, int cpu
, struct rt_rq
*rt_rq
)
243 #ifdef CONFIG_RT_GROUP_SCHED
244 SEQ_printf(m
, "\nrt_rq[%d]:%s\n", cpu
, task_group_path(rt_rq
->tg
));
246 SEQ_printf(m
, "\nrt_rq[%d]:\n", cpu
);
250 SEQ_printf(m, " .%-30s: %Ld\n", #x, (long long)(rt_rq->x))
252 SEQ_printf(m, " .%-30s: %Ld.%06ld\n", #x, SPLIT_NS(rt_rq->x))
263 void print_dl_rq(struct seq_file
*m
, int cpu
, struct dl_rq
*dl_rq
)
265 SEQ_printf(m
, "\ndl_rq[%d]:\n", cpu
);
266 SEQ_printf(m
, " .%-30s: %ld\n", "dl_nr_running", dl_rq
->dl_nr_running
);
269 extern __read_mostly
int sched_clock_running
;
271 static void print_cpu(struct seq_file
*m
, int cpu
)
273 struct rq
*rq
= cpu_rq(cpu
);
278 unsigned int freq
= cpu_khz
? : 1;
280 SEQ_printf(m
, "cpu#%d, %u.%03u MHz\n",
281 cpu
, freq
/ 1000, (freq
% 1000));
284 SEQ_printf(m
, "cpu#%d\n", cpu
);
289 if (sizeof(rq->x) == 4) \
290 SEQ_printf(m, " .%-30s: %ld\n", #x, (long)(rq->x)); \
292 SEQ_printf(m, " .%-30s: %Ld\n", #x, (long long)(rq->x));\
296 SEQ_printf(m, " .%-30s: %Ld.%06ld\n", #x, SPLIT_NS(rq->x))
299 SEQ_printf(m
, " .%-30s: %lu\n", "load",
303 P(nr_uninterruptible
);
305 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);
322 P64(max_idle_balance_cost
);
325 if (schedstat_enabled()) {
336 spin_lock_irqsave(&sched_debug_lock
, flags
);
337 print_cfs_stats(m
, cpu
);
338 print_rt_stats(m
, cpu
);
339 print_dl_stats(m
, cpu
);
341 print_rq(m
, rq
, cpu
);
342 spin_unlock_irqrestore(&sched_debug_lock
, flags
);
346 static const char *sched_tunable_scaling_names
[] = {
352 static void sched_debug_header(struct seq_file
*m
)
354 u64 ktime
, sched_clk
, cpu_clk
;
357 local_irq_save(flags
);
358 ktime
= ktime_to_ns(ktime_get());
359 sched_clk
= sched_clock();
360 cpu_clk
= local_clock();
361 local_irq_restore(flags
);
363 SEQ_printf(m
, "Sched Debug Version: v0.11, %s %.*s\n",
364 init_utsname()->release
,
365 (int)strcspn(init_utsname()->version
, " "),
366 init_utsname()->version
);
369 SEQ_printf(m, "%-40s: %Ld\n", #x, (long long)(x))
371 SEQ_printf(m, "%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
376 #ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
377 P(sched_clock_stable());
383 SEQ_printf(m
, "sysctl_sched\n");
386 SEQ_printf(m, " .%-40s: %Ld\n", #x, (long long)(x))
388 SEQ_printf(m, " .%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
389 PN(sysctl_sched_latency
);
390 PN(sysctl_sched_min_granularity
);
391 PN(sysctl_sched_wakeup_granularity
);
392 P(sysctl_sched_child_runs_first
);
393 P(sysctl_sched_features
);
397 SEQ_printf(m
, " .%-40s: %d (%s)\n",
398 "sysctl_sched_tunable_scaling",
399 sysctl_sched_tunable_scaling
,
400 sched_tunable_scaling_names
[sysctl_sched_tunable_scaling
]);
404 static int sched_debug_show(struct seq_file
*m
, void *v
)
406 int cpu
= (unsigned long)(v
- 2);
411 sched_debug_header(m
);
416 void sysrq_sched_debug_show(void)
420 sched_debug_header(NULL
);
421 for_each_online_cpu(cpu
)
422 print_cpu(NULL
, cpu
);
427 * This itererator needs some explanation.
428 * It returns 1 for the header position.
429 * This means 2 is cpu 0.
430 * In a hotplugged system some cpus, including cpu 0, may be missing so we have
431 * to use cpumask_* to iterate over the cpus.
433 static void *sched_debug_start(struct seq_file
*file
, loff_t
*offset
)
435 unsigned long n
= *offset
;
443 n
= cpumask_next(n
- 1, cpu_online_mask
);
445 n
= cpumask_first(cpu_online_mask
);
450 return (void *)(unsigned long)(n
+ 2);
454 static void *sched_debug_next(struct seq_file
*file
, void *data
, loff_t
*offset
)
457 return sched_debug_start(file
, offset
);
460 static void sched_debug_stop(struct seq_file
*file
, void *data
)
464 static const struct seq_operations sched_debug_sops
= {
465 .start
= sched_debug_start
,
466 .next
= sched_debug_next
,
467 .stop
= sched_debug_stop
,
468 .show
= sched_debug_show
,
471 static int sched_debug_release(struct inode
*inode
, struct file
*file
)
473 seq_release(inode
, file
);
478 static int sched_debug_open(struct inode
*inode
, struct file
*filp
)
482 ret
= seq_open(filp
, &sched_debug_sops
);
487 static const struct file_operations sched_debug_fops
= {
488 .open
= sched_debug_open
,
491 .release
= sched_debug_release
,
494 static int __init
init_sched_debug_procfs(void)
496 struct proc_dir_entry
*pe
;
498 pe
= proc_create("sched_debug", 0444, NULL
, &sched_debug_fops
);
504 __initcall(init_sched_debug_procfs
);
507 SEQ_printf(m, "%-45s:%21Ld\n", #F, (long long)F)
509 SEQ_printf(m, "%-45s:%21Ld\n", #F, (long long)p->F)
511 SEQ_printf(m, "%-45s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)F))
513 SEQ_printf(m, "%-45s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)p->F))
516 #ifdef CONFIG_NUMA_BALANCING
517 void print_numa_stats(struct seq_file
*m
, int node
, unsigned long tsf
,
518 unsigned long tpf
, unsigned long gsf
, unsigned long gpf
)
520 SEQ_printf(m
, "numa_faults node=%d ", node
);
521 SEQ_printf(m
, "task_private=%lu task_shared=%lu ", tsf
, tpf
);
522 SEQ_printf(m
, "group_private=%lu group_shared=%lu\n", gsf
, gpf
);
527 static void sched_show_numa(struct task_struct
*p
, struct seq_file
*m
)
529 #ifdef CONFIG_NUMA_BALANCING
530 struct mempolicy
*pol
;
533 P(mm
->numa_scan_seq
);
537 if (pol
&& !(pol
->flags
& MPOL_F_MORON
))
542 P(numa_pages_migrated
);
543 P(numa_preferred_nid
);
544 P(total_numa_faults
);
545 SEQ_printf(m
, "current_node=%d, numa_group_id=%d\n",
546 task_node(p
), task_numa_group_id(p
));
547 show_numa_stats(p
, m
);
552 void proc_sched_show_task(struct task_struct
*p
, struct seq_file
*m
)
554 unsigned long nr_switches
;
556 SEQ_printf(m
, "%s (%d, #threads: %d)\n", p
->comm
, task_pid_nr(p
),
559 "---------------------------------------------------------"
562 SEQ_printf(m, "%-45s:%21Ld\n", #F, (long long)F)
564 SEQ_printf(m, "%-45s:%21Ld\n", #F, (long long)p->F)
566 SEQ_printf(m, "%-45s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)F))
568 SEQ_printf(m, "%-45s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)p->F))
572 PN(se
.sum_exec_runtime
);
574 nr_switches
= p
->nvcsw
+ p
->nivcsw
;
576 #ifdef CONFIG_SCHEDSTATS
579 if (schedstat_enabled()) {
580 u64 avg_atom
, avg_per_cpu
;
582 PN(se
.statistics
.sum_sleep_runtime
);
583 PN(se
.statistics
.wait_start
);
584 PN(se
.statistics
.sleep_start
);
585 PN(se
.statistics
.block_start
);
586 PN(se
.statistics
.sleep_max
);
587 PN(se
.statistics
.block_max
);
588 PN(se
.statistics
.exec_max
);
589 PN(se
.statistics
.slice_max
);
590 PN(se
.statistics
.wait_max
);
591 PN(se
.statistics
.wait_sum
);
592 P(se
.statistics
.wait_count
);
593 PN(se
.statistics
.iowait_sum
);
594 P(se
.statistics
.iowait_count
);
595 P(se
.statistics
.nr_migrations_cold
);
596 P(se
.statistics
.nr_failed_migrations_affine
);
597 P(se
.statistics
.nr_failed_migrations_running
);
598 P(se
.statistics
.nr_failed_migrations_hot
);
599 P(se
.statistics
.nr_forced_migrations
);
600 P(se
.statistics
.nr_wakeups
);
601 P(se
.statistics
.nr_wakeups_sync
);
602 P(se
.statistics
.nr_wakeups_migrate
);
603 P(se
.statistics
.nr_wakeups_local
);
604 P(se
.statistics
.nr_wakeups_remote
);
605 P(se
.statistics
.nr_wakeups_affine
);
606 P(se
.statistics
.nr_wakeups_affine_attempts
);
607 P(se
.statistics
.nr_wakeups_passive
);
608 P(se
.statistics
.nr_wakeups_idle
);
610 avg_atom
= p
->se
.sum_exec_runtime
;
612 avg_atom
= div64_ul(avg_atom
, nr_switches
);
616 avg_per_cpu
= p
->se
.sum_exec_runtime
;
617 if (p
->se
.nr_migrations
) {
618 avg_per_cpu
= div64_u64(avg_per_cpu
,
619 p
->se
.nr_migrations
);
629 SEQ_printf(m
, "%-45s:%21Ld\n",
630 "nr_voluntary_switches", (long long)p
->nvcsw
);
631 SEQ_printf(m
, "%-45s:%21Ld\n",
632 "nr_involuntary_switches", (long long)p
->nivcsw
);
640 P(se
.avg
.last_update_time
);
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
));