Commit 442284a8 authored by Stephen Boyd's avatar Stephen Boyd Committed by Linus Torvalds
Browse files

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: default avatarStephen 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: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 449ca0c9

scripts/gdb/linux/constants.py.in

+13 −0
Original line number Diff line number Diff line
@@ -13,8 +13,10 @@ 
 */



#include <linux/fs.h>

#include <linux/hrtimer.h>

#include <linux/mount.h>

#include <linux/of_fdt.h>

#include <linux/threads.h>



/* 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_NODIRATIME)



/* linux/htimer.h */

LX_GDBPARSED(hrtimer_resolution)



/* linux/mount.h */

LX_VALUE(MNT_NOSUID)

LX_VALUE(MNT_NODEV)
@@ -52,8 +57,16 @@ LX_VALUE(MNT_NOATIME) 
LX_VALUE(MNT_NODIRATIME)

LX_VALUE(MNT_RELATIME)



/* linux/threads.h */

LX_VALUE(NR_CPUS)



/* linux/of_fdt.h> */

LX_VALUE(OF_DT_HEADER)



/* 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_TICK_ONESHOT)

scripts/gdb/linux/timerlist.py

0 → 100644
+219 −0
Original line number Diff line number Diff line 
# 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()

scripts/gdb/vmlinux-gdb.py

+1 −0
Original line number Diff line number Diff line
@@ -33,3 +33,4 @@ else: 
    import linux.rbtree

    import linux.proc

    import linux.constants

    import linux.timerlist

CRA Git | Maintained and supported by SUSTech CRA and CCSE