| #!/usr/bin/env python3 |
| # SPDX-License-Identifier: GPL-2.0 |
| # pylint: disable=too-many-lines |
| |
| import errno |
| import glob |
| |
| from lib.py import ksft_run, ksft_exit |
| from lib.py import ksft_eq, ksft_true, ksft_raises, KsftSkipEx |
| from lib.py import EthtoolFamily, NetshaperFamily |
| from lib.py import NetDrvEnv |
| from lib.py import NlError |
| from lib.py import cmd, defer |
| |
| def _delete_shaper(cfg, nl_shaper, handle) -> None: |
| """ Delete the shaper identified by handle, ignoring a missing-shaper error. """ |
| try: |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': handle}) |
| except NlError as e: |
| if e.error != errno.ENOENT: |
| raise |
| |
| def _require_queues(cfg, count): |
| """ Return the netdev TX queue count, skipping the test if fewer than count exist. """ |
| qcnt = len(glob.glob(f"/sys/class/net/{cfg.ifname}/queues/tx-*")) |
| if qcnt < count: |
| raise KsftSkipEx(f"netdev has {qcnt} queues, {count} required") |
| return qcnt |
| |
| def _cap_get(cfg, nl_shaper, scope): |
| """ Return the shaper capabilities for the given scope, caching them on cfg. """ |
| if not hasattr(cfg, 'cap_cache'): |
| cfg.cap_cache = {} |
| if scope not in cfg.cap_cache: |
| cfg.cap_cache[scope] = nl_shaper.cap_get({'ifindex': cfg.ifindex, |
| 'scope': scope}) |
| |
| return cfg.cap_cache[scope] |
| |
| def _require_caps(cfg, nl_shaper, scope, caps, msg) -> None: |
| """ Skip the test unless the given scope advertises all the required caps. """ |
| try: |
| supported = _cap_get(cfg, nl_shaper, scope) |
| except NlError as e: |
| if e.error == errno.EOPNOTSUPP: |
| raise KsftSkipEx(f"{scope} scope shapers not supported by the device") |
| raise |
| |
| if not set(caps).issubset(supported): |
| raise KsftSkipEx(msg) |
| |
| def get_shapers(cfg, nl_shaper) -> None: |
| try: |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| except NlError as e: |
| if e.error == 95: |
| raise KsftSkipEx("shapers not supported by the device") |
| raise |
| |
| # Default configuration: no shapers configured. |
| ksft_eq(len(shapers), 0) |
| |
| def get_caps(cfg, nl_shaper) -> None: |
| try: |
| caps = nl_shaper.cap_get({'ifindex': cfg.ifindex}, dump=True) |
| except NlError as e: |
| if e.error == 95: |
| raise KsftSkipEx("shapers not supported by the device") |
| raise |
| |
| # Each device implementing shaper support must support some |
| # features in at least a scope. |
| ksft_true(len(caps)> 0) |
| |
| def set_qshapers(cfg, nl_shaper) -> None: |
| try: |
| caps = nl_shaper.cap_get({'ifindex': cfg.ifindex, |
| 'scope':'queue'}) |
| except NlError as e: |
| if e.error == 95: |
| raise KsftSkipEx("shapers not supported by the device") |
| raise |
| if not 'support-bw-max' in caps or not 'support-metric-bps' in caps: |
| raise KsftSkipEx("device does not support queue scope shapers with bw_max and metric bps") |
| |
| _require_queues(cfg, 3) |
| cfg.queues = True |
| |
| nl_shaper.set({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'metric': 'bps', |
| 'bw-max': 10000}) |
| nl_shaper.set({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 2}, |
| 'metric': 'bps', |
| 'bw-max': 20000}) |
| |
| # Querying a specific shaper not yet configured must fail. |
| raised = False |
| try: |
| shaper_q0 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 0}}) |
| except (NlError): |
| raised = True |
| ksft_eq(raised, True) |
| |
| shaper_q1 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 1}}) |
| ksft_eq(shaper_q1, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'metric': 'bps', |
| 'bw-max': 10000}) |
| |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(shapers, [{'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'metric': 'bps', |
| 'bw-max': 10000}, |
| {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 2}, |
| 'metric': 'bps', |
| 'bw-max': 20000}]) |
| |
| def del_qshapers(cfg, nl_shaper) -> None: |
| if not cfg.queues: |
| raise KsftSkipEx("queue shapers not supported by device, skipping delete") |
| |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 2}}) |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 1}}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def set_nshapers(cfg, nl_shaper) -> None: |
| # Check required features. |
| try: |
| caps = nl_shaper.cap_get({'ifindex': cfg.ifindex, |
| 'scope':'netdev'}) |
| except NlError as e: |
| if e.error == 95: |
| raise KsftSkipEx("shapers not supported by the device") |
| raise |
| if not 'support-bw-max' in caps or not 'support-metric-bps' in caps: |
| raise KsftSkipEx("device does not support nested netdev scope shapers with weight") |
| |
| cfg.netdev = True; |
| nl_shaper.set({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'netdev', 'id': 0}, |
| 'bw-max': 100000}) |
| |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(shapers, [{'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'netdev'}, |
| 'metric': 'bps', |
| 'bw-max': 100000}]) |
| |
| def del_nshapers(cfg, nl_shaper) -> None: |
| if not cfg.netdev: |
| raise KsftSkipEx("netdev shaper not supported by device, skipping delete") |
| |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'netdev'}}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def set_all_supported_attrs(cfg, nl_shaper) -> None: |
| """ Set every queue-scope attribute the device advertises and verify the read-back. """ |
| _require_queues(cfg, 1) |
| |
| _require_caps(cfg, nl_shaper, 'queue', [], |
| "queue scope shapers not supported by the device") |
| caps = _cap_get(cfg, nl_shaper, 'queue') |
| |
| attrs = {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 0}} |
| expected = {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 0}} |
| |
| rate_attrs = {'support-bw-min': ('bw-min', 10000, 100), |
| 'support-bw-max': ('bw-max', 20000, 200), |
| 'support-burst': ('burst', 3000, 30)} |
| rate_attr_supported = any(cap in caps for cap in rate_attrs) |
| bps_supported = 'support-metric-bps' in caps |
| pps_supported = 'support-metric-pps' in caps |
| |
| def add_rate_attrs(metric, value_idx) -> None: |
| attrs['metric'] = metric |
| expected['metric'] = metric |
| for cap, (attr, bps_value, pps_value) in rate_attrs.items(): |
| if cap not in caps: |
| continue |
| |
| value = bps_value if value_idx == 0 else pps_value |
| attrs[attr] = value |
| expected[attr] = value |
| |
| if rate_attr_supported: |
| if bps_supported: |
| add_rate_attrs('bps', 0) |
| elif pps_supported: |
| add_rate_attrs('pps', 1) |
| |
| if 'support-priority' in caps: |
| attrs['priority'] = 1 |
| expected['priority'] = 1 |
| if 'support-weight' in caps: |
| attrs['weight'] = 2 |
| expected['weight'] = 2 |
| |
| if len(attrs) == 2: |
| raise KsftSkipEx("device does not advertise any supported queue shaper attributes") |
| |
| nl_shaper.set(attrs) |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': 0}) |
| |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 0}}) |
| ksft_eq(shaper, expected) |
| |
| if rate_attr_supported and bps_supported and pps_supported: |
| add_rate_attrs('pps', 1) |
| nl_shaper.set(attrs) |
| |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 0}}) |
| ksft_eq(shaper, expected) |
| |
| _delete_shaper(cfg, nl_shaper, {'scope': 'queue', 'id': 0}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def invalid_set_preserves_state(cfg, nl_shaper) -> None: |
| """ Verify a rejected .set leaves the existing shaper configuration unchanged. """ |
| nq = _require_queues(cfg, 1) |
| _require_caps(cfg, nl_shaper, 'queue', |
| ['support-bw-max', 'support-metric-bps'], |
| "device does not support queue scope bw_max with bps metric") |
| |
| initial = {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 0}, |
| 'metric': 'bps', |
| 'bw-max': 10000} |
| nl_shaper.set({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 0}, |
| 'metric': 'bps', |
| 'bw-max': 10000}) |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': 0}) |
| |
| with ksft_raises(NlError): |
| nl_shaper.set({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': 0}, |
| 'metric': 'bps', |
| 'bw-max': 20000}) |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 0}}) |
| ksft_eq(shaper, initial) |
| |
| with ksft_raises(NlError): |
| nl_shaper.set({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': nq}, |
| 'metric': 'bps', |
| 'bw-max': 20000}) |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 0}}) |
| ksft_eq(shaper, initial) |
| |
| _delete_shaper(cfg, nl_shaper, {'scope': 'queue', 'id': 0}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def mixed_parent_group_requires_parent(cfg, nl_shaper) -> None: |
| r"""Grouping leaves from different nodes requires an explicit parent. |
| |
| netdev netdev |
| / \ parent=netdev |
| N1 N2 group N |
| | | {Q0,Q1} / \ |
| Q0 Q1 -------> Q0 Q1 |
| |
| Without an explicit parent the group is rejected; parent=netdev |
| collapses the leaves into one new node. |
| """ |
| _require_queues(cfg, 2) |
| _require_caps(cfg, nl_shaper, 'node', |
| ['support-bw-max', 'support-metric-bps'], |
| "device does not support node scope shapers with bw_max and metric bps") |
| _require_caps(cfg, nl_shaper, 'queue', |
| ['support-nesting', 'support-weight'], |
| "device does not support nested queue scope shapers with weight") |
| |
| n1_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 0}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': 10000}) |
| n1_id = n1_handle['handle']['id'] |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': 0}) |
| |
| n2_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 2}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': 20000}) |
| n2_id = n2_handle['handle']['id'] |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': 1}) |
| |
| with ksft_raises(NlError): |
| nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 0}, |
| 'weight': 3}, |
| {'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 4}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': 30000}) |
| |
| shaper_q0 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 0}}) |
| ksft_eq(shaper_q0, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': n1_id}, |
| 'handle': {'scope': 'queue', 'id': 0}, |
| 'weight': 1}) |
| shaper_q1 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 1}}) |
| ksft_eq(shaper_q1, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': n2_id}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 2}) |
| |
| node_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 0}, |
| 'weight': 3}, |
| {'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 4}], |
| 'handle': {'scope':'node'}, |
| 'parent': {'scope': 'netdev'}, |
| 'metric': 'bps', |
| 'bw-max': 30000}) |
| node_id = node_handle['handle']['id'] |
| |
| for old_id in (n1_id, n2_id): |
| with ksft_raises(NlError): |
| nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': old_id}}) |
| |
| shaper_q0 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 0}}) |
| ksft_eq(shaper_q0, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'queue', 'id': 0}, |
| 'weight': 3}) |
| shaper_q1 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 1}}) |
| ksft_eq(shaper_q1, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 4}) |
| |
| for i in range(2): |
| _delete_shaper(cfg, nl_shaper, {'scope': 'queue', 'id': i}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def recursive_empty_node_cleanup(cfg, nl_shaper) -> None: |
| r"""Deleting the last leaf recursively removes the emptied ancestors. |
| |
| netdev netdev |
| | del Q0 |
| N1 ------> (N1 and N2 removed too) |
| | |
| N2 |
| | |
| Q0 |
| """ |
| _require_queues(cfg, 1) |
| _require_caps(cfg, nl_shaper, 'node', |
| ['support-bw-max', 'support-metric-bps', 'support-nesting'], |
| "device does not support nested node scope shapers") |
| _require_caps(cfg, nl_shaper, 'queue', |
| ['support-nesting', 'support-weight'], |
| "device does not support nested queue scope shapers with weight") |
| |
| n1_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 0}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': 10000}) |
| n1_id = n1_handle['handle']['id'] |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': 0}) |
| |
| n2_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 0}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'parent': {'scope': 'node', 'id': n1_id}, |
| 'metric': 'bps', |
| 'bw-max': 5000}) |
| n2_id = n2_handle['handle']['id'] |
| |
| shaper_q0 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 0}}) |
| ksft_eq(shaper_q0, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': n2_id}, |
| 'handle': {'scope': 'queue', 'id': 0}, |
| 'weight': 1}) |
| |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 0}}) |
| |
| for handle in ({'scope': 'queue', 'id': 0}, |
| {'scope': 'node', 'id': n2_id}, |
| {'scope': 'node', 'id': n1_id}): |
| with ksft_raises(NlError): |
| nl_shaper.get({'ifindex': cfg.ifindex, 'handle': handle}) |
| |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def _group_under_netdev(cfg, nl_shaper, bw_max=None): |
| r"""Group queues under a netdev-scope node; caller owns node teardown. |
| |
| netdev netdev |
| / \ del Q1,Q2 |
| Q1 Q2 -------> (netdev node persists) |
| """ |
| group_args = { |
| 'ifindex': cfg.ifindex, |
| 'leaves': [{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 1}, |
| {'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 2}], |
| 'handle': {'scope': 'netdev'}} |
| if bw_max: |
| group_args['metric'] = 'bps' |
| group_args['bw-max'] = bw_max |
| |
| node_handle = nl_shaper.group(group_args) |
| ksft_eq(node_handle, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'netdev'}}) |
| |
| del_node = defer(_delete_shaper, cfg, nl_shaper, {'scope': 'netdev'}) |
| del_queues = [defer(_delete_shaper, cfg, nl_shaper, |
| {'scope': 'queue', 'id': qid}) |
| for qid in (1, 2)] |
| |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 1}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 1}) |
| for dq in del_queues: |
| dq.exec() |
| |
| # Caller owns the node teardown so it can verify the netdev-scope node |
| # survives leaf deletion before removing it. |
| return del_node |
| |
| def basic_groups(cfg, nl_shaper) -> None: |
| r"""Group queues under a netdev-scope node, then tear it down. |
| |
| netdev |
| / \ |
| Q1 Q2 |
| """ |
| _require_queues(cfg, 3) |
| |
| _require_caps(cfg, nl_shaper, 'netdev', [], "netdev scope not supported by the device") |
| _require_caps(cfg, nl_shaper, 'queue', ['support-nesting', 'support-weight'], |
| "queue scope not supported with nesting and weight") |
| |
| del_node = _group_under_netdev(cfg, nl_shaper) |
| |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(shapers, [{'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'netdev'}}]) |
| |
| del_node.exec() |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def basic_groups_with_rate(cfg, nl_shaper) -> None: |
| r"""Rate-limited netdev-scope node outlives deletion of its leaves. |
| |
| netdev[10kbps] netdev[10kbps] |
| / \ del Q1,Q2 |
| Q1 Q2 -------> (node persists) |
| """ |
| bw_max = 10000 |
| |
| _require_queues(cfg, 3) |
| |
| _require_caps(cfg, nl_shaper, 'netdev', ['support-bw-max', 'support-metric-bps'], |
| "device does not support netdev scope rate limiting") |
| _require_caps(cfg, nl_shaper, 'queue', ['support-nesting', 'support-weight'], |
| "device does not support queue scope shapers with nesting and weight") |
| |
| del_node = _group_under_netdev(cfg, nl_shaper, bw_max=bw_max) |
| |
| # Deleting all the leaves shaper does not affect the node one |
| # when the latter has 'netdev' scope. |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(shapers, [{'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'netdev'}, |
| 'metric': 'bps', |
| 'bw-max': bw_max}]) |
| |
| del_node.exec() |
| |
| def qgroups(cfg, nl_shaper) -> None: |
| _require_queues(cfg, 4) |
| _require_caps(cfg, nl_shaper, 'node', |
| ['support-bw-max', 'support-metric-bps'], |
| "device does not support node scope shapers with bw_max and metric bps") |
| _require_caps(cfg, nl_shaper, 'queue', |
| ['support-nesting', 'support-weight'], |
| "device does not support nested queue scope shapers with weight") |
| |
| node_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 3}, |
| {'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 2}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': 10000}) |
| node_id = node_handle['handle']['id'] |
| |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 1}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 3}) |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}, |
| 'parent': {'scope': 'netdev'}, |
| 'metric': 'bps', |
| 'bw-max': 10000}) |
| |
| # Grouping to a specified, not existing node scope shaper must fail |
| raised = False |
| try: |
| nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 3}], |
| 'handle': {'scope':'node', 'id': node_id + 1}, |
| 'metric': 'bps', |
| 'bw-max': 10000}) |
| |
| except (NlError): |
| raised = True |
| ksft_eq(raised, True) |
| |
| # Add to an existing node |
| node_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 4}], |
| 'handle': {'scope':'node', 'id': node_id}}) |
| ksft_eq(node_handle, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}}) |
| |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 3}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 4}) |
| |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 2}}) |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 1}}) |
| |
| # Deleting a non empty node will move the leaves downstream. |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(shapers, [{'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 4}]) |
| |
| # Finish and verify the complete cleanup. |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 3}}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def set_node_shaper(cfg, nl_shaper) -> None: |
| """ Verify a node-scope shaper rate can be updated via .set. """ |
| _require_queues(cfg, 2) |
| _require_caps(cfg, nl_shaper, 'node', ['support-bw-max', 'support-metric-bps'], |
| "device does not support node scope shapers with bw_max and metric bps") |
| _require_caps(cfg, nl_shaper, 'queue', ['support-nesting', 'support-weight'], |
| "device does not support nested queue scope shapers with weight") |
| |
| node_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': 10000}) |
| node_id = node_handle['handle']['id'] |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': 1}) |
| |
| # Update the node's rate via .set |
| nl_shaper.set({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}, |
| 'metric': 'bps', |
| 'bw-max': 20000}) |
| |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}, |
| 'parent': {'scope': 'netdev'}, |
| 'metric': 'bps', |
| 'bw-max': 20000}) |
| |
| # Cleanup |
| _delete_shaper(cfg, nl_shaper, {'scope': 'queue', 'id': 1}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def group_update_rate(cfg, nl_shaper) -> None: |
| """ Verify re-grouping a node updates its rate while leaving the leaves untouched. """ |
| _require_queues(cfg, 3) |
| _require_caps(cfg, nl_shaper, 'node', ['support-bw-max', 'support-metric-bps'], |
| "device does not support node scope shapers with bw_max and metric bps") |
| _require_caps(cfg, nl_shaper, 'queue', ['support-nesting', 'support-weight'], |
| "device does not support nested queue scope shapers with weight") |
| |
| # Create node with Q1, Q2 at bw_max=10000 |
| node_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 1}, |
| {'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': 10000}) |
| node_id = node_handle['handle']['id'] |
| for i in range(1, 3): |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': i}) |
| |
| # Update rate via .group on the same node |
| nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 1}, |
| {'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 1}], |
| 'handle': {'scope':'node', 'id': node_id}, |
| 'metric': 'bps', |
| 'bw-max': 50000}) |
| |
| # Verify rate updated |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}, |
| 'parent': {'scope': 'netdev'}, |
| 'metric': 'bps', |
| 'bw-max': 50000}) |
| |
| # Verify leaves unchanged |
| shaper_q1 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 1}}) |
| ksft_eq(shaper_q1, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 1}) |
| shaper_q2 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 2}}) |
| ksft_eq(shaper_q2, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 1}) |
| |
| # Make sure we only have 3 shapers including 2 queues and the node |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 3) |
| |
| # Cleanup |
| for i in range(1, 3): |
| _delete_shaper(cfg, nl_shaper, {'scope': 'queue', 'id': i}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def delegation(cfg, nl_shaper) -> None: |
| _require_queues(cfg, 4) |
| _require_caps(cfg, nl_shaper, 'node', |
| ['support-bw-max', 'support-metric-bps', 'support-nesting'], |
| "device does not support node scope shapers with bw_max, metric bps and nesting") |
| _require_caps(cfg, nl_shaper, 'queue', ['support-nesting', 'support-weight'], |
| "device does not support nested queue scope shapers with weight") |
| |
| node_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 3}, |
| {'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 2}, |
| {'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': 10000}) |
| node_id = node_handle['handle']['id'] |
| |
| # Create the nested node and validate the hierarchy |
| nested_node_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 3}, |
| {'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 2}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': 5000}) |
| nested_node_id = nested_node_handle['handle']['id'] |
| ksft_true(nested_node_id != node_id) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(shapers, [{'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': nested_node_id}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 3}, |
| {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': nested_node_id}, |
| 'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 2}, |
| {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 1}, |
| {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'node', 'id': node_id}, |
| 'metric': 'bps', |
| 'bw-max': 10000}, |
| {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'node', 'id': nested_node_id}, |
| 'metric': 'bps', |
| 'bw-max': 5000}]) |
| |
| # Deleting a non empty node will move the leaves downstream. |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': nested_node_id}}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(shapers, [{'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 3}, |
| {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 2}, |
| {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 1}, |
| {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'node', 'id': node_id}, |
| 'metric': 'bps', |
| 'bw-max': 10000}]) |
| |
| # Final cleanup. |
| for i in range(1, 4): |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': i}}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def nested_depth_limit(cfg, nl_shaper) -> None: |
| r"""Nest nodes as deep as the device allows to find the max depth. |
| |
| netdev |
| | |
| N1 -- Q1 |
| | |
| N2 -- Q2 |
| | |
| N3 -- Q3 |
| : (deepen until the driver rejects) |
| """ |
| bw_max = 10000 |
| |
| _require_caps(cfg, nl_shaper, 'node', |
| ['support-bw-max', 'support-metric-bps', 'support-nesting'], |
| "device does not support node scope shapers with bw_max, metric bps and nesting") |
| _require_caps(cfg, nl_shaper, 'queue', ['support-nesting', 'support-weight'], |
| "device does not support nested queue scope shapers with weight") |
| |
| nq = _require_queues(cfg, 3) |
| |
| node_ids = [] |
| cleanups = [] |
| queue_id = 1 |
| max_depth = 0 |
| limit_err = None |
| |
| # Create initial node with a queue leaf |
| node_id = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves': [{'handle': {'scope': 'queue', 'id': queue_id}, |
| 'weight': 1}], |
| 'handle': {'scope': 'node'}, |
| 'metric': 'bps', |
| 'bw-max': bw_max})['handle']['id'] |
| node_ids.append(node_id) |
| cleanups.append(defer(_delete_shaper, cfg, nl_shaper, |
| {'scope': 'node', 'id': node_id})) |
| cleanups.append(defer(_delete_shaper, cfg, nl_shaper, |
| {'scope': 'queue', 'id': queue_id})) |
| max_depth = 1 |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}, |
| 'parent': {'scope': 'netdev'}, |
| 'metric': 'bps', |
| 'bw-max': bw_max}) |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': queue_id}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'queue', 'id': queue_id}, |
| 'weight': 1}) |
| queue_id += 1 |
| |
| # Keep nesting deeper until the driver rejects or queues run out. |
| while queue_id < nq: |
| parent_id = node_ids[-1] |
| try: |
| node_id = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves': [{'handle': {'scope': 'queue', |
| 'id': queue_id}, |
| 'weight': 1}], |
| 'handle': {'scope': 'node'}, |
| 'parent': {'scope': 'node', |
| 'id': parent_id}, |
| 'metric': 'bps', |
| 'bw-max': bw_max})['handle']['id'] |
| except NlError as e: |
| # Only treat "cannot nest deeper" errors as the depth limit; |
| # drivers report it differently (EOPNOTSUPP/ENOSPC/E2BIG/EINVAL). |
| # Anything else (ENOMEM, EIO, EPERM, driver bug) is a real failure. |
| if e.error not in (errno.EOPNOTSUPP, errno.ENOSPC, |
| errno.E2BIG, errno.EINVAL): |
| raise |
| limit_err = e |
| break |
| |
| node_ids.append(node_id) |
| cleanups.append(defer(_delete_shaper, cfg, nl_shaper, |
| {'scope': 'node', 'id': node_id})) |
| cleanups.append(defer(_delete_shaper, cfg, nl_shaper, |
| {'scope': 'queue', 'id': queue_id})) |
| max_depth += 1 |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node_id}, |
| 'parent': {'scope': 'node', 'id': parent_id}, |
| 'metric': 'bps', |
| 'bw-max': bw_max}) |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', |
| 'id': queue_id}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node_id}, |
| 'handle': {'scope': 'queue', 'id': queue_id}, |
| 'weight': 1}) |
| queue_id += 1 |
| |
| if limit_err: |
| print(f"# max nesting depth supported: {max_depth} (errno {limit_err.error})") |
| else: |
| print(f"# max nesting depth tested: {max_depth}") |
| ksft_true(max_depth >= 2, |
| f"max nesting depth: {max_depth}") |
| |
| # Cleanup: exec the deferred deletes in reverse creation order, so each |
| # queue leaf and deeper node is removed before its parent node. |
| for cleanup in reversed(cleanups): |
| cleanup.exec() |
| ksft_eq(len(nl_shaper.get({'ifindex': cfg.ifindex}, dump=True)), 0) |
| |
| def delete_child_reparent(cfg, nl_shaper) -> None: |
| r"""Deleting a child node reparents its queue leaf to the parent. |
| |
| netdev netdev |
| | | |
| N1 del N2 N1 |
| / | \ -----> / | \ |
| Q1 Q2 N2 Q1 Q2 Q3 |
| | |
| Q3 |
| """ |
| n1_bw_max = 10000 |
| n2_bw_max = 5000 |
| |
| _require_caps(cfg, nl_shaper, 'node', |
| ['support-bw-max', 'support-metric-bps', 'support-nesting'], |
| "device does not support node scope shapers with bw_max, metric bps and nesting") |
| _require_caps(cfg, nl_shaper, 'queue', ['support-nesting', 'support-weight'], |
| "device does not support nested queue scope shapers with weight") |
| |
| _require_queues(cfg, 4) |
| |
| # Create parent node N1 with Q1, Q2 |
| n1_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 1}, |
| {'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': n1_bw_max}) |
| n1_id = n1_handle['handle']['id'] |
| for i in range(1, 3): |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': i}) |
| |
| # Create child node N2 under N1 with Q3 |
| n2_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'parent': {'scope': 'node', 'id': n1_id}, |
| 'metric': 'bps', |
| 'bw-max': n2_bw_max}) |
| n2_id = n2_handle['handle']['id'] |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': 3}) |
| |
| # Delete child N2 - Q3 should reparent to N1 |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': n2_id}}) |
| |
| with ksft_raises(NlError): |
| nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': n2_id}}) |
| |
| shaper_n1 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': n1_id}}) |
| ksft_eq(shaper_n1, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': n1_id}, |
| 'parent': {'scope': 'netdev'}, |
| 'metric': 'bps', |
| 'bw-max': n1_bw_max}) |
| shaper_q3 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 3}}) |
| ksft_eq(shaper_q3, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': n1_id}, |
| 'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 1}) |
| |
| # Cleanup |
| for i in range(1, 4): |
| _delete_shaper(cfg, nl_shaper, {'scope': 'queue', 'id': i}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def move_queue_between_nodes(cfg, nl_shaper) -> None: |
| r"""Move a queue between nodes by re-grouping the destination node. |
| |
| netdev netdev |
| / \ .group N2 / \ |
| N1 N2 {Q1,Q3} N1 N2 |
| / \ | -------> | / \ |
| Q1 Q2 Q3 Q2 Q1 Q3 |
| """ |
| n1_bw_max = 10000 |
| n2_bw_max = 20000 |
| |
| _require_caps(cfg, nl_shaper, 'node', |
| ['support-bw-max', 'support-metric-bps', 'support-nesting'], |
| "device does not support node scope shapers with bw_max, metric bps and nesting") |
| _require_caps(cfg, nl_shaper, 'queue', ['support-nesting', 'support-weight'], |
| "device does not support nested queue scope shapers with weight") |
| |
| _require_queues(cfg, 4) |
| |
| # Create N1 with Q1, Q2 |
| n1_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 1}, |
| {'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': n1_bw_max}) |
| n1_id = n1_handle['handle']['id'] |
| for i in range(1, 3): |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': i}) |
| |
| # Create N2 with Q3 |
| n2_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': n2_bw_max}) |
| n2_id = n2_handle['handle']['id'] |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': 3}) |
| |
| # Move Q1 from N1 to N2 by re-grouping N2 with Q1, Q3 |
| nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 2}, |
| {'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 1}], |
| 'handle': {'scope':'node', 'id': n2_id}, |
| 'metric': 'bps', |
| 'bw-max': n2_bw_max}) |
| |
| shaper_n1 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': n1_id}}) |
| ksft_eq(shaper_n1, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': n1_id}, |
| 'parent': {'scope': 'netdev'}, |
| 'metric': 'bps', |
| 'bw-max': n1_bw_max}) |
| shaper_n2 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': n2_id}}) |
| ksft_eq(shaper_n2, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': n2_id}, |
| 'parent': {'scope': 'netdev'}, |
| 'metric': 'bps', |
| 'bw-max': n2_bw_max}) |
| |
| # Verify Q1 moved to N2 |
| shaper_q1 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 1}}) |
| ksft_eq(shaper_q1, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': n2_id}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 2}) |
| |
| # Verify Q2 still under N1 |
| shaper_q2 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 2}}) |
| ksft_eq(shaper_q2, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': n1_id}, |
| 'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 1}) |
| |
| # Verify Q3 remained under N2 |
| shaper_q3 = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 3}}) |
| ksft_eq(shaper_q3, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': n2_id}, |
| 'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 1}) |
| |
| # Cleanup |
| for i in range(1, 4): |
| _delete_shaper(cfg, nl_shaper, {'scope': 'queue', 'id': i}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def reject_reparenting(cfg, nl_shaper) -> None: |
| r"""Reject reparenting an existing node; the hierarchy stays intact. |
| |
| netdev |
| / \ rejected: N3 -> netdev |
| N1 N2 rejected: N1 -> N2 |
| / \ | (both EOPNOTSUPP) |
| Q1 N3 Q2 |
| | |
| Q3 |
| """ |
| node1_bw_max = 10000 |
| node2_bw_max = 5000 |
| node3_bw_max = 20000 |
| |
| _require_caps(cfg, nl_shaper, 'node', |
| ['support-bw-max', 'support-metric-bps', 'support-nesting'], |
| "device does not support node scope shapers with bw_max, metric bps and nesting") |
| _require_caps(cfg, nl_shaper, 'queue', ['support-nesting', 'support-weight'], |
| "device does not support nested queue scope shapers with weight") |
| |
| _require_queues(cfg, 4) |
| |
| # Create Node1 under netdev with Q1. |
| node1_id = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': node1_bw_max})['handle']['id'] |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': 1}) |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'node', 'id': node1_id}) |
| |
| # Create Node2 under netdev with Q2. |
| node2_id = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': node2_bw_max})['handle']['id'] |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': 2}) |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'node', 'id': node2_id}) |
| |
| # Create Node3 nested under Node1 with Q3. |
| node3_id = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 1}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': node3_bw_max, |
| 'parent': {'scope': 'node', 'id': node1_id}})['handle']['id'] |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'queue', 'id': 3}) |
| defer(_delete_shaper, cfg, nl_shaper, {'scope': 'node', 'id': node3_id}) |
| |
| # Reparenting a nested node up to netdev must fail. |
| with ksft_raises(NlError) as cm: |
| nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 1}], |
| 'handle': {'scope':'node', 'id': node3_id}, |
| 'parent': {'scope': 'netdev'}}) |
| if cm.exception: |
| ksft_eq(cm.exception.error, errno.EOPNOTSUPP) |
| |
| # Reparenting a node under another node must fail as well. |
| with ksft_raises(NlError) as cm: |
| nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 1}], |
| 'handle': {'scope':'node', 'id': node1_id}, |
| 'parent': {'scope': 'node', 'id': node2_id}}) |
| if cm.exception: |
| ksft_eq(cm.exception.error, errno.EOPNOTSUPP) |
| |
| # Updating a node with the same parent must succeed. |
| nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 5}], |
| 'handle': {'scope':'node', 'id': node1_id}, |
| 'parent': {'scope': 'netdev'}}) |
| |
| # Updating a node without specifying the parent must succeed. |
| nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 7}], |
| 'handle': {'scope':'node', 'id': node2_id}}) |
| |
| # The rejected reparents must have left the hierarchy intact. |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node1_id}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node1_id}, |
| 'parent': {'scope': 'netdev'}, |
| 'metric': 'bps', |
| 'bw-max': node1_bw_max}) |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node2_id}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node2_id}, |
| 'parent': {'scope': 'netdev'}, |
| 'metric': 'bps', |
| 'bw-max': node2_bw_max}) |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node3_id}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'node', 'id': node3_id}, |
| 'parent': {'scope': 'node', 'id': node1_id}, |
| 'metric': 'bps', |
| 'bw-max': node3_bw_max}) |
| |
| # Verify the leaf weights were updated and parents unchanged. |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 1}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node1_id}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'weight': 5}) |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 2}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node2_id}, |
| 'handle': {'scope': 'queue', 'id': 2}, |
| 'weight': 7}) |
| shaper = nl_shaper.get({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': 3}}) |
| ksft_eq(shaper, {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'node', 'id': node3_id}, |
| 'handle': {'scope': 'queue', 'id': 3}, |
| 'weight': 1}) |
| |
| # Cleanup. Delete the nodes explicitly instead of relying on the |
| # empty-node auto-delete: a kernel that wrongly accepts a reparent may |
| # mishandle the leaf accounting and leave a node behind. Removing them |
| # by handle keeps a failing run from leaking state into later tests. |
| for i in range(1, 4): |
| _delete_shaper(cfg, nl_shaper, {'scope': 'queue', 'id': i}) |
| for nid in (node1_id, node2_id, node3_id): |
| _delete_shaper(cfg, nl_shaper, {'scope': 'node', 'id': nid}) |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(len(shapers), 0) |
| |
| def queue_update(cfg, nl_shaper) -> None: |
| nq = _require_queues(cfg, 4) |
| if not cfg.queues: |
| raise KsftSkipEx("device does not support queue scope") |
| |
| netnl = EthtoolFamily() |
| channels = netnl.channels_get({'header': {'dev-index': cfg.ifindex}}) |
| ch_type = 'combined' if channels['combined-count'] else 'tx' |
| |
| for i in range(3): |
| nl_shaper.set({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': i}, |
| 'metric': 'bps', |
| 'bw-max': (i + 1) * 1000}) |
| defer(cmd, f"ethtool -L {cfg.dev['ifname']} {ch_type} {nq}") |
| |
| # Delete a channel, with no shapers configured on top of the related |
| # queue: no changes expected |
| cmd(f"ethtool -L {cfg.dev['ifname']} {ch_type} 3") |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(shapers, [{'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 0}, |
| 'metric': 'bps', |
| 'bw-max': 1000}, |
| {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'metric': 'bps', |
| 'bw-max': 2000}, |
| {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 2}, |
| 'metric': 'bps', |
| 'bw-max': 3000}]) |
| |
| # Delete a channel, with a shaper configured on top of the related |
| # queue: the shaper must be deleted, too |
| cmd(f"ethtool -L {cfg.dev['ifname']} {ch_type} 2") |
| |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(shapers, [{'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 0}, |
| 'metric': 'bps', |
| 'bw-max': 1000}, |
| {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'metric': 'bps', |
| 'bw-max': 2000}]) |
| |
| # Restore the original channels number, no expected changes |
| cmd(f"ethtool -L {cfg.dev['ifname']} {ch_type} {nq}") |
| shapers = nl_shaper.get({'ifindex': cfg.ifindex}, dump=True) |
| ksft_eq(shapers, [{'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 0}, |
| 'metric': 'bps', |
| 'bw-max': 1000}, |
| {'ifindex': cfg.ifindex, |
| 'parent': {'scope': 'netdev'}, |
| 'handle': {'scope': 'queue', 'id': 1}, |
| 'metric': 'bps', |
| 'bw-max': 2000}]) |
| |
| # Final cleanup. |
| for i in range(0, 2): |
| nl_shaper.delete({'ifindex': cfg.ifindex, |
| 'handle': {'scope': 'queue', 'id': i}}) |
| |
| def dup_leaves(cfg, nl_shaper) -> None: |
| """ Ensure that the kernel rejects duplicate leaves. """ |
| _require_caps(cfg, nl_shaper, 'node', ['support-bw-max', 'support-metric-bps'], |
| "device does not support node scope shapers with bw_max and metric bps") |
| _require_caps(cfg, nl_shaper, 'queue', ['support-nesting', 'support-weight'], |
| "device does not support nested queue scope shapers with weight") |
| |
| node_handle = None |
| with ksft_raises(NlError) as cm: |
| node_handle = nl_shaper.group({ |
| 'ifindex': cfg.ifindex, |
| 'leaves':[{'handle': {'scope': 'queue', 'id': 0}, |
| 'weight': 1}, |
| {'handle': {'scope': 'queue', 'id': 0}, |
| 'weight': 2}], |
| 'handle': {'scope':'node'}, |
| 'metric': 'bps', |
| 'bw-max': 10000}) |
| |
| # Clean up in case the kernel wrongly accepted the request. |
| if node_handle: |
| _delete_shaper(cfg, nl_shaper, node_handle['handle']) |
| _delete_shaper(cfg, nl_shaper, {'scope': 'queue', 'id': 0}) |
| |
| # ksft_raises() has already recorded the failure if nothing was raised. |
| if cm.exception is None: |
| return |
| ksft_eq(cm.exception.error, errno.EINVAL) |
| |
| def main() -> None: |
| with NetDrvEnv(__file__, queue_count=4) as cfg: |
| cfg.queues = False |
| cfg.netdev = False |
| ksft_run([get_shapers, |
| get_caps, |
| set_qshapers, |
| del_qshapers, |
| set_nshapers, |
| del_nshapers, |
| set_all_supported_attrs, |
| invalid_set_preserves_state, |
| mixed_parent_group_requires_parent, |
| recursive_empty_node_cleanup, |
| basic_groups, |
| basic_groups_with_rate, |
| qgroups, |
| set_node_shaper, |
| group_update_rate, |
| delegation, |
| nested_depth_limit, |
| delete_child_reparent, |
| move_queue_between_nodes, |
| reject_reparenting, |
| dup_leaves, |
| queue_update], |
| args=(cfg, NetshaperFamily())) |
| ksft_exit() |
| |
| |
| if __name__ == "__main__": |
| main() |
