| #!/usr/bin/env python3 | |
| # SPDX-License-Identifier: GPL-2.0 | |
| import datetime | |
| import random | |
| import re | |
| import time | |
| from lib.py import ksft_disruptive | |
| from lib.py import ksft_run, ksft_pr, ksft_exit | |
| from lib.py import ksft_eq, ksft_ne, ksft_ge, ksft_in, ksft_lt, ksft_true, ksft_raises | |
| from lib.py import NetDrvEpEnv | |
| from lib.py import EthtoolFamily, NetdevFamily, NlError | |
| from lib.py import KsftSkipEx, KsftFailEx | |
| from lib.py import rand_port, rand_ports | |
| from lib.py import cmd, ethtool, ip, defer, CmdExitFailure, wait_file | |
| from lib.py import GenerateTraffic | |
| def _rss_key_str(key): | |
| return ":".join(["{:02x}".format(x) for x in key]) | |
| def _rss_key_rand(length): | |
| return [random.randint(0, 255) for _ in range(length)] | |
| def _rss_key_check(cfg, data=None, context=0): | |
| if data is None: | |
| data = get_rss(cfg, context=context) | |
| if 'rss-hash-key' not in data: | |
| return | |
| non_zero = [x for x in data['rss-hash-key'] if x != 0] | |
| ksft_eq(bool(non_zero), True, comment=f"RSS key is all zero {data['rss-hash-key']}") | |
| def get_rss(cfg, context=0): | |
| return ethtool(f"-x {cfg.ifname} context {context}", json=True)[0] | |
| def get_drop_err_sum(cfg): | |
| stats = ip("-s -s link show dev " + cfg.ifname, json=True)[0] | |
| cnt = 0 | |
| for key in ['errors', 'dropped', 'over_errors', 'fifo_errors', | |
| 'length_errors', 'crc_errors', 'missed_errors', | |
| 'frame_errors']: | |
| cnt += stats["stats64"]["rx"][key] | |
| return cnt, stats["stats64"]["tx"]["carrier_changes"] | |
| 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 require_ntuple(cfg): | |
| features = ethtool(f"-k {cfg.ifname}", json=True)[0] | |
| if not features["ntuple-filters"]["active"]: | |
| if features["ntuple-filters"]["fixed"]: | |
| raise KsftSkipEx("Device does not support ntuple-filters") | |
| ethtool(f"-K {cfg.ifname} ntuple-filters on") | |
| defer(ethtool, f"-K {cfg.ifname} ntuple-filters off") | |
| def require_context_cnt(cfg, need_cnt): | |
| # There's no good API to get the context count, so the tests | |
| # which try to add a lot opportunisitically set the count they | |
| # discovered. Careful with test ordering! | |
| if need_cnt and cfg.context_cnt and cfg.context_cnt < need_cnt: | |
| raise KsftSkipEx(f"Test requires at least {need_cnt} contexts, but device only has {cfg.context_cnt}") | |
| # Get Rx packet counts for all queues, as a simple list of integers | |
| # if @prev is specified the prev counts will be subtracted | |
| def _get_rx_cnts(cfg, prev=None): | |
| cfg.wait_hw_stats_settle() | |
| data = cfg.netdevnl.qstats_get({"ifindex": cfg.ifindex, "scope": ["queue"]}, dump=True) | |
| data = [x for x in data if x['queue-type'] == "rx"] | |
| max_q = max([x["queue-id"] for x in data]) | |
| queue_stats = [0] * (max_q + 1) | |
| for q in data: | |
| queue_stats[q["queue-id"]] = q["rx-packets"] | |
| if prev and q["queue-id"] < len(prev): | |
| queue_stats[q["queue-id"]] -= prev[q["queue-id"]] | |
| return queue_stats | |
| def _send_traffic_check(cfg, port, name, params): | |
| # params is a dict with 3 possible keys: | |
| # - "target": required, which queues we expect to get iperf traffic | |
| # - "empty": optional, which queues should see no traffic at all | |
| # - "noise": optional, which queues we expect to see low traffic; | |
| # used for queues of the main context, since some background | |
| # OS activity may use those queues while we're testing | |
| # the value for each is a list, or some other iterable containing queue ids. | |
| cnts = _get_rx_cnts(cfg) | |
| GenerateTraffic(cfg, port=port).wait_pkts_and_stop(20000) | |
| cnts = _get_rx_cnts(cfg, prev=cnts) | |
| directed = sum(cnts[i] for i in params['target']) | |
| ksft_ge(directed, 20000, f"traffic on {name}: " + str(cnts)) | |
| if params.get('noise'): | |
| ksft_lt(sum(cnts[i] for i in params['noise']), directed / 2, | |
| f"traffic on other queues ({name})':" + str(cnts)) | |
| if params.get('empty'): | |
| ksft_eq(sum(cnts[i] for i in params['empty']), 0, | |
| f"traffic on inactive queues ({name}): " + str(cnts)) | |
| def _ntuple_rule_check(cfg, rule_id, ctx_id): | |
| """Check that ntuple rule references RSS context ID""" | |
| text = ethtool(f"-n {cfg.ifname} rule {rule_id}").stdout | |
| pattern = f"RSS Context (ID: )?{ctx_id}" | |
| ksft_true(re.search(pattern, text), "RSS context not referenced in ntuple rule") | |
| def test_rss_key_indir(cfg): | |
| """Test basics like updating the main RSS key and indirection table.""" | |
| qcnt = len(_get_rx_cnts(cfg)) | |
| if qcnt < 3: | |
| raise KsftSkipEx("Device has fewer than 3 queues (or doesn't support queue stats)") | |
| data = get_rss(cfg) | |
| want_keys = ['rss-hash-key', 'rss-hash-function', 'rss-indirection-table'] | |
| for k in want_keys: | |
| if k not in data: | |
| raise KsftFailEx("ethtool results missing key: " + k) | |
| if not data[k]: | |
| raise KsftFailEx(f"ethtool results empty for '{k}': {data[k]}") | |
| _rss_key_check(cfg, data=data) | |
| key_len = len(data['rss-hash-key']) | |
| # Set the key | |
| key = _rss_key_rand(key_len) | |
| ethtool(f"-X {cfg.ifname} hkey " + _rss_key_str(key)) | |
| data = get_rss(cfg) | |
| ksft_eq(key, data['rss-hash-key']) | |
| # Set the indirection table and the key together | |
| key = _rss_key_rand(key_len) | |
| ethtool(f"-X {cfg.ifname} equal 3 hkey " + _rss_key_str(key)) | |
| reset_indir = defer(ethtool, f"-X {cfg.ifname} default") | |
| data = get_rss(cfg) | |
| _rss_key_check(cfg, data=data) | |
| ksft_eq(0, min(data['rss-indirection-table'])) | |
| ksft_eq(2, max(data['rss-indirection-table'])) | |
| # Reset indirection table and set the key | |
| key = _rss_key_rand(key_len) | |
| ethtool(f"-X {cfg.ifname} default hkey " + _rss_key_str(key)) | |
| data = get_rss(cfg) | |
| _rss_key_check(cfg, data=data) | |
| ksft_eq(0, min(data['rss-indirection-table'])) | |
| ksft_eq(qcnt - 1, max(data['rss-indirection-table'])) | |
| # Set the indirection table | |
| ethtool(f"-X {cfg.ifname} equal 2") | |
| data = get_rss(cfg) | |
| ksft_eq(0, min(data['rss-indirection-table'])) | |
| ksft_eq(1, max(data['rss-indirection-table'])) | |
| # Check we only get traffic on the first 2 queues | |
| # Retry a few times in case the flows skew to a single queue. | |
| attempts = 3 | |
| for attempt in range(attempts): | |
| cnts = _get_rx_cnts(cfg) | |
| GenerateTraffic(cfg).wait_pkts_and_stop(20000) | |
| cnts = _get_rx_cnts(cfg, prev=cnts) | |
| if cnts[0] >= 5000 and cnts[1] >= 5000: | |
| break | |
| ksft_pr(f"Skewed queue distribution, attempt {attempt + 1}/{attempts}: " + str(cnts)) | |
| # 2 queues, 20k packets, must be at least 5k per queue | |
| ksft_ge(cnts[0], 5000, "traffic on main context (1/2): " + str(cnts)) | |
| ksft_ge(cnts[1], 5000, "traffic on main context (2/2): " + str(cnts)) | |
| # The other queues should be unused | |
| ksft_eq(sum(cnts[2:]), 0, "traffic on unused queues: " + str(cnts)) | |
| # Restore, and check traffic gets spread again | |
| reset_indir.exec() | |
| for attempt in range(attempts): | |
| cnts = _get_rx_cnts(cfg) | |
| GenerateTraffic(cfg).wait_pkts_and_stop(20000) | |
| cnts = _get_rx_cnts(cfg, prev=cnts) | |
| if qcnt > 4: | |
| if sum(cnts[:2]) < sum(cnts[2:]): | |
| break | |
| else: | |
| if cnts[2] >= 3500: | |
| break | |
| ksft_pr(f"Skewed queue distribution, attempt {attempt + 1}/{attempts}: " + str(cnts)) | |
| if qcnt > 4: | |
| # First two queues get less traffic than all the rest | |
| ksft_lt(sum(cnts[:2]), sum(cnts[2:]), | |
| "traffic distributed: " + str(cnts)) | |
| else: | |
| # When queue count is low make sure third queue got significant pkts | |
| ksft_ge(cnts[2], 3500, "traffic distributed: " + str(cnts)) | |
| def test_rss_queue_reconfigure(cfg, main_ctx=True): | |
| """Make sure queue changes can't override requested RSS config. | |
| By default main RSS table should change to include all queues. | |
| When user sets a specific RSS config the driver should preserve it, | |
| even when queue count changes. Driver should refuse to deactivate | |
| queues used in the user-set RSS config. | |
| """ | |
| if not main_ctx: | |
| require_ntuple(cfg) | |
| # Start with 4 queues, an arbitrary known number. | |
| try: | |
| qcnt = len(_get_rx_cnts(cfg)) | |
| ethtool(f"-L {cfg.ifname} combined 4") | |
| defer(ethtool, f"-L {cfg.ifname} combined {qcnt}") | |
| except: | |
| raise KsftSkipEx("Not enough queues for the test or qstat not supported") | |
| if main_ctx: | |
| ctx_id = 0 | |
| ctx_ref = "" | |
| else: | |
| ctx_id = ethtool_create(cfg, "-X", "context new") | |
| ctx_ref = f"context {ctx_id}" | |
| defer(ethtool, f"-X {cfg.ifname} {ctx_ref} delete") | |
| # Indirection table should be distributing to all queues. | |
| data = get_rss(cfg, context=ctx_id) | |
| ksft_eq(0, min(data['rss-indirection-table'])) | |
| ksft_eq(3, max(data['rss-indirection-table'])) | |
| # Increase queues, indirection table should be distributing to all queues. | |
| # It's unclear whether tables of additional contexts should be reset, too. | |
| if main_ctx: | |
| ethtool(f"-L {cfg.ifname} combined 5") | |
| data = get_rss(cfg) | |
| ksft_eq(0, min(data['rss-indirection-table'])) | |
| ksft_eq(4, max(data['rss-indirection-table'])) | |
| ethtool(f"-L {cfg.ifname} combined 4") | |
| # Configure the table explicitly | |
| port = rand_port() | |
| ethtool(f"-X {cfg.ifname} {ctx_ref} weight 1 0 0 1") | |
| if main_ctx: | |
| other_key = 'empty' | |
| defer(ethtool, f"-X {cfg.ifname} default") | |
| else: | |
| other_key = 'noise' | |
| flow = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} dst-port {port} context {ctx_id}" | |
| ntuple = ethtool_create(cfg, "-N", flow) | |
| defer(ethtool, f"-N {cfg.ifname} delete {ntuple}") | |
| _send_traffic_check(cfg, port, ctx_ref, { 'target': (0, 3), | |
| other_key: (1, 2) }) | |
| # We should be able to increase queues, but table should be left untouched | |
| ethtool(f"-L {cfg.ifname} combined 5") | |
| data = get_rss(cfg, context=ctx_id) | |
| ksft_eq({0, 3}, set(data['rss-indirection-table'])) | |
| _send_traffic_check(cfg, port, ctx_ref, { 'target': (0, 3), | |
| other_key: (1, 2, 4) }) | |
| # Setting queue count to 3 should fail, queue 3 is used | |
| try: | |
| ethtool(f"-L {cfg.ifname} combined 3") | |
| except CmdExitFailure: | |
| pass | |
| else: | |
| raise Exception(f"Driver didn't prevent us from deactivating a used queue (context {ctx_id})") | |
| if not main_ctx: | |
| ethtool(f"-L {cfg.ifname} combined 4") | |
| flow = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} dst-port {port} context {ctx_id} action 1" | |
| try: | |
| # this targets queue 4, which doesn't exist | |
| ntuple2 = ethtool_create(cfg, "-N", flow) | |
| defer(ethtool, f"-N {cfg.ifname} delete {ntuple2}") | |
| except CmdExitFailure: | |
| pass | |
| else: | |
| raise Exception(f"Driver didn't prevent us from targeting a nonexistent queue (context {ctx_id})") | |
| # change the table to target queues 0 and 2 | |
| ethtool(f"-X {cfg.ifname} {ctx_ref} weight 1 0 1 0") | |
| # ntuple rule therefore targets queues 1 and 3 | |
| try: | |
| ntuple2 = ethtool_create(cfg, "-N", flow) | |
| except CmdExitFailure: | |
| ksft_pr("Driver does not support rss + queue offset") | |
| return | |
| defer(ethtool, f"-N {cfg.ifname} delete {ntuple2}") | |
| # should replace existing filter | |
| ksft_eq(ntuple, ntuple2) | |
| _send_traffic_check(cfg, port, ctx_ref, { 'target': (1, 3), | |
| 'noise' : (0, 2) }) | |
| # Setting queue count to 3 should fail, queue 3 is used | |
| try: | |
| ethtool(f"-L {cfg.ifname} combined 3") | |
| except CmdExitFailure: | |
| pass | |
| else: | |
| raise Exception(f"Driver didn't prevent us from deactivating a used queue (context {ctx_id})") | |
| def test_rss_resize(cfg): | |
| """Test resizing of the RSS table. | |
| Some devices dynamically increase and decrease the size of the RSS | |
| indirection table based on the number of enabled queues. | |
| When that happens driver must maintain the balance of entries | |
| (preferably duplicating the smaller table). | |
| """ | |
| channels = cfg.ethnl.channels_get({'header': {'dev-index': cfg.ifindex}}) | |
| ch_max = channels['combined-max'] | |
| qcnt = channels['combined-count'] | |
| if ch_max < 2: | |
| raise KsftSkipEx(f"Not enough queues for the test: {ch_max}") | |
| ethtool(f"-L {cfg.ifname} combined 2") | |
| defer(ethtool, f"-L {cfg.ifname} combined {qcnt}") | |
| ethtool(f"-X {cfg.ifname} weight 1 7") | |
| defer(ethtool, f"-X {cfg.ifname} default") | |
| ethtool(f"-L {cfg.ifname} combined {ch_max}") | |
| data = get_rss(cfg) | |
| ksft_eq(0, min(data['rss-indirection-table'])) | |
| ksft_eq(1, max(data['rss-indirection-table'])) | |
| ksft_eq(7, | |
| data['rss-indirection-table'].count(1) / | |
| data['rss-indirection-table'].count(0), | |
| f"Table imbalance after resize: {data['rss-indirection-table']}") | |
| def test_hitless_key_update(cfg): | |
| """Test that flows may be rehashed without impacting traffic. | |
| Some workloads may want to rehash the flows in response to an imbalance. | |
| Most effective way to do that is changing the RSS key. Check that changing | |
| the key does not cause link flaps or traffic disruption. | |
| Disrupting traffic for key update is not a bug, but makes the key | |
| update unusable for rehashing under load. | |
| """ | |
| data = get_rss(cfg) | |
| key_len = len(data['rss-hash-key']) | |
| ethnl = EthtoolFamily() | |
| key = random.randbytes(key_len) | |
| tgen = GenerateTraffic(cfg) | |
| try: | |
| errors0, carrier0 = get_drop_err_sum(cfg) | |
| t0 = datetime.datetime.now() | |
| ethnl.rss_set({"header": {"dev-index": cfg.ifindex}, "hkey": key}) | |
| t1 = datetime.datetime.now() | |
| errors1, carrier1 = get_drop_err_sum(cfg) | |
| finally: | |
| tgen.wait_pkts_and_stop(5000) | |
| ksft_lt((t1 - t0).total_seconds(), 0.15) | |
| ksft_eq(errors1 - errors0, 0) | |
| ksft_eq(carrier1 - carrier0, 0) | |
| def test_rss_context_dump(cfg): | |
| """ | |
| Test dumping RSS contexts. This tests mostly exercises the kernel APIs. | |
| """ | |
| # Get a random key of the right size | |
| data = get_rss(cfg) | |
| if 'rss-hash-key' in data: | |
| key_data = _rss_key_rand(len(data['rss-hash-key'])) | |
| key = _rss_key_str(key_data) | |
| else: | |
| key_data = [] | |
| key = "ba:ad" | |
| ids = [] | |
| try: | |
| ids.append(ethtool_create(cfg, "-X", f"context new")) | |
| defer(ethtool, f"-X {cfg.ifname} context {ids[-1]} delete") | |
| ids.append(ethtool_create(cfg, "-X", f"context new weight 1 1")) | |
| defer(ethtool, f"-X {cfg.ifname} context {ids[-1]} delete") | |
| ids.append(ethtool_create(cfg, "-X", f"context new hkey {key}")) | |
| defer(ethtool, f"-X {cfg.ifname} context {ids[-1]} delete") | |
| except CmdExitFailure: | |
| if not ids: | |
| raise KsftSkipEx("Unable to add any contexts") | |
| ksft_pr(f"Added only {len(ids)} out of 3 contexts") | |
| expect_tuples = set([(cfg.ifname, -1)] + [(cfg.ifname, ctx_id) for ctx_id in ids]) | |
| # Dump all | |
| ctxs = cfg.ethnl.rss_get({}, dump=True) | |
| tuples = [(c['header']['dev-name'], c.get('context', -1)) for c in ctxs] | |
| ksft_eq(len(tuples), len(set(tuples)), "duplicates in context dump") | |
| ctx_tuples = set([ctx for ctx in tuples if ctx[0] == cfg.ifname]) | |
| ksft_eq(expect_tuples, ctx_tuples) | |
| # Sanity-check the results | |
| for data in ctxs: | |
| ksft_ne(set(data.get('indir', [1])), {0}, "indir table is all zero") | |
| ksft_ne(set(data.get('hkey', [1])), {0}, "key is all zero") | |
| # More specific checks | |
| if len(ids) > 1 and data.get('context') == ids[1]: | |
| ksft_eq(set(data['indir']), {0, 1}, | |
| "ctx1 - indir table mismatch") | |
| if len(ids) > 2 and data.get('context') == ids[2]: | |
| ksft_eq(data['hkey'], bytes(key_data), "ctx2 - key mismatch") | |
| # Ifindex filter | |
| ctxs = cfg.ethnl.rss_get({'header': {'dev-name': cfg.ifname}}, dump=True) | |
| tuples = [(c['header']['dev-name'], c.get('context', -1)) for c in ctxs] | |
| ctx_tuples = set(tuples) | |
| ksft_eq(len(tuples), len(ctx_tuples), "duplicates in context dump") | |
| ksft_eq(expect_tuples, ctx_tuples) | |
| # Skip ctx 0 | |
| expect_tuples.remove((cfg.ifname, -1)) | |
| ctxs = cfg.ethnl.rss_get({'start-context': 1}, dump=True) | |
| tuples = [(c['header']['dev-name'], c.get('context', -1)) for c in ctxs] | |
| ksft_eq(len(tuples), len(set(tuples)), "duplicates in context dump") | |
| ctx_tuples = set([ctx for ctx in tuples if ctx[0] == cfg.ifname]) | |
| ksft_eq(expect_tuples, ctx_tuples) | |
| # And finally both with ifindex and skip main | |
| ctxs = cfg.ethnl.rss_get({'header': {'dev-name': cfg.ifname}, 'start-context': 1}, dump=True) | |
| ctx_tuples = set([(c['header']['dev-name'], c.get('context', -1)) for c in ctxs]) | |
| ksft_eq(expect_tuples, ctx_tuples) | |
| def test_rss_context(cfg, ctx_cnt=1, create_with_cfg=None): | |
| """ | |
| Test separating traffic into RSS contexts. | |
| The queues will be allocated 2 for each context: | |
| ctx0 ctx1 ctx2 ctx3 | |
| [0 1] [2 3] [4 5] [6 7] ... | |
| """ | |
| require_ntuple(cfg) | |
| requested_ctx_cnt = ctx_cnt | |
| # Try to allocate more queues when necessary | |
| qcnt = len(_get_rx_cnts(cfg)) | |
| if qcnt < 2 + 2 * ctx_cnt: | |
| try: | |
| ksft_pr(f"Increasing queue count {qcnt} -> {2 + 2 * ctx_cnt}") | |
| ethtool(f"-L {cfg.ifname} combined {2 + 2 * ctx_cnt}") | |
| defer(ethtool, f"-L {cfg.ifname} combined {qcnt}") | |
| except: | |
| raise KsftSkipEx("Not enough queues for the test") | |
| ports = rand_ports(ctx_cnt) | |
| # Use queues 0 and 1 for normal traffic | |
| ethtool(f"-X {cfg.ifname} equal 2") | |
| defer(ethtool, f"-X {cfg.ifname} default") | |
| for i in range(ctx_cnt): | |
| want_cfg = f"start {2 + i * 2} equal 2" | |
| create_cfg = want_cfg if create_with_cfg else "" | |
| try: | |
| ctx_id = ethtool_create(cfg, "-X", f"context new {create_cfg}") | |
| defer(ethtool, f"-X {cfg.ifname} context {ctx_id} delete") | |
| except CmdExitFailure: | |
| # try to carry on and skip at the end | |
| if i == 0: | |
| raise | |
| ksft_pr(f"Failed to create context {i + 1}, trying to test what we got") | |
| ctx_cnt = i | |
| if cfg.context_cnt is None: | |
| cfg.context_cnt = ctx_cnt | |
| break | |
| _rss_key_check(cfg, context=ctx_id) | |
| if not create_with_cfg: | |
| ethtool(f"-X {cfg.ifname} context {ctx_id} {want_cfg}") | |
| _rss_key_check(cfg, context=ctx_id) | |
| # Sanity check the context we just created | |
| data = get_rss(cfg, ctx_id) | |
| ksft_eq(min(data['rss-indirection-table']), 2 + i * 2, "Unexpected context cfg: " + str(data)) | |
| ksft_eq(max(data['rss-indirection-table']), 2 + i * 2 + 1, "Unexpected context cfg: " + str(data)) | |
| flow = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} dst-port {ports[i]} context {ctx_id}" | |
| ntuple = ethtool_create(cfg, "-N", flow) | |
| defer(ethtool, f"-N {cfg.ifname} delete {ntuple}") | |
| _ntuple_rule_check(cfg, ntuple, ctx_id) | |
| for i in range(ctx_cnt): | |
| _send_traffic_check(cfg, ports[i], f"context {i}", | |
| { 'target': (2+i*2, 3+i*2), | |
| 'noise': (0, 1), | |
| 'empty': list(range(2, 2+i*2)) + list(range(4+i*2, 2+2*ctx_cnt)) }) | |
| if requested_ctx_cnt != ctx_cnt: | |
| raise KsftSkipEx(f"Tested only {ctx_cnt} contexts, wanted {requested_ctx_cnt}") | |
| def test_rss_context4(cfg): | |
| test_rss_context(cfg, 4) | |
| def test_rss_context32(cfg): | |
| test_rss_context(cfg, 32) | |
| def test_rss_context4_create_with_cfg(cfg): | |
| test_rss_context(cfg, 4, create_with_cfg=True) | |
| def test_rss_context_queue_reconfigure(cfg): | |
| test_rss_queue_reconfigure(cfg, main_ctx=False) | |
| def test_rss_context_out_of_order(cfg, ctx_cnt=4): | |
| """ | |
| Test separating traffic into RSS contexts. | |
| Contexts are removed in semi-random order, and steering re-tested | |
| to make sure removal doesn't break steering to surviving contexts. | |
| Test requires 3 contexts to work. | |
| """ | |
| require_ntuple(cfg) | |
| require_context_cnt(cfg, 4) | |
| # Try to allocate more queues when necessary | |
| qcnt = len(_get_rx_cnts(cfg)) | |
| if qcnt < 2 + 2 * ctx_cnt: | |
| try: | |
| ksft_pr(f"Increasing queue count {qcnt} -> {2 + 2 * ctx_cnt}") | |
| ethtool(f"-L {cfg.ifname} combined {2 + 2 * ctx_cnt}") | |
| defer(ethtool, f"-L {cfg.ifname} combined {qcnt}") | |
| except: | |
| raise KsftSkipEx("Not enough queues for the test") | |
| ntuple = [] | |
| ctx = [] | |
| ports = rand_ports(ctx_cnt) | |
| def remove_ctx(idx): | |
| ntuple[idx].exec() | |
| ntuple[idx] = None | |
| ctx[idx].exec() | |
| ctx[idx] = None | |
| def check_traffic(): | |
| for i in range(ctx_cnt): | |
| if ctx[i]: | |
| expected = { | |
| 'target': (2+i*2, 3+i*2), | |
| 'noise': (0, 1), | |
| 'empty': list(range(2, 2+i*2)) + list(range(4+i*2, 2+2*ctx_cnt)) | |
| } | |
| else: | |
| expected = { | |
| 'target': (0, 1), | |
| 'empty': range(2, 2+2*ctx_cnt) | |
| } | |
| _send_traffic_check(cfg, ports[i], f"context {i}", expected) | |
| # Use queues 0 and 1 for normal traffic | |
| ethtool(f"-X {cfg.ifname} equal 2") | |
| defer(ethtool, f"-X {cfg.ifname} default") | |
| for i in range(ctx_cnt): | |
| ctx_id = ethtool_create(cfg, "-X", f"context new start {2 + i * 2} equal 2") | |
| ctx.append(defer(ethtool, f"-X {cfg.ifname} context {ctx_id} delete")) | |
| flow = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} dst-port {ports[i]} context {ctx_id}" | |
| ntuple_id = ethtool_create(cfg, "-N", flow) | |
| ntuple.append(defer(ethtool, f"-N {cfg.ifname} delete {ntuple_id}")) | |
| check_traffic() | |
| # Remove middle context | |
| remove_ctx(ctx_cnt // 2) | |
| check_traffic() | |
| # Remove first context | |
| remove_ctx(0) | |
| check_traffic() | |
| # Remove last context | |
| remove_ctx(-1) | |
| check_traffic() | |
| def test_rss_context_overlap(cfg, other_ctx=0): | |
| """ | |
| Test contexts overlapping with each other. | |
| Use 4 queues for the main context, but only queues 2 and 3 for context 1. | |
| """ | |
| require_ntuple(cfg) | |
| if other_ctx: | |
| require_context_cnt(cfg, 2) | |
| queue_cnt = len(_get_rx_cnts(cfg)) | |
| if queue_cnt < 4: | |
| try: | |
| ksft_pr(f"Increasing queue count {queue_cnt} -> 4") | |
| ethtool(f"-L {cfg.ifname} combined 4") | |
| defer(ethtool, f"-L {cfg.ifname} combined {queue_cnt}") | |
| except: | |
| raise KsftSkipEx("Not enough queues for the test") | |
| if other_ctx == 0: | |
| ethtool(f"-X {cfg.ifname} equal 4") | |
| defer(ethtool, f"-X {cfg.ifname} default") | |
| else: | |
| other_ctx = ethtool_create(cfg, "-X", "context new") | |
| ethtool(f"-X {cfg.ifname} context {other_ctx} equal 4") | |
| defer(ethtool, f"-X {cfg.ifname} context {other_ctx} delete") | |
| ctx_id = ethtool_create(cfg, "-X", "context new") | |
| ethtool(f"-X {cfg.ifname} context {ctx_id} start 2 equal 2") | |
| defer(ethtool, f"-X {cfg.ifname} context {ctx_id} delete") | |
| port = rand_port() | |
| if other_ctx: | |
| flow = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} dst-port {port} context {other_ctx}" | |
| ntuple_id = ethtool_create(cfg, "-N", flow) | |
| ntuple = defer(ethtool, f"-N {cfg.ifname} delete {ntuple_id}") | |
| # Test the main context | |
| attempts = 3 | |
| for attempt in range(attempts): | |
| cnts = _get_rx_cnts(cfg) | |
| GenerateTraffic(cfg, port=port).wait_pkts_and_stop(20000) | |
| cnts = _get_rx_cnts(cfg, prev=cnts) | |
| if sum(cnts[:2]) >= 7000 and sum(cnts[2:4]) >= 7000: | |
| break | |
| ksft_pr(f"Skewed queue distribution, attempt {attempt + 1}/{attempts}: " + str(cnts)) | |
| ksft_ge(sum(cnts[ :4]), 20000, "traffic on main context: " + str(cnts)) | |
| ksft_ge(sum(cnts[ :2]), 7000, "traffic on main context (1/2): " + str(cnts)) | |
| ksft_ge(sum(cnts[2:4]), 7000, "traffic on main context (2/2): " + str(cnts)) | |
| if other_ctx == 0: | |
| ksft_eq(sum(cnts[4: ]), 0, "traffic on other queues: " + str(cnts)) | |
| # Now create a rule for context 1 and make sure traffic goes to a subset | |
| if other_ctx: | |
| ntuple.exec() | |
| flow = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} dst-port {port} context {ctx_id}" | |
| ntuple_id = ethtool_create(cfg, "-N", flow) | |
| defer(ethtool, f"-N {cfg.ifname} delete {ntuple_id}") | |
| cnts = _get_rx_cnts(cfg) | |
| GenerateTraffic(cfg, port=port).wait_pkts_and_stop(20000) | |
| cnts = _get_rx_cnts(cfg, prev=cnts) | |
| directed = sum(cnts[2:4]) | |
| ksft_lt(sum(cnts[ :2]), directed / 2, "traffic on main context: " + str(cnts)) | |
| ksft_ge(directed, 20000, "traffic on extra context: " + str(cnts)) | |
| if other_ctx == 0: | |
| ksft_eq(sum(cnts[4: ]), 0, "traffic on other queues: " + str(cnts)) | |
| def test_rss_context_overlap2(cfg): | |
| test_rss_context_overlap(cfg, True) | |
| def test_flow_add_context_missing(cfg): | |
| """ | |
| Test that we are not allowed to add a rule pointing to an RSS context | |
| which was never created. | |
| """ | |
| require_ntuple(cfg) | |
| # Find a context which doesn't exist | |
| for ctx_id in range(1, 100): | |
| try: | |
| get_rss(cfg, context=ctx_id) | |
| except CmdExitFailure: | |
| break | |
| with ksft_raises(CmdExitFailure) as cm: | |
| flow = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} dst-port 1234 context {ctx_id}" | |
| ntuple_id = ethtool_create(cfg, "-N", flow) | |
| ethtool(f"-N {cfg.ifname} delete {ntuple_id}") | |
| if cm.exception: | |
| ksft_in('Invalid argument', cm.exception.cmd.stderr) | |
| def test_delete_rss_context_busy(cfg): | |
| """ | |
| Test that deletion returns -EBUSY when an rss context is being used | |
| by an ntuple filter. | |
| """ | |
| require_ntuple(cfg) | |
| # create additional rss context | |
| ctx_id = ethtool_create(cfg, "-X", "context new") | |
| ctx_deleter = defer(ethtool, f"-X {cfg.ifname} context {ctx_id} delete") | |
| # utilize context from ntuple filter | |
| port = rand_port() | |
| flow = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} dst-port {port} context {ctx_id}" | |
| ntuple_id = ethtool_create(cfg, "-N", flow) | |
| defer(ethtool, f"-N {cfg.ifname} delete {ntuple_id}") | |
| # attempt to delete in-use context | |
| try: | |
| ctx_deleter.exec_only() | |
| ctx_deleter.cancel() | |
| raise KsftFailEx(f"deleted context {ctx_id} used by rule {ntuple_id}") | |
| except CmdExitFailure: | |
| pass | |
| def test_rss_ntuple_addition(cfg): | |
| """ | |
| Test that the queue offset (ring_cookie) of an ntuple rule is added | |
| to the queue number read from the indirection table. | |
| """ | |
| require_ntuple(cfg) | |
| queue_cnt = len(_get_rx_cnts(cfg)) | |
| if queue_cnt < 4: | |
| try: | |
| ksft_pr(f"Increasing queue count {queue_cnt} -> 4") | |
| ethtool(f"-L {cfg.ifname} combined 4") | |
| defer(ethtool, f"-L {cfg.ifname} combined {queue_cnt}") | |
| except: | |
| raise KsftSkipEx("Not enough queues for the test") | |
| # Use queue 0 for normal traffic | |
| ethtool(f"-X {cfg.ifname} equal 1") | |
| defer(ethtool, f"-X {cfg.ifname} default") | |
| # create additional rss context | |
| ctx_id = ethtool_create(cfg, "-X", "context new equal 2") | |
| defer(ethtool, f"-X {cfg.ifname} context {ctx_id} delete") | |
| # utilize context from ntuple filter | |
| port = rand_port() | |
| flow = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} dst-port {port} context {ctx_id} action 2" | |
| try: | |
| ntuple_id = ethtool_create(cfg, "-N", flow) | |
| except CmdExitFailure: | |
| raise KsftSkipEx("Ntuple filter with RSS and nonzero action not supported") | |
| defer(ethtool, f"-N {cfg.ifname} delete {ntuple_id}") | |
| _send_traffic_check(cfg, port, f"context {ctx_id}", { 'target': (2, 3), | |
| 'empty' : (1,), | |
| 'noise' : (0,) }) | |
| def test_rss_default_context_rule(cfg): | |
| """ | |
| Allocate a port, direct this port to context 0, then create a new RSS | |
| context and steer all TCP traffic to it (context 1). Verify that: | |
| * Traffic to the specific port continues to use queues of the main | |
| context (0/1). | |
| * Traffic to any other TCP port is redirected to the new context | |
| (queues 2/3). | |
| """ | |
| require_ntuple(cfg) | |
| queue_cnt = len(_get_rx_cnts(cfg)) | |
| if queue_cnt < 4: | |
| try: | |
| ksft_pr(f"Increasing queue count {queue_cnt} -> 4") | |
| ethtool(f"-L {cfg.ifname} combined 4") | |
| defer(ethtool, f"-L {cfg.ifname} combined {queue_cnt}") | |
| except Exception as exc: | |
| raise KsftSkipEx("Not enough queues for the test") from exc | |
| # Use queues 0 and 1 for the main context | |
| ethtool(f"-X {cfg.ifname} equal 2") | |
| defer(ethtool, f"-X {cfg.ifname} default") | |
| # Create a new RSS context that uses queues 2 and 3 | |
| ctx_id = ethtool_create(cfg, "-X", "context new start 2 equal 2") | |
| defer(ethtool, f"-X {cfg.ifname} context {ctx_id} delete") | |
| # Generic low-priority rule: redirect all TCP traffic to the new context. | |
| # Give it an explicit higher location number (lower priority). | |
| flow_generic = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} context {ctx_id} loc 1" | |
| ethtool(f"-N {cfg.ifname} {flow_generic}") | |
| defer(ethtool, f"-N {cfg.ifname} delete 1") | |
| ports = rand_ports(2) | |
| # Specific high-priority rule for a random port that should stay on context 0. | |
| # Assign loc 0 so it is evaluated before the generic rule. | |
| port_main = ports[0] | |
| flow_main = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} dst-port {port_main} context 0 loc 0" | |
| ethtool(f"-N {cfg.ifname} {flow_main}") | |
| defer(ethtool, f"-N {cfg.ifname} delete 0") | |
| _ntuple_rule_check(cfg, 1, ctx_id) | |
| # Verify that traffic matching the specific rule still goes to queues 0/1 | |
| _send_traffic_check(cfg, port_main, "context 0", | |
| { 'target': (0, 1), | |
| 'empty' : (2, 3) }) | |
| # And that traffic for any other port is steered to the new context | |
| port_other = ports[1] | |
| _send_traffic_check(cfg, port_other, f"context {ctx_id}", | |
| { 'target': (2, 3), | |
| 'noise' : (0, 1) }) | |
| def _set_flow_hash(cfg, fl_type, fields, context=0): | |
| req = {"header": {"dev-index": cfg.ifindex}, | |
| "flow-hash": {fl_type: fields}} | |
| if context: | |
| req["context"] = context | |
| cfg.ethnl.rss_set(req) | |
| def _get_flow_hash(cfg, fl_type, context=0): | |
| req = {"header": {"dev-index": cfg.ifindex}} | |
| if context: | |
| req["context"] = context | |
| rss = cfg.ethnl.rss_get(req) | |
| return rss.get("flow-hash", {}).get(fl_type, set()) | |
| def test_rss_context_flow_hash(cfg): | |
| """ | |
| Validate, with traffic, that an additional RSS context honors the | |
| flow-hash field selection. If the driver lacks per-context field | |
| configuration ("ops->rxfh_per_ctx_fields") fall back to setting the | |
| fields on the main context, which the kernel applies device-wide. | |
| """ | |
| require_ntuple(cfg) | |
| queue_cnt = len(_get_rx_cnts(cfg)) | |
| if queue_cnt < 6: | |
| try: | |
| ksft_pr(f"Increasing queue count {queue_cnt} -> 6") | |
| ethtool(f"-L {cfg.ifname} combined 6") | |
| defer(ethtool, f"-L {cfg.ifname} combined {queue_cnt}") | |
| except CmdExitFailure as exc: | |
| raise KsftSkipEx("Not enough queues for the test") from exc | |
| fl_type = f"tcp{cfg.addr_ipver}" | |
| if not _get_flow_hash(cfg, fl_type): | |
| raise KsftSkipEx(f"Device does not report flow-hash for {fl_type}") | |
| # Reserve queues 0/1 for main, build a new context spanning 2..5 | |
| ethtool(f"-X {cfg.ifname} equal 2") | |
| defer(ethtool, f"-X {cfg.ifname} default") | |
| ctx_id = ethtool_create(cfg, "-X", "context new start 2 equal 4") | |
| defer(ethtool, f"-X {cfg.ifname} context {ctx_id} delete") | |
| port = rand_port() | |
| flow = f"flow-type {fl_type} dst-ip {cfg.addr} dst-port {port} context {ctx_id}" | |
| ntuple = ethtool_create(cfg, "-N", flow) | |
| defer(ethtool, f"-N {cfg.ifname} delete {ntuple}") | |
| ip_only = {"ip-src", "ip-dst"} | |
| ip_l4 = ip_only | {"l4-b-0-1", "l4-b-2-3"} | |
| # Try per-context flow-hash; fall back to main context if unsupported. | |
| cfg_ctx = ctx_id | |
| try: | |
| orig = _get_flow_hash(cfg, fl_type, context=ctx_id) | |
| _set_flow_hash(cfg, fl_type, ip_only, context=ctx_id) | |
| except NlError: | |
| ksft_pr("Per-context flow-hash not supported, using device-wide") | |
| cfg_ctx = 0 | |
| orig = _get_flow_hash(cfg, fl_type) | |
| _set_flow_hash(cfg, fl_type, ip_only) | |
| defer(_set_flow_hash, cfg, fl_type, orig, context=cfg_ctx) | |
| def measure(): | |
| cnts = _get_rx_cnts(cfg) | |
| GenerateTraffic(cfg, port=port).wait_pkts_and_stop(20000) | |
| cnts = _get_rx_cnts(cfg, prev=cnts) | |
| ctx_cnts = cnts[2:6] | |
| directed = sum(ctx_cnts) | |
| used = sum(1 for c in ctx_cnts if c > directed / 200) | |
| return cnts, directed, used | |
| # IP-only hash: iperf3 streams share src/dst IP, all should land on the | |
| # same queue inside the context's range. | |
| cnts, directed, used = measure() | |
| ksft_ge(directed, 20000, f"traffic on context {ctx_id} (IP-only): {cnts}") | |
| ksft_eq(used, 1, f"IP-only hash should use one queue in context {ctx_id}, got: {cnts}") | |
| # IP+L4 hash: streams have distinct src ports, traffic should spread. | |
| _set_flow_hash(cfg, fl_type, ip_l4, context=cfg_ctx) | |
| cnts, directed, used = measure() | |
| ksft_ge(directed, 20000, f"traffic on context {ctx_id} (IP+L4): {cnts}") | |
| ksft_ge(used, 2, f"IP+L4 hash should spread across context {ctx_id} queues, got: {cnts}") | |
| @ksft_disruptive | |
| def test_rss_context_persist_ifupdown(cfg, pre_down=False): | |
| """ | |
| Test that RSS contexts and their associated ntuple filters persist across | |
| an interface down/up cycle. | |
| """ | |
| require_ntuple(cfg) | |
| qcnt = len(_get_rx_cnts(cfg)) | |
| if qcnt < 6: | |
| try: | |
| ethtool(f"-L {cfg.ifname} combined 6") | |
| defer(ethtool, f"-L {cfg.ifname} combined {qcnt}") | |
| except Exception as exc: | |
| raise KsftSkipEx("Not enough queues for the test") from exc | |
| ethtool(f"-X {cfg.ifname} equal 2") | |
| defer(ethtool, f"-X {cfg.ifname} default") | |
| ifup = defer(ip, f"link set dev {cfg.ifname} up") | |
| if pre_down: | |
| ip(f"link set dev {cfg.ifname} down") | |
| try: | |
| ctx1_id = ethtool_create(cfg, "-X", "context new start 2 equal 2") | |
| defer(ethtool, f"-X {cfg.ifname} context {ctx1_id} delete") | |
| except CmdExitFailure as exc: | |
| raise KsftSkipEx("Create context not supported with interface down") from exc | |
| ctx2_id = ethtool_create(cfg, "-X", "context new start 4 equal 2") | |
| defer(ethtool, f"-X {cfg.ifname} context {ctx2_id} delete") | |
| port_ctx2 = rand_port() | |
| flow = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} dst-port {port_ctx2} context {ctx2_id}" | |
| ntuple_id = ethtool_create(cfg, "-N", flow) | |
| defer(ethtool, f"-N {cfg.ifname} delete {ntuple_id}") | |
| if not pre_down: | |
| ip(f"link set dev {cfg.ifname} down") | |
| ifup.exec() | |
| wait_file(f"/sys/class/net/{cfg.ifname}/carrier", | |
| lambda x: x.strip() == "1", deadline=20) | |
| remote_addr = cfg.remote_addr_v[cfg.addr_ipver] | |
| for _ in range(10): | |
| if cmd(f"ping -c 1 -W 1 {remote_addr}", fail=False).ret == 0: | |
| break | |
| time.sleep(1) | |
| else: | |
| raise KsftSkipEx("Cannot reach remote host after interface up") | |
| ctxs = cfg.ethnl.rss_get({'header': {'dev-name': cfg.ifname}}, dump=True) | |
| data1 = [c for c in ctxs if c.get('context') == ctx1_id] | |
| ksft_eq(len(data1), 1, f"Context {ctx1_id} should persist after ifup") | |
| data2 = [c for c in ctxs if c.get('context') == ctx2_id] | |
| ksft_eq(len(data2), 1, f"Context {ctx2_id} should persist after ifup") | |
| _ntuple_rule_check(cfg, ntuple_id, ctx2_id) | |
| cnts = _get_rx_cnts(cfg) | |
| GenerateTraffic(cfg).wait_pkts_and_stop(20000) | |
| cnts = _get_rx_cnts(cfg, prev=cnts) | |
| main_traffic = sum(cnts[0:2]) | |
| ksft_ge(main_traffic, 18000, f"Main context traffic distribution: {cnts}") | |
| ksft_lt(sum(cnts[2:6]), 500, f"Other context queues should be mostly empty: {cnts}") | |
| _send_traffic_check(cfg, port_ctx2, f"context {ctx2_id}", | |
| {'target': (4, 5), | |
| 'noise': (0, 1), | |
| 'empty': (2, 3)}) | |
| def test_rss_context_persist_create_and_ifdown(cfg): | |
| """ | |
| Create RSS contexts then cycle the interface down and up. | |
| """ | |
| test_rss_context_persist_ifupdown(cfg, pre_down=False) | |
| def test_rss_context_persist_ifdown_and_create(cfg): | |
| """ | |
| Bring interface down first, then create RSS contexts and bring up. | |
| """ | |
| test_rss_context_persist_ifupdown(cfg, pre_down=True) | |
| def main() -> None: | |
| with NetDrvEpEnv(__file__, nsim_test=False) as cfg: | |
| cfg.context_cnt = None | |
| cfg.ethnl = EthtoolFamily() | |
| cfg.netdevnl = NetdevFamily() | |
| ksft_run([test_rss_key_indir, test_rss_queue_reconfigure, | |
| test_rss_resize, test_hitless_key_update, | |
| test_rss_context, test_rss_context4, test_rss_context32, | |
| test_rss_context_dump, test_rss_context_queue_reconfigure, | |
| test_rss_context_overlap, test_rss_context_overlap2, | |
| test_rss_context_out_of_order, test_rss_context4_create_with_cfg, | |
| test_flow_add_context_missing, | |
| test_delete_rss_context_busy, test_rss_ntuple_addition, | |
| test_rss_default_context_rule, | |
| test_rss_context_flow_hash, | |
| test_rss_context_persist_create_and_ifdown, | |
| test_rss_context_persist_ifdown_and_create], | |
| args=(cfg, )) | |
| ksft_exit() | |
| if __name__ == "__main__": | |
| main() |