Debian Codegraph @

tests/linux_kernel/crash_commands/test_bpf.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import contextlib
5 import errno
6 import os
7 from unittest import SkipTest
8
9 from tests.linux_kernel.bpf import (
10 BPF_LD_MAP_FD,
11 BPF_MAP_TYPE_HASH,
12 BPF_PROG_TYPE_KPROBE,
13 BPF_PROG_TYPE_SOCKET_FILTER,
14 BPF_REG_0,
15 bpf_map_create,
16 bpf_map_get_info_by_fd,
17 bpf_prog_get_info_by_fd,
18 bpf_prog_ids,
19 bpf_prog_load,
20 )
21 from tests.linux_kernel.crash_commands import CrashCommandTestCase
22 from tests.linux_kernel.helpers.test_bpf import BpfTestCase
23
24
25 class TestBpf(CrashCommandTestCase, BpfTestCase):
26 @classmethod
27 def setUpClass(cls):
28 super().setUpClass()
29 # This command isn't supported before Linux kernel commits dc4bb0e23561
30 # ("bpf: Introduce bpf_prog ID") and f3f1c054c288 ("bpf: Introduce bpf_map
31 # ID") (in v4.13).
32 try:
33 next(bpf_prog_ids())
34 except StopIteration:
35 # Kernel supports BPF IDs but no programs exist yet
36 pass
37 except OSError as e:
38 if e.errno != errno.EINVAL:
39 raise
40 raise SkipTest("This kernel version doesn't support BPF object IDs")
41
42 def test_bpf(self):
43 with contextlib.ExitStack() as exit_stack:
44 map_fd = bpf_map_create(BPF_MAP_TYPE_HASH, 8, 8, 8)
45 exit_stack.callback(os.close, map_fd)
46
47 prog1_fd = bpf_prog_load(BPF_PROG_TYPE_KPROBE, self.INSNS, b"GPL")
48 exit_stack.callback(os.close, prog1_fd)
49
50 prog2_insns = BPF_LD_MAP_FD(BPF_REG_0, map_fd) + self.INSNS
51 prog2_fd = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, prog2_insns, b"GPL")
52 exit_stack.callback(os.close, prog2_fd)
53
54 map_id = bpf_map_get_info_by_fd(map_fd).id
55 prog1_id = bpf_prog_get_info_by_fd(prog1_fd).id
56 prog2_info = bpf_prog_get_info_by_fd(prog2_fd)
57 prog2_id = prog2_info.id
58 prog2_tag = "".join(f"{b:02x}" for b in prog2_info.tag)
59
60 cmd = self.check_crash_command("bpf")
61
62 self.assertIn("BPF_PROG_TYPE", cmd.stdout)
63 self.assertRegex(
64 cmd.stdout,
65 rf"(?sm)BPF_PROG.*^\s*{prog1_id}\s+.*KPROBE\s+[0-9a-f]{{16}}\s*$",
66 )
67 self.assertRegex(
68 cmd.stdout,
69 rf"(?sm)BPF_PROG.*^\s*{prog2_id}\s+.*SOCKET_FILTER\s+.*{prog2_tag}\s+{map_id}$",
70 )
71 self.assertIn("BPF_MAP_TYPE", cmd.stdout)
72 self.assertRegex(
73 cmd.stdout,
74 rf"(?sm)BPF_MAP.*^\s*{map_id}\s+.*HASH\s+",
75 )
76
77 def test_bpf_program_by_id(self):
78 with contextlib.ExitStack() as exit_stack:
79 prog_fd = bpf_prog_load(BPF_PROG_TYPE_KPROBE, self.INSNS, b"GPL")
80 exit_stack.callback(os.close, prog_fd)
81
82 prog_info = bpf_prog_get_info_by_fd(prog_fd)
83 prog_id = prog_info.id
84 prog_tag = "".join(f"{b:02x}" for b in prog_info.tag)
85
86 cmd = self.check_crash_command(f"bpf -p {prog_id}")
87
88 self.assertRegex(
89 cmd.stdout,
90 rf"(?sm)ID\s+.*BPF_PROG_TYPE.*^\s*{prog_id}\s+.*KPROBE\s+.*{prog_tag}\s*$",
91 )
92
93 self.assertRegex(
94 cmd.stdout,
95 r"(?sm)^\s*XLATED:\s*\d+\s+JITED:\s*\d+\s+MEMLOCK:\s*\d+",
96 )
97
98 self.assertRegex(
99 cmd.stdout,
100 r"(?sm)^\s*LOAD_TIME:\s*((\w+\s+){3}\d{2}:\d{2}:\d{2}\s+\d{4}|\(unknown\))",
101 )
102
103 self.assertRegex(
104 cmd.stdout,
105 r"(?sm)^\s*GPL_COMPATIBLE:\s*(yes|no)\s+NAME:\s*(\(unused\)|\(unknown\)|\S+)\s+UID:\s*\d+",
106 )
107
108 def test_bpf_program_by_id_invalid(self):
109 self.assertRaises(
110 Exception,
111 self.check_crash_command,
112 "bpf -p 1a",
113 )
114 self.assertRaises(
115 Exception,
116 self.check_crash_command,
117 "bpf -p 1$^7",
118 )
119
120 def test_bpf_map_by_id(self):
121 with contextlib.ExitStack() as exit_stack:
122 map_fd = bpf_map_create(BPF_MAP_TYPE_HASH, 4, 8, 256)
123 exit_stack.callback(os.close, map_fd)
124
125 map_info = bpf_map_get_info_by_fd(map_fd)
126 map_id = map_info.id
127
128 cmd = self.check_crash_command(f"bpf -m {map_id}")
129
130 self.assertIn("BPF_MAP_TYPE", cmd.stdout)
131
132 self.assertRegex(
133 cmd.stdout,
134 rf"(?sm)ID\s+.*BPF_MAP.*^\s*{map_id}\s+.*HASH\s+",
135 )
136
137 self.assertRegex(
138 cmd.stdout,
139 r"(?sm)^\s*KEY_SIZE:\s*4\s+VALUE_SIZE:\s*8\s+MAX_ENTRIES:\s*256",
140 )
141
142 self.assertRegex(
143 cmd.stdout,
144 r"(?sm)NAME:\s*(\(unused\)|\(unknown\)|\"[^\"]*\")\s+UID:\s*(\d+|\(unknown\)|\(unused\))",
145 )
146
147 def test_bpf_map_by_id_with_program(self):
148 with contextlib.ExitStack() as exit_stack:
149 map_fd = bpf_map_create(BPF_MAP_TYPE_HASH, 8, 8, 16)
150 exit_stack.callback(os.close, map_fd)
151
152 prog_insns = BPF_LD_MAP_FD(BPF_REG_0, map_fd) + self.INSNS
153 prog_fd = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, prog_insns, b"GPL")
154 exit_stack.callback(os.close, prog_fd)
155
156 map_info = bpf_map_get_info_by_fd(map_fd)
157 map_id = map_info.id
158
159 cmd = self.check_crash_command(f"bpf -m {map_id}")
160
161 self.assertIn(f"{map_id}", cmd.stdout)
162 self.assertIn("HASH", cmd.stdout)
163 self.assertIn("KEY_SIZE:", cmd.stdout)
164 self.assertIn("VALUE_SIZE:", cmd.stdout)
165 self.assertIn("MAX_ENTRIES:", cmd.stdout)
166
167 def test_bpf_map_by_id_invalid(self):
168 self.assertRaises(
169 Exception,
170 self.check_crash_command,
171 "bpf -m abc",
172 )
173
174 self.assertRaises(
175 Exception,
176 self.check_crash_command,
177 "bpf -m 1$^7",
178 )
179
180 def test_bpf_command_shows_maps(self):
181 with contextlib.ExitStack() as exit_stack:
182 map_fd = bpf_map_create(BPF_MAP_TYPE_HASH, 8, 8, 8)
183 exit_stack.callback(os.close, map_fd)
184
185 map_id = bpf_map_get_info_by_fd(map_fd).id
186
187 cmd = self.check_crash_command("bpf")
188
189 self.assertIn("BPF_MAP", cmd.stdout)
190
191 self.assertRegex(
192 cmd.stdout,
193 rf"(?sm)^\s*{map_id}\s+.*HASH\s+",
194 )