mctpd: allow configurable dynamic address ranges

As proposed in #94, add a
new configuration option for specifying a global dynamic EID range:

    # dynamic EID range: a 2-element array of min and max (inclusive) EID values.
    dynamic_eid_range = [8, 254]

We use this to confine the any dynamic allocations; EIDs of local
interfaces and statically-defined allocations may fall outside of this
range.

Fixes: #94
Signed-off-by: Jeremy Kerr <[email protected]>

Author: jk-ozlabs

CHANGELOG.md

@@ -20,6 +20,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 3. Added documentation for `mctpd.conf` settings
 
+4. `mctpd`'s dynamic EID range is now configurable
+
 ## [2.2] - 2025-07-28
 
 ### Fixed

conf/mctpd.conf

@@ -11,5 +11,8 @@ message_timeout_ms = 30
 
 # bus-owner configuration
 [bus-owner]
-max_pool_size = 15
 
+# dynamic EID range: a 2-element array of min and max (inclusive) EID values.
+dynamic_eid_range = [8, 254]
+
+max_pool_size = 15

docs/mctpd.md

@@ -276,6 +276,20 @@ uuid = "21f0f554-7f7c-4211-9ca1-6d0f000ea9e7"
 
 This section affects behaviour when `mctpd` is running in bus owner mode
 
+#### `dynamic_eid_range`: Range for dynamic EID allocations
+
+* type: array of integers, 2 elements
+* default: `[ 8, 254 ]`
+
+This setting specifies the range of dynamic EIDs that `mctpd` will allocate
+new peers' EIDs from. Values are inclusive.
+
+Local interface EIDs and statically-allocated EIDs may fall outside this range;
+it is only used when a peer needs a new dynamic address.
+
+The default value makes the entire MCTP EID address space available for dynamic
+allocations.
+
 #### `max_pool_size`: Maximum peer allocation pool size
 
 * type: integer

src/mctpd.c

@@ -57,8 +57,8 @@ static const char *mctpd_appid = "67369c05-4b97-4b7e-be72-65cfd8639f10";
 
 static const char *conf_file_default = MCTPD_CONF_FILE_DEFAULT;
 
-static mctp_eid_t eid_alloc_min = 0x08;
-static mctp_eid_t eid_alloc_max = 0xfe;
+static const mctp_eid_t eid_alloc_min = 0x08;
+static const mctp_eid_t eid_alloc_max = 0xfe;
 
 // arbitrary sanity
 static size_t MAX_PEER_SIZE = 1000000;
