| 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 |
) |