1#
2# gdb helper commands and functions for Linux kernel debugging
3#
4#  per-cpu tools
5#
6# Copyright (c) Siemens AG, 2011-2013
7#
8# Authors:
9#  Jan Kiszka <jan.kiszka@siemens.com>
10#
11# This work is licensed under the terms of the GNU GPL version 2.
12#
13
14import gdb
15
16from linux import tasks, utils
17
18
19task_type = utils.CachedType("struct task_struct")
20
21
22MAX_CPUS = 4096
23
24
25def get_current_cpu():
26    if utils.get_gdbserver_type() == utils.GDBSERVER_QEMU:
27        return gdb.selected_thread().num - 1
28    elif utils.get_gdbserver_type() == utils.GDBSERVER_KGDB:
29        return gdb.parse_and_eval("kgdb_active.counter")
30    else:
31        raise gdb.GdbError("Sorry, obtaining the current CPU is not yet "
32                           "supported with this gdb server.")
33
34
35def per_cpu(var_ptr, cpu):
36    if cpu == -1:
37        cpu = get_current_cpu()
38    if utils.is_target_arch("sparc:v9"):
39        offset = gdb.parse_and_eval(
40            "trap_block[{0}].__per_cpu_base".format(str(cpu)))
41    else:
42        try:
43            offset = gdb.parse_and_eval(
44                "__per_cpu_offset[{0}]".format(str(cpu)))
45        except gdb.error:
46            # !CONFIG_SMP case
47            offset = 0
48    pointer = var_ptr.cast(utils.get_long_type()) + offset
49    return pointer.cast(var_ptr.type)
50
51
52cpu_mask = {}
53
54
55def cpu_mask_invalidate(event):
56    global cpu_mask
57    cpu_mask = {}
58    gdb.events.stop.disconnect(cpu_mask_invalidate)
59    if hasattr(gdb.events, 'new_objfile'):
60        gdb.events.new_objfile.disconnect(cpu_mask_invalidate)
61
62
63def cpu_list(mask_name):
64    global cpu_mask
65    mask = None
66    if mask_name in cpu_mask:
67        mask = cpu_mask[mask_name]
68    if mask is None:
69        mask = gdb.parse_and_eval(mask_name + ".bits")
70        if hasattr(gdb, 'events'):
71            cpu_mask[mask_name] = mask
72            gdb.events.stop.connect(cpu_mask_invalidate)
73            if hasattr(gdb.events, 'new_objfile'):
74                gdb.events.new_objfile.connect(cpu_mask_invalidate)
75    bits_per_entry = mask[0].type.sizeof * 8
76    num_entries = mask.type.sizeof * 8 / bits_per_entry
77    entry = -1
78    bits = 0
79
80    while True:
81        while bits == 0:
82            entry += 1
83            if entry == num_entries:
84                return
85            bits = mask[entry]
86            if bits != 0:
87                bit = 0
88                break
89
90        while bits & 1 == 0:
91            bits >>= 1
92            bit += 1
93
94        cpu = entry * bits_per_entry + bit
95
96        bits >>= 1
97        bit += 1
98
99        yield int(cpu)
100
101
102def each_online_cpu():
103    for cpu in cpu_list("__cpu_online_mask"):
104        yield cpu
105
106
107def each_present_cpu():
108    for cpu in cpu_list("__cpu_present_mask"):
109        yield cpu
110
111
112def each_possible_cpu():
113    for cpu in cpu_list("__cpu_possible_mask"):
114        yield cpu
115
116
117def each_active_cpu():
118    for cpu in cpu_list("__cpu_active_mask"):
119        yield cpu
120
121
122class LxCpus(gdb.Command):
123    """List CPU status arrays
124
125Displays the known state of each CPU based on the kernel masks
126and can help identify the state of hotplugged CPUs"""
127
128    def __init__(self):
129        super(LxCpus, self).__init__("lx-cpus", gdb.COMMAND_DATA)
130
131    def invoke(self, arg, from_tty):
132        gdb.write("Possible CPUs : {}\n".format(list(each_possible_cpu())))
133        gdb.write("Present CPUs  : {}\n".format(list(each_present_cpu())))
134        gdb.write("Online CPUs   : {}\n".format(list(each_online_cpu())))
135        gdb.write("Active CPUs   : {}\n".format(list(each_active_cpu())))
136
137
138LxCpus()
139
140
141class PerCpu(gdb.Function):
142    """Return per-cpu variable.
143
144$lx_per_cpu("VAR"[, CPU]): Return the per-cpu variable called VAR for the
145given CPU number. If CPU is omitted, the CPU of the current context is used.
146Note that VAR has to be quoted as string."""
147
148    def __init__(self):
149        super(PerCpu, self).__init__("lx_per_cpu")
150
151    def invoke(self, var, cpu=-1):
152        return per_cpu(var.address, cpu).dereference()
153
154
155PerCpu()
156
157
158class PerCpuPtr(gdb.Function):
159    """Return per-cpu pointer.
160
161$lx_per_cpu_ptr("VAR"[, CPU]): Return the per-cpu pointer called VAR for the
162given CPU number. If CPU is omitted, the CPU of the current context is used.
163Note that VAR has to be quoted as string."""
164
165    def __init__(self):
166        super(PerCpuPtr, self).__init__("lx_per_cpu_ptr")
167
168    def invoke(self, var, cpu=-1):
169        return per_cpu(var, cpu)
170
171
172PerCpuPtr()
173
174
175def get_current_task(cpu):
176    task_ptr_type = task_type.get_type().pointer()
177
178    if utils.is_target_arch("x86"):
179        if gdb.lookup_global_symbol("cpu_tasks"):
180            # This is a UML kernel, which stores the current task
181            # differently than other x86 sub architectures
182            var_ptr = gdb.parse_and_eval("(struct task_struct *)cpu_tasks[0].task")
183            return var_ptr.dereference()
184        else:
185            var_ptr = gdb.parse_and_eval("&current_task")
186            return per_cpu(var_ptr, cpu).dereference()
187    elif utils.is_target_arch("aarch64"):
188        current_task_addr = gdb.parse_and_eval("(unsigned long)$SP_EL0")
189        if (current_task_addr >> 63) != 0:
190            current_task = current_task_addr.cast(task_ptr_type)
191            return current_task.dereference()
192        else:
193            raise gdb.GdbError("Sorry, obtaining the current task is not allowed "
194                               "while running in userspace(EL0)")
195    elif utils.is_target_arch("riscv"):
196        current_tp = gdb.parse_and_eval("$tp")
197        scratch_reg = gdb.parse_and_eval("$sscratch")
198
199        # by default tp points to current task
200        current_task = current_tp.cast(task_ptr_type)
201
202        # scratch register is set 0 in trap handler after entering kernel.
203        # When hart is in user mode, scratch register is pointing to task_struct.
204        # and tp is used by user mode. So when scratch register holds larger value
205        # (negative address as ulong is larger value) than tp, then use scratch register.
206        if (scratch_reg.cast(utils.get_ulong_type()) > current_tp.cast(utils.get_ulong_type())):
207            current_task = scratch_reg.cast(task_ptr_type)
208
209        return current_task.dereference()
210    else:
211        raise gdb.GdbError("Sorry, obtaining the current task is not yet "
212                           "supported with this arch")
213
214class LxCurrentFunc(gdb.Function):
215    """Return current task.
216
217$lx_current([CPU]): Return the per-cpu task variable for the given CPU
218number. If CPU is omitted, the CPU of the current context is used."""
219
220    def __init__(self):
221        super(LxCurrentFunc, self).__init__("lx_current")
222
223    def invoke(self, cpu=-1):
224        return get_current_task(cpu)
225
226
227LxCurrentFunc()
228