Debian Codegraph @

tests/test_debuginfod.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4
5 import http.server
6 import os
7 import os.path
8 from pathlib import Path
9 import re
10 import shutil
11 import socket
12 import socketserver
13 import tempfile
14 import threading
15
16 from drgn import ModuleFileStatus, Program, SupplementaryFileKind
17 from tests import TestCase, modifyenv
18 from tests.test_debug_info import NamedTemporaryElfFile
19
20
21 class _DebuginfodHTTPHandler(http.server.BaseHTTPRequestHandler):
22 def do_GET(self):
23 match = re.fullmatch(
24 r"/buildid/((?:[0-9a-fA-F][0-9a-fA-F])+)/(executable|debuginfo)", self.path
25 )
26 if not match:
27 self.send_error(http.HTTPStatus.BAD_REQUEST)
28 return
29
30 build_id = bytes.fromhex(match.group(1))
31 type = match.group(2)
32
33 try:
34 file_path = self.server.build_ids[build_id][type]
35 except KeyError:
36 self.send_error(http.HTTPStatus.NOT_FOUND)
37 return
38
39 try:
40 f = open(file_path, "rb")
41 except OSError:
42 self.send_error(http.HTTPStatus.INTERNAL_SERVER_ERROR)
43 return
44
45 with f:
46 self.send_response(http.HTTPStatus.OK)
47 st = os.fstat(f.fileno())
48 self.send_header("Content-Type", "application/octet-stream")
49 self.send_header("Content-Length", str(st.st_size))
50 self.send_header("X-Debuginfod-Size", str(st.st_size))
51 self.send_header("Last-Modified", self.date_time_string(st.st_mtime))
52 self.end_headers()
53 shutil.copyfileobj(f, self.wfile)
54
55
56 class TestDebuginfodDebugInfoFinder(TestCase):
57 @classmethod
58 def setUpClass(cls):
59 super().setUpClass()
60 cls.server = socketserver.TCPServer(("localhost", 0), _DebuginfodHTTPHandler)
61 cls.server.build_ids = {}
62 cls.server_thread = threading.Thread(
63 target=cls.server.serve_forever, daemon=True
64 )
65 cls.server_thread.start()
66
67 @classmethod
68 def tearDownClass(cls):
69 # By default, serve_forever() only checks if it should shut down every
70 # 0.5 seconds. Shutting down the socket makes it check immediately.
71 cls.server.socket.shutdown(socket.SHUT_RD)
72 cls.server.shutdown()
73 cls.server_thread.join()
74 cls.server.server_close()
75
76 def setUp(self):
77 self.prog = Program()
78 try:
79 self.prog.set_enabled_debug_info_finders(["debuginfod"])
80 except ValueError:
81 self.skipTest("no debuginfod support")
82
83 self.server.build_ids.clear()
84 self.cache_dir = Path(
85 self.enterContext(tempfile.TemporaryDirectory(prefix="debuginfod-cache-"))
86 )
87 self.enterContext(
88 modifyenv(
89 {
90 "DEBUGINFOD_URLS": "http://{}:{}/".format(
91 *self.server.server_address
92 ),
93 "DEBUGINFOD_CACHE_PATH": str(self.cache_dir),
94 }
95 )
96 )
97
98 def test_no_build_id(self):
99 module = self.prog.extra_module("foo", create=True)
100 self.prog.load_module_debug_info(module)
101 self.assertEqual(module.loaded_file_status, ModuleFileStatus.WANT)
102 self.assertEqual(module.debug_file_status, ModuleFileStatus.WANT)
103
104 def test_separate(self):
105 build_id = b"\x01\x23\x45\x67\x89\xab\xcd\xef"
106
107 with NamedTemporaryElfFile(
108 loadable=True, debug=False, build_id=build_id
109 ) as loadable_file, NamedTemporaryElfFile(
110 loadable=False, debug=True, build_id=build_id
111 ) as debug_file:
112 self.server.build_ids[build_id] = {
113 "executable": loadable_file.name,
114 "debuginfo": debug_file.name,
115 }
116
117 module = self.prog.extra_module("foo", create=True)
118 module.build_id = build_id
119 self.prog.load_module_debug_info(module)
120 self.assertEqual(module.loaded_file_status, ModuleFileStatus.HAVE)
121 self.assertEqual(module.debug_file_status, ModuleFileStatus.HAVE)
122 self.assertEqual(
123 module.loaded_file_path,
124 str(self.cache_dir / build_id.hex() / "executable"),
125 )
126 self.assertEqual(
127 module.debug_file_path,
128 str(self.cache_dir / build_id.hex() / "debuginfo"),
129 )
130
131 def test_no_servers(self):
132 build_id = b"\x01\x23\x45\x67\x89\xab\xcd\xef"
133
134 with NamedTemporaryElfFile(
135 loadable=True, debug=False, build_id=build_id
136 ) as loadable_file, NamedTemporaryElfFile(
137 loadable=False, debug=True, build_id=build_id
138 ) as debug_file, modifyenv(
139 {"DEBUGINFOD_URLS": None}
140 ):
141 self.server.build_ids[build_id] = {
142 "executable": loadable_file.name,
143 "debuginfo": debug_file.name,
144 }
145
146 module = self.prog.extra_module("foo", create=True)
147 module.build_id = build_id
148 self.prog.load_module_debug_info(module)
149 self.assertEqual(module.loaded_file_status, ModuleFileStatus.WANT)
150 self.assertEqual(module.debug_file_status, ModuleFileStatus.WANT)
151
152 def test_cache_hit(self):
153 build_id = b"\x01\x23\x45\x67\x89\xab\xcd\xef"
154
155 with NamedTemporaryElfFile(
156 loadable=False, debug=True, build_id=build_id
157 ) as debug_file:
158 self.server.build_ids[build_id] = {"debuginfo": debug_file.name}
159
160 for i in range(2):
161 module = self.prog.extra_module("foo", i, create=True)
162 module.build_id = build_id
163 self.prog.load_module_debug_info(module)
164 self.assertEqual(module.debug_file_status, ModuleFileStatus.HAVE)
165 self.assertEqual(
166 module.debug_file_path,
167 str(self.cache_dir / build_id.hex() / "debuginfo"),
168 )
169
170 def test_gnu_debugaltlink(self):
171 build_id = b"\x01\x23\x45\x67\x89\xab\xcd\xef"
172 alt_build_id = b"\xfe\xdc\xba\x98\x76\x54\x32\x10"
173
174 with NamedTemporaryElfFile(
175 loadable=True, debug=False, build_id=build_id
176 ) as loadable_file, NamedTemporaryElfFile(
177 loadable=False,
178 debug=True,
179 build_id=build_id,
180 gnu_debugaltlink=("alt.debug", alt_build_id),
181 ) as debug_file, NamedTemporaryElfFile(
182 loadable=False, debug=True, build_id=alt_build_id
183 ) as alt_f:
184 self.server.build_ids[build_id] = {
185 "executable": loadable_file.name,
186 "debuginfo": debug_file.name,
187 }
188 self.server.build_ids[alt_build_id] = {"debuginfo": alt_f.name}
189
190 module = self.prog.extra_module("foo", create=True)
191 module.build_id = build_id
192 self.prog.load_module_debug_info(module)
193 self.assertEqual(module.loaded_file_status, ModuleFileStatus.HAVE)
194 self.assertEqual(module.debug_file_status, ModuleFileStatus.HAVE)
195 self.assertEqual(
196 module.loaded_file_path,
197 str(self.cache_dir / build_id.hex() / "executable"),
198 )
199 self.assertEqual(
200 module.debug_file_path,
201 str(self.cache_dir / build_id.hex() / "debuginfo"),
202 )
203 self.assertEqual(
204 module.supplementary_debug_file_path,
205 str(self.cache_dir / alt_build_id.hex() / "debuginfo"),
206 )
207
208 def test_gnu_debugaltlink_not_found(self):
209 build_id = b"\x01\x23\x45\x67\x89\xab\xcd\xef"
210 alt_build_id = b"\xfe\xdc\xba\x98\x76\x54\x32\x10"
211
212 with NamedTemporaryElfFile(
213 loadable=True, debug=False, build_id=build_id
214 ) as loadable_file, NamedTemporaryElfFile(
215 loadable=False,
216 debug=True,
217 build_id=build_id,
218 gnu_debugaltlink=("alt.debug", alt_build_id),
219 ) as debug_file:
220 self.server.build_ids[build_id] = {
221 "executable": loadable_file.name,
222 "debuginfo": debug_file.name,
223 }
224
225 module = self.prog.extra_module("foo", create=True)
226 module.build_id = build_id
227 self.prog.load_module_debug_info(module)
228 self.assertEqual(module.loaded_file_status, ModuleFileStatus.HAVE)
229 self.assertEqual(
230 module.debug_file_status, ModuleFileStatus.WANT_SUPPLEMENTARY
231 )
232 self.assertEqual(
233 module.wanted_supplementary_debug_file(),
234 (
235 SupplementaryFileKind.GNU_DEBUGALTLINK,
236 str(self.cache_dir / build_id.hex() / "debuginfo"),
237 "alt.debug",
238 alt_build_id,
239 ),
240 )
241 self.assertEqual(
242 module.loaded_file_path,
243 str(self.cache_dir / build_id.hex() / "executable"),
244 )
245
246 def test_only_gnu_debugaltlink(self):
247 build_id = b"\x01\x23\x45\x67\x89\xab\xcd\xef"
248 alt_build_id = b"\xfe\xdc\xba\x98\x76\x54\x32\x10"
249
250 with NamedTemporaryElfFile(
251 build_id=build_id,
252 gnu_debugaltlink=("alt.debug", alt_build_id),
253 ) as f, NamedTemporaryElfFile(
254 loadable=False, debug=True, build_id=alt_build_id
255 ) as alt_f:
256 self.server.build_ids[alt_build_id] = {"debuginfo": alt_f.name}
257
258 module = self.prog.extra_module("foo", create=True)
259 module.try_file(f.name)
260 self.assertEqual(module.loaded_file_status, ModuleFileStatus.HAVE)
261 self.assertEqual(
262 module.debug_file_status, ModuleFileStatus.WANT_SUPPLEMENTARY
263 )
264 self.assertEqual(module.loaded_file_path, f.name)
265
266 self.prog.load_module_debug_info(module)
267 self.assertEqual(module.loaded_file_status, ModuleFileStatus.HAVE)
268 self.assertEqual(module.debug_file_status, ModuleFileStatus.HAVE)
269 self.assertEqual(module.debug_file_path, f.name)
270 self.assertEqual(
271 module.supplementary_debug_file_path,
272 str(self.cache_dir / alt_build_id.hex() / "debuginfo"),
273 )
274
275 def test_only_gnu_debugaltlink_not_found(self):
276 build_id = b"\x01\x23\x45\x67\x89\xab\xcd\xef"
277 alt_build_id = b"\xfe\xdc\xba\x98\x76\x54\x32\x10"
278
279 with NamedTemporaryElfFile(
280 build_id=build_id,
281 gnu_debugaltlink=("alt.debug", alt_build_id),
282 ) as f:
283 module = self.prog.extra_module("foo", create=True)
284 module.try_file(f.name)
285 self.assertEqual(module.loaded_file_status, ModuleFileStatus.HAVE)
286 self.assertEqual(
287 module.debug_file_status, ModuleFileStatus.WANT_SUPPLEMENTARY
288 )
289 self.assertEqual(
290 module.wanted_supplementary_debug_file(),
291 (
292 SupplementaryFileKind.GNU_DEBUGALTLINK,
293 f.name,
294 "alt.debug",
295 alt_build_id,
296 ),
297 )
298 self.assertEqual(module.loaded_file_path, f.name)
299
300 self.prog.load_module_debug_info(module)
301 self.assertEqual(module.loaded_file_status, ModuleFileStatus.HAVE)
302 self.assertEqual(
303 module.debug_file_status, ModuleFileStatus.WANT_SUPPLEMENTARY
304 )