kernel/time/timer_list.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * List pending timers
   4  *
   5  * Copyright(C) 2006, Red Hat, Inc., Ingo Molnar
   6  */
   7
   8 #include <linux/proc_fs.h>
   9 #include <linux/module.h>
  10 #include <linux/spinlock.h>
  11 #include <linux/sched.h>
  12 #include <linux/seq_file.h>
  13 #include <linux/kallsyms.h>
  14 #include <linux/nmi.h>
  15
  16 #include <linux/uaccess.h>
  17
  18 #include "tick-internal.h"
  19
  20 struct timer_list_iter {
  21         int cpu;
  22         bool second_pass;
  23         u64 now;
  24 };
  25
  26 /*
  27  * This allows printing both to /proc/timer_list and
  28  * to the console (on SysRq-Q):
  29  */
  30 __printf(2, 3)
  31 static void SEQ_printf(struct seq_file *m, const char *fmt, ...)
  32 {
  33         va_list args;
  34
  35         va_start(args, fmt);
  36
  37         if (m)
  38                 seq_vprintf(m, fmt, args);
  39         else
  40                 vprintk(fmt, args);
  41
  42         va_end(args);
  43 }
  44
  45 static void print_name_offset(struct seq_file *m, void *sym)
  46 {
  47         char symname[KSYM_NAME_LEN];
  48
  49         if (lookup_symbol_name((unsigned long)sym, symname) < 0)
  50                 SEQ_printf(m, "<%pK>", sym);
  51         else
  52                 SEQ_printf(m, "%s", symname);
  53 }
  54
  55 static void
  56 print_timer(struct seq_file *m, struct hrtimer *taddr, struct hrtimer *timer,
  57             int idx, u64 now)
  58 {
  59         SEQ_printf(m, " #%d: ", idx);
  60         print_name_offset(m, taddr);
  61         SEQ_printf(m, ", ");
  62         print_name_offset(m, timer->function);
  63         SEQ_printf(m, ", S:%02x", timer->state);
  64         SEQ_printf(m, "\n");
  65         SEQ_printf(m, " # expires at %Lu-%Lu nsecs [in %Ld to %Ld nsecs]\n",
  66                 (unsigned long long)ktime_to_ns(hrtimer_get_softexpires(timer)),
  67                 (unsigned long long)ktime_to_ns(hrtimer_get_expires(timer)),
  68                 (long long)(ktime_to_ns(hrtimer_get_softexpires(timer)) - now),
  69                 (long long)(ktime_to_ns(hrtimer_get_expires(timer)) - now));
  70 }
  71
  72 static void
  73 print_active_timers(struct seq_file *m, struct hrtimer_clock_base *base,
  74                     u64 now)
  75 {
  76         struct hrtimer *timer, tmp;
  77         unsigned long next = 0, i;
  78         struct timerqueue_node *curr;
  79         unsigned long flags;
  80
  81 next_one:
  82         i = 0;
  83
  84         touch_nmi_watchdog();
  85
  86         raw_spin_lock_irqsave(&base->cpu_base->lock, flags);
  87
  88         curr = timerqueue_getnext(&base->active);
  89         /*
  90          * Crude but we have to do this O(N*N) thing, because
  91          * we have to unlock the base when printing:
  92          */
  93         while (curr && i < next) {
  94                 curr = timerqueue_iterate_next(curr);
  95                 i++;
  96         }
  97
  98         if (curr) {
  99
 100                 timer = container_of(curr, struct hrtimer, node);
 101                 tmp = *timer;
 102                 raw_spin_unlock_irqrestore(&base->cpu_base->lock, flags);
 103
 104                 print_timer(m, timer, &tmp, i, now);
 105                 next++;
 106                 goto next_one;
 107         }
 108         raw_spin_unlock_irqrestore(&base->cpu_base->lock, flags);
 109 }
 110
 111 static void
 112 print_base(struct seq_file *m, struct hrtimer_clock_base *base, u64 now)
 113 {
 114         SEQ_printf(m, "  .base:       %pK\n", base);
 115         SEQ_printf(m, "  .index:      %d\n", base->index);
 116
 117         SEQ_printf(m, "  .resolution: %u nsecs\n", hrtimer_resolution);
 118
 119         SEQ_printf(m,   "  .get_time:   ");
 120         print_name_offset(m, base->get_time);
 121         SEQ_printf(m,   "\n");
 122 #ifdef CONFIG_HIGH_RES_TIMERS
 123         SEQ_printf(m, "  .offset:     %Lu nsecs\n",
 124                    (unsigned long long) ktime_to_ns(base->offset));
 125 #endif
 126         SEQ_printf(m,   "active timers:\n");
 127         print_active_timers(m, base, now + ktime_to_ns(base->offset));
 128 }
 129
 130 static void print_cpu(struct seq_file *m, int cpu, u64 now)
 131 {
 132         struct hrtimer_cpu_base *cpu_base = &per_cpu(hrtimer_bases, cpu);
 133         int i;
 134
 135         SEQ_printf(m, "cpu: %d\n", cpu);
 136         for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {
 137                 SEQ_printf(m, " clock %d:\n", i);
 138                 print_base(m, cpu_base->clock_base + i, now);
 139         }
 140 #define P(x) \
 141         SEQ_printf(m, "  .%-15s: %Lu\n", #x, \
 142                    (unsigned long long)(cpu_base->x))
 143 #define P_ns(x) \
 144         SEQ_printf(m, "  .%-15s: %Lu nsecs\n", #x, \
 145                    (unsigned long long)(ktime_to_ns(cpu_base->x)))
 146
 147 #ifdef CONFIG_HIGH_RES_TIMERS
 148         P_ns(expires_next);
 149         P(hres_active);
 150         P(nr_events);
 151         P(nr_retries);
 152         P(nr_hangs);
 153         P(max_hang_time);
 154 #endif
 155 #undef P
 156 #undef P_ns
 157
 158 #ifdef CONFIG_TICK_ONESHOT
 159 # define P(x) \
 160         SEQ_printf(m, "  .%-15s: %Lu\n", #x, \
 161                    (unsigned long long)(ts->x))
 162 # define P_ns(x) \
 163         SEQ_printf(m, "  .%-15s: %Lu nsecs\n", #x, \
 164                    (unsigned long long)(ktime_to_ns(ts->x)))
 165         {
 166                 struct tick_sched *ts = tick_get_tick_sched(cpu);
 167                 P(nohz_mode);
 168                 P_ns(last_tick);
 169                 P(tick_stopped);
 170                 P(idle_jiffies);
 171                 P(idle_calls);
 172                 P(idle_sleeps);
 173                 P_ns(idle_entrytime);
 174                 P_ns(idle_waketime);
 175                 P_ns(idle_exittime);
 176                 P_ns(idle_sleeptime);
 177                 P_ns(iowait_sleeptime);
 178                 P(last_jiffies);
 179                 P(next_timer);
 180                 P_ns(idle_expires);
 181                 SEQ_printf(m, "jiffies: %Lu\n",
 182                            (unsigned long long)jiffies);
 183         }
 184 #endif
 185
 186 #undef P
 187 #undef P_ns
 188         SEQ_printf(m, "\n");
 189 }
 190
 191 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 192 static void
 193 print_tickdevice(struct seq_file *m, struct tick_device *td, int cpu)
 194 {
 195         struct clock_event_device *dev = td->evtdev;
 196
 197         touch_nmi_watchdog();
 198
 199         SEQ_printf(m, "Tick Device: mode:     %d\n", td->mode);
 200         if (cpu < 0)
 201                 SEQ_printf(m, "Broadcast device\n");
 202         else
 203                 SEQ_printf(m, "Per CPU device: %d\n", cpu);
 204
 205         SEQ_printf(m, "Clock Event Device: ");
 206         if (!dev) {
 207                 SEQ_printf(m, "<NULL>\n");
 208                 return;
 209         }
 210         SEQ_printf(m, "%s\n", dev->name);
 211         SEQ_printf(m, " max_delta_ns:   %llu\n",
 212                    (unsigned long long) dev->max_delta_ns);
 213         SEQ_printf(m, " min_delta_ns:   %llu\n",
 214                    (unsigned long long) dev->min_delta_ns);
 215         SEQ_printf(m, " mult:           %u\n", dev->mult);
 216         SEQ_printf(m, " shift:          %u\n", dev->shift);
 217         SEQ_printf(m, " mode:           %d\n", clockevent_get_state(dev));
 218         SEQ_printf(m, " next_event:     %Ld nsecs\n",
 219                    (unsigned long long) ktime_to_ns(dev->next_event));
 220
 221         SEQ_printf(m, " set_next_event: ");
 222         print_name_offset(m, dev->set_next_event);
 223         SEQ_printf(m, "\n");
 224
 225         if (dev->set_state_shutdown) {
 226                 SEQ_printf(m, " shutdown: ");
 227                 print_name_offset(m, dev->set_state_shutdown);
 228                 SEQ_printf(m, "\n");
 229         }
 230
 231         if (dev->set_state_periodic) {
 232                 SEQ_printf(m, " periodic: ");
 233                 print_name_offset(m, dev->set_state_periodic);
 234                 SEQ_printf(m, "\n");
 235         }
 236
 237         if (dev->set_state_oneshot) {
 238                 SEQ_printf(m, " oneshot:  ");
 239                 print_name_offset(m, dev->set_state_oneshot);
 240                 SEQ_printf(m, "\n");
 241         }
 242
 243         if (dev->set_state_oneshot_stopped) {
 244                 SEQ_printf(m, " oneshot stopped: ");
 245                 print_name_offset(m, dev->set_state_oneshot_stopped);
 246                 SEQ_printf(m, "\n");
 247         }
 248
 249         if (dev->tick_resume) {
 250                 SEQ_printf(m, " resume:   ");
 251                 print_name_offset(m, dev->tick_resume);
 252                 SEQ_printf(m, "\n");
 253         }
 254
 255         SEQ_printf(m, " event_handler:  ");
 256         print_name_offset(m, dev->event_handler);
 257         SEQ_printf(m, "\n");
 258         SEQ_printf(m, " retries:        %lu\n", dev->retries);
 259         SEQ_printf(m, "\n");
 260 }
 261
 262 static void timer_list_show_tickdevices_header(struct seq_file *m)
 263 {
 264 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
 265         print_tickdevice(m, tick_get_broadcast_device(), -1);
 266         SEQ_printf(m, "tick_broadcast_mask: %*pb\n",
 267                    cpumask_pr_args(tick_get_broadcast_mask()));
 268 #ifdef CONFIG_TICK_ONESHOT
 269         SEQ_printf(m, "tick_broadcast_oneshot_mask: %*pb\n",
 270                    cpumask_pr_args(tick_get_broadcast_oneshot_mask()));
 271 #endif
 272         SEQ_printf(m, "\n");
 273 #endif
 274 }
 275 #endif
 276
 277 static inline void timer_list_header(struct seq_file *m, u64 now)
 278 {
 279         SEQ_printf(m, "Timer List Version: v0.8\n");
 280         SEQ_printf(m, "HRTIMER_MAX_CLOCK_BASES: %d\n", HRTIMER_MAX_CLOCK_BASES);
 281         SEQ_printf(m, "now at %Ld nsecs\n", (unsigned long long)now);
 282         SEQ_printf(m, "\n");
 283 }
 284
 285 void sysrq_timer_list_show(void)
 286 {
 287         u64 now = ktime_to_ns(ktime_get());
 288         int cpu;
 289
 290         timer_list_header(NULL, now);
 291
 292         for_each_online_cpu(cpu)
 293                 print_cpu(NULL, cpu, now);
 294
 295 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 296         timer_list_show_tickdevices_header(NULL);
 297         for_each_online_cpu(cpu)
 298                 print_tickdevice(NULL, tick_get_device(cpu), cpu);
 299 #endif
 300         return;
 301 }
 302
 303 #ifdef CONFIG_PROC_FS
 304 static int timer_list_show(struct seq_file *m, void *v)
 305 {
 306         struct timer_list_iter *iter = v;
 307
 308         if (iter->cpu == -1 && !iter->second_pass)
 309                 timer_list_header(m, iter->now);
 310         else if (!iter->second_pass)
 311                 print_cpu(m, iter->cpu, iter->now);
 312 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 313         else if (iter->cpu == -1 && iter->second_pass)
 314                 timer_list_show_tickdevices_header(m);
 315         else
 316                 print_tickdevice(m, tick_get_device(iter->cpu), iter->cpu);
 317 #endif
 318         return 0;
 319 }
 320
 321 static void *move_iter(struct timer_list_iter *iter, loff_t offset)
 322 {
 323         for (; offset; offset--) {
 324                 iter->cpu = cpumask_next(iter->cpu, cpu_online_mask);
 325                 if (iter->cpu >= nr_cpu_ids) {
 326 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 327                         if (!iter->second_pass) {
 328                                 iter->cpu = -1;
 329                                 iter->second_pass = true;
 330                         } else
 331                                 return NULL;
 332 #else
 333                         return NULL;
 334 #endif
 335                 }
 336         }
 337         return iter;
 338 }
 339
 340 static void *timer_list_start(struct seq_file *file, loff_t *offset)
 341 {
 342         struct timer_list_iter *iter = file->private;
 343
 344         if (!*offset)
 345                 iter->now = ktime_to_ns(ktime_get());
 346         iter->cpu = -1;
 347         iter->second_pass = false;
 348         return move_iter(iter, *offset);
 349 }
 350
 351 static void *timer_list_next(struct seq_file *file, void *v, loff_t *offset)
 352 {
 353         struct timer_list_iter *iter = file->private;
 354         ++*offset;
 355         return move_iter(iter, 1);
 356 }
 357
 358 static void timer_list_stop(struct seq_file *seq, void *v)
 359 {
 360 }
 361
 362 static const struct seq_operations timer_list_sops = {
 363         .start = timer_list_start,
 364         .next = timer_list_next,
 365         .stop = timer_list_stop,
 366         .show = timer_list_show,
 367 };
 368
 369 static int __init init_timer_list_procfs(void)
 370 {
 371         struct proc_dir_entry *pe;
 372
 373         pe = proc_create_seq_private("timer_list", 0400, NULL, &timer_list_sops,
 374                         sizeof(struct timer_list_iter), NULL);
 375         if (!pe)
 376                 return -ENOMEM;
 377         return 0;
 378 }
 379 __initcall(init_timer_list_procfs);
 380 #endif