mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2026-01-11 17:10:13 +00:00
f0e5126f5e
test_case will only take on the formatted name after being
called. This does not work with the way ksft_run() currently
works. Assign the name after the test_case is created.
Fixes: 81236c74dba6 ("selftests: drv-net: psp: add test for auto-adjusting TCP MSS")
Signed-off-by: Daniel Zahka <daniel.zahka@gmail.com>
Link: https://patch.msgid.link/20251216-psp-test-fix-v1-2-3b5a6dde186f@gmail.com
Signed-off-by: Paolo Abeni <pabeni@redhat.com>
643 lines
20 KiB
Python
Executable File
643 lines
20 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# SPDX-License-Identifier: GPL-2.0
|
|
|
|
"""Test suite for PSP capable drivers."""
|
|
|
|
import errno
|
|
import fcntl
|
|
import socket
|
|
import struct
|
|
import termios
|
|
import time
|
|
|
|
from lib.py import defer
|
|
from lib.py import ksft_run, ksft_exit, ksft_pr
|
|
from lib.py import ksft_true, ksft_eq, ksft_ne, ksft_gt, ksft_raises
|
|
from lib.py import ksft_not_none
|
|
from lib.py import KsftSkipEx
|
|
from lib.py import NetDrvEpEnv, PSPFamily, NlError
|
|
from lib.py import bkg, rand_port, wait_port_listen
|
|
|
|
|
|
def _get_outq(s):
|
|
one = b'\0' * 4
|
|
outq = fcntl.ioctl(s.fileno(), termios.TIOCOUTQ, one)
|
|
return struct.unpack("I", outq)[0]
|
|
|
|
|
|
def _send_with_ack(cfg, msg):
|
|
cfg.comm_sock.send(msg)
|
|
response = cfg.comm_sock.recv(4)
|
|
if response != b'ack\0':
|
|
raise RuntimeError("Unexpected server response", response)
|
|
|
|
|
|
def _remote_read_len(cfg):
|
|
cfg.comm_sock.send(b'read len\0')
|
|
return int(cfg.comm_sock.recv(1024)[:-1].decode('utf-8'))
|
|
|
|
|
|
def _make_clr_conn(cfg, ipver=None):
|
|
_send_with_ack(cfg, b'conn clr\0')
|
|
remote_addr = cfg.remote_addr_v[ipver] if ipver else cfg.remote_addr
|
|
s = socket.create_connection((remote_addr, cfg.comm_port), )
|
|
return s
|
|
|
|
|
|
def _make_psp_conn(cfg, version=0, ipver=None):
|
|
_send_with_ack(cfg, b'conn psp\0' + struct.pack('BB', version, version))
|
|
remote_addr = cfg.remote_addr_v[ipver] if ipver else cfg.remote_addr
|
|
s = socket.create_connection((remote_addr, cfg.comm_port), )
|
|
return s
|
|
|
|
|
|
def _close_conn(cfg, s):
|
|
_send_with_ack(cfg, b'data close\0')
|
|
s.close()
|
|
|
|
|
|
def _close_psp_conn(cfg, s):
|
|
_close_conn(cfg, s)
|
|
|
|
|
|
def _spi_xchg(s, rx):
|
|
s.send(struct.pack('I', rx['spi']) + rx['key'])
|
|
tx = s.recv(4 + len(rx['key']))
|
|
return {
|
|
'spi': struct.unpack('I', tx[:4])[0],
|
|
'key': tx[4:]
|
|
}
|
|
|
|
|
|
def _send_careful(cfg, s, rounds):
|
|
data = b'0123456789' * 200
|
|
for i in range(rounds):
|
|
n = 0
|
|
for _ in range(10): # allow 10 retries
|
|
try:
|
|
n += s.send(data[n:], socket.MSG_DONTWAIT)
|
|
if n == len(data):
|
|
break
|
|
except BlockingIOError:
|
|
time.sleep(0.05)
|
|
else:
|
|
rlen = _remote_read_len(cfg)
|
|
outq = _get_outq(s)
|
|
report = f'sent: {i * len(data) + n} remote len: {rlen} outq: {outq}'
|
|
raise RuntimeError(report)
|
|
|
|
return len(data) * rounds
|
|
|
|
|
|
def _check_data_rx(cfg, exp_len):
|
|
read_len = -1
|
|
for _ in range(30):
|
|
cfg.comm_sock.send(b'read len\0')
|
|
read_len = int(cfg.comm_sock.recv(1024)[:-1].decode('utf-8'))
|
|
if read_len == exp_len:
|
|
break
|
|
time.sleep(0.01)
|
|
ksft_eq(read_len, exp_len)
|
|
|
|
|
|
def _check_data_outq(s, exp_len, force_wait=False):
|
|
outq = 0
|
|
for _ in range(10):
|
|
outq = _get_outq(s)
|
|
if not force_wait and outq == exp_len:
|
|
break
|
|
time.sleep(0.01)
|
|
ksft_eq(outq, exp_len)
|
|
|
|
|
|
def _get_stat(cfg, key):
|
|
return cfg.pspnl.get_stats({'dev-id': cfg.psp_dev_id})[key]
|
|
|
|
#
|
|
# Test case boiler plate
|
|
#
|
|
|
|
def _init_psp_dev(cfg):
|
|
if not hasattr(cfg, 'psp_dev_id'):
|
|
# Figure out which local device we are testing against
|
|
for dev in cfg.pspnl.dev_get({}, dump=True):
|
|
if dev['ifindex'] == cfg.ifindex:
|
|
cfg.psp_info = dev
|
|
cfg.psp_dev_id = cfg.psp_info['id']
|
|
break
|
|
else:
|
|
raise KsftSkipEx("No PSP devices found")
|
|
|
|
# Enable PSP if necessary
|
|
cap = cfg.psp_info['psp-versions-cap']
|
|
ena = cfg.psp_info['psp-versions-ena']
|
|
if cap != ena:
|
|
cfg.pspnl.dev_set({'id': cfg.psp_dev_id, 'psp-versions-ena': cap})
|
|
defer(cfg.pspnl.dev_set, {'id': cfg.psp_dev_id,
|
|
'psp-versions-ena': ena })
|
|
|
|
#
|
|
# Test cases
|
|
#
|
|
|
|
def dev_list_devices(cfg):
|
|
""" Dump all devices """
|
|
_init_psp_dev(cfg)
|
|
|
|
devices = cfg.pspnl.dev_get({}, dump=True)
|
|
|
|
found = False
|
|
for dev in devices:
|
|
found |= dev['id'] == cfg.psp_dev_id
|
|
ksft_true(found)
|
|
|
|
|
|
def dev_get_device(cfg):
|
|
""" Get the device we intend to use """
|
|
_init_psp_dev(cfg)
|
|
|
|
dev = cfg.pspnl.dev_get({'id': cfg.psp_dev_id})
|
|
ksft_eq(dev['id'], cfg.psp_dev_id)
|
|
|
|
|
|
def dev_get_device_bad(cfg):
|
|
""" Test getting device which doesn't exist """
|
|
raised = False
|
|
try:
|
|
cfg.pspnl.dev_get({'id': 1234567})
|
|
except NlError as e:
|
|
ksft_eq(e.nl_msg.error, -errno.ENODEV)
|
|
raised = True
|
|
ksft_true(raised)
|
|
|
|
|
|
def dev_rotate(cfg):
|
|
""" Test key rotation """
|
|
_init_psp_dev(cfg)
|
|
|
|
prev_rotations = _get_stat(cfg, 'key-rotations')
|
|
|
|
rot = cfg.pspnl.key_rotate({"id": cfg.psp_dev_id})
|
|
ksft_eq(rot['id'], cfg.psp_dev_id)
|
|
rot = cfg.pspnl.key_rotate({"id": cfg.psp_dev_id})
|
|
ksft_eq(rot['id'], cfg.psp_dev_id)
|
|
|
|
cur_rotations = _get_stat(cfg, 'key-rotations')
|
|
ksft_eq(cur_rotations, prev_rotations + 2)
|
|
|
|
|
|
def dev_rotate_spi(cfg):
|
|
""" Test key rotation and SPI check """
|
|
_init_psp_dev(cfg)
|
|
|
|
top_a = top_b = 0
|
|
with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
|
|
assoc_a = cfg.pspnl.rx_assoc({"version": 0,
|
|
"dev-id": cfg.psp_dev_id,
|
|
"sock-fd": s.fileno()})
|
|
top_a = assoc_a['rx-key']['spi'] >> 31
|
|
s.close()
|
|
rot = cfg.pspnl.key_rotate({"id": cfg.psp_dev_id})
|
|
with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
|
|
ksft_eq(rot['id'], cfg.psp_dev_id)
|
|
assoc_b = cfg.pspnl.rx_assoc({"version": 0,
|
|
"dev-id": cfg.psp_dev_id,
|
|
"sock-fd": s.fileno()})
|
|
top_b = assoc_b['rx-key']['spi'] >> 31
|
|
s.close()
|
|
ksft_ne(top_a, top_b)
|
|
|
|
|
|
def assoc_basic(cfg):
|
|
""" Test creating associations """
|
|
_init_psp_dev(cfg)
|
|
|
|
with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
|
|
assoc = cfg.pspnl.rx_assoc({"version": 0,
|
|
"dev-id": cfg.psp_dev_id,
|
|
"sock-fd": s.fileno()})
|
|
ksft_eq(assoc['dev-id'], cfg.psp_dev_id)
|
|
ksft_gt(assoc['rx-key']['spi'], 0)
|
|
ksft_eq(len(assoc['rx-key']['key']), 16)
|
|
|
|
assoc = cfg.pspnl.tx_assoc({"dev-id": cfg.psp_dev_id,
|
|
"version": 0,
|
|
"tx-key": assoc['rx-key'],
|
|
"sock-fd": s.fileno()})
|
|
ksft_eq(len(assoc), 0)
|
|
s.close()
|
|
|
|
|
|
def assoc_bad_dev(cfg):
|
|
""" Test creating associations with bad device ID """
|
|
_init_psp_dev(cfg)
|
|
|
|
with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
|
|
with ksft_raises(NlError) as cm:
|
|
cfg.pspnl.rx_assoc({"version": 0,
|
|
"dev-id": cfg.psp_dev_id + 1234567,
|
|
"sock-fd": s.fileno()})
|
|
ksft_eq(cm.exception.nl_msg.error, -errno.ENODEV)
|
|
|
|
|
|
def assoc_sk_only_conn(cfg):
|
|
""" Test creating associations based on socket """
|
|
_init_psp_dev(cfg)
|
|
|
|
with _make_clr_conn(cfg) as s:
|
|
assoc = cfg.pspnl.rx_assoc({"version": 0,
|
|
"sock-fd": s.fileno()})
|
|
ksft_eq(assoc['dev-id'], cfg.psp_dev_id)
|
|
cfg.pspnl.tx_assoc({"version": 0,
|
|
"tx-key": assoc['rx-key'],
|
|
"sock-fd": s.fileno()})
|
|
_close_conn(cfg, s)
|
|
|
|
|
|
def assoc_sk_only_mismatch(cfg):
|
|
""" Test creating associations based on socket (dev mismatch) """
|
|
_init_psp_dev(cfg)
|
|
|
|
with _make_clr_conn(cfg) as s:
|
|
with ksft_raises(NlError) as cm:
|
|
cfg.pspnl.rx_assoc({"version": 0,
|
|
"dev-id": cfg.psp_dev_id + 1234567,
|
|
"sock-fd": s.fileno()})
|
|
the_exception = cm.exception
|
|
ksft_eq(the_exception.nl_msg.extack['bad-attr'], ".dev-id")
|
|
ksft_eq(the_exception.nl_msg.error, -errno.EINVAL)
|
|
|
|
|
|
def assoc_sk_only_mismatch_tx(cfg):
|
|
""" Test creating associations based on socket (dev mismatch) """
|
|
_init_psp_dev(cfg)
|
|
|
|
with _make_clr_conn(cfg) as s:
|
|
with ksft_raises(NlError) as cm:
|
|
assoc = cfg.pspnl.rx_assoc({"version": 0,
|
|
"sock-fd": s.fileno()})
|
|
cfg.pspnl.tx_assoc({"version": 0,
|
|
"tx-key": assoc['rx-key'],
|
|
"dev-id": cfg.psp_dev_id + 1234567,
|
|
"sock-fd": s.fileno()})
|
|
the_exception = cm.exception
|
|
ksft_eq(the_exception.nl_msg.extack['bad-attr'], ".dev-id")
|
|
ksft_eq(the_exception.nl_msg.error, -errno.EINVAL)
|
|
|
|
|
|
def assoc_sk_only_unconn(cfg):
|
|
""" Test creating associations based on socket (unconnected, should fail) """
|
|
_init_psp_dev(cfg)
|
|
|
|
with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
|
|
with ksft_raises(NlError) as cm:
|
|
cfg.pspnl.rx_assoc({"version": 0,
|
|
"sock-fd": s.fileno()})
|
|
the_exception = cm.exception
|
|
ksft_eq(the_exception.nl_msg.extack['miss-type'], "dev-id")
|
|
ksft_eq(the_exception.nl_msg.error, -errno.EINVAL)
|
|
|
|
|
|
def assoc_version_mismatch(cfg):
|
|
""" Test creating associations where Rx and Tx PSP versions do not match """
|
|
_init_psp_dev(cfg)
|
|
|
|
versions = list(cfg.psp_info['psp-versions-cap'])
|
|
if len(versions) < 2:
|
|
raise KsftSkipEx("Not enough PSP versions supported by the device for the test")
|
|
|
|
# Translate versions to integers
|
|
versions = [cfg.pspnl.consts["version"].entries[v].value for v in versions]
|
|
|
|
with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
|
|
rx = cfg.pspnl.rx_assoc({"version": versions[0],
|
|
"dev-id": cfg.psp_dev_id,
|
|
"sock-fd": s.fileno()})
|
|
|
|
for version in versions[1:]:
|
|
with ksft_raises(NlError) as cm:
|
|
cfg.pspnl.tx_assoc({"dev-id": cfg.psp_dev_id,
|
|
"version": version,
|
|
"tx-key": rx['rx-key'],
|
|
"sock-fd": s.fileno()})
|
|
the_exception = cm.exception
|
|
ksft_eq(the_exception.nl_msg.error, -errno.EINVAL)
|
|
|
|
|
|
def assoc_twice(cfg):
|
|
""" Test reusing Tx assoc for two sockets """
|
|
_init_psp_dev(cfg)
|
|
|
|
def rx_assoc_check(s):
|
|
assoc = cfg.pspnl.rx_assoc({"version": 0,
|
|
"dev-id": cfg.psp_dev_id,
|
|
"sock-fd": s.fileno()})
|
|
ksft_eq(assoc['dev-id'], cfg.psp_dev_id)
|
|
ksft_gt(assoc['rx-key']['spi'], 0)
|
|
ksft_eq(len(assoc['rx-key']['key']), 16)
|
|
|
|
return assoc
|
|
|
|
with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
|
|
assoc = rx_assoc_check(s)
|
|
tx = cfg.pspnl.tx_assoc({"dev-id": cfg.psp_dev_id,
|
|
"version": 0,
|
|
"tx-key": assoc['rx-key'],
|
|
"sock-fd": s.fileno()})
|
|
ksft_eq(len(tx), 0)
|
|
|
|
# Use the same Tx assoc second time
|
|
with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s2:
|
|
rx_assoc_check(s2)
|
|
tx = cfg.pspnl.tx_assoc({"dev-id": cfg.psp_dev_id,
|
|
"version": 0,
|
|
"tx-key": assoc['rx-key'],
|
|
"sock-fd": s2.fileno()})
|
|
ksft_eq(len(tx), 0)
|
|
|
|
s.close()
|
|
|
|
|
|
def _data_basic_send(cfg, version, ipver):
|
|
""" Test basic data send """
|
|
_init_psp_dev(cfg)
|
|
|
|
# Version 0 is required by spec, don't let it skip
|
|
if version:
|
|
name = cfg.pspnl.consts["version"].entries_by_val[version].name
|
|
if name not in cfg.psp_info['psp-versions-cap']:
|
|
with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
|
|
with ksft_raises(NlError) as cm:
|
|
cfg.pspnl.rx_assoc({"version": version,
|
|
"dev-id": cfg.psp_dev_id,
|
|
"sock-fd": s.fileno()})
|
|
ksft_eq(cm.exception.nl_msg.error, -errno.EOPNOTSUPP)
|
|
raise KsftSkipEx("PSP version not supported", name)
|
|
|
|
s = _make_psp_conn(cfg, version, ipver)
|
|
|
|
rx_assoc = cfg.pspnl.rx_assoc({"version": version,
|
|
"dev-id": cfg.psp_dev_id,
|
|
"sock-fd": s.fileno()})
|
|
rx = rx_assoc['rx-key']
|
|
tx = _spi_xchg(s, rx)
|
|
|
|
cfg.pspnl.tx_assoc({"dev-id": cfg.psp_dev_id,
|
|
"version": version,
|
|
"tx-key": tx,
|
|
"sock-fd": s.fileno()})
|
|
|
|
data_len = _send_careful(cfg, s, 100)
|
|
_check_data_rx(cfg, data_len)
|
|
_close_psp_conn(cfg, s)
|
|
|
|
|
|
def __bad_xfer_do(cfg, s, tx, version='hdr0-aes-gcm-128'):
|
|
# Make sure we accept the ACK for the SPI before we seal with the bad assoc
|
|
_check_data_outq(s, 0)
|
|
|
|
cfg.pspnl.tx_assoc({"dev-id": cfg.psp_dev_id,
|
|
"version": version,
|
|
"tx-key": tx,
|
|
"sock-fd": s.fileno()})
|
|
|
|
data_len = _send_careful(cfg, s, 20)
|
|
_check_data_outq(s, data_len, force_wait=True)
|
|
_check_data_rx(cfg, 0)
|
|
_close_psp_conn(cfg, s)
|
|
|
|
|
|
def data_send_bad_key(cfg):
|
|
""" Test send data with bad key """
|
|
_init_psp_dev(cfg)
|
|
|
|
s = _make_psp_conn(cfg)
|
|
|
|
rx_assoc = cfg.pspnl.rx_assoc({"version": 0,
|
|
"dev-id": cfg.psp_dev_id,
|
|
"sock-fd": s.fileno()})
|
|
rx = rx_assoc['rx-key']
|
|
tx = _spi_xchg(s, rx)
|
|
tx['key'] = (tx['key'][0] ^ 0xff).to_bytes(1, 'little') + tx['key'][1:]
|
|
__bad_xfer_do(cfg, s, tx)
|
|
|
|
|
|
def data_send_disconnect(cfg):
|
|
""" Test socket close after sending data """
|
|
_init_psp_dev(cfg)
|
|
|
|
with _make_psp_conn(cfg) as s:
|
|
assoc = cfg.pspnl.rx_assoc({"version": 0,
|
|
"sock-fd": s.fileno()})
|
|
tx = _spi_xchg(s, assoc['rx-key'])
|
|
cfg.pspnl.tx_assoc({"version": 0,
|
|
"tx-key": tx,
|
|
"sock-fd": s.fileno()})
|
|
|
|
data_len = _send_careful(cfg, s, 100)
|
|
_check_data_rx(cfg, data_len)
|
|
|
|
s.shutdown(socket.SHUT_RDWR)
|
|
s.close()
|
|
|
|
|
|
def _data_mss_adjust(cfg, ipver):
|
|
_init_psp_dev(cfg)
|
|
|
|
# First figure out what the MSS would be without any adjustments
|
|
s = _make_clr_conn(cfg, ipver)
|
|
s.send(b"0123456789abcdef" * 1024)
|
|
_check_data_rx(cfg, 16 * 1024)
|
|
mss = s.getsockopt(socket.IPPROTO_TCP, socket.TCP_MAXSEG)
|
|
_close_conn(cfg, s)
|
|
|
|
s = _make_psp_conn(cfg, 0, ipver)
|
|
try:
|
|
rx_assoc = cfg.pspnl.rx_assoc({"version": 0,
|
|
"dev-id": cfg.psp_dev_id,
|
|
"sock-fd": s.fileno()})
|
|
rx = rx_assoc['rx-key']
|
|
tx = _spi_xchg(s, rx)
|
|
|
|
rxmss = s.getsockopt(socket.IPPROTO_TCP, socket.TCP_MAXSEG)
|
|
ksft_eq(mss, rxmss)
|
|
|
|
cfg.pspnl.tx_assoc({"dev-id": cfg.psp_dev_id,
|
|
"version": 0,
|
|
"tx-key": tx,
|
|
"sock-fd": s.fileno()})
|
|
|
|
txmss = s.getsockopt(socket.IPPROTO_TCP, socket.TCP_MAXSEG)
|
|
ksft_eq(mss, txmss + 40)
|
|
|
|
data_len = _send_careful(cfg, s, 100)
|
|
_check_data_rx(cfg, data_len)
|
|
_check_data_outq(s, 0)
|
|
|
|
txmss = s.getsockopt(socket.IPPROTO_TCP, socket.TCP_MAXSEG)
|
|
ksft_eq(mss, txmss + 40)
|
|
finally:
|
|
_close_psp_conn(cfg, s)
|
|
|
|
|
|
def data_stale_key(cfg):
|
|
""" Test send on a double-rotated key """
|
|
_init_psp_dev(cfg)
|
|
|
|
prev_stale = _get_stat(cfg, 'stale-events')
|
|
s = _make_psp_conn(cfg)
|
|
try:
|
|
rx_assoc = cfg.pspnl.rx_assoc({"version": 0,
|
|
"dev-id": cfg.psp_dev_id,
|
|
"sock-fd": s.fileno()})
|
|
rx = rx_assoc['rx-key']
|
|
tx = _spi_xchg(s, rx)
|
|
|
|
cfg.pspnl.tx_assoc({"dev-id": cfg.psp_dev_id,
|
|
"version": 0,
|
|
"tx-key": tx,
|
|
"sock-fd": s.fileno()})
|
|
|
|
data_len = _send_careful(cfg, s, 100)
|
|
_check_data_rx(cfg, data_len)
|
|
_check_data_outq(s, 0)
|
|
|
|
cfg.pspnl.key_rotate({"id": cfg.psp_dev_id})
|
|
cfg.pspnl.key_rotate({"id": cfg.psp_dev_id})
|
|
|
|
cur_stale = _get_stat(cfg, 'stale-events')
|
|
ksft_gt(cur_stale, prev_stale)
|
|
|
|
s.send(b'0123456789' * 200)
|
|
_check_data_outq(s, 2000, force_wait=True)
|
|
finally:
|
|
_close_psp_conn(cfg, s)
|
|
|
|
|
|
def __nsim_psp_rereg(cfg):
|
|
# The PSP dev ID will change, remember what was there before
|
|
before = set([x['id'] for x in cfg.pspnl.dev_get({}, dump=True)])
|
|
|
|
cfg._ns.nsims[0].dfs_write('psp_rereg', '1')
|
|
|
|
after = set([x['id'] for x in cfg.pspnl.dev_get({}, dump=True)])
|
|
|
|
new_devs = list(after - before)
|
|
ksft_eq(len(new_devs), 1)
|
|
cfg.psp_dev_id = list(after - before)[0]
|
|
|
|
|
|
def removal_device_rx(cfg):
|
|
""" Test removing a netdev / PSD with active Rx assoc """
|
|
|
|
# We could technically devlink reload real devices, too
|
|
# but that kills the control socket. So test this on
|
|
# netdevsim only for now
|
|
cfg.require_nsim()
|
|
|
|
s = _make_clr_conn(cfg)
|
|
try:
|
|
rx_assoc = cfg.pspnl.rx_assoc({"version": 0,
|
|
"dev-id": cfg.psp_dev_id,
|
|
"sock-fd": s.fileno()})
|
|
ksft_not_none(rx_assoc)
|
|
|
|
__nsim_psp_rereg(cfg)
|
|
finally:
|
|
_close_conn(cfg, s)
|
|
|
|
|
|
def removal_device_bi(cfg):
|
|
""" Test removing a netdev / PSD with active Rx/Tx assoc """
|
|
|
|
# We could technically devlink reload real devices, too
|
|
# but that kills the control socket. So test this on
|
|
# netdevsim only for now
|
|
cfg.require_nsim()
|
|
|
|
s = _make_clr_conn(cfg)
|
|
try:
|
|
rx_assoc = cfg.pspnl.rx_assoc({"version": 0,
|
|
"dev-id": cfg.psp_dev_id,
|
|
"sock-fd": s.fileno()})
|
|
cfg.pspnl.tx_assoc({"dev-id": cfg.psp_dev_id,
|
|
"version": 0,
|
|
"tx-key": rx_assoc['rx-key'],
|
|
"sock-fd": s.fileno()})
|
|
__nsim_psp_rereg(cfg)
|
|
finally:
|
|
_close_conn(cfg, s)
|
|
|
|
|
|
def psp_ip_ver_test_builder(name, test_func, psp_ver, ipver):
|
|
"""Build test cases for each combo of PSP version and IP version"""
|
|
def test_case(cfg):
|
|
cfg.require_ipver(ipver)
|
|
test_func(cfg, psp_ver, ipver)
|
|
|
|
test_case.__name__ = f"{name}_v{psp_ver}_ip{ipver}"
|
|
return test_case
|
|
|
|
|
|
def ipver_test_builder(name, test_func, ipver):
|
|
"""Build test cases for each IP version"""
|
|
def test_case(cfg):
|
|
cfg.require_ipver(ipver)
|
|
test_func(cfg, ipver)
|
|
|
|
test_case.__name__ = f"{name}_ip{ipver}"
|
|
return test_case
|
|
|
|
|
|
def main() -> None:
|
|
""" Ksft boiler plate main """
|
|
|
|
with NetDrvEpEnv(__file__) as cfg:
|
|
cfg.pspnl = PSPFamily()
|
|
|
|
# Set up responder and communication sock
|
|
responder = cfg.remote.deploy("psp_responder")
|
|
|
|
cfg.comm_port = rand_port()
|
|
srv = None
|
|
try:
|
|
with bkg(responder + f" -p {cfg.comm_port}", host=cfg.remote,
|
|
exit_wait=True) as srv:
|
|
wait_port_listen(cfg.comm_port, host=cfg.remote)
|
|
|
|
cfg.comm_sock = socket.create_connection((cfg.remote_addr,
|
|
cfg.comm_port),
|
|
timeout=1)
|
|
|
|
cases = [
|
|
psp_ip_ver_test_builder(
|
|
"data_basic_send", _data_basic_send, version, ipver
|
|
)
|
|
for version in range(0, 4)
|
|
for ipver in ("4", "6")
|
|
]
|
|
cases += [
|
|
ipver_test_builder("data_mss_adjust", _data_mss_adjust, ipver)
|
|
for ipver in ("4", "6")
|
|
]
|
|
|
|
ksft_run(cases=cases, globs=globals(),
|
|
case_pfx={"dev_", "data_", "assoc_", "removal_"},
|
|
args=(cfg, ))
|
|
|
|
cfg.comm_sock.send(b"exit\0")
|
|
cfg.comm_sock.close()
|
|
finally:
|
|
if srv and (srv.stdout or srv.stderr):
|
|
ksft_pr("")
|
|
ksft_pr(f"Responder logs ({srv.ret}):")
|
|
if srv and srv.stdout:
|
|
ksft_pr("STDOUT:\n# " + srv.stdout.strip().replace("\n", "\n# "))
|
|
if srv and srv.stderr:
|
|
ksft_pr("STDERR:\n# " + srv.stderr.strip().replace("\n", "\n# "))
|
|
ksft_exit()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|