path: root/tools/testing/selftests/drivers/net/hw/rss_api.py

#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0

"""
API level tests for RSS (mostly Netlink vs IOCTL).
"""

import errno
import glob
import random
from lib.py import ksft_run, ksft_exit, ksft_eq, ksft_is, ksft_ne, ksft_raises
from lib.py import KsftSkipEx, KsftFailEx
from lib.py import defer, ethtool, CmdExitFailure
from lib.py import EthtoolFamily, NlError
from lib.py import NetDrvEnv


def _require_2qs(cfg):
    qcnt = len(glob.glob(f"/sys/class/net/{cfg.ifname}/queues/rx-*"))
    if qcnt < 2:
        raise KsftSkipEx(f"Local has only {qcnt} queues")
    return qcnt


def _ethtool_create(cfg, act, opts):
    output = ethtool(f"{act} {cfg.ifname} {opts}").stdout
    # Output will be something like: "New RSS context is 1" or
    # "Added rule with ID 7", we want the integer from the end
    return int(output.split()[-1])


def _ethtool_get_cfg(cfg, fl_type, to_nl=False):
    descr = ethtool(f"-n {cfg.ifname} rx-flow-hash {fl_type}").stdout

    if to_nl:
        converter = {
            "IP SA": "ip-src",
            "IP DA": "ip-dst",
            "L4 bytes 0 & 1 [TCP/UDP src port]": "l4-b-0-1",
            "L4 bytes 2 & 3 [TCP/UDP dst port]": "l4-b-2-3",
        }

        ret = set()
    else:
        converter = {
            "IP SA": "s",
            "IP DA": "d",
            "L3 proto": "t",
            "L4 bytes 0 & 1 [TCP/UDP src port]": "f",
            "L4 bytes 2 & 3 [TCP/UDP dst port]": "n",
        }

        ret = ""

    for line in descr.split("\n")[1:-2]:
        # if this raises we probably need to add more keys to converter above
        if to_nl:
            ret.add(converter[line])
        else:
            ret += converter[line]
    return ret


def test_rxfh_nl_set_fail(cfg):
    """
    Test error path of Netlink SET.
    """
    _require_2qs(cfg)

    ethnl = EthtoolFamily()
    ethnl.ntf_subscribe("monitor")

    with ksft_raises(NlError):
        ethnl.rss_set({"header": {"dev-name": "lo"},
                       "indir": None})

    with ksft_raises(NlError):
        ethnl.rss_set({"header": {"dev-index": cfg.ifindex},
                       "indir": [100000]})
    ntf = next(ethnl.poll_ntf(duration=0.2), None)
    ksft_is(ntf, None)


def test_rxfh_nl_set_indir(cfg):
    """
    Test setting indirection table via Netlink.
    """
    qcnt = _require_2qs(cfg)

    # Test some SETs with a value
    reset = defer(cfg.ethnl.rss_set,
                  {"header": {"dev-index": cfg.ifindex}, "indir": None})
    cfg.ethnl.rss_set({"header": {"dev-index": cfg.ifindex},
                       "indir": [1]})
    rss = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
    ksft_eq(set(rss.get("indir", [-1])), {1})

    cfg.ethnl.rss_set({"header": {"dev-index": cfg.ifindex},
                       "indir": [0, 1]})
    rss = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
    ksft_eq(set(rss.get("indir", [-1])), {0, 1})

    # Make sure we can't set the queue count below max queue used
    with ksft_raises(CmdExitFailure):
        ethtool(f"-L {cfg.ifname} combined 0 rx 1")
    with ksft_raises(CmdExitFailure):
        ethtool(f"-L {cfg.ifname} combined 1 rx 0")

    # Test reset back to default
    reset.exec()
    rss = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
    ksft_eq(set(rss.get("indir", [-1])), set(range(qcnt)))


def test_rxfh_nl_set_indir_ctx(cfg):
    """
    Test setting indirection table for a custom context via Netlink.
    """
    _require_2qs(cfg)

    # Get setting for ctx 0, we'll make sure they don't get clobbered
    dflt = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})

    # Create context
    ctx_id = _ethtool_create(cfg, "-X", "context new")
    defer(ethtool, f"-X {cfg.ifname} context {ctx_id} delete")

    cfg.ethnl.rss_set({"header": {"dev-index": cfg.ifindex},
                       "context": ctx_id, "indir": [1]})
    rss = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex},
                             "context": ctx_id})
    ksft_eq(set(rss.get("indir", [-1])), {1})

    ctx0 = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
    ksft_eq(ctx0, dflt)

    cfg.ethnl.rss_set({"header": {"dev-index": cfg.ifindex},
                       "context": ctx_id, "indir": [0, 1]})
    rss = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex},
                             "context": ctx_id})
    ksft_eq(set(rss.get("indir", [-1])), {0, 1})

    ctx0 = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
    ksft_eq(ctx0, dflt)

    # Make sure we can't set the queue count below max queue used
    with ksft_raises(CmdExitFailure):
        ethtool(f"-L {cfg.ifname} combined 0 rx 1")
    with ksft_raises(CmdExitFailure):
        ethtool(f"-L {cfg.ifname} combined 1 rx 0")


