| 1 |
# Copyright (c) Meta Platforms, Inc. and affiliates. |
| 2 |
# SPDX-License-Identifier: LGPL-2.1-or-later |
| 3 |
|
| 4 |
import ipaddress |
| 5 |
import os |
| 6 |
import socket |
| 7 |
import tempfile |
| 8 |
|
| 9 |
from drgn import cast |
| 10 |
from drgn.helpers.linux.fs import fget |
| 11 |
from drgn.helpers.linux.net import ( |
| 12 |
_S_IFMT, |
| 13 |
_S_IFSOCK, |
| 14 |
SOCK_INODE, |
| 15 |
SOCKET_I, |
| 16 |
for_each_net, |
| 17 |
for_each_netdev, |
| 18 |
get_net_ns_by_fd, |
| 19 |
is_pp_page, |
| 20 |
neigh_table_for_each_neighbor, |
| 21 |
netdev_for_each_tx_queue, |
| 22 |
netdev_get_by_index, |
| 23 |
netdev_get_by_name, |
| 24 |
netdev_ipv4_addrs, |
| 25 |
netdev_ipv6_addrs, |
| 26 |
netdev_name, |
| 27 |
netdev_priv, |
| 28 |
sk_fullsock, |
| 29 |
skb_shinfo, |
| 30 |
) |
| 31 |
from drgn.helpers.linux.pid import find_task |
| 32 |
from tests.linux_kernel import ( |
| 33 |
LinuxKernelTestCase, |
| 34 |
create_socket, |
| 35 |
skip_unless_have_pyroute2, |
| 36 |
skip_unless_have_test_kmod, |
| 37 |
temp_netns, |
| 38 |
) |
| 39 |
from util import KernelVersion |
| 40 |
|
| 41 |
|
| 42 |
class TestNet(LinuxKernelTestCase): |
| 43 |
@classmethod |
| 44 |
def setUpClass(cls): |
| 45 |
super().setUpClass() |
| 46 |
cls.pid = os.getpid() |
| 47 |
cls.task = find_task(cls.prog, cls.pid) |
| 48 |
with open(f"/proc/{cls.pid}/ns/net") as file: |
| 49 |
cls.net = get_net_ns_by_fd(cls.task, file.fileno()) |
| 50 |
|
| 51 |
def test_sk_fullsock(self): |
| 52 |
with create_socket() as skt: |
| 53 |
file = fget(self.task, skt.fileno()) |
| 54 |
sk = cast("struct socket *", file.private_data).sk.read_() |
| 55 |
self.assertTrue(sk_fullsock(sk)) |
| 56 |
|
| 57 |
def test_for_each_netdev(self): |
| 58 |
self.assertCountEqual( |
| 59 |
[netdev_name(dev) for dev in for_each_netdev(self.net)], |
| 60 |
[name.encode() for _, name in socket.if_nameindex()], |
| 61 |
) |
| 62 |
|
| 63 |
@skip_unless_have_test_kmod |
| 64 |
def test_for_each_netdev_init_net(self): |
| 65 |
self.assertIn(self.prog["drgn_test_netdev"], for_each_netdev(self.prog)) |
| 66 |
|
| 67 |
@skip_unless_have_test_kmod |
| 68 |
def test_netdev_name(self): |
| 69 |
self.assertEqual(netdev_name(self.prog["drgn_test_netdev"]), b"lo") |
| 70 |
|
| 71 |
def test_netdev_get_by_index(self): |
| 72 |
for index, name in socket.if_nameindex(): |
| 73 |
netdev = netdev_get_by_index(self.net, index) |
| 74 |
self.assertEqual(netdev.name.string_().decode(), name) |
| 75 |
|
| 76 |
def test_netdev_get_by_name(self): |
| 77 |
for index, name in socket.if_nameindex(): |
| 78 |
netdev = netdev_get_by_name(self.net, name) |
| 79 |
self.assertEqual(netdev.ifindex, index) |
| 80 |
|
| 81 |
@skip_unless_have_test_kmod |
| 82 |
def test_netdev_get_by_name_init_net(self): |
| 83 |
self.assertEqual( |
| 84 |
netdev_get_by_name(self.prog, "lo"), self.prog["drgn_test_netdev"] |
| 85 |
) |
| 86 |
|
| 87 |
@skip_unless_have_test_kmod |
| 88 |
def test_netdev_priv(self): |
| 89 |
self.assertEqual( |
| 90 |
netdev_priv(self.prog["drgn_test_netdev"]), |
| 91 |
self.prog["drgn_test_netdev_priv"], |
| 92 |
) |
| 93 |
|
| 94 |
def test_for_each_net(self): |
| 95 |
self.assertIn(self.prog["init_net"].address_of_(), for_each_net(self.prog)) |
| 96 |
|
| 97 |
def test_get_net_ns_by_fd(self): |
| 98 |
for index, name in socket.if_nameindex(): |
| 99 |
netdev = netdev_get_by_index(self.net, index) |
| 100 |
self.assertEqual(netdev.name.string_().decode(), name) |
| 101 |
|
| 102 |
with tempfile.TemporaryFile("rb") as file: |
| 103 |
self.assertRaisesRegex( |
| 104 |
ValueError, |
| 105 |
"not a namespace inode", |
| 106 |
get_net_ns_by_fd, |
| 107 |
self.task, |
| 108 |
file.fileno(), |
| 109 |
) |
| 110 |
|
| 111 |
with open(f"/proc/{self.pid}/ns/mnt") as file: |
| 112 |
self.assertRaisesRegex( |
| 113 |
ValueError, |
| 114 |
"not a network namespace inode", |
| 115 |
get_net_ns_by_fd, |
| 116 |
self.task, |
| 117 |
file.fileno(), |
| 118 |
) |
| 119 |
|
| 120 |
def test_netdev_for_each_tx_queue(self): |
| 121 |
for index, _ in socket.if_nameindex(): |
| 122 |
netdev = netdev_get_by_index(self.net, index) |
| 123 |
for queue in netdev_for_each_tx_queue(netdev): |
| 124 |
self.assertEqual(queue.dev, netdev) |
| 125 |
|
| 126 |
def test_SOCKET_I(self): |
| 127 |
with create_socket(type=socket.SOCK_DGRAM) as skt: |
| 128 |
sock = SOCKET_I(fget(self.task, skt.fileno()).f_inode) |
| 129 |
self.assertEqual(sock.type, socket.SOCK_DGRAM) |
| 130 |
|
| 131 |
with open("/dev/null") as null: |
| 132 |
file = fget(self.task, null.fileno()) |
| 133 |
self.assertRaisesRegex( |
| 134 |
ValueError, "not a socket inode", SOCKET_I, file.f_inode |
| 135 |
) |
| 136 |
|
| 137 |
def test_SOCK_INODE(self): |
| 138 |
with create_socket() as skt: |
| 139 |
sock = SOCKET_I(fget(self.task, skt.fileno()).f_inode) |
| 140 |
inode = SOCK_INODE(sock) |
| 141 |
self.assertEqual(inode.i_mode & _S_IFMT, _S_IFSOCK) |
| 142 |
|
| 143 |
@skip_unless_have_test_kmod |
| 144 |
def test_skb_shinfo(self): |
| 145 |
self.assertEqual( |
| 146 |
skb_shinfo(self.prog["drgn_test_skb"]), self.prog["drgn_test_skb_shinfo"] |
| 147 |
) |
| 148 |
|
| 149 |
@skip_unless_have_test_kmod |
| 150 |
def test_is_pp_page(self): |
| 151 |
if not self.prog["drgn_test_have_page_pool"]: |
| 152 |
self.skipTest("kernel does not support page pools") |
| 153 |
if KernelVersion(os.uname().release) < KernelVersion("5.14"): |
| 154 |
self.skipTest("kernel does not support identifying page_pool pages") |
| 155 |
self.assertTrue(is_pp_page(self.prog["drgn_test_page_pool_page"])) |
| 156 |
self.assertFalse(is_pp_page(self.prog["drgn_test_page"])) |
| 157 |
|
| 158 |
@skip_unless_have_pyroute2 |
| 159 |
def test_netdev_ipv4_addrs(self): |
| 160 |
import pyroute2 |
| 161 |
|
| 162 |
with pyroute2.IPRoute() as ipr: |
| 163 |
idx = ipr.link_lookup(ifname="lo")[0] |
| 164 |
addrs = ipr.get_addr(index=idx, family=socket.AF_INET) |
| 165 |
expected = [ |
| 166 |
ipaddress.IPv4Address(addr.get_attr("IFA_ADDRESS")) for addr in addrs |
| 167 |
] |
| 168 |
self.assertCountEqual( |
| 169 |
netdev_ipv4_addrs(netdev_get_by_name(self.prog, "lo")), |
| 170 |
expected, |
| 171 |
) |
| 172 |
|
| 173 |
@skip_unless_have_pyroute2 |
| 174 |
def test_netdev_ipv6_addrs(self): |
| 175 |
import pyroute2 |
| 176 |
|
| 177 |
with pyroute2.IPRoute() as ipr: |
| 178 |
idx = ipr.link_lookup(ifname="lo")[0] |
| 179 |
addrs = ipr.get_addr(index=idx, family=socket.AF_INET6) |
| 180 |
expected = [ |
| 181 |
ipaddress.IPv6Address(addr.get_attr("IFA_ADDRESS")) for addr in addrs |
| 182 |
] |
| 183 |
self.assertCountEqual( |
| 184 |
netdev_ipv6_addrs(netdev_get_by_name(self.prog, "lo")), |
| 185 |
expected, |
| 186 |
) |
| 187 |
|
| 188 |
@skip_unless_have_pyroute2 |
| 189 |
def test_neigh_table_for_each_neighbor(self): |
| 190 |
import pyroute2 |
| 191 |
import pyroute2.netlink.rtnl.ndmsg |
| 192 |
|
| 193 |
with temp_netns() as (_, ns): |
| 194 |
try: |
| 195 |
ns.link("add", ifname="dummy0", kind="dummy") |
| 196 |
except pyroute2.NetlinkError: |
| 197 |
self.skipTest("kernel does not support dummy interface (CONFIG_DUMMY)") |
| 198 |
|
| 199 |
try: |
| 200 |
idx = ns.link_lookup(ifname="dummy0")[0] |
| 201 |
# Add a permanent neighbor entry so there's something to find |
| 202 |
ns.neigh( |
| 203 |
"add", |
| 204 |
dst="192.0.2.1", |
| 205 |
lladdr="00:11:22:33:44:55", |
| 206 |
ifindex=idx, |
| 207 |
state=pyroute2.netlink.rtnl.ndmsg.states["permanent"], |
| 208 |
) |
| 209 |
nht = self.prog["arp_tbl"].nht.read_() |
| 210 |
neighbor_addrs = [ |
| 211 |
ipaddress.IPv4Address(self.prog.read(n.primary_key.address_, 4)) |
| 212 |
for n in neigh_table_for_each_neighbor(nht) |
| 213 |
] |
| 214 |
self.assertIn(ipaddress.IPv4Address("192.0.2.1"), neighbor_addrs) |
| 215 |
finally: |
| 216 |
ns.link("delete", ifname="dummy0") |