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 extern __read_mostly
int sched_clock_running
;
266 static void print_cpu(struct seq_file
*m
, int cpu
)
268 struct rq
*rq
= cpu_rq(cpu
);
273 unsigned int freq
= cpu_khz
? : 1;
275 SEQ_printf(m
, "cpu#%d, %u.%03u MHz\n",
276 cpu
, freq
/ 1000, (freq
% 1000));
279 SEQ_printf(m
, "cpu#%d\n", cpu
);
284 if (sizeof(rq->x) == 4) \
285 SEQ_printf(m, " .%-30s: %ld\n", #x, (long)(rq->x)); \
287 SEQ_printf(m, " .%-30s: %Ld\n", #x, (long long)(rq->x));\
291 SEQ_printf(m, " .%-30s: %Ld.%06ld\n", #x, SPLIT_NS(rq->x))
294 SEQ_printf(m
, " .%-30s: %lu\n", "load",
298 P(nr_uninterruptible
);
300 SEQ_printf(m
, " .%-30s: %ld\n", "curr->pid", (long)(task_pid_nr(rq
->curr
)));
310 #ifdef CONFIG_SCHEDSTATS
311 #define P(n) SEQ_printf(m, " .%-30s: %d\n", #n, rq->n);
312 #define P64(n) SEQ_printf(m, " .%-30s: %Ld\n", #n, rq->n);
320 P64(max_idle_balance_cost
);
329 spin_lock_irqsave(&sched_debug_lock
, flags
);
330 print_cfs_stats(m
, cpu
);
331 print_rt_stats(m
, cpu
);
333 print_rq(m
, rq
, cpu
);
334 spin_unlock_irqrestore(&sched_debug_lock
, flags
);
338 static const char *sched_tunable_scaling_names
[] = {
344 static void sched_debug_header(struct seq_file
*m
)
346 u64 ktime
, sched_clk
, cpu_clk
;
349 local_irq_save(flags
);
350 ktime
= ktime_to_ns(ktime_get());
351 sched_clk
= sched_clock();
352 cpu_clk
= local_clock();
353 local_irq_restore(flags
);
355 SEQ_printf(m
, "Sched Debug Version: v0.11, %s %.*s\n",
356 init_utsname()->release
,
357 (int)strcspn(init_utsname()->version
, " "),
358 init_utsname()->version
);
361 SEQ_printf(m, "%-40s: %Ld\n", #x, (long long)(x))
363 SEQ_printf(m, "%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
368 #ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
369 P(sched_clock_stable());
375 SEQ_printf(m
, "sysctl_sched\n");
378 SEQ_printf(m, " .%-40s: %Ld\n", #x, (long long)(x))
380 SEQ_printf(m, " .%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
381 PN(sysctl_sched_latency
);
382 PN(sysctl_sched_min_granularity
);
383 PN(sysctl_sched_wakeup_granularity
);
384 P(sysctl_sched_child_runs_first
);
385 P(sysctl_sched_features
);
389 SEQ_printf(m
, " .%-40s: %d (%s)\n",
390 "sysctl_sched_tunable_scaling",
391 sysctl_sched_tunable_scaling
,
392 sched_tunable_scaling_names
[sysctl_sched_tunable_scaling
]);
396 static int sched_debug_show(struct seq_file
*m
, void *v
)
398 int cpu
= (unsigned long)(v
- 2);
403 sched_debug_header(m
);
408 void sysrq_sched_debug_show(void)
412 sched_debug_header(NULL
);
413 for_each_online_cpu(cpu
)
414 print_cpu(NULL
, cpu
);
419 * This itererator needs some explanation.
420 * It returns 1 for the header position.
421 * This means 2 is cpu 0.
422 * In a hotplugged system some cpus, including cpu 0, may be missing so we have
423 * to use cpumask_* to iterate over the cpus.
425 static void *sched_debug_start(struct seq_file
*file
, loff_t
*offset
)
427 unsigned long n
= *offset
;
435 n
= cpumask_next(n
- 1, cpu_online_mask
);
437 n
= cpumask_first(cpu_online_mask
);
442 return (void *)(unsigned long)(n
+ 2);
446 static void *sched_debug_next(struct seq_file
*file
, void *data
, loff_t
*offset
)
449 return sched_debug_start(file
, offset
);
452 static void sched_debug_stop(struct seq_file
*file
, void *data
)
456 static const struct seq_operations sched_debug_sops
= {
457 .start
= sched_debug_start
,
458 .next
= sched_debug_next
,
459 .stop
= sched_debug_stop
,
460 .show
= sched_debug_show
,
463 static int sched_debug_release(struct inode
*inode
, struct file
*file
)
465 seq_release(inode
, file
);
470 static int sched_debug_open(struct inode
*inode
, struct file
*filp
)
474 ret
= seq_open(filp
, &sched_debug_sops
);
479 static const struct file_operations sched_debug_fops
= {
480 .open
= sched_debug_open
,
483 .release
= sched_debug_release
,
486 static int __init
init_sched_debug_procfs(void)
488 struct proc_dir_entry
*pe
;
490 pe
= proc_create("sched_debug", 0444, NULL
, &sched_debug_fops
);
496 __initcall(init_sched_debug_procfs
);
499 SEQ_printf(m, "%-45s:%21Ld\n", #F, (long long)F)
501 SEQ_printf(m, "%-45s:%21Ld\n", #F, (long long)p->F)
503 SEQ_printf(m, "%-45s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)F))
505 SEQ_printf(m, "%-45s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)p->F))
508 static void sched_show_numa(struct task_struct
*p
, struct seq_file
*m
)
510 #ifdef CONFIG_NUMA_BALANCING
511 struct mempolicy
*pol
;
515 P(mm
->numa_scan_seq
);
519 if (pol
&& !(pol
->flags
& MPOL_F_MORON
))
524 SEQ_printf(m
, "numa_migrations, %ld\n", xchg(&p
->numa_pages_migrated
, 0));
526 for_each_online_node(node
) {
527 for (i
= 0; i
< 2; i
++) {
528 unsigned long nr_faults
= -1;
529 int cpu_current
, home_node
;
531 if (p
->numa_faults_memory
)
532 nr_faults
= p
->numa_faults_memory
[2*node
+ i
];
534 cpu_current
= !i
? (task_node(p
) == node
) :
535 (pol
&& node_isset(node
, pol
->v
.nodes
));
537 home_node
= (p
->numa_preferred_nid
== node
);
539 SEQ_printf(m
, "numa_faults_memory, %d, %d, %d, %d, %ld\n",
540 i
, node
, cpu_current
, home_node
, nr_faults
);
548 void proc_sched_show_task(struct task_struct
*p
, struct seq_file
*m
)
550 unsigned long nr_switches
;
552 SEQ_printf(m
, "%s (%d, #threads: %d)\n", p
->comm
, task_pid_nr(p
),
555 "---------------------------------------------------------"
558 SEQ_printf(m, "%-45s:%21Ld\n", #F, (long long)F)
560 SEQ_printf(m, "%-45s:%21Ld\n", #F, (long long)p->F)
562 SEQ_printf(m, "%-45s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)F))
564 SEQ_printf(m, "%-45s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)p->F))
568 PN(se
.sum_exec_runtime
);
570 nr_switches
= p
->nvcsw
+ p
->nivcsw
;
572 #ifdef CONFIG_SCHEDSTATS
573 PN(se
.statistics
.wait_start
);
574 PN(se
.statistics
.sleep_start
);
575 PN(se
.statistics
.block_start
);
576 PN(se
.statistics
.sleep_max
);
577 PN(se
.statistics
.block_max
);
578 PN(se
.statistics
.exec_max
);
579 PN(se
.statistics
.slice_max
);
580 PN(se
.statistics
.wait_max
);
581 PN(se
.statistics
.wait_sum
);
582 P(se
.statistics
.wait_count
);
583 PN(se
.statistics
.iowait_sum
);
584 P(se
.statistics
.iowait_count
);
586 P(se
.statistics
.nr_migrations_cold
);
587 P(se
.statistics
.nr_failed_migrations_affine
);
588 P(se
.statistics
.nr_failed_migrations_running
);
589 P(se
.statistics
.nr_failed_migrations_hot
);
590 P(se
.statistics
.nr_forced_migrations
);
591 P(se
.statistics
.nr_wakeups
);
592 P(se
.statistics
.nr_wakeups_sync
);
593 P(se
.statistics
.nr_wakeups_migrate
);
594 P(se
.statistics
.nr_wakeups_local
);
595 P(se
.statistics
.nr_wakeups_remote
);
596 P(se
.statistics
.nr_wakeups_affine
);
597 P(se
.statistics
.nr_wakeups_affine_attempts
);
598 P(se
.statistics
.nr_wakeups_passive
);
599 P(se
.statistics
.nr_wakeups_idle
);
602 u64 avg_atom
, avg_per_cpu
;
604 avg_atom
= p
->se
.sum_exec_runtime
;
606 avg_atom
= div64_ul(avg_atom
, nr_switches
);
610 avg_per_cpu
= p
->se
.sum_exec_runtime
;
611 if (p
->se
.nr_migrations
) {
612 avg_per_cpu
= div64_u64(avg_per_cpu
,
613 p
->se
.nr_migrations
);
623 SEQ_printf(m
, "%-45s:%21Ld\n",
624 "nr_voluntary_switches", (long long)p
->nvcsw
);
625 SEQ_printf(m
, "%-45s:%21Ld\n",
626 "nr_involuntary_switches", (long long)p
->nivcsw
);
630 P(se
.avg
.runnable_avg_sum
);
631 P(se
.avg
.runnable_avg_period
);
632 P(se
.avg
.load_avg_contrib
);
633 P(se
.avg
.decay_count
);
643 unsigned int this_cpu
= raw_smp_processor_id();
646 t0
= cpu_clock(this_cpu
);
647 t1
= cpu_clock(this_cpu
);
648 SEQ_printf(m
, "%-45s:%21Ld\n",
649 "clock-delta", (long long)(t1
-t0
));
652 sched_show_numa(p
, m
);
655 void proc_sched_set_task(struct task_struct
*p
)
657 #ifdef CONFIG_SCHEDSTATS
658 memset(&p
->se
.statistics
, 0, sizeof(p
->se
.statistics
));