linux/kernel/sched_debug.c
<<
>>
Prefs
   1/*
   2 * kernel/time/sched_debug.c
   3 *
   4 * Print the CFS rbtree
   5 *
   6 * Copyright(C) 2007, Red Hat, Inc., Ingo Molnar
   7 *
   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.
  11 */
  12
  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
  19/*
  20 * This allows printing both to /proc/sched_debug and
  21 * to the console
  22 */
  23#define SEQ_printf(m, x...)                     \
  24 do {                                           \
  25        if (m)                                  \
  26                seq_printf(m, x);               \
  27        else                                    \
  28                printk(x);                      \
  29 } while (0)
  30
  31/*
  32 * Ease the printing of nsec fields:
  33 */
  34static long long nsec_high(unsigned long long nsec)
  35{
  36        if ((long long)nsec < 0) {
  37                nsec = -nsec;
  38                do_div(nsec, 1000000);
  39                return -nsec;
  40        }
  41        do_div(nsec, 1000000);
  42
  43        return nsec;
  44}
  45
  46static unsigned long nsec_low(unsigned long long nsec)
  47{
  48        if ((long long)nsec < 0)
  49                nsec = -nsec;
  50
  51        return do_div(nsec, 1000000);
  52}
  53
  54#define SPLIT_NS(x) nsec_high(x), nsec_low(x)
  55
  56#ifdef CONFIG_FAIR_GROUP_SCHED
  57static void print_cfs_group_stats(struct seq_file *m, int cpu,
  58                struct task_group *tg)
  59{
  60        struct sched_entity *se = tg->se[cpu];
  61        if (!se)
  62                return;
  63
  64#define P(F) \
  65        SEQ_printf(m, "  .%-30s: %lld\n", #F, (long long)F)
  66#define PN(F) \
  67        SEQ_printf(m, "  .%-30s: %lld.%06ld\n", #F, SPLIT_NS((long long)F))
  68
  69        PN(se->exec_start);
  70        PN(se->vruntime);
  71        PN(se->sum_exec_runtime);
  72#ifdef CONFIG_SCHEDSTATS
  73        PN(se->wait_start);
  74        PN(se->sleep_start);
  75        PN(se->block_start);
  76        PN(se->sleep_max);
  77        PN(se->block_max);
  78        PN(se->exec_max);
  79        PN(se->slice_max);
  80        PN(se->wait_max);
  81        PN(se->wait_sum);
  82        P(se->wait_count);
  83#endif
  84        P(se->load.weight);
  85#undef PN
  86#undef P
  87}
  88#endif
  89
  90static void
  91print_task(struct seq_file *m, struct rq *rq, struct task_struct *p)
  92{
  93        if (rq->curr == p)
  94                SEQ_printf(m, "R");
  95        else
  96                SEQ_printf(m, " ");
  97
  98        SEQ_printf(m, "%15s %5d %9Ld.%06ld %9Ld %5d ",
  99                p->comm, p->pid,
 100                SPLIT_NS(p->se.vruntime),
 101                (long long)(p->nvcsw + p->nivcsw),
 102                p->prio);
 103#ifdef CONFIG_SCHEDSTATS
 104        SEQ_printf(m, "%9Ld.%06ld %9Ld.%06ld %9Ld.%06ld",
 105                SPLIT_NS(p->se.vruntime),
 106                SPLIT_NS(p->se.sum_exec_runtime),
 107                SPLIT_NS(p->se.sum_sleep_runtime));
 108#else
 109        SEQ_printf(m, "%15Ld %15Ld %15Ld.%06ld %15Ld.%06ld %15Ld.%06ld",
 110                0LL, 0LL, 0LL, 0L, 0LL, 0L, 0LL, 0L);
 111#endif
 112
 113#ifdef CONFIG_CGROUP_SCHED
 114        {
 115                char path[64];
 116
 117                cgroup_path(task_group(p)->css.cgroup, path, sizeof(path));
 118                SEQ_printf(m, " %s", path);
 119        }
 120#endif
 121        SEQ_printf(m, "\n");
 122}
 123
 124static void print_rq(struct seq_file *m, struct rq *rq, int rq_cpu)
 125{
 126        struct task_struct *g, *p;
 127        unsigned long flags;
 128
 129        SEQ_printf(m,
 130        "\nrunnable tasks:\n"
 131        "            task   PID         tree-key  switches  prio"
 132        "     exec-runtime         sum-exec        sum-sleep\n"
 133        "------------------------------------------------------"
 134        "----------------------------------------------------\n");
 135
 136        read_lock_irqsave(&tasklist_lock, flags);
 137
 138        do_each_thread(g, p) {
 139                if (!p->se.on_rq || task_cpu(p) != rq_cpu)
 140                        continue;
 141
 142                print_task(m, rq, p);
 143        } while_each_thread(g, p);
 144
 145        read_unlock_irqrestore(&tasklist_lock, flags);
 146}
 147
 148#if defined(CONFIG_CGROUP_SCHED) && \
 149        (defined(CONFIG_FAIR_GROUP_SCHED) || defined(CONFIG_RT_GROUP_SCHED))
 150static void task_group_path(struct task_group *tg, char *buf, int buflen)
 151{
 152        /* may be NULL if the underlying cgroup isn't fully-created yet */
 153        if (!tg->css.cgroup) {
 154                buf[0] = '\0';
 155                return;
 156        }
 157        cgroup_path(tg->css.cgroup, buf, buflen);
 158}
 159#endif
 160
 161void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
 162{
 163        s64 MIN_vruntime = -1, min_vruntime, max_vruntime = -1,
 164                spread, rq0_min_vruntime, spread0;
 165        struct rq *rq = &per_cpu(runqueues, cpu);
 166        struct sched_entity *last;
 167        unsigned long flags;
 168
 169#if defined(CONFIG_CGROUP_SCHED) && defined(CONFIG_FAIR_GROUP_SCHED)
 170        char path[128];
 171        struct task_group *tg = cfs_rq->tg;
 172
 173        task_group_path(tg, path, sizeof(path));
 174
 175        SEQ_printf(m, "\ncfs_rq[%d]:%s\n", cpu, path);
 176#elif defined(CONFIG_USER_SCHED) && defined(CONFIG_FAIR_GROUP_SCHED)
 177        {
 178                uid_t uid = cfs_rq->tg->uid;
 179                SEQ_printf(m, "\ncfs_rq[%d] for UID: %u\n", cpu, uid);
 180        }
 181#else
 182        SEQ_printf(m, "\ncfs_rq[%d]:\n", cpu);
 183#endif
 184        SEQ_printf(m, "  .%-30s: %Ld.%06ld\n", "exec_clock",
 185                        SPLIT_NS(cfs_rq->exec_clock));
 186
 187        spin_lock_irqsave(&rq->lock, flags);
 188        if (cfs_rq->rb_leftmost)
 189                MIN_vruntime = (__pick_next_entity(cfs_rq))->vruntime;
 190        last = __pick_last_entity(cfs_rq);
 191        if (last)
 192                max_vruntime = last->vruntime;
 193        min_vruntime = cfs_rq->min_vruntime;
 194        rq0_min_vruntime = per_cpu(runqueues, 0).cfs.min_vruntime;
 195        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",
 204                        SPLIT_NS(spread));
 205        spread0 = min_vruntime - rq0_min_vruntime;
 206        SEQ_printf(m, "  .%-30s: %Ld.%06ld\n", "spread0",
 207                        SPLIT_NS(spread0));
 208        SEQ_printf(m, "  .%-30s: %ld\n", "nr_running", cfs_rq->nr_running);
 209        SEQ_printf(m, "  .%-30s: %ld\n", "load", cfs_rq->load.weight);
 210
 211        SEQ_printf(m, "  .%-30s: %d\n", "nr_spread_over",
 212                        cfs_rq->nr_spread_over);
 213#ifdef CONFIG_FAIR_GROUP_SCHED
 214#ifdef CONFIG_SMP
 215        SEQ_printf(m, "  .%-30s: %lu\n", "shares", cfs_rq->shares);
 216#endif
 217        print_cfs_group_stats(m, cpu, cfs_rq->tg);
 218#endif
 219}
 220
 221void print_rt_rq(struct seq_file *m, int cpu, struct rt_rq *rt_rq)
 222{
 223#if defined(CONFIG_CGROUP_SCHED) && defined(CONFIG_RT_GROUP_SCHED)
 224        char path[128];
 225        struct task_group *tg = rt_rq->tg;
 226
 227        task_group_path(tg, path, sizeof(path));
 228
 229        SEQ_printf(m, "\nrt_rq[%d]:%s\n", cpu, path);
 230#else
 231        SEQ_printf(m, "\nrt_rq[%d]:\n", cpu);
 232#endif
 233
 234
 235#define P(x) \
 236        SEQ_printf(m, "  .%-30s: %Ld\n", #x, (long long)(rt_rq->x))
 237#define PN(x) \
 238        SEQ_printf(m, "  .%-30s: %Ld.%06ld\n", #x, SPLIT_NS(rt_rq->x))
 239
 240        P(rt_nr_running);
 241        P(rt_throttled);
 242        PN(rt_time);
 243        PN(rt_runtime);
 244
 245#undef PN
 246#undef P
 247}
 248
 249static void print_cpu(struct seq_file *m, int cpu)
 250{
 251        struct rq *rq = &per_cpu(runqueues, cpu);
 252
 253#ifdef CONFIG_X86
 254        {
 255                unsigned int freq = cpu_khz ? : 1;
 256
 257                SEQ_printf(m, "\ncpu#%d, %u.%03u MHz\n",
 258                           cpu, freq / 1000, (freq % 1000));
 259        }
 260#else
 261        SEQ_printf(m, "\ncpu#%d\n", cpu);
 262#endif
 263
 264#define P(x) \
 265        SEQ_printf(m, "  .%-30s: %Ld\n", #x, (long long)(rq->x))
 266#define PN(x) \
 267        SEQ_printf(m, "  .%-30s: %Ld.%06ld\n", #x, SPLIT_NS(rq->x))
 268
 269        P(nr_running);
 270        SEQ_printf(m, "  .%-30s: %lu\n", "load",
 271                   rq->load.weight);
 272        P(nr_switches);
 273        P(nr_load_updates);
 274        P(nr_uninterruptible);
 275        PN(next_balance);
 276        P(curr->pid);
 277        PN(clock);
 278        P(cpu_load[0]);
 279        P(cpu_load[1]);
 280        P(cpu_load[2]);
 281        P(cpu_load[3]);
 282        P(cpu_load[4]);
 283#undef P
 284#undef PN
 285
 286#ifdef CONFIG_SCHEDSTATS
 287#define P(n) SEQ_printf(m, "  .%-30s: %d\n", #n, rq->n);
 288
 289        P(yld_count);
 290
 291        P(sched_switch);
 292        P(sched_count);
 293        P(sched_goidle);
 294
 295        P(ttwu_count);
 296        P(ttwu_local);
 297
 298        P(bkl_count);
 299
 300#undef P
 301#endif
 302        print_cfs_stats(m, cpu);
 303        print_rt_stats(m, cpu);
 304
 305        print_rq(m, rq, cpu);
 306}
 307
 308static int sched_debug_show(struct seq_file *m, void *v)
 309{
 310        u64 now = ktime_to_ns(ktime_get());
 311        int cpu;
 312
 313        SEQ_printf(m, "Sched Debug Version: v0.09, %s %.*s\n",
 314                init_utsname()->release,
 315                (int)strcspn(init_utsname()->version, " "),
 316                init_utsname()->version);
 317
 318        SEQ_printf(m, "now at %Lu.%06ld msecs\n", SPLIT_NS(now));
 319
 320#define P(x) \
 321        SEQ_printf(m, "  .%-40s: %Ld\n", #x, (long long)(x))
 322#define PN(x) \
 323        SEQ_printf(m, "  .%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
 324        P(jiffies);
 325        PN(sysctl_sched_latency);
 326        PN(sysctl_sched_min_granularity);
 327        PN(sysctl_sched_wakeup_granularity);
 328        PN(sysctl_sched_child_runs_first);
 329        P(sysctl_sched_features);
 330#undef PN
 331#undef P
 332
 333        for_each_online_cpu(cpu)
 334                print_cpu(m, cpu);
 335
 336        SEQ_printf(m, "\n");
 337
 338        return 0;
 339}
 340
 341static void sysrq_sched_debug_show(void)
 342{
 343        sched_debug_show(NULL, NULL);
 344}
 345
 346static int sched_debug_open(struct inode *inode, struct file *filp)
 347{
 348        return single_open(filp, sched_debug_show, NULL);
 349}
 350
 351static const struct file_operations sched_debug_fops = {
 352        .open           = sched_debug_open,
 353        .read           = seq_read,
 354        .llseek         = seq_lseek,
 355        .release        = single_release,
 356};
 357
 358static int __init init_sched_debug_procfs(void)
 359{
 360        struct proc_dir_entry *pe;
 361
 362        pe = proc_create("sched_debug", 0444, NULL, &sched_debug_fops);
 363        if (!pe)
 364                return -ENOMEM;
 365        return 0;
 366}
 367
 368__initcall(init_sched_debug_procfs);
 369
 370void proc_sched_show_task(struct task_struct *p, struct seq_file *m)
 371{
 372        unsigned long nr_switches;
 373        unsigned long flags;
 374        int num_threads = 1;
 375
 376        if (lock_task_sighand(p, &flags)) {
 377                num_threads = atomic_read(&p->signal->count);
 378                unlock_task_sighand(p, &flags);
 379        }
 380
 381        SEQ_printf(m, "%s (%d, #threads: %d)\n", p->comm, p->pid, num_threads);
 382        SEQ_printf(m,
 383                "---------------------------------------------------------\n");
 384#define __P(F) \
 385        SEQ_printf(m, "%-35s:%21Ld\n", #F, (long long)F)
 386#define P(F) \
 387        SEQ_printf(m, "%-35s:%21Ld\n", #F, (long long)p->F)
 388#define __PN(F) \
 389        SEQ_printf(m, "%-35s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)F))
 390#define PN(F) \
 391        SEQ_printf(m, "%-35s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)p->F))
 392
 393        PN(se.exec_start);
 394        PN(se.vruntime);
 395        PN(se.sum_exec_runtime);
 396        PN(se.avg_overlap);
 397        PN(se.avg_wakeup);
 398
 399        nr_switches = p->nvcsw + p->nivcsw;
 400
 401#ifdef CONFIG_SCHEDSTATS
 402        PN(se.wait_start);
 403        PN(se.sleep_start);
 404        PN(se.block_start);
 405        PN(se.sleep_max);
 406        PN(se.block_max);
 407        PN(se.exec_max);
 408        PN(se.slice_max);
 409        PN(se.wait_max);
 410        PN(se.wait_sum);
 411        P(se.wait_count);
 412        P(sched_info.bkl_count);
 413        P(se.nr_migrations);
 414        P(se.nr_migrations_cold);
 415        P(se.nr_failed_migrations_affine);
 416        P(se.nr_failed_migrations_running);
 417        P(se.nr_failed_migrations_hot);
 418        P(se.nr_forced_migrations);
 419        P(se.nr_forced2_migrations);
 420        P(se.nr_wakeups);
 421        P(se.nr_wakeups_sync);
 422        P(se.nr_wakeups_migrate);
 423        P(se.nr_wakeups_local);
 424        P(se.nr_wakeups_remote);
 425        P(se.nr_wakeups_affine);
 426        P(se.nr_wakeups_affine_attempts);
 427        P(se.nr_wakeups_passive);
 428        P(se.nr_wakeups_idle);
 429
 430        {
 431                u64 avg_atom, avg_per_cpu;
 432
 433                avg_atom = p->se.sum_exec_runtime;
 434                if (nr_switches)
 435                        do_div(avg_atom, nr_switches);
 436                else
 437                        avg_atom = -1LL;
 438
 439                avg_per_cpu = p->se.sum_exec_runtime;
 440                if (p->se.nr_migrations) {
 441                        avg_per_cpu = div64_u64(avg_per_cpu,
 442                                                p->se.nr_migrations);
 443                } else {
 444                        avg_per_cpu = -1LL;
 445                }
 446
 447                __PN(avg_atom);
 448                __PN(avg_per_cpu);
 449        }
 450#endif
 451        __P(nr_switches);
 452        SEQ_printf(m, "%-35s:%21Ld\n",
 453                   "nr_voluntary_switches", (long long)p->nvcsw);
 454        SEQ_printf(m, "%-35s:%21Ld\n",
 455                   "nr_involuntary_switches", (long long)p->nivcsw);
 456
 457        P(se.load.weight);
 458        P(policy);
 459        P(prio);
 460#undef PN
 461#undef __PN
 462#undef P
 463#undef __P
 464
 465        {
 466                unsigned int this_cpu = raw_smp_processor_id();
 467                u64 t0, t1;
 468
 469                t0 = cpu_clock(this_cpu);
 470                t1 = cpu_clock(this_cpu);
 471                SEQ_printf(m, "%-35s:%21Ld\n",
 472                           "clock-delta", (long long)(t1-t0));
 473        }
 474}
 475
 476void proc_sched_set_task(struct task_struct *p)
 477{
 478#ifdef CONFIG_SCHEDSTATS
 479        p->se.wait_max                          = 0;
 480        p->se.wait_sum                          = 0;
 481        p->se.wait_count                        = 0;
 482        p->se.sleep_max                         = 0;
 483        p->se.sum_sleep_runtime                 = 0;
 484        p->se.block_max                         = 0;
 485        p->se.exec_max                          = 0;
 486        p->se.slice_max                         = 0;
 487        p->se.nr_migrations                     = 0;
 488        p->se.nr_migrations_cold                = 0;
 489        p->se.nr_failed_migrations_affine       = 0;
 490        p->se.nr_failed_migrations_running      = 0;
 491        p->se.nr_failed_migrations_hot          = 0;
 492        p->se.nr_forced_migrations              = 0;
 493        p->se.nr_forced2_migrations             = 0;
 494        p->se.nr_wakeups                        = 0;
 495        p->se.nr_wakeups_sync                   = 0;
 496        p->se.nr_wakeups_migrate                = 0;
 497        p->se.nr_wakeups_local                  = 0;
 498        p->se.nr_wakeups_remote                 = 0;
 499        p->se.nr_wakeups_affine                 = 0;
 500        p->se.nr_wakeups_affine_attempts        = 0;
 501        p->se.nr_wakeups_passive                = 0;
 502        p->se.nr_wakeups_idle                   = 0;
 503        p->sched_info.bkl_count                 = 0;
 504#endif
 505        p->se.sum_exec_runtime                  = 0;
 506        p->se.prev_sum_exec_runtime             = 0;
 507        p->nvcsw                                = 0;
 508        p->nivcsw                               = 0;
 509}
 510