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