scripts/gdb: add a timer list command

Implement a command to print the timer list, much like how
/proc/timer_list is implemented.  This can be used to look at the
pending timers on a crashed system.

[swboyd@chromium.org: v2]
  Link: http://lkml.kernel.org/r/20190329220844.38234-5-swboyd@chromium.org
Link: http://lkml.kernel.org/r/20190325184522.260535-5-swboyd@chromium.org
Signed-off-by: Stephen Boyd <swboyd@chromium.org>
Cc: Douglas Anderson <dianders@chromium.org>
Cc: Nikolay Borisov <n.borisov.lkml@gmail.com>
Cc: Kieran Bingham <kbingham@kernel.org>
Cc: Jan Kiszka <jan.kiszka@siemens.com>
Cc: Jackie Liu <liuyun01@kylinos.cn>
Cc: Jason Wessel <jason.wessel@windriver.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Stephen Boyd 2019-05-14 15:45:59 -07:00 committed by Linus Torvalds
parent 449ca0c95e
commit 442284a89a
3 changed files with 233 additions and 0 deletions

View File

@ -13,8 +13,10 @@
*/ */
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/hrtimer.h>
#include <linux/mount.h> #include <linux/mount.h>
#include <linux/of_fdt.h> #include <linux/of_fdt.h>
#include <linux/threads.h>
/* We need to stringify expanded macros so that they can be parsed */ /* We need to stringify expanded macros so that they can be parsed */
@ -44,6 +46,9 @@ LX_VALUE(SB_DIRSYNC)
LX_VALUE(SB_NOATIME) LX_VALUE(SB_NOATIME)
LX_VALUE(SB_NODIRATIME) LX_VALUE(SB_NODIRATIME)
/* linux/htimer.h */
LX_GDBPARSED(hrtimer_resolution)
/* linux/mount.h */ /* linux/mount.h */
LX_VALUE(MNT_NOSUID) LX_VALUE(MNT_NOSUID)
LX_VALUE(MNT_NODEV) LX_VALUE(MNT_NODEV)
@ -52,8 +57,16 @@ LX_VALUE(MNT_NOATIME)
LX_VALUE(MNT_NODIRATIME) LX_VALUE(MNT_NODIRATIME)
LX_VALUE(MNT_RELATIME) LX_VALUE(MNT_RELATIME)
/* linux/threads.h */
LX_VALUE(NR_CPUS)
/* linux/of_fdt.h> */ /* linux/of_fdt.h> */
LX_VALUE(OF_DT_HEADER) LX_VALUE(OF_DT_HEADER)
/* Kernel Configs */ /* Kernel Configs */
LX_CONFIG(CONFIG_GENERIC_CLOCKEVENTS)
LX_CONFIG(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)
LX_CONFIG(CONFIG_HIGH_RES_TIMERS)
LX_CONFIG(CONFIG_NR_CPUS)
LX_CONFIG(CONFIG_OF) LX_CONFIG(CONFIG_OF)
LX_CONFIG(CONFIG_TICK_ONESHOT)

View File