def test_rxfh_indir_ntf(cfg):
    """
    Check that Netlink notifications are generated when RSS indirection
    table was modified.
    """
    _require_2qs(cfg)

    ethnl = EthtoolFamily()
    ethnl.ntf_subscribe("monitor")

    ethtool(f"--disable-netlink -X {cfg.ifname} weight 0 1")
    reset = defer(ethtool, f"-X {cfg.ifname} default")

    ntf = next(ethnl.poll_ntf(duration=0.2), None)
    if ntf is None:
        raise KsftFailEx("No notification received")
    ksft_eq(ntf["name"], "rss-ntf")
    ksft_eq(set(ntf["msg"]["indir"]), {1})

    reset.exec()
    ntf = next(ethnl.poll_ntf(duration=0.2), None)
    if ntf is None:
        raise KsftFailEx("No notification received after reset")
    ksft_eq(ntf["name"], "rss-ntf")
    ksft_is(ntf["msg"].get("context"), None)
    ksft_ne(set(ntf["msg"]["indir"]), {1})


def test_rxfh_indir_ctx_ntf(cfg):
    """
    Check that Netlink notifications are generated when RSS indirection
    table was modified on an additional RSS context.
    """
    _require_2qs(cfg)

    ctx_id = _ethtool_create(cfg, "-X", "context new")
    defer(ethtool, f"-X {cfg.ifname} context {ctx_id} delete")

    ethnl = EthtoolFamily()
    ethnl.ntf_subscribe("monitor")

    ethtool(f"--disable-netlink -X {cfg.ifname} context {ctx_id} weight 0 1")

    ntf = next(ethnl.poll_ntf(duration=0.2), None)
    if ntf is None:
        raise KsftFailEx("No notification received")
    ksft_eq(ntf["name"], "rss-ntf")
    ksft_eq(ntf["msg"].get("context"), ctx_id)
    ksft_eq(set(ntf["msg"]["indir"]), {1})


def test_rxfh_nl_set_key(cfg):
    """
    Test setting hashing key via Netlink.
    """

    dflt = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
    defer(cfg.ethnl.rss_set,
          {"header": {"dev-index": cfg.ifindex},
           "hkey": dflt["hkey"], "indir": None})

    # Empty key should error out
    with ksft_raises(NlError) as cm:
        cfg.ethnl.rss_set({"header": {"dev-index": cfg.ifindex},
                           "hkey": None})
    ksft_eq(cm.exception.nl_msg.extack['bad-attr'], '.hkey')

    # Set key to random
    mod = random.randbytes(len(dflt["hkey"]))
    cfg.ethnl.rss_set({"header": {"dev-index": cfg.ifindex},
                       "hkey": mod})
    rss = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
    ksft_eq(rss.get("hkey", [-1]), mod)

    # Set key to random and indir tbl to something at once
    mod = random.randbytes(len(dflt["hkey"]))
    cfg.ethnl.rss_set({"header": {"dev-index": cfg.ifindex},
                       "indir": [0, 1], "hkey": mod})
    rss = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
    ksft_eq(rss.get("hkey", [-1]), mod)
    ksft_eq(set(rss.get("indir", [-1])), {0, 1})


def test_rxfh_fields(cfg):
    """
    Test reading Rx Flow Hash over Netlink.
    """

    flow_types = ["tcp4", "tcp6", "udp4", "udp6"]
    ethnl = EthtoolFamily()

    cfg_nl = ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
    for fl_type in flow_types:
        one = _ethtool_get_cfg(cfg, fl_type, to_nl=True)
        ksft_eq(one, cfg_nl["flow-hash"][fl_type],
                comment="Config for " + fl_type)


