path: root/tools/testing/selftests/drivers/net/shaper.py

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