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