def test_rxfh_fields_set(cfg):
    """ Test configuring Rx Flow Hash over Netlink. """

    flow_types = ["tcp4", "tcp6", "udp4", "udp6"]

    # Collect current settings
    cfg_old = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
    # symmetric hashing is config-order-sensitive make sure we leave
    # symmetric mode, or make the flow-hash sym-compatible first
    changes = [{"flow-hash": cfg_old["flow-hash"],},
               {"input-xfrm": cfg_old.get("input-xfrm", {}),}]
    if cfg_old.get("input-xfrm"):
        changes = list(reversed(changes))
    for old in changes:
        defer(cfg.ethnl.rss_set, {"header": {"dev-index": cfg.ifindex},} | old)

    # symmetric hashing prevents some of the configs below
    if cfg_old.get("input-xfrm"):
        cfg.ethnl.rss_set({"header": {"dev-index": cfg.ifindex},
                           "input-xfrm": {}})

    for fl_type in flow_types:
        cur = _ethtool_get_cfg(cfg, fl_type)
        if cur == "sdfn":
            change_nl = {"ip-src", "ip-dst"}
            change_ic = "sd"
        else:
            change_nl = {"l4-b-0-1", "l4-b-2-3", "ip-src", "ip-dst"}
            change_ic = "sdfn"

        cfg.ethnl.rss_set({
            "header": {"dev-index": cfg.ifindex},
            "flow-hash": {fl_type: change_nl}
        })
        reset = defer(ethtool, f"--disable-netlink -N {cfg.ifname} "
                      f"rx-flow-hash {fl_type} {cur}")

        cfg_nl = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
        ksft_eq(change_nl, cfg_nl["flow-hash"][fl_type],
                comment=f"Config for {fl_type} over Netlink")
        cfg_ic = _ethtool_get_cfg(cfg, fl_type)
        ksft_eq(change_ic, cfg_ic,
                comment=f"Config for {fl_type} over IOCTL")

        reset.exec()
        cfg_nl = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
        ksft_eq(cfg_old["flow-hash"][fl_type], cfg_nl["flow-hash"][fl_type],
                comment=f"Un-config for {fl_type} over Netlink")
        cfg_ic = _ethtool_get_cfg(cfg, fl_type)
        ksft_eq(cur, cfg_ic, comment=f"Un-config for {fl_type} over IOCTL")

    # Try to set multiple at once, the defer was already installed at the start
    change = {"ip-src"}
    if change == cfg_old["flow-hash"]["tcp4"]:
        change = {"ip-dst"}
    cfg.ethnl.rss_set({
        "header": {"dev-index": cfg.ifindex},
        "flow-hash": {x: change for x in flow_types}
    })

    cfg_nl = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
    for fl_type in flow_types:
        ksft_eq(change, cfg_nl["flow-hash"][fl_type],
                comment=f"multi-config for {fl_type} over Netlink")


def test_rxfh_fields_set_xfrm(cfg):
    """ Test changing Rx Flow Hash vs xfrm_input at once.  """

    def set_rss(cfg, xfrm, fh):
        cfg.ethnl.rss_set({"header": {"dev-index": cfg.ifindex},
                           "input-xfrm": xfrm, "flow-hash": fh})

    # Install the reset handler
    cfg_old = cfg.ethnl.rss_get({"header": {"dev-index": cfg.ifindex}})
    # symmetric hashing is config-order-sensitive make sure we leave
    # symmetric mode, or make the flow-hash sym-compatible first
    changes = [{"flow-hash": cfg_old["flow-hash"],},
               {"input-xfrm": cfg_old.get("input-xfrm", {}),}]
    if cfg_old.get("input-xfrm"):
        changes = list(reversed(changes))
    for old in changes:
        defer(cfg.ethnl.rss_set, {"header": {"dev-index": cfg.ifindex},} | old)

    # Make sure we start with input-xfrm off, and tcp4 config non-sym
    set_rss(cfg, {}, {})
    set_rss(cfg, {}, {"tcp4": {"ip-src"}})

    # Setting sym and fixing tcp4 config not expected to pass right now
    with ksft_raises(NlError):
        set_rss(cfg, {"sym-xor"}, {"tcp4": {"ip-src", "ip-dst"}})
    # One at a time should work, hopefully
    set_rss(cfg, 0, {"tcp4": {"ip-src", "ip-dst"}})
    no_support = False
    try:
        set_rss(cfg, {"sym-xor"}, {})
    except NlError:
        try:
            set_rss(cfg, {"sym-or-xor"}, {})
        except NlError:
            no_support = True
    if no_support:
        raise KsftSkipEx("no input-xfrm supported")
    # Disabling two at once should not work either without kernel changes
    with ksft_raises(NlError):
        set_rss(cfg, {}, {"tcp4": {"ip-src"}})


