#!/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()