1 #
2 # gdb helper commands and functions for Linux kernel debugging
3 #
4 # list tools
5 #
6 # Copyright (c) Thiebaud Weksteen, 2015
7 #
8 # Authors:
9 # Thiebaud Weksteen <thiebaud@weksteen.fr>
10 #
11 # This work is licensed under the terms of the GNU GPL version 2.
12 #
13
14 import gdb
15
16 from linux import utils
17
18 list_head = utils.CachedType("struct list_head")
19 hlist_head = utils.CachedType("struct hlist_head")
20 hlist_node = utils.CachedType("struct hlist_node")
21
22
23 def list_for_each(head):
24 if head.type == list_head.get_type().pointer():
25 head = head.dereference()
26 elif head.type != list_head.get_type():
27 raise TypeError("Must be struct list_head not {}"
28 .format(head.type))
29
30 if head['next'] == 0:
31 gdb.write("list_for_each: Uninitialized list '{}' treated as empty\n"
32 .format(head.address))
33 return
34
35 node = head['next'].dereference()
36 while node.address != head.address:
37 yield node.address
38 node = node['next'].dereference()
39
40
41 def list_for_each_entry(head, gdbtype, member):
42 for node in list_for_each(head):
43 yield utils.container_of(node, gdbtype, member)
44
45
46 def hlist_for_each(head):
47 if head.type == hlist_head.get_type().pointer():
48 head = head.dereference()
49 elif head.type != hlist_head.get_type():
50 raise TypeError("Must be struct hlist_head not {}"
51 .format(head.type))
52
53 node = head['first'].dereference()
54 while node.address:
55 yield node.address
56 node = node['next'].dereference()
57
58
59 def hlist_for_each_entry(head, gdbtype, member):
60 for node in hlist_for_each(head):
61 yield utils.container_of(node, gdbtype, member)
62
63
64 def list_check(head):
65 nb = 0
66 if (head.type == list_head.get_type().pointer()):
67 head = head.dereference()
68 elif (head.type != list_head.get_type()):
69 raise gdb.GdbError('argument must be of type (struct list_head [*])')
70 c = head
71 try:
72 gdb.write("Starting with: {}\n".format(c))
73 except gdb.MemoryError:
74 gdb.write('head is not accessible\n')
75 return
76 while True:
77 p = c['prev'].dereference()
78 n = c['next'].dereference()
79 try:
80 if p['next'] != c.address:
81 gdb.write('prev.next != current: '
82 'current@{current_addr}={current} '
83 'prev@{p_addr}={p}\n'.format(
84 current_addr=c.address,
85 current=c,
86 p_addr=p.address,
87 p=p,
88 ))
89 return
90 except gdb.MemoryError:
91 gdb.write('prev is not accessible: '
92 'current@{current_addr}={current}\n'.format(
93 current_addr=c.address,
94 current=c
95 ))
96 return
97 try:
98 if n['prev'] != c.address:
99 gdb.write('next.prev != current: '
100 'current@{current_addr}={current} '
101 'next@{n_addr}={n}\n'.format(
102 current_addr=c.address,
103 current=c,
104 n_addr=n.address,
105 n=n,
106 ))
107 return
108 except gdb.MemoryError:
109 gdb.write('next is not accessible: '
110 'current@{current_addr}={current}\n'.format(
111 current_addr=c.address,
112 current=c
113 ))
114 return
115 c = n
116 nb += 1
117 if c == head:
118 gdb.write("list is consistent: {} node(s)\n".format(nb))
119 return
120
121
122 class LxListChk(gdb.Command):
123 """Verify a list consistency"""
124
125 def __init__(self):
126 super(LxListChk, self).__init__("lx-list-check", gdb.COMMAND_DATA,
127 gdb.COMPLETE_EXPRESSION)
128
129 def invoke(self, arg, from_tty):
130 argv = gdb.string_to_argv(arg)
131 if len(argv) != 1:
132 raise gdb.GdbError("lx-list-check takes one argument")
133 list_check(gdb.parse_and_eval(argv[0]))
134
135
136 LxListChk()
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.