def test_rxfh_fields_ntf(cfg):
    """ Test Rx Flow Hash notifications. """

    cur = _ethtool_get_cfg(cfg, "tcp4")
    if cur == "sdfn":
        change = {"ip-src", "ip-dst"}
    else:
        change = {"l4-b-0-1", "l4-b-2-3", "ip-src", "ip-dst"}

    ethnl = EthtoolFamily()
    ethnl.ntf_subscribe("monitor")

    ethnl.rss_set({
        "header": {"dev-index": cfg.ifindex},
        "flow-hash": {"tcp4": change}
    })
    reset = defer(ethtool,
                  f"--disable-netlink -N {cfg.ifname} rx-flow-hash tcp4 {cur}")

    ntf = next(ethnl.poll_ntf(duration=0.2), None)
    if ntf is None:
        raise KsftFailEx("No notification received after IOCTL change")
    ksft_eq(ntf["name"], "rss-ntf")
    ksft_eq(ntf["msg"]["flow-hash"]["tcp4"], change)
    ksft_eq(next(ethnl.poll_ntf(duration=0.01), None), None)

    reset.exec()
    ntf = next(ethnl.poll_ntf(duration=0.2), None)
    if ntf is None:
        raise KsftFailEx("No notification received after Netlink change")
    ksft_eq(ntf["name"], "rss-ntf")
    ksft_ne(ntf["msg"]["flow-hash"]["tcp4"], change)
    ksft_eq(next(ethnl.poll_ntf(duration=0.01), None), None)


def test_rss_ctx_add(cfg):
    """ Test creating an additional RSS context via Netlink """

    _require_2qs(cfg)

    # Test basic creation
    ctx = cfg.ethnl.rss_create_act({"header": {"dev-index": cfg.ifindex}})
    d = defer(ethtool, f"-X {cfg.ifname} context {ctx.get('context')} delete")
    ksft_ne(ctx.get("context", 0), 0)
    ksft_ne(set(ctx.get("indir", [0])), {0},
            comment="Driver should init the indirection table")

    # Try requesting the ID we just got allocated
    with ksft_raises(NlError) as cm:
        ctx = cfg.ethnl.rss_create_act({
            "header": {"dev-index": cfg.ifindex},
            "context": ctx.get("context"),
        })
        ethtool(f"-X {cfg.ifname} context {ctx.get('context')} delete")
    d.exec()
    ksft_eq(cm.exception.nl_msg.error, -errno.EBUSY)

    # Test creating with a specified RSS table, and context ID
    ctx_id = ctx.get("context")
    ctx = cfg.ethnl.rss_create_act({
        "header": {"dev-index": cfg.ifindex},
        "context": ctx_id,
        "indir": [1],
    })
    ethtool(f"-X {cfg.ifname} context {ctx.get('context')} delete")
    ksft_eq(ctx.get("context"), ctx_id)
    ksft_eq(set(ctx.get("indir", [0])), {1})


def test_rss_ctx_ntf(cfg):
    """ Test notifications for creating additional RSS contexts """

    ethnl = EthtoolFamily()
    ethnl.ntf_subscribe("monitor")

    # Create / delete via Netlink
    ctx = cfg.ethnl.rss_create_act({"header": {"dev-index": cfg.ifindex}})
    cfg.ethnl.rss_delete_act({
        "header": {"dev-index": cfg.ifindex},
        "context": ctx["context"],
    })

    ntf = next(ethnl.poll_ntf(duration=0.2), None)
    if ntf is None:
        raise KsftFailEx("[NL] No notification after context creation")
    ksft_eq(ntf["name"], "rss-create-ntf")
    ksft_eq(ctx, ntf["msg"])

    ntf = next(ethnl.poll_ntf(duration=0.2), None)
    if ntf is None:
        raise KsftFailEx("[NL] No notification after context deletion")
    ksft_eq(ntf["name"], "rss-delete-ntf")

    # Create / deleve via IOCTL
    ctx_id = _ethtool_create(cfg, "--disable-netlink -X", "context new")
    ethtool(f"--disable-netlink -X {cfg.ifname} context {ctx_id} delete")
    ntf = next(ethnl.poll_ntf(duration=0.2), None)
    if ntf is None:
        raise KsftFailEx("[IOCTL] No notification after context creation")
    ksft_eq(ntf["name"], "rss-create-ntf")

    ntf = next(ethnl.poll_ntf(duration=0.2), None)
    if ntf is None:
        raise KsftFailEx("[IOCTL] No notification after context deletion")
    ksft_eq(ntf["name"], "rss-delete-ntf")


def main() -> None:
    """ Ksft boiler plate main """

    with NetDrvEnv(__file__, nsim_test=False) as cfg:
        cfg.ethnl = EthtoolFamily()
        ksft_run(globs=globals(), case_pfx={"test_"}, args=(cfg, ))
    ksft_exit()


if __name__ == "__main__":
    main()