@@ -206,6 +206,10 @@ struct ctx {
 	struct net **nets;
 	size_t num_nets;
 
+	// the range we allocate any dynamic EIDs from
+	mctp_eid_t dyn_eid_min;
+	mctp_eid_t dyn_eid_max;
+
 	// Timeout in usecs for a MCTP response
 	uint64_t mctp_timeout;
 
@@ -1667,16 +1671,16 @@ static int endpoint_assign_eid(struct ctx *ctx, sd_bus_error *berr,
 
 		new_eid = static_eid;
 	} else {
-		/* Find an unused EID */
-		for (e = eid_alloc_min; e <= eid_alloc_max; e++) {
+		/* Find an unused dynamic EID */
+		for (e = ctx->dyn_eid_min; e <= ctx->dyn_eid_max; e++) {
 			if (n->peers[e])
 				continue;
 			rc = add_peer(ctx, dest, e, net, &peer);
 			if (rc < 0)
 				return rc;
 			break;
 		}
-		if (e > eid_alloc_max) {
+		if (e > ctx->dyn_eid_max) {
 			warnx("Ran out of EIDs for net %d, allocating %s", net,
 			      dest_phys_tostr(dest));
 			sd_bus_error_setf(berr, SD_BUS_ERROR_FAILED,
@@ -3935,21 +3939,67 @@ static int parse_config_mctp(struct ctx *ctx, toml_table_t *mctp_tab)
 	return 0;
 }
 
+static int parse_config_dyn_eid_range(struct ctx *ctx, toml_array_t *arr)
+{
+	int sz = toml_array_nelem(arr);
+	toml_datum_t min_val, max_val;
+
+	if (sz < 2) {
+		warnx("dynamic_eid_range has invalid format - needs two elements");
+		return -1;
+	}
+	if (sz > 2) {
+		warnx("dynamic_eid_range: ignoring extra (> 2) elements");
+	}
+
+	min_val = toml_int_at(arr, 0);
+	max_val = toml_int_at(arr, 1);
+
+	if (!min_val.ok || !max_val.ok) {
+		warnx("dynamic_eid_range: invalid range data");
+		return -1;
+	}
+
+	if (min_val.u.i < eid_alloc_min || min_val.u.i > eid_alloc_max) {
+		warnx("dynamic_eid_range: start address is invalid");
+		return -1;
+	}
+
+	if (max_val.u.i < eid_alloc_min || max_val.u.i > eid_alloc_max ||
+	    max_val.u.i < min_val.u.i) {
+		warnx("dynamic_eid_range: end address is invalid");
+		return -1;
+	}
+
+	ctx->dyn_eid_max = max_val.u.i;
+	ctx->dyn_eid_min = min_val.u.i;
+	return 0;
+}
+
 static int parse_config_bus_owner(struct ctx *ctx, toml_table_t *bus_owner)
 {
+	toml_array_t *array;
 	toml_datum_t val;
+	int rc;
 
 	val = toml_int_in(bus_owner, "max_pool_size");
 	if (val.ok) {
 		int64_t i = val.u.i;
-		if (i <= 0 || i > (eid_alloc_max - eid_alloc_min)) {
+		if (i <= 0 || i > (ctx->dyn_eid_max - ctx->dyn_eid_min)) {
 			warnx("invalid max_pool_size value (must be 1-%d)",
-			      eid_alloc_max - eid_alloc_min);
+			      ctx->dyn_eid_max - ctx->dyn_eid_min);
 			return -1;
 		}
 		ctx->max_pool_size = i;
 	}
 
+	array = toml_array_in(bus_owner, "dynamic_eid_range");
+	if (array) {
+		rc = parse_config_dyn_eid_range(ctx, array);
+		if (rc)
+			return rc;
+	}
+
 	return 0;
 }
 
@@ -4021,6 +4071,8 @@ static void setup_config_defaults(struct ctx *ctx)
 	ctx->mctp_timeout = 250000; // 250ms
 	ctx->default_role = ENDPOINT_ROLE_BUS_OWNER;
 	ctx->max_pool_size = 15;
+	ctx->dyn_eid_min = eid_alloc_min;
+	ctx->dyn_eid_max = eid_alloc_max;
 }
 
 static void free_config(struct ctx *ctx)

tests/test_mctpd.py

@@ -9,7 +9,7 @@
     mctpd_mctp_endpoint_common_obj,
     mctpd_mctp_endpoint_control_obj
 )
-from mctpenv import Endpoint, MCTPSockAddr, MCTPControlCommand
+from mctpenv import Endpoint, MCTPSockAddr, MCTPControlCommand, MctpdWrapper
 
 # DBus constant symbol suffixes:
 #
@@ -869,3 +869,60 @@ async def test_interface_rename_with_peers(dbus, mctpd):
     # ensure the endpoint persists after rename
     ep_obj = await dbus.get_proxy_object(MCTPD_C, ep_path)
     assert ep_obj is not None
+
+""" Test that we use the minimum EID from the dynamic_eid_range config """
+async def test_config_dyn_eid_range_min(nursery, dbus, sysnet):
+    (min_dyn_eid, max_dyn_eid) = (20, 254)
+    config = f"""
+    [bus-owner]
+    dynamic_eid_range = [{min_dyn_eid}, {max_dyn_eid}]
+    """
+
+    # since we're specifying per-test config, we create the wrapper directly
+    # rather than using the fixture.
+    mctpd = MctpdWrapper(dbus, sysnet, config = config)
+    await mctpd.start_mctpd(nursery)
+
+    iface = mctpd.system.interfaces[0]
+    ep = mctpd.network.endpoints[0]
+
+    mctp = await mctpd_mctp_iface_obj(dbus, iface)
+    (eid, net, path, new) = await mctp.call_setup_endpoint(ep.lladdr)
+    assert eid == min_dyn_eid
+    assert ep.eid == eid
+
+    res = await mctpd.stop_mctpd()
+    assert res == 0
+
+""" Test that we use the maximum EID from the dynamic_eid_range config """
+async def test_config_dyn_eid_range_max(nursery, dbus, sysnet):
+    (min_dyn_eid, max_dyn_eid) = (20, 21)
+    config = f"""
+    [bus-owner]
+    dynamic_eid_range = [{min_dyn_eid}, {max_dyn_eid}]
+    """
+
+    mctpd = MctpdWrapper(dbus, sysnet, config = config)
+    await mctpd.start_mctpd(nursery)
+
+    iface = mctpd.system.interfaces[0]
+    mctp = await mctpd_mctp_iface_obj(dbus, iface)
+
+    mctpd.network.add_endpoint(Endpoint(iface, bytes([0x01]), types = [0, 1]))
+    mctpd.network.add_endpoint(Endpoint(iface, bytes([0x02]), types = [0, 1]))
+
+    for i in range(0, 2):
+        ep = mctpd.network.endpoints[i]
+        (eid, net, path, new) = await mctp.call_setup_endpoint(ep.lladdr)
+        assert eid >= 20 and eid <= 21
+
+    # we should have run out of EIDs
+    with pytest.raises(asyncdbus.errors.DBusError) as ex:
+        ep = mctpd.network.endpoints[2]
+        (eid, net, path, new) = await mctp.call_setup_endpoint(ep.lladdr)
+
+    assert str(ex.value) == "Ran out of EIDs"
+    assert mctpd.network.endpoints[2].eid == 0
+
+    res = await mctpd.stop_mctpd()
+    assert res == 0