#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0
"""
Driver-related behavior tests for RSS.
"""
from lib.py import ksft_run, ksft_exit, ksft_eq, ksft_ge
from lib.py import ksft_variants, KsftNamedVariant, KsftSkipEx, ksft_raises
from lib.py import defer, ethtool, CmdExitFailure
from lib.py import EthtoolFamily, NlError
from lib.py import NetDrvEnv
def _is_power_of_two(n):
return n > 0 and (n & (n - 1)) == 0
def _get_rss(cfg, context=0):
return ethtool(f"-x {cfg.ifname} context {context}", json=True)[0]
def _test_rss_indir_size(cfg, qcnt, context=0):
"""Test that indirection table size is at least 4x queue count."""
ethtool(f"-L {cfg.ifname} combined {qcnt}")
rss = _get_rss(cfg, context=context)
indir = rss['rss-indirection-table']
ksft_ge(len(indir), 4 * qcnt, "Table smaller than 4x")
return len(indir)
def _maybe_create_context(cfg, create_context):
""" Either create a context and return its ID or return 0 for main ctx """
if not create_context:
return 0
try:
ctx = cfg.ethnl.rss_create_act({'header': {'dev-index': cfg.ifindex}})
ctx_id = ctx['context']
defer(cfg.ethnl.rss_delete_act,
{'header': {'dev-index': cfg.ifindex}, 'context': ctx_id})
except NlError:
raise KsftSkipEx("Device does not support additional RSS contexts")
return ctx_id
def _require_dynamic_indir_size(cfg, ch_max):
"""Skip if the device does not dynamically size its indirection table."""
ethtool(f"-X {cfg.ifname} default")
ethtool(f"-L {cfg.ifname} combined 2")
small = len(_get_rss(cfg)['rss-indirection-table'])
ethtool(f"-L {cfg.ifname} combined {ch_max}")
large = len(_get_rss(cfg)['rss-indirection-table'])
if small == large:
raise KsftSkipEx("Device does not dynamically size indirection table")
@ksft_variants([
KsftNamedVariant("main", False),
KsftNamedVariant("ctx", True),
])
def indir_size_4x(cfg, create_context):
"""
Test that the indirection table has at least 4 entries per queue.
Empirically network-heavy workloads like memcache suffer with the 33%
imbalance of a 2x indirection table size.
4x table translates to a 16% imbalance.
"""
channels = cfg.ethnl.channels_get({'header': {'dev-index': cfg.ifindex}})
ch_max = channels.get('combined-max', 0)
qcnt = channels['combined-count']
if ch_max < 3:
raise KsftSkipEx(f"Not enough queues for the test: max={ch_max}")
defer(ethtool, f"-L {cfg.ifname} combined {qcnt}")
ethtool(f"-L {cfg.ifname} combined 3")
ctx_id = _maybe_create_context(cfg, create_context)
indir_sz = _test_rss_indir_size(cfg, 3, context=ctx_id)
# Test with max queue count (max - 1 if max is a power of two)
test_max = ch_max - 1 if _is_power_of_two(ch_max) else ch_max
if test_max > 3 and indir_sz < test_max * 4:
_test_rss_indir_size(cfg, test_max, context=ctx_id)
@ksft_variants([
KsftNamedVariant("main", False),
KsftNamedVariant("ctx", True),
])
def resize_periodic(cfg, create_context):
"""Test that a periodic indirection table survives channel changes.
Set a non-default periodic table ([3, 2, 1, 0] x N) via netlink,
reduce channels to trigger a fold, then increase to trigger an
unfold. Using a reversed pattern (instead of [0, 1, 2, 3]) ensures
the test can distinguish a correct fold from a driver that silently
resets the table to defaults. Verify the exact pattern is preserved
and the size tracks the channel count.
"""
channels = cfg.ethnl.channels_get({'header': {'dev-index': cfg.ifindex}})
ch_max = channels.get('combined-max', 0)
qcnt = channels['combined-count']
if ch_max < 4:
raise KsftSkipEx(f"Not enough queues for the test: max={ch_max}")
defer(ethtool, f"-L {cfg.ifname} combined {qcnt}")
_require_dynamic_indir_size(cfg, ch_max)
ctx_id = _maybe_create_context(cfg, create_context)
# Set a non-default periodic pattern via netlink.
# Send only 4 entries (user_size=4) so the kernel replicates it
# to fill the device table. This allows folding down to 4 entries.
rss = _get_rss(cfg, context=ctx_id)
orig_size = len(rss['rss-indirection-table'])
pattern = [3, 2, 1, 0]
req = {'header': {'dev-index': cfg.ifindex}, 'indir': pattern}
if ctx_id:
req['context'] = ctx_id
else:
defer(ethtool, f"-X {cfg.ifname} default")
cfg.ethnl.rss_set(req)
# Shrink — should fold
ethtool(f"-L {cfg.ifname} combined 4")
rss = _get_rss(cfg, context=ctx_id)
indir = rss['rss-indirection-table']
ksft_ge(orig_size, len(indir), "Table did not shrink")
ksft_eq(indir, [3, 2, 1, 0] * (len(indir) // 4),
"Folded table has wrong pattern")
# Grow back — should unfold
ethtool(f"-L {cfg.ifname} combined {ch_max}")
rss = _get_rss(cfg, context=ctx_id)
indir = rss['rss-indirection-table']
ksft_eq(len(indir), orig_size, "Table size not restored")
ksft_eq(indir, [3, 2, 1, 0] * (len(indir) // 4),
"Unfolded table has wrong pattern")
@ksft_variants([
KsftNamedVariant("main", False),
KsftNamedVariant("ctx", True),
])
def resize_below_user_size_reject(cfg, create_context):
"""Test that shrinking below user_size is rejected.
Send a table via netlink whose size (user_size) sits between
the small and large device table sizes. The table is periodic,
so folding would normally succeed, but the user_size floor must
prevent it.
"""
channels = cfg.ethnl.channels_get({'header': {'dev-index': cfg.ifindex}})
ch_max = channels.get('combined-max', 0)
qcnt = channels['combined-count']
if ch_max < 4:
raise KsftSkipEx(f"Not enough queues for the test: max={ch_max}")
defer(ethtool, f"-L {cfg.ifname} combined {qcnt}")
_require_dynamic_indir_size(cfg, ch_max)
ctx_id = _maybe_create_context(cfg, create_context)
# Measure the table size at max channels
rss = _get_rss(cfg, context=ctx_id)
big_size = len(rss['rss-indirection-table'])
# Measure the table size at reduced channels
ethtool(f"-L {cfg.ifname} combined 4")
rss = _get_rss(cfg, context=ctx_id)
small_size = len(rss['rss-indirection-table'])
ethtool(f"-L {cfg.ifname} combined {ch_max}")
if small_size >= big_size:
raise KsftSkipEx("Table did not shrink at reduced channels")
# Find a user_size
user_size = None
for div in [2, 4]:
candidate = big_size // div
if candidate > small_size and big_size % candidate == 0:
user_size = candidate
break
if user_size is None:
raise KsftSkipEx("No suitable user_size between small and big table")
# Send a periodic sub-table of exactly user_size entries.
# Pattern safe for 4 channels.
pattern = [0, 1, 2, 3] * (user_size // 4)
if len(pattern) != user_size:
raise KsftSkipEx(f"user_size ({user_size}) not divisible by 4")
req = {'header': {'dev-index': cfg.ifindex}, 'indir': pattern}
if ctx_id:
req['context'] = ctx_id
else:
defer(ethtool, f"-X {cfg.ifname} default")
cfg.ethnl.rss_set(req)
# Shrink channels — table would go to small_size < user_size.
# The table is periodic so folding would work, but user_size
# floor must reject it.
with ksft_raises(CmdExitFailure):
ethtool(f"-L {cfg.ifname} combined 4")
@ksft_variants([
KsftNamedVariant("main", False),
KsftNamedVariant("ctx", True),
])
def resize_nonperiodic_reject(cfg, create_context):
"""Test that a non-periodic table blocks channel reduction.
Set equal weight across all queues so the table is not periodic
at any smaller size, then verify channel reduction is rejected.
An additional context with a periodic table is created to verify
that validation catches the non-periodic one even when others
are fine.
"""
channels = cfg.ethnl.channels_get({'header': {'dev-index': cfg.ifindex}})
ch_max = channels.get('combined-max', 0)
qcnt = channels['combined-count']
if ch_max < 4:
raise KsftSkipEx(f"Not enough queues for the test: max={ch_max}")
defer(ethtool, f"-L {cfg.ifname} combined {qcnt}")
_require_dynamic_indir_size(cfg, ch_max)
ctx_id = _maybe_create_context(cfg, create_context)
ctx_ref = f"context {ctx_id}" if ctx_id else ""
# Create an extra context with a periodic (foldable) table so that
# the validation must iterate all contexts to find the bad one.
extra_ctx = _maybe_create_context(cfg, True)
ethtool(f"-X {cfg.ifname} context {extra_ctx} equal 2")
ethtool(f"-X {cfg.ifname} {ctx_ref} equal {ch_max}")
if not create_context:
defer(ethtool, f"-X {cfg.ifname} default")
with ksft_raises(CmdExitFailure):
ethtool(f"-L {cfg.ifname} combined 2")
@ksft_variants([
KsftNamedVariant("main", False),
KsftNamedVariant("ctx", True),
])
def resize_nonperiodic_no_corruption(cfg, create_context):
"""Test that a failed resize does not corrupt table or channel count.
Set a non-periodic table, attempt a channel reduction (which must
fail), then verify both the indirection table contents and the
channel count are unchanged.
"""
channels = cfg.ethnl.channels_get({'header': {'dev-index': cfg.ifindex}})
ch_max = channels.get('combined-max', 0)
qcnt = channels['combined-count']
if ch_max < 4:
raise KsftSkipEx(f"Not enough queues for the test: max={ch_max}")
defer(ethtool, f"-L {cfg.ifname} combined {qcnt}")
_require_dynamic_indir_size(cfg, ch_max)
ctx_id = _maybe_create_context(cfg, create_context)
ctx_ref = f"context {ctx_id}" if ctx_id else ""
ethtool(f"-X {cfg.ifname} {ctx_ref} equal {ch_max}")
if not create_context:
defer(ethtool, f"-X {cfg.ifname} default")
rss_before = _get_rss(cfg, context=ctx_id)
with ksft_raises(CmdExitFailure):
ethtool(f"-L {cfg.ifname} combined 2")
rss_after = _get_rss(cfg, context=ctx_id)
ksft_eq(rss_after['rss-indirection-table'],
rss_before['rss-indirection-table'],
"Indirection table corrupted after failed resize")
channels = cfg.ethnl.channels_get({'header': {'dev-index': cfg.ifindex}})
ksft_eq(channels['combined-count'], ch_max,
"Channel count changed after failed resize")
def main() -> None:
""" Ksft boiler plate main """
with NetDrvEnv(__file__) as cfg:
cfg.ethnl = EthtoolFamily()
ksft_run([indir_size_4x, resize_periodic,
resize_below_user_size_reject,
resize_nonperiodic_reject,
resize_nonperiodic_no_corruption], args=(cfg, ))
ksft_exit()
if __name__ == "__main__":
main()
