| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20260119182230.1296164-2-allison.henderson@oracle.com>
Date: Mon, 19 Jan 2026 11:22:29 -0700
From: allison.henderson@...cle.com
To: netdev@...r.kernel.org
Cc: linux-kselftest@...r.kernel.org, pabeni@...hat.com, edumazet@...gle.com,
rds-devel@....oracle.com, kuba@...nel.org, horms@...nel.org,
linux-rdma@...r.kernel.org, allison.henderson@...cle.com
Subject: [RFC net-next 1/2] selftests: rds: Refactor test.py
From: Allison Henderson <allison.henderson@...cle.com>
This patch hoists the send and recv logic from test.py into a helper
module rds_basic.py, keeping the namespace and networking configurations
in the calling test.py script. This will allow us to reuse the test.py
infrastructure to add additional rds tests. No functional changes are
added in this initial refactor.
Signed-off-by: Allison Henderson <allison.henderson@...cle.com>
---
tools/testing/selftests/net/rds/rds_basic.py | 184 +++++++++++++++++++
tools/testing/selftests/net/rds/test.py | 167 +----------------
2 files changed, 190 insertions(+), 161 deletions(-)
diff --git a/tools/testing/selftests/net/rds/rds_basic.py b/tools/testing/selftests/net/rds/rds_basic.py
new file mode 100755
index 0000000000000..f585770f77096
--- /dev/null
+++ b/tools/testing/selftests/net/rds/rds_basic.py
@@ -0,0 +1,184 @@
+#! /usr/bin/env python3
+# SPDX-License-Identifier: GPL-2.0
+
+import ctypes
+import errno
+import hashlib
+import os
+import select
+import socket
+import sys
+
+# Allow utils module to be imported from different directory
+this_dir = os.path.dirname(os.path.realpath(__file__))
+sys.path.append(os.path.join(this_dir, "../"))
+from lib.py.utils import ip
+
+libc = ctypes.cdll.LoadLibrary('libc.so.6')
+setns = libc.setns
+
+# Helper function for creating a socket inside a network namespace.
+# We need this because otherwise RDS will detect that the two TCP
+# sockets are on the same interface and use the loop transport instead
+# of the TCP transport.
+def netns_socket(netns, *args):
+ u0, u1 = socket.socketpair(socket.AF_UNIX, socket.SOCK_SEQPACKET)
+
+ child = os.fork()
+ if child == 0:
+ # change network namespace
+ with open(f'/var/run/netns/{netns}') as f:
+ try:
+ ret = setns(f.fileno(), 0)
+ except IOError as e:
+ print(e.errno)
+ print(e)
+
+ # create socket in target namespace
+ s = socket.socket(*args)
+
+ # send resulting socket to parent
+ socket.send_fds(u0, [], [s.fileno()])
+
+ sys.exit(0)
+
+ # receive socket from child
+ _, s, _, _ = socket.recv_fds(u1, 0, 1)
+ os.waitpid(child, 0)
+ u0.close()
+ u1.close()
+ return socket.fromfd(s[0], *args)
+
+def run_test(env):
+ """Run basic RDS selftest.
+
+ env is a dictionary provided by test.py and is expected to contain:
+ - 'addrs': list of (ip, port) tuples matching the sockets
+ - 'netns': list of network namespace names (for sysctl exercises)
+ """
+ addrs = env['addrs'] # [('10.0.0.1', 10000), ('10.0.0.2', 20000)]
+ netns_list = env['netns'] # ['net0', 'net1']
+
+ sockets = [
+ netns_socket(netns_list[0], socket.AF_RDS, socket.SOCK_SEQPACKET),
+ netns_socket(netns_list[1], socket.AF_RDS, socket.SOCK_SEQPACKET),
+ ]
+
+ for s, addr in zip(sockets, addrs):
+ s.bind(addr)
+ s.setblocking(0)
+
+ fileno_to_socket = {
+ s.fileno(): s for s in sockets
+ }
+
+ addr_to_socket = {
+ addr: s for addr, s in zip(addrs, sockets)
+ }
+
+ socket_to_addr = {
+ s: addr for addr, s in zip(addrs, sockets)
+ }
+
+ send_hashes = {}
+ recv_hashes = {}
+
+ ep = select.epoll()
+
+ for s in sockets:
+ ep.register(s, select.EPOLLRDNORM)
+
+ n = 50000
+ nr_send = 0
+ nr_recv = 0
+
+ while nr_send < n:
+ # Send as much as we can without blocking
+ print("sending...", nr_send, nr_recv)
+ while nr_send < n:
+ send_data = hashlib.sha256(
+ f'packet {nr_send}'.encode('utf-8')).hexdigest().encode('utf-8')
+
+ # pseudo-random send/receive pattern
+ sender = sockets[nr_send % 2]
+ receiver = sockets[1 - (nr_send % 3) % 2]
+
+ try:
+ sender.sendto(send_data, socket_to_addr[receiver])
+ send_hashes.setdefault((sender.fileno(), receiver.fileno()),
+ hashlib.sha256()).update(f'<{send_data}>'.encode('utf-8'))
+ nr_send = nr_send + 1
+ except BlockingIOError as e:
+ break
+ except OSError as e:
+ if e.errno in [errno.ENOBUFS, errno.ECONNRESET, errno.EPIPE]:
+ break
+ raise
+
+ # Receive as much as we can without blocking
+ print("receiving...", nr_send, nr_recv)
+ while nr_recv < nr_send:
+ for fileno, eventmask in ep.poll():
+ receiver = fileno_to_socket[fileno]
+
+ if eventmask & select.EPOLLRDNORM:
+ while True:
+ try:
+ recv_data, address = receiver.recvfrom(1024)
+ sender = addr_to_socket[address]
+ recv_hashes.setdefault((sender.fileno(),
+ receiver.fileno()), hashlib.sha256()).update(
+ f'<{recv_data}>'.encode('utf-8'))
+ nr_recv = nr_recv + 1
+ except BlockingIOError as e:
+ break
+
+ # exercise net/rds/tcp.c:rds_tcp_sysctl_reset()
+ for net in netns_list:
+ ip(f"netns exec {net} /usr/sbin/sysctl net.rds.tcp.rds_tcp_rcvbuf=10000")
+ ip(f"netns exec {net} /usr/sbin/sysctl net.rds.tcp.rds_tcp_sndbuf=10000")
+
+ print("done", nr_send, nr_recv)
+
+ # the Python socket module doesn't know these
+ RDS_INFO_FIRST = 10000
+ RDS_INFO_LAST = 10017
+
+ nr_success = 0
+ nr_error = 0
+
+ for s in sockets:
+ for optname in range(RDS_INFO_FIRST, RDS_INFO_LAST + 1):
+ # Sigh, the Python socket module doesn't allow us to pass
+ # buffer lengths greater than 1024 for some reason. RDS
+ # wants multiple pages.
+ try:
+ s.getsockopt(socket.SOL_RDS, optname, 1024)
+ nr_success = nr_success + 1
+ except OSError as e:
+ nr_error = nr_error + 1
+ if e.errno == errno.ENOSPC:
+ # ignore
+ pass
+
+ print(f"getsockopt(): {nr_success}/{nr_error}")
+
+ # We're done sending and receiving stuff, now let's check if what
+ # we received is what we sent.
+ for (sender, receiver), send_hash in send_hashes.items():
+ recv_hash = recv_hashes.get((sender, receiver))
+
+ if recv_hash is None:
+ print("FAIL: No data received")
+ return 1
+
+ if send_hash.hexdigest() != recv_hash.hexdigest():
+ print("FAIL: Send/recv mismatch")
+ print("hash expected:", send_hash.hexdigest())
+ print("hash received:", recv_hash.hexdigest())
+ return 1
+
+ print(f"{sender}/{receiver}: ok")
+
+ print("Success")
+ return 0
diff --git a/tools/testing/selftests/net/rds/test.py b/tools/testing/selftests/net/rds/test.py
index 4a7178d11193f..1ac52e9c7aaa8 100755
--- a/tools/testing/selftests/net/rds/test.py
+++ b/tools/testing/selftests/net/rds/test.py
@@ -2,65 +2,25 @@
# SPDX-License-Identifier: GPL-2.0
import argparse
-import ctypes
-import errno
-import hashlib
import os
-import select
import signal
-import socket
import subprocess
import sys
-import atexit
from pwd import getpwuid
from os import stat
+import rds_basic
# Allow utils module to be imported from different directory
this_dir = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(this_dir, "../"))
from lib.py.utils import ip
-libc = ctypes.cdll.LoadLibrary('libc.so.6')
-setns = libc.setns
-
net0 = 'net0'
net1 = 'net1'
veth0 = 'veth0'
veth1 = 'veth1'
-# Helper function for creating a socket inside a network namespace.
-# We need this because otherwise RDS will detect that the two TCP
-# sockets are on the same interface and use the loop transport instead
-# of the TCP transport.
-def netns_socket(netns, *args):
- u0, u1 = socket.socketpair(socket.AF_UNIX, socket.SOCK_SEQPACKET)
-
- child = os.fork()
- if child == 0:
- # change network namespace
- with open(f'/var/run/netns/{netns}') as f:
- try:
- ret = setns(f.fileno(), 0)
- except IOError as e:
- print(e.errno)
- print(e)
-
- # create socket in target namespace
- s = socket.socket(*args)
-
- # send resulting socket to parent
- socket.send_fds(u0, [], [s.fileno()])
-
- sys.exit(0)
-
- # receive socket from child
- _, s, _, _ = socket.recv_fds(u1, 0, 1)
- os.waitpid(child, 0)
- u0.close()
- u1.close()
- return socket.fromfd(s[0], *args)
-
def signal_handler(sig, frame):
print('Test timed out')
sys.exit(1)
@@ -137,129 +97,14 @@ if args.timeout > 0:
signal.alarm(args.timeout)
signal.signal(signal.SIGALRM, signal_handler)
-sockets = [
- netns_socket(net0, socket.AF_RDS, socket.SOCK_SEQPACKET),
- netns_socket(net1, socket.AF_RDS, socket.SOCK_SEQPACKET),
-]
-
-for s, addr in zip(sockets, addrs):
- s.bind(addr)
- s.setblocking(0)
-
-fileno_to_socket = {
- s.fileno(): s for s in sockets
-}
-
-addr_to_socket = {
- addr: s for addr, s in zip(addrs, sockets)
+env = {
+ 'addrs': addrs,
+ 'netns': [net0, net1],
}
-socket_to_addr = {
- s: addr for addr, s in zip(addrs, sockets)
-}
-
-send_hashes = {}
-recv_hashes = {}
-
-ep = select.epoll()
-
-for s in sockets:
- ep.register(s, select.EPOLLRDNORM)
-
-n = 50000
-nr_send = 0
-nr_recv = 0
-
-while nr_send < n:
- # Send as much as we can without blocking
- print("sending...", nr_send, nr_recv)
- while nr_send < n:
- send_data = hashlib.sha256(
- f'packet {nr_send}'.encode('utf-8')).hexdigest().encode('utf-8')
-
- # pseudo-random send/receive pattern
- sender = sockets[nr_send % 2]
- receiver = sockets[1 - (nr_send % 3) % 2]
-
- try:
- sender.sendto(send_data, socket_to_addr[receiver])
- send_hashes.setdefault((sender.fileno(), receiver.fileno()),
- hashlib.sha256()).update(f'<{send_data}>'.encode('utf-8'))
- nr_send = nr_send + 1
- except BlockingIOError as e:
- break
- except OSError as e:
- if e.errno in [errno.ENOBUFS, errno.ECONNRESET, errno.EPIPE]:
- break
- raise
-
- # Receive as much as we can without blocking
- print("receiving...", nr_send, nr_recv)
- while nr_recv < nr_send:
- for fileno, eventmask in ep.poll():
- receiver = fileno_to_socket[fileno]
-
- if eventmask & select.EPOLLRDNORM:
- while True:
- try:
- recv_data, address = receiver.recvfrom(1024)
- sender = addr_to_socket[address]
- recv_hashes.setdefault((sender.fileno(),
- receiver.fileno()), hashlib.sha256()).update(
- f'<{recv_data}>'.encode('utf-8'))
- nr_recv = nr_recv + 1
- except BlockingIOError as e:
- break
-
- # exercise net/rds/tcp.c:rds_tcp_sysctl_reset()
- for net in [net0, net1]:
- ip(f"netns exec {net} /usr/sbin/sysctl net.rds.tcp.rds_tcp_rcvbuf=10000")
- ip(f"netns exec {net} /usr/sbin/sysctl net.rds.tcp.rds_tcp_sndbuf=10000")
-
-print("done", nr_send, nr_recv)
-
-# the Python socket module doesn't know these
-RDS_INFO_FIRST = 10000
-RDS_INFO_LAST = 10017
-
-nr_success = 0
-nr_error = 0
-
-for s in sockets:
- for optname in range(RDS_INFO_FIRST, RDS_INFO_LAST + 1):
- # Sigh, the Python socket module doesn't allow us to pass
- # buffer lengths greater than 1024 for some reason. RDS
- # wants multiple pages.
- try:
- s.getsockopt(socket.SOL_RDS, optname, 1024)
- nr_success = nr_success + 1
- except OSError as e:
- nr_error = nr_error + 1
- if e.errno == errno.ENOSPC:
- # ignore
- pass
-
-print(f"getsockopt(): {nr_success}/{nr_error}")
+ret = rds_basic.run_test(env)
print("Stopping network packet captures")
subprocess.check_call(['killall', '-q', 'tcpdump'])
-# We're done sending and receiving stuff, now let's check if what
-# we received is what we sent.
-for (sender, receiver), send_hash in send_hashes.items():
- recv_hash = recv_hashes.get((sender, receiver))
-
- if recv_hash is None:
- print("FAIL: No data received")
- sys.exit(1)
-
- if send_hash.hexdigest() != recv_hash.hexdigest():
- print("FAIL: Send/recv mismatch")
- print("hash expected:", send_hash.hexdigest())
- print("hash received:", recv_hash.hexdigest())
- sys.exit(1)
-
- print(f"{sender}/{receiver}: ok")
-
-print("Success")
-sys.exit(0)
+sys.exit(ret)
--
2.43.0
Powered by blists - more mailing lists