1 #
2 # gdb helper commands and functions for Linux kernel debugging
3 #
4 # common utilities
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
14 import gdb
15
16
17 class CachedType:
18 def __init__(self, name):
19 self._type = None
20 self._name = name
21
22 def _new_objfile_handler(self, event):
23 self._type = None
24 gdb.events.new_objfile.disconnect(self._new_objfile_handler)
25
26 def get_type(self):
27 if self._type is None:
28 self._type = gdb.lookup_type(self._name)
29 if self._type is None:
30 raise gdb.GdbError(
31 "cannot resolve type '{0}'".format(self._name))
32 if hasattr(gdb, 'events') and hasattr(gdb.events, 'new_objfile'):
33 gdb.events.new_objfile.connect(self._new_objfile_handler)
34 return self._type
35
36
37 long_type = CachedType("long")
38 ulong_type = CachedType("unsigned long")
39 uint_type = CachedType("unsigned int")
40 atomic_long_type = CachedType("atomic_long_t")
41 size_t_type = CachedType("size_t")
42 struct_page_type = CachedType("struct page")
43
44 def get_uint_type():
45 global uint_type
46 return uint_type.get_type()
47
48 def get_page_type():
49 global struct_page_type
50 return struct_page_type.get_type()
51
52 def get_long_type():
53 global long_type
54 return long_type.get_type()
55
56 def get_ulong_type():
57 global ulong_type
58 return ulong_type.get_type()
59
60 def get_size_t_type():
61 global size_t_type
62 return size_t_type.get_type()
63
64 def offset_of(typeobj, field):
65 element = gdb.Value(0).cast(typeobj)
66 return int(str(element[field].address).split()[0], 16)
67
68
69 def container_of(ptr, typeobj, member):
70 return (ptr.cast(get_long_type()) -
71 offset_of(typeobj, member)).cast(typeobj)
72
73
74 class ContainerOf(gdb.Function):
75 """Return pointer to containing data structure.
76
77 $container_of(PTR, "TYPE", "ELEMENT"): Given PTR, return a pointer to the
78 data structure of the type TYPE in which PTR is the address of ELEMENT.
79 Note that TYPE and ELEMENT have to be quoted as strings."""
80
81 def __init__(self):
82 super(ContainerOf, self).__init__("container_of")
83
84 def invoke(self, ptr, typename, elementname):
85 return container_of(ptr, gdb.lookup_type(typename.string()).pointer(),
86 elementname.string())
87
88
89 ContainerOf()
90
91
92 BIG_ENDIAN = 0
93 LITTLE_ENDIAN = 1
94 target_endianness = None
95
96
97 def get_target_endianness():
98 global target_endianness
99 if target_endianness is None:
100 endian = gdb.execute("show endian", to_string=True)
101 if "little endian" in endian:
102 target_endianness = LITTLE_ENDIAN
103 elif "big endian" in endian:
104 target_endianness = BIG_ENDIAN
105 else:
106 raise gdb.GdbError("unknown endianness '{0}'".format(str(endian)))
107 return target_endianness
108
109
110 def read_memoryview(inf, start, length):
111 m = inf.read_memory(start, length)
112 if type(m) is memoryview:
113 return m
114 return memoryview(m)
115
116
117 def read_u16(buffer, offset):
118 buffer_val = buffer[offset:offset + 2]
119 value = [0, 0]
120
121 if type(buffer_val[0]) is str:
122 value[0] = ord(buffer_val[0])
123 value[1] = ord(buffer_val[1])
124 else:
125 value[0] = buffer_val[0]
126 value[1] = buffer_val[1]
127
128 if get_target_endianness() == LITTLE_ENDIAN:
129 return value[0] + (value[1] << 8)
130 else:
131 return value[1] + (value[0] << 8)
132
133
134 def read_u32(buffer, offset):
135 if get_target_endianness() == LITTLE_ENDIAN:
136 return read_u16(buffer, offset) + (read_u16(buffer, offset + 2) << 16)
137 else:
138 return read_u16(buffer, offset + 2) + (read_u16(buffer, offset) << 16)
139
140
141 def read_u64(buffer, offset):
142 if get_target_endianness() == LITTLE_ENDIAN:
143 return read_u32(buffer, offset) + (read_u32(buffer, offset + 4) << 32)
144 else:
145 return read_u32(buffer, offset + 4) + (read_u32(buffer, offset) << 32)
146
147
148 def read_ulong(buffer, offset):
149 if get_long_type().sizeof == 8:
150 return read_u64(buffer, offset)
151 else:
152 return read_u32(buffer, offset)
153
154 atomic_long_counter_offset = atomic_long_type.get_type()['counter'].bitpos
155 atomic_long_counter_sizeof = atomic_long_type.get_type()['counter'].type.sizeof
156
157 def read_atomic_long(buffer, offset):
158 global atomic_long_counter_offset
159 global atomic_long_counter_sizeof
160
161 if atomic_long_counter_sizeof == 8:
162 return read_u64(buffer, offset + atomic_long_counter_offset)
163 else:
164 return read_u32(buffer, offset + atomic_long_counter_offset)
165
166 target_arch = None
167
168
169 def is_target_arch(arch):
170 if hasattr(gdb.Frame, 'architecture'):
171 return arch in gdb.newest_frame().architecture().name()
172 else:
173 global target_arch
174 if target_arch is None:
175 target_arch = gdb.execute("show architecture", to_string=True)
176 return arch in target_arch
177
178
179 GDBSERVER_QEMU = 0
180 GDBSERVER_KGDB = 1
181 gdbserver_type = None
182
183
184 def get_gdbserver_type():
185 def exit_handler(event):
186 global gdbserver_type
187 gdbserver_type = None
188 gdb.events.exited.disconnect(exit_handler)
189
190 def probe_qemu():
191 try:
192 return gdb.execute("monitor info version", to_string=True) != ""
193 except gdb.error:
194 return False
195
196 def probe_kgdb():
197 try:
198 thread_info = gdb.execute("info thread 2", to_string=True)
199 return "shadowCPU" in thread_info
200 except gdb.error:
201 return False
202
203 global gdbserver_type
204 if gdbserver_type is None:
205 if probe_qemu():
206 gdbserver_type = GDBSERVER_QEMU
207 elif probe_kgdb():
208 gdbserver_type = GDBSERVER_KGDB
209 if gdbserver_type is not None and hasattr(gdb, 'events'):
210 gdb.events.exited.connect(exit_handler)
211 return gdbserver_type
212
213
214 def gdb_eval_or_none(expresssion):
215 try:
216 return gdb.parse_and_eval(expresssion)
217 except gdb.error:
218 return None
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.