Add tests for dynamic bridge eid and downstream eid assignment

Add new test for validating AssignEndpoint D-Bus method
to verify bridge endpoint EID allocation being contiguous to its
downstream eids. Add Allocate Endpoint control message support with
new endpoint property for allocated pool size also assign dynamic eid
contiguous to bridge during Allocate Endpoint control message.

Signed-off-by: Faizan Ali <[email protected]>

Author: faizana-nvidia

tests/mctpenv/__init__.py

@@ -303,6 +303,10 @@ def __init__(self, iface, lladdr, ep_uuid = None, eid = 0, types = None):
         self.eid = eid
         self.types = types or [0]
         self.bridged_eps = []
+        self.pool_size = 0
+        self.pool_start = 0
+        self.allocated_pool_size = 0
+
         # keyed by (type, type-specific-instance)
         self.commands = {}
 
@@ -348,7 +352,9 @@ async def handle_mctp_control(self, sock, addr, data):
                 # Set Endpoint ID
                 (op, eid) = data[2:]
                 self.eid = eid
-                data = bytes(hdr + [0x00, 0x00, self.eid, 0x00])
+                self.pool_size = len(self.bridged_eps)
+                alloc_status = 0x01 if self.pool_size > 0 else 0x00
+                data = bytes(hdr + [0x00, alloc_status, self.eid, self.pool_size])
                 await sock.send(raddr, data)
 
             elif opcode == 2:
@@ -367,6 +373,24 @@ async def handle_mctp_control(self, sock, addr, data):
                 data = bytes(hdr + [0x00, len(types)] + types)
                 await sock.send(raddr, data)
 
+            elif opcode == 8:
+                # Allocate Endpoint IDs
+                (_, _, _, pool_size, pool_start) = data
+                alloc_status = 0x00
+                if self.allocated_pool_size > 0:
+                    alloc_status = 0x01
+                else:
+                    num_eps = min(pool_size, self.pool_size)
+                    self.allocated_pool_size = num_eps
+                    self.pool_start = pool_start
+                    # Assign sequential EIDs starting from pool_start
+                    for ep in range(num_eps):
+                        self.bridged_eps[ep].eid = pool_start + ep
+
+                data = bytes(hdr + [0x00, alloc_status,
+                                self.allocated_pool_size, self.pool_start])
+                await sock.send(raddr, data)
+
             else:
                 await sock.send(raddr, bytes(hdr + [0x05])) # unsupported command
 

tests/test_mctpd.py

@@ -926,3 +926,48 @@ async def test_config_dyn_eid_range_max(nursery, dbus, sysnet):
 
     res = await mctpd.stop_mctpd()
     assert res == 0
+
+""" Test bridge endpoint dynamic EID assignment and downstream
+endpoint EID allocation
+
+Tests that:
+- Bridge endpoint can be assigned a dynamic EID
+- Downstream endpoints get contiguous EIDs after bridge's own eid
+"""
+async def test_assign_dynamic_bridge_eid(dbus, mctpd):
+    iface = mctpd.system.interfaces[0]
+    mctp = await mctpd_mctp_iface_obj(dbus, iface)
+    ep = mctpd.network.endpoints[0]
+    pool_size = 2
+
+    # Set up bridged endpoints as undiscovered EID 0
+    for i in range(pool_size):
+        br_ep = Endpoint(iface, bytes(), types=[0, 2])
+        ep.add_bridged_ep(br_ep)
+        mctpd.network.add_endpoint(br_ep)
+
+    mctp = await mctpd_mctp_iface_obj(dbus, iface)
+
+    # dynamic EID assigment for dev1
+    (eid, _, path, new) = await mctp.call_assign_endpoint(
+        ep.lladdr,
+    )
+
+    assert new
+
+    # check if we can assign non-bridged endpoint dev2, eid from 
+    #bridge's already assigned pool
+    dev2 = Endpoint(iface, bytes([0x1e]))
+    mctpd.network.add_endpoint(dev2)
+    with pytest.raises(asyncdbus.errors.DBusError) as ex:
+        await mctp.call_assign_endpoint_static(dev2.lladdr, ep.eid + 1)
+
+    assert str(ex.value) == "EID belongs to another MCTP bridge pool"
+
+    # check if downstream endpoint EID of dev1 is in allocated pool range
+    net = await mctpd_mctp_network_obj(dbus, iface.net)
+    for i in range(pool_size):
+        br_ep = ep.bridged_eps[i]
+        assert ep.eid < br_ep.eid <= ep.eid + ep.allocated_pool_size
+        (_, new) = await net.call_learn_endpoint(br_ep.eid)
+        assert new