1 # SPDX-License-Identifier: GPL-2.0 1 # SPDX-License-Identifier: GPL-2.0
2 # 2 #
3 # gdb helper commands and functions for Linux 3 # gdb helper commands and functions for Linux kernel debugging
4 # 4 #
5 # Kernel proc information reader 5 # Kernel proc information reader
6 # 6 #
7 # Copyright (c) 2016 Linaro Ltd 7 # Copyright (c) 2016 Linaro Ltd
8 # 8 #
9 # Authors: 9 # Authors:
10 # Kieran Bingham <kieran.bingham@linaro.org> 10 # Kieran Bingham <kieran.bingham@linaro.org>
11 # 11 #
12 # This work is licensed under the terms of the 12 # This work is licensed under the terms of the GNU GPL version 2.
13 # 13 #
14 14
15 import gdb 15 import gdb
16 from linux import constants 16 from linux import constants
17 from linux import utils 17 from linux import utils
18 from linux import tasks 18 from linux import tasks
19 from linux import lists 19 from linux import lists
20 from linux import vfs 20 from linux import vfs
21 from linux import rbtree <<
22 from struct import * 21 from struct import *
23 22
24 23
25 class LxCmdLine(gdb.Command): 24 class LxCmdLine(gdb.Command):
26 """ Report the Linux Commandline used in t 25 """ Report the Linux Commandline used in the current kernel.
27 Equivalent to cat /proc/cmdline on a r 26 Equivalent to cat /proc/cmdline on a running target"""
28 27
29 def __init__(self): 28 def __init__(self):
30 super(LxCmdLine, self).__init__("lx-cm 29 super(LxCmdLine, self).__init__("lx-cmdline", gdb.COMMAND_DATA)
31 30
32 def invoke(self, arg, from_tty): 31 def invoke(self, arg, from_tty):
33 gdb.write(gdb.parse_and_eval("saved_co 32 gdb.write(gdb.parse_and_eval("saved_command_line").string() + "\n")
34 33
35 34
36 LxCmdLine() 35 LxCmdLine()
37 36
38 37
39 class LxVersion(gdb.Command): 38 class LxVersion(gdb.Command):
40 """ Report the Linux Version of the curren 39 """ Report the Linux Version of the current kernel.
41 Equivalent to cat /proc/version on a r 40 Equivalent to cat /proc/version on a running target"""
42 41
43 def __init__(self): 42 def __init__(self):
44 super(LxVersion, self).__init__("lx-ve 43 super(LxVersion, self).__init__("lx-version", gdb.COMMAND_DATA)
45 44
46 def invoke(self, arg, from_tty): 45 def invoke(self, arg, from_tty):
47 # linux_banner should contain a newlin 46 # linux_banner should contain a newline
48 gdb.write(gdb.parse_and_eval("(char *) 47 gdb.write(gdb.parse_and_eval("(char *)linux_banner").string())
49 48
50 49
51 LxVersion() 50 LxVersion()
52 51
53 52
54 # Resource Structure Printers 53 # Resource Structure Printers
55 # /proc/iomem 54 # /proc/iomem
56 # /proc/ioports 55 # /proc/ioports
57 56
58 def get_resources(resource, depth): 57 def get_resources(resource, depth):
59 while resource: 58 while resource:
60 yield resource, depth 59 yield resource, depth
61 60
62 child = resource['child'] 61 child = resource['child']
63 if child: 62 if child:
64 for res, deep in get_resources(chi 63 for res, deep in get_resources(child, depth + 1):
65 yield res, deep 64 yield res, deep
66 65
67 resource = resource['sibling'] 66 resource = resource['sibling']
68 67
69 68
70 def show_lx_resources(resource_str): 69 def show_lx_resources(resource_str):
71 resource = gdb.parse_and_eval(resource 70 resource = gdb.parse_and_eval(resource_str)
72 width = 4 if resource['end'] < 0x10000 71 width = 4 if resource['end'] < 0x10000 else 8
73 # Iterate straight to the first child 72 # Iterate straight to the first child
74 for res, depth in get_resources(resour 73 for res, depth in get_resources(resource['child'], 0):
75 start = int(res['start']) 74 start = int(res['start'])
76 end = int(res['end']) 75 end = int(res['end'])
77 gdb.write(" " * depth * 2 + 76 gdb.write(" " * depth * 2 +
78 "{0:0{1}x}-".format(star 77 "{0:0{1}x}-".format(start, width) +
79 "{0:0{1}x} : ".format(en 78 "{0:0{1}x} : ".format(end, width) +
80 res['name'].string() + " 79 res['name'].string() + "\n")
81 80
82 81
83 class LxIOMem(gdb.Command): 82 class LxIOMem(gdb.Command):
84 """Identify the IO memory resource locatio 83 """Identify the IO memory resource locations defined by the kernel
85 84
86 Equivalent to cat /proc/iomem on a running tar 85 Equivalent to cat /proc/iomem on a running target"""
87 86
88 def __init__(self): 87 def __init__(self):
89 super(LxIOMem, self).__init__("lx-iome 88 super(LxIOMem, self).__init__("lx-iomem", gdb.COMMAND_DATA)
90 89
91 def invoke(self, arg, from_tty): 90 def invoke(self, arg, from_tty):
92 return show_lx_resources("iomem_resour 91 return show_lx_resources("iomem_resource")
93 92
94 93
95 LxIOMem() 94 LxIOMem()
96 95
97 96
98 class LxIOPorts(gdb.Command): 97 class LxIOPorts(gdb.Command):
99 """Identify the IO port resource locations 98 """Identify the IO port resource locations defined by the kernel
100 99
101 Equivalent to cat /proc/ioports on a running t 100 Equivalent to cat /proc/ioports on a running target"""
102 101
103 def __init__(self): 102 def __init__(self):
104 super(LxIOPorts, self).__init__("lx-io 103 super(LxIOPorts, self).__init__("lx-ioports", gdb.COMMAND_DATA)
105 104
106 def invoke(self, arg, from_tty): 105 def invoke(self, arg, from_tty):
107 return show_lx_resources("ioport_resou 106 return show_lx_resources("ioport_resource")
108 107
109 108
110 LxIOPorts() 109 LxIOPorts()
111 110
112 111
113 # Mount namespace viewer 112 # Mount namespace viewer
114 # /proc/mounts 113 # /proc/mounts
115 114
116 def info_opts(lst, opt): 115 def info_opts(lst, opt):
117 opts = "" 116 opts = ""
118 for key, string in lst.items(): 117 for key, string in lst.items():
119 if opt & key: 118 if opt & key:
120 opts += string 119 opts += string
121 return opts 120 return opts
122 121
123 122
124 FS_INFO = {constants.LX_SB_SYNCHRONOUS: ",sync 123 FS_INFO = {constants.LX_SB_SYNCHRONOUS: ",sync",
125 constants.LX_SB_MANDLOCK: ",mand", 124 constants.LX_SB_MANDLOCK: ",mand",
126 constants.LX_SB_DIRSYNC: ",dirsync" 125 constants.LX_SB_DIRSYNC: ",dirsync",
127 constants.LX_SB_NOATIME: ",noatime" 126 constants.LX_SB_NOATIME: ",noatime",
128 constants.LX_SB_NODIRATIME: ",nodir 127 constants.LX_SB_NODIRATIME: ",nodiratime"}
129 128
130 MNT_INFO = {constants.LX_MNT_NOSUID: ",nosuid" 129 MNT_INFO = {constants.LX_MNT_NOSUID: ",nosuid",
131 constants.LX_MNT_NODEV: ",nodev", 130 constants.LX_MNT_NODEV: ",nodev",
132 constants.LX_MNT_NOEXEC: ",noexec" 131 constants.LX_MNT_NOEXEC: ",noexec",
133 constants.LX_MNT_NOATIME: ",noatim 132 constants.LX_MNT_NOATIME: ",noatime",
134 constants.LX_MNT_NODIRATIME: ",nod 133 constants.LX_MNT_NODIRATIME: ",nodiratime",
135 constants.LX_MNT_RELATIME: ",relat 134 constants.LX_MNT_RELATIME: ",relatime"}
136 135
137 mount_type = utils.CachedType("struct mount") 136 mount_type = utils.CachedType("struct mount")
138 mount_ptr_type = mount_type.get_type().pointer 137 mount_ptr_type = mount_type.get_type().pointer()
139 138
140 139
141 class LxMounts(gdb.Command): 140 class LxMounts(gdb.Command):
142 """Report the VFS mounts of the current pr 141 """Report the VFS mounts of the current process namespace.
143 142
144 Equivalent to cat /proc/mounts on a running ta 143 Equivalent to cat /proc/mounts on a running target
145 An integer value can be supplied to display th 144 An integer value can be supplied to display the mount
146 values of that process namespace""" 145 values of that process namespace"""
147 146
148 def __init__(self): 147 def __init__(self):
149 super(LxMounts, self).__init__("lx-mou 148 super(LxMounts, self).__init__("lx-mounts", gdb.COMMAND_DATA)
150 149
151 # Equivalent to proc_namespace.c:show_vfsm 150 # Equivalent to proc_namespace.c:show_vfsmnt
152 # However, that has the ability to call in 151 # However, that has the ability to call into s_op functions
153 # whereas we cannot and must make do with 152 # whereas we cannot and must make do with the information we can obtain.
154 def invoke(self, arg, from_tty): 153 def invoke(self, arg, from_tty):
155 argv = gdb.string_to_argv(arg) 154 argv = gdb.string_to_argv(arg)
156 if len(argv) >= 1: 155 if len(argv) >= 1:
157 try: 156 try:
158 pid = int(argv[0]) 157 pid = int(argv[0])
159 except gdb.error: 158 except gdb.error:
160 raise gdb.GdbError("Provide a 159 raise gdb.GdbError("Provide a PID as integer value")
161 else: 160 else:
162 pid = 1 161 pid = 1
163 162
164 task = tasks.get_task_by_pid(pid) 163 task = tasks.get_task_by_pid(pid)
165 if not task: 164 if not task:
166 raise gdb.GdbError("Couldn't find 165 raise gdb.GdbError("Couldn't find a process with PID {}"
167 .format(pid)) 166 .format(pid))
168 167
169 namespace = task['nsproxy']['mnt_ns'] 168 namespace = task['nsproxy']['mnt_ns']
170 if not namespace: 169 if not namespace:
171 raise gdb.GdbError("No namespace f 170 raise gdb.GdbError("No namespace for current process")
172 171
173 gdb.write("{:^18} {:^15} {:>9} {} {} o 172 gdb.write("{:^18} {:^15} {:>9} {} {} options\n".format(
174 "mount", "super_block", "dev 173 "mount", "super_block", "devname", "pathname", "fstype"))
175 174
176 for mnt in rbtree.rb_inorder_for_each_ !! 175 for mnt in lists.list_for_each_entry(namespace['list'],
>> 176 mount_ptr_type, "mnt_list"):
177 devname = mnt['mnt_devname'].strin 177 devname = mnt['mnt_devname'].string()
178 devname = devname if devname else 178 devname = devname if devname else "none"
179 179
180 pathname = "" 180 pathname = ""
181 parent = mnt 181 parent = mnt
182 while True: 182 while True:
183 mntpoint = parent['mnt_mountpo 183 mntpoint = parent['mnt_mountpoint']
184 pathname = vfs.dentry_name(mnt 184 pathname = vfs.dentry_name(mntpoint) + pathname
185 if (parent == parent['mnt_pare 185 if (parent == parent['mnt_parent']):
186 break 186 break
187 parent = parent['mnt_parent'] 187 parent = parent['mnt_parent']
188 188
189 if (pathname == ""): 189 if (pathname == ""):
190 pathname = "/" 190 pathname = "/"
191 191
192 superblock = mnt['mnt']['mnt_sb'] 192 superblock = mnt['mnt']['mnt_sb']
193 fstype = superblock['s_type']['nam 193 fstype = superblock['s_type']['name'].string()
194 s_flags = int(superblock['s_flags' 194 s_flags = int(superblock['s_flags'])
195 m_flags = int(mnt['mnt']['mnt_flag 195 m_flags = int(mnt['mnt']['mnt_flags'])
196 rd = "ro" if (s_flags & constants. 196 rd = "ro" if (s_flags & constants.LX_SB_RDONLY) else "rw"
197 197
198 gdb.write("{} {} {} {} {} {}{}{} 0 198 gdb.write("{} {} {} {} {} {}{}{} 0 0\n".format(
199 mnt.format_string(), sup 199 mnt.format_string(), superblock.format_string(), devname,
200 pathname, fstype, rd, in 200 pathname, fstype, rd, info_opts(FS_INFO, s_flags),
201 info_opts(MNT_INFO, m_fl 201 info_opts(MNT_INFO, m_flags)))
202 202
203 203
204 LxMounts() 204 LxMounts()
205 205
206 206
207 class LxFdtDump(gdb.Command): 207 class LxFdtDump(gdb.Command):
208 """Output Flattened Device Tree header and 208 """Output Flattened Device Tree header and dump FDT blob to the filename
209 specified as the command argument. Equi 209 specified as the command argument. Equivalent to
210 'cat /proc/fdt > fdtdump.dtb' on a runn 210 'cat /proc/fdt > fdtdump.dtb' on a running target"""
211 211
212 def __init__(self): 212 def __init__(self):
213 super(LxFdtDump, self).__init__("lx-fd 213 super(LxFdtDump, self).__init__("lx-fdtdump", gdb.COMMAND_DATA,
214 gdb.CO 214 gdb.COMPLETE_FILENAME)
215 215
216 def fdthdr_to_cpu(self, fdt_header): 216 def fdthdr_to_cpu(self, fdt_header):
217 217
218 fdt_header_be = ">IIIIIII" 218 fdt_header_be = ">IIIIIII"
219 fdt_header_le = "<IIIIIII" 219 fdt_header_le = "<IIIIIII"
220 220
221 if utils.get_target_endianness() == 1: 221 if utils.get_target_endianness() == 1:
222 output_fmt = fdt_header_le 222 output_fmt = fdt_header_le
223 else: 223 else:
224 output_fmt = fdt_header_be 224 output_fmt = fdt_header_be
225 225
226 return unpack(output_fmt, pack(fdt_hea 226 return unpack(output_fmt, pack(fdt_header_be,
227 fdt_hea 227 fdt_header['magic'],
228 fdt_hea 228 fdt_header['totalsize'],
229 fdt_hea 229 fdt_header['off_dt_struct'],
230 fdt_hea 230 fdt_header['off_dt_strings'],
231 fdt_hea 231 fdt_header['off_mem_rsvmap'],
232 fdt_hea 232 fdt_header['version'],
233 fdt_hea 233 fdt_header['last_comp_version']))
234 234
235 def invoke(self, arg, from_tty): 235 def invoke(self, arg, from_tty):
236 236
237 if not constants.LX_CONFIG_OF: 237 if not constants.LX_CONFIG_OF:
238 raise gdb.GdbError("Kernel not com 238 raise gdb.GdbError("Kernel not compiled with CONFIG_OF\n")
239 239
240 if len(arg) == 0: 240 if len(arg) == 0:
241 filename = "fdtdump.dtb" 241 filename = "fdtdump.dtb"
242 else: 242 else:
243 filename = arg 243 filename = arg
244 244
245 py_fdt_header_ptr = gdb.parse_and_eval 245 py_fdt_header_ptr = gdb.parse_and_eval(
246 "(const struct fdt_header *) initi 246 "(const struct fdt_header *) initial_boot_params")
247 py_fdt_header = py_fdt_header_ptr.dere 247 py_fdt_header = py_fdt_header_ptr.dereference()
248 248
249 fdt_header = self.fdthdr_to_cpu(py_fdt 249 fdt_header = self.fdthdr_to_cpu(py_fdt_header)
250 250
251 if fdt_header[0] != constants.LX_OF_DT 251 if fdt_header[0] != constants.LX_OF_DT_HEADER:
252 raise gdb.GdbError("No flattened d 252 raise gdb.GdbError("No flattened device tree magic found\n")
253 253
254 gdb.write("fdt_magic: 0x{:02X} 254 gdb.write("fdt_magic: 0x{:02X}\n".format(fdt_header[0]))
255 gdb.write("fdt_totalsize: 0x{:02X} 255 gdb.write("fdt_totalsize: 0x{:02X}\n".format(fdt_header[1]))
256 gdb.write("off_dt_struct: 0x{:02X} 256 gdb.write("off_dt_struct: 0x{:02X}\n".format(fdt_header[2]))
257 gdb.write("off_dt_strings: 0x{:02X} 257 gdb.write("off_dt_strings: 0x{:02X}\n".format(fdt_header[3]))
258 gdb.write("off_mem_rsvmap: 0x{:02X} 258 gdb.write("off_mem_rsvmap: 0x{:02X}\n".format(fdt_header[4]))
259 gdb.write("version: {}\n".fo 259 gdb.write("version: {}\n".format(fdt_header[5]))
260 gdb.write("last_comp_version: {}\n".fo 260 gdb.write("last_comp_version: {}\n".format(fdt_header[6]))
261 261
262 inf = gdb.inferiors()[0] 262 inf = gdb.inferiors()[0]
263 fdt_buf = utils.read_memoryview(inf, p 263 fdt_buf = utils.read_memoryview(inf, py_fdt_header_ptr,
264 fdt_he 264 fdt_header[1]).tobytes()
265 265
266 try: 266 try:
267 f = open(filename, 'wb') 267 f = open(filename, 'wb')
268 except gdb.error: 268 except gdb.error:
269 raise gdb.GdbError("Could not open 269 raise gdb.GdbError("Could not open file to dump fdt")
270 270
271 f.write(fdt_buf) 271 f.write(fdt_buf)
272 f.close() 272 f.close()
273 273
274 gdb.write("Dumped fdt blob to " + file 274 gdb.write("Dumped fdt blob to " + filename + "\n")
275 275
276 276
277 LxFdtDump() 277 LxFdtDump()
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.