Debian Codegraph @

tests/linux_kernel/helpers/test_net.py

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