1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
# Copyright (C) 2021-2024 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import xml.etree.ElementTree as ET
import gdb
# Make use of gdb.RemoteTargetConnection.send_packet to fetch the
# thread list from the remote target.
#
# Sending existing serial protocol packets like this is not a good
# idea, there should be better ways to get this information using an
# official API, this is just being used as a test case.
#
# Really, the send_packet API would be used to send target
# specific packets to the target, but these are, by definition, target
# specific, so hard to test in a general testsuite.
def get_thread_list_str():
start_pos = 0
thread_desc = ""
conn = gdb.selected_inferior().connection
if not isinstance(conn, gdb.RemoteTargetConnection):
raise gdb.GdbError("connection is the wrong type")
while True:
str = conn.send_packet("qXfer:threads:read::%d,200" % start_pos).decode("ascii")
start_pos += 200
c = str[0]
str = str[1:]
thread_desc += str
if c == "l":
break
return thread_desc
# Use gdb.RemoteTargetConnection.send_packet to manually fetch the
# thread list, then extract the thread list using the gdb.Inferior and
# gdb.InferiorThread API. Compare the two results to ensure we
# managed to successfully read the thread list from the remote.
def run_send_packet_test():
# Find the IDs of all current threads.
all_threads = {}
for inf in gdb.inferiors():
for thr in inf.threads():
id = "p%x.%x" % (thr.ptid[0], thr.ptid[1])
all_threads[id] = False
# Now fetch the thread list from the remote, and parse the XML.
str = get_thread_list_str()
threads_xml = ET.fromstring(str)
# Look over all threads in the XML list and check we expected to
# find them, mark the ones we do find.
for thr in threads_xml:
id = thr.get("id")
if not id in all_threads:
raise "found unexpected thread in remote thread list"
else:
all_threads[id] = True
# Check that all the threads were found in the XML list.
for id in all_threads:
if not all_threads[id]:
raise "thread missingt from remote thread list"
# Test complete.
print("Send packet test passed")
# Convert a bytes object to a string. This follows the same rules as
# the 'maint packet' command so that the output from the two sources
# can be compared.
def bytes_to_string(byte_array):
res = ""
for b in byte_array:
b = int(b)
if b >= 32 and b <= 126:
res = res + ("%c" % b)
else:
res = res + ("\\x%02x" % b)
return res
# A very simple test for sending the packet that reads the auxv data.
# We convert the result to a string and expect to find some
# hex-encoded bytes in the output. This test will only work on
# targets that actually supply auxv data.
def run_auxv_send_packet_test(expected_result):
inf = gdb.selected_inferior()
conn = inf.connection
assert isinstance(conn, gdb.RemoteTargetConnection)
res = conn.send_packet("qXfer:auxv:read::0,1000")
assert isinstance(res, bytes)
string = bytes_to_string(res)
assert string.count("\\x") > 0
assert string == expected_result
print("auxv send packet test passed")
# Check that the value of 'global_var' is EXPECTED_VAL.
def check_global_var(expected_val):
val = int(gdb.parse_and_eval("global_var"))
val = val & 0xFFFFFFFF
if val != expected_val:
raise gdb.GdbError("global_var is 0x%x, expected 0x%x" % (val, expected_val))
# Return a bytes object representing an 'X' packet header with
# address ADDR.
def xpacket_header(addr):
return ("X%x,4:" % addr).encode("ascii")
# Set the 'X' packet to the remote target to set a global variable.
# Checks that we can send byte values.
def run_set_global_var_test():
inf = gdb.selected_inferior()
conn = inf.connection
assert isinstance(conn, gdb.RemoteTargetConnection)
addr = gdb.parse_and_eval("&global_var")
res = conn.send_packet("X%x,4:\x01\x01\x01\x01" % addr)
assert isinstance(res, bytes)
check_global_var(0x01010101)
res = conn.send_packet(xpacket_header(addr) + b"\x02\x02\x02\x02")
assert isinstance(res, bytes)
check_global_var(0x02020202)
# This first attempt will not work as we're passing a Unicode string
# containing non-ascii characters.
saw_error = False
try:
res = conn.send_packet("X%x,4:\xff\xff\xff\xff" % addr)
except UnicodeError:
saw_error = True
except:
assert False
assert saw_error
check_global_var(0x02020202)
# Now we pass a bytes object, which will work.
res = conn.send_packet(xpacket_header(addr) + b"\xff\xff\xff\xff")
check_global_var(0xFFFFFFFF)
print("set global_var test passed")
# Just to indicate the file was sourced correctly.
print("Sourcing complete.")
|