@ -0,0 +1,219 @@
# SPDX-License-Identifier: GPL-2.0
#
# Copyright 2019 Google LLC.
import binascii
import gdb
from linux import constants
from linux import cpus
from linux import rbtree
from linux import utils
timerqueue_node_type = utils.CachedType("struct timerqueue_node").get_type()
hrtimer_type = utils.CachedType("struct hrtimer").get_type()
def ktime_get():
"""Returns the current time, but not very accurately
We can't read the hardware timer itself to add any nanoseconds
that need to be added since we last stored the time in the
timekeeper. But this is probably good enough for debug purposes."""
tk_core = gdb.parse_and_eval("&tk_core")
return tk_core['timekeeper']['tkr_mono']['base']
def print_timer(rb_node, idx):
timerqueue = utils.container_of(rb_node, timerqueue_node_type.pointer(),
"node")
timer = utils.container_of(timerqueue, hrtimer_type.pointer(), "node")
function = str(timer['function']).split(" ")[1].strip("<>")
softexpires = timer['_softexpires']
expires = timer['node']['expires']
now = ktime_get()
text = " #{}: <{}>, {}, ".format(idx, timer, function)
text += "S:{:02x}\n".format(int(timer['state']))
text += " # expires at {}-{} nsecs [in {} to {} nsecs]\n".format(
softexpires, expires, softexpires - now, expires - now)
return text
def print_active_timers(base):
curr = base['active']['next']['node']
curr = curr.address.cast(rbtree.rb_node_type.get_type().pointer())
idx = 0
while curr:
yield print_timer(curr, idx)
curr = rbtree.rb_next(curr)
idx += 1
def print_base(base):
text = " .base: {}\n".format(base.address)
text += " .index: {}\n".format(base['index'])
text += " .resolution: {} nsecs\n".format(constants.LX_hrtimer_resolution)
text += " .get_time: {}\n".format(base['get_time'])
if constants.LX_CONFIG_HIGH_RES_TIMERS:
text += " .offset: {} nsecs\n".format(base['offset'])
text += "active timers:\n"
text += "".join([x for x in print_active_timers(base)])
return text
def print_cpu(hrtimer_bases, cpu, max_clock_bases):
cpu_base = cpus.per_cpu(hrtimer_bases, cpu)
jiffies = gdb.parse_and_eval("jiffies_64")
tick_sched_ptr = gdb.parse_and_eval("&tick_cpu_sched")
ts = cpus.per_cpu(tick_sched_ptr, cpu)
text = "cpu: {}\n".format(cpu)
for i in xrange(max_clock_bases):
text += " clock {}:\n".format(i)
text += print_base(cpu_base['clock_base'][i])
if constants.LX_CONFIG_HIGH_RES_TIMERS:
fmts = [(" .{} : {} nsecs", 'expires_next'),
(" .{} : {}", 'hres_active'),
(" .{} : {}", 'nr_events'),
(" .{} : {}", 'nr_retries'),
(" .{} : {}", 'nr_hangs'),
(" .{} : {}", 'max_hang_time')]
text += "\n".join([s.format(f, cpu_base[f]) for s, f in fmts])
text += "\n"
if constants.LX_CONFIG_TICK_ONESHOT:
fmts = [(" .{} : {}", 'nohz_mode'),
(" .{} : {} nsecs", 'last_tick'),
(" .{} : {}", 'tick_stopped'),
(" .{} : {}", 'idle_jiffies'),
(" .{} : {}", 'idle_calls'),
(" .{} : {}", 'idle_sleeps'),
(" .{} : {} nsecs", 'idle_entrytime'),
(" .{} : {} nsecs", 'idle_waketime'),
(" .{} : {} nsecs", 'idle_exittime'),
(" .{} : {} nsecs", 'idle_sleeptime'),
(" .{}: {} nsecs", 'iowait_sleeptime'),
(" .{} : {}", 'last_jiffies'),
(" .{} : {}", 'next_timer'),
(" .{} : {} nsecs", 'idle_expires')]
text += "\n".join([s.format(f, ts[f]) for s, f in fmts])
text += "\njiffies: {}\n".format(jiffies)
text += "\n"
return text
def print_tickdevice(td, cpu):
dev = td['evtdev']
text = "Tick Device: mode: {}\n".format(td['mode'])
if cpu < 0:
text += "Broadcast device\n"
else:
text += "Per CPU device: {}\n".format(cpu)
text += "Clock Event Device: "
if dev == 0:
text += "<NULL>\n"
return text
text += "{}\n".format(dev['name'])
text += " max_delta_ns: {}\n".format(dev['max_delta_ns'])
text += " min_delta_ns: {}\n".format(dev['min_delta_ns'])
text += " mult: {}\n".format(dev['mult'])
text += " shift: {}\n".format(dev['shift'])
text += " mode: {}\n".format(dev['state_use_accessors'])
text += " next_event: {} nsecs\n".format(dev['next_event'])
text += " set_next_event: {}\n".format(dev['set_next_event'])
members = [('set_state_shutdown', " shutdown: {}\n"),
('set_state_periodic', " periodic: {}\n"),
('set_state_oneshot', " oneshot: {}\n"),
('set_state_oneshot_stopped', " oneshot stopped: {}\n"),
('tick_resume', " resume: {}\n")]
for member, fmt in members:
if dev[member]:
text += fmt.format(dev[member])
text += " event_handler: {}\n".format(dev['event_handler'])
text += " retries: {}\n".format(dev['retries'])
return text
def pr_cpumask(mask):
nr_cpu_ids = 1
if constants.LX_NR_CPUS > 1:
nr_cpu_ids = gdb.parse_and_eval("nr_cpu_ids")
inf = gdb.inferiors()[0]
bits = mask['bits']
num_bytes = (nr_cpu_ids + 7) / 8
buf = utils.read_memoryview(inf, bits, num_bytes).tobytes()
buf = binascii.b2a_hex(buf)
chunks = []
i = num_bytes
while i > 0:
i -= 1
start = i * 2
end = start + 2
chunks.append(buf[start:end])
if i != 0 and i % 4 == 0:
chunks.append(',')
extra = nr_cpu_ids % 8
if 0 < extra <= 4:
chunks[0] = chunks[0][0] # Cut off the first 0
return "".join(chunks)
class LxTimerList(gdb.Command):
"""Print /proc/timer_list"""
def __init__(self):
super(LxTimerList, self).__init__("lx-timerlist", gdb.COMMAND_DATA)
def invoke(self, arg, from_tty):
hrtimer_bases = gdb.parse_and_eval("&hrtimer_bases")
max_clock_bases = gdb.parse_and_eval("HRTIMER_MAX_CLOCK_BASES")
text = "Timer List Version: gdb scripts\n"
text += "HRTIMER_MAX_CLOCK_BASES: {}\n".format(max_clock_bases)
text += "now at {} nsecs\n".format(ktime_get())
for cpu in cpus.each_online_cpu():
text += print_cpu(hrtimer_bases, cpu, max_clock_bases)
if constants.LX_CONFIG_GENERIC_CLOCKEVENTS:
if constants.LX_CONFIG_GENERIC_CLOCKEVENTS_BROADCAST:
bc_dev = gdb.parse_and_eval("&tick_broadcast_device")
text += print_tickdevice(bc_dev, -1)
text += "\n"
mask = gdb.parse_and_eval("tick_broadcast_mask")
mask = pr_cpumask(mask)
text += "tick_broadcast_mask: {}\n".format(mask)
if constants.LX_CONFIG_TICK_ONESHOT:
mask = gdb.parse_and_eval("tick_broadcast_oneshot_mask")
mask = pr_cpumask(mask)
text += "tick_broadcast_oneshot_mask: {}\n".format(mask)
text += "\n"
tick_cpu_devices = gdb.parse_and_eval("&tick_cpu_device")
for cpu in cpus.each_online_cpu():
tick_dev = cpus.per_cpu(tick_cpu_devices, cpu)
text += print_tickdevice(tick_dev, cpu)
text += "\n"
gdb.write(text)
LxTimerList()

View File

@ -33,3 +33,4 @@ else:
import linux.rbtree import linux.rbtree
import linux.proc import linux.proc
import linux.constants import linux.constants
import linux.timerlist