mctpd: support discovery requests

This adds support for the Discovered flag and discovery requests,
as described in DSP0236
12.14 Prepare for Endpoint Discovery and
12.15 Endpoint Discovery.

Signed-off-by: Khang D Nguyen <khangng@os.amperecomputing.com>

Author: khangng-ampere

src/mctp-netlink.c

@@ -1075,6 +1075,16 @@ int mctp_nl_hwaddr_len_byindex(const mctp_nl *nl, int index,
 	return 0;
 }
 
+enum mctp_phys_binding mctp_nl_phys_binding_byindex(const mctp_nl *nl,
+						    int index)
+{
+	struct linkmap_entry *entry = entry_byindex(nl, index);
+	if (!entry) {
+		return MCTP_PHYS_BINDING_UNSPEC;
+	}
+	return entry->phys_binding;
+}
+
 mctp_eid_t *mctp_nl_addrs_byindex(const mctp_nl *nl, int index, size_t *ret_num)
 {
 	struct linkmap_entry *entry = entry_byindex(nl, index);

src/mctp-netlink.h

@@ -6,6 +6,7 @@
 #include <linux/if.h>
 #include <linux/rtnetlink.h>
 
+#include "mctp-control-spec.h"
 #include "mctp.h"
 
 struct mctp_nl;
@@ -83,6 +84,9 @@ uint32_t mctp_nl_max_mtu_byindex(const mctp_nl *nl, int index);
 /* Returns negative errno on failure */
 int mctp_nl_hwaddr_len_byindex(const mctp_nl *nl, int index,
 			       size_t *ret_hwaddr_len);
+/* Returns interface physical binding, or MCTP_PHYS_BINDING_UNSPEC if bad index */
+enum mctp_phys_binding mctp_nl_phys_binding_byindex(const mctp_nl *nl,
+						    int index);
 /* Caller to free */
 mctp_eid_t *mctp_nl_addrs_byindex(const mctp_nl *nl, int index,
 				  size_t *ret_num);

src/mctpd.c

@@ -117,7 +117,14 @@ static const struct role roles[] = {
 	},
 };
 
+enum discovery_state {
+	DISCOVERY_UNSUPPORTED,
+	DISCOVERY_DISCOVERED,
+	DISCOVERY_UNDISCOVERED,
+};
+
 struct link {
+	enum discovery_state discovered;
 	bool published;
 	int ifindex;
 	enum endpoint_role role;
@@ -777,6 +784,9 @@ static int handle_control_set_endpoint_id(struct ctx *ctx, int sd,
 			warnx("ERR: cannot add bus owner to object lists");
 		}
 
+		if (link_data->discovered != DISCOVERY_UNSUPPORTED) {
+			link_data->discovered = DISCOVERY_DISCOVERED;
+		}
 		resp->status =
 			SET_MCTP_EID_ASSIGNMENT_STATUS(MCTP_SET_EID_ACCEPTED) |
 			SET_MCTP_EID_ALLOCATION_STATUS(MCTP_SET_EID_POOL_NONE);
@@ -786,6 +796,20 @@ static int handle_control_set_endpoint_id(struct ctx *ctx, int sd,
 		return reply_message(ctx, sd, resp, resp_len, addr);
 
 	case MCTP_SET_EID_DISCOVERED:
+		if (link_data->discovered == DISCOVERY_UNSUPPORTED) {
+			resp->completion_code = MCTP_CTRL_CC_ERROR_INVALID_DATA;
+			resp_len = sizeof(struct mctp_ctrl_resp);
+			return reply_message(ctx, sd, resp, resp_len, addr);
+		}
+
+		link_data->discovered = DISCOVERY_DISCOVERED;
+		resp->status =
+			SET_MCTP_EID_ASSIGNMENT_STATUS(MCTP_SET_EID_REJECTED) |
+			SET_MCTP_EID_ALLOCATION_STATUS(MCTP_SET_EID_POOL_NONE);
+		resp->eid_set = req->eid;
+		resp->eid_pool_size = 0;
+		return reply_message(ctx, sd, resp, resp_len, addr);
+
 	case MCTP_SET_EID_RESET:
 		// unsupported
 		resp->completion_code = MCTP_CTRL_CC_ERROR_INVALID_DATA;
@@ -948,6 +972,97 @@ handle_control_resolve_endpoint_id(struct ctx *ctx, int sd,
 	return reply_message(ctx, sd, resp, resp_len, addr);
 }
 
+static int handle_control_prepare_endpoint_discovery(
+	struct ctx *ctx, int sd, const struct sockaddr_mctp_ext *addr,
+	const uint8_t *buf, const size_t buf_size)
+{
+	struct mctp_ctrl_msg_hdr *req = NULL;
+	struct mctp_ctrl_resp_prepare_discovery respi = { 0 }, *resp = &respi;
+	struct link *link_data;
+
+	if (buf_size < sizeof(*req)) {
+		warnx("short Prepare for Endpoint Discovery message");
+		return -ENOMSG;
+	}
+
+	link_data = mctp_nl_get_link_userdata(ctx->nl, addr->smctp_ifindex);
+	if (!link_data) {
+		bug_warn("unconfigured interface %d", addr->smctp_ifindex);
+		return -ENOENT;
+	}
+
+	if (link_data->role == ENDPOINT_ROLE_BUS_OWNER) {
+		// ignore message if we are bus owner
+		return 0;
+	}
+
+	req = (void *)buf;
+	resp = (void *)resp;
+	mctp_ctrl_msg_hdr_init_resp(&resp->ctrl_hdr, *req);
+
+	if (link_data->discovered == DISCOVERY_UNSUPPORTED) {
+		warnx("received prepare for discovery request to unsupported interface %d",
+		      addr->smctp_ifindex);
+		resp->completion_code = MCTP_CTRL_CC_ERROR_UNSUPPORTED_CMD;
+		return reply_message_phys(ctx, sd, resp,
+					  sizeof(struct mctp_ctrl_resp), addr);
+	}
+
+	if (link_data->discovered == DISCOVERY_DISCOVERED) {
+		link_data->discovered = DISCOVERY_UNDISCOVERED;
+		warnx("clear discovered flag of interface %d",
+		      addr->smctp_ifindex);
+	}
+
+	// we need to send using physical addressing, no entry in routing table yet
+	resp->completion_code = MCTP_CTRL_CC_SUCCESS;
+	return reply_message_phys(ctx, sd, resp, sizeof(*resp), addr);
+}
+
+static int
+handle_control_endpoint_discovery(struct ctx *ctx, int sd,
+				  const struct sockaddr_mctp_ext *addr,
+				  const uint8_t *buf, const size_t buf_size)
+{
+	struct mctp_ctrl_msg_hdr *req = NULL;
+	struct mctp_ctrl_resp_endpoint_discovery respi = { 0 }, *resp = &respi;
+	struct link *link_data;
+
+	if (buf_size < sizeof(*req)) {
+		warnx("short Endpoint Discovery message");
+		return -ENOMSG;
+	}
+
+	link_data = mctp_nl_get_link_userdata(ctx->nl, addr->smctp_ifindex);
+	if (!link_data) {
+		bug_warn("unconfigured interface %d", addr->smctp_ifindex);
+		return -ENOENT;
+	}
+
+	if (link_data->role == ENDPOINT_ROLE_BUS_OWNER) {
+		// ignore message if we are bus owner
+		return 0;
+	}
+
+	if (link_data->discovered == DISCOVERY_UNSUPPORTED) {
+		resp->completion_code = MCTP_CTRL_CC_ERROR_INVALID_DATA;
+		return reply_message(ctx, sd, resp,
+				     sizeof(struct mctp_ctrl_resp), addr);
+	}
+
+	if (link_data->discovered == DISCOVERY_DISCOVERED) {
+		// if we are already discovered (i.e, assigned an EID), then no reply
+		return 0;
+	}
+
+	req = (void *)buf;
+	resp = (void *)resp;
+	mctp_ctrl_msg_hdr_init_resp(&resp->ctrl_hdr, *req);
+
+	// we need to send using physical addressing, no entry in routing table yet
+	return reply_message_phys(ctx, sd, resp, sizeof(*resp), addr);
+}
+
 static int handle_control_unsupported(struct ctx *ctx, int sd,
 				      const struct sockaddr_mctp_ext *addr,
 				      const uint8_t *buf, const size_t buf_size)
@@ -1030,6 +1145,14 @@ static int cb_listen_control_msg(sd_event_source *s, int sd, uint32_t revents,
 		rc = handle_control_resolve_endpoint_id(ctx, sd, &addr, buf,
 							buf_size);
 		break;
+	case MCTP_CTRL_CMD_PREPARE_ENDPOINT_DISCOVERY:
+		rc = handle_control_prepare_endpoint_discovery(ctx, sd, &addr,
+							       buf, buf_size);
+		break;
+	case MCTP_CTRL_CMD_ENDPOINT_DISCOVERY:
+		rc = handle_control_endpoint_discovery(ctx, sd, &addr, buf,
+						       buf_size);
+		break;
 	default:
 		if (ctx->verbose) {
 			warnx("Ignoring unsupported command code 0x%02x",
@@ -3905,10 +4028,14 @@ static int add_interface(struct ctx *ctx, int ifindex)
 		return -ENOENT;
 	}
 
+	enum mctp_phys_binding phys_binding =
+		mctp_nl_phys_binding_byindex(ctx->nl, ifindex);
+
 	struct link *link = calloc(1, sizeof(*link));
 	if (!link)
 		return -ENOMEM;
 
+	link->discovered = DISCOVERY_UNSUPPORTED;
 	link->published = false;
 	link->ifindex = ifindex;
 	link->ctx = ctx;
@@ -3937,6 +4064,11 @@ static int add_interface(struct ctx *ctx, int ifindex)
 					 bus_link_owner_vtable, link);
 	}
 
+	if (phys_binding == MCTP_PHYS_BINDING_PCIE_VDM ||
+	    phys_binding == MCTP_PHYS_BINDING_I3C) {
+		link->discovered = DISCOVERY_UNDISCOVERED;
+	}
+
 	link->published = true;
 	rc = emit_interface_added(link);
 	if (rc < 0) {

tests/test_mctpd_endpoint.py

@@ -18,7 +18,7 @@ def config():
 @pytest.fixture
 async def sysnet():
     system = System()
-    iface = System.Interface("mctp0", 1, 1, bytes([0x1D]), 68, 254, True)
+    iface = System.Interface("mctp0", 1, 1, bytes([0x1D]), 68, 254, True, PhysicalBinding.PCIE_VDM)
     await system.add_interface(iface)
     network = Network()
     network.add_endpoint(Endpoint(iface, bytes([0x10]), eid=8))
@@ -101,3 +101,44 @@ async def test_accept_multiple_set_eids_for_single_interface(dbus, mctpd):
 
     # expect new EID on D-Bus
     assert await mctpd_mctp_endpoint_control_obj(dbus, f"/au/com/codeconstruct/mctp1/networks/1/endpoints/{second_eid}")
+
+
+""" Test simple Discovery sequence """
+async def test_simple_discovery_sequence(dbus, mctpd):
+    bo = mctpd.network.endpoints[0]
+
+    assert len(mctpd.system.addresses) == 0
+
+    # no EID yet
+    rsp = await bo.send_control(mctpd.network.mctp_socket, MCTPControlCommand(True, 0, 0x02))
+    assert rsp.hex(' ') == '00 02 00 00 02 00'
+
+    # BMC response to Prepare for Discovery
+    rsp = await bo.send_control(mctpd.network.mctp_socket, MCTPControlCommand(True, 0, 0x0B))
+    assert rsp.hex(' ') == '00 0b 00'
+
+    # BMC response to Endpoint Discovery
+    rsp = await bo.send_control(mctpd.network.mctp_socket, MCTPControlCommand(True, 0, 0x0C))
+    assert rsp.hex(' ') == '00 0c 00'
+
+    # set EID = 42
+    eid = 42
+    rsp = await bo.send_control(mctpd.network.mctp_socket, MCTPControlCommand(True, 0, 0x01, bytes([0x00, eid])))
+    assert rsp.hex(' ') == f'00 01 00 00 {eid:02x} 00'
+
+    # BMC should contains two object paths: bus owner and itself
+    assert await mctpd_mctp_endpoint_control_obj(dbus, f"/au/com/codeconstruct/mctp1/networks/1/endpoints/{bo.eid}")
+    assert await mctpd_mctp_endpoint_control_obj(dbus, f"/au/com/codeconstruct/mctp1/networks/1/endpoints/{eid}")
+
+
+""" Discovery command on unsupported interface """
+async def test_discovery_on_unsupported_interface(dbus, mctpd):
+    iface = System.Interface("mctp1", 2, 1, bytes([0x1D]), 68, 254, True, PhysicalBinding.SMBUS)
+    await mctpd.system.add_interface(iface)
+
+    bo = Endpoint(iface, bytes([0x10]), eid=10)
+    mctpd.network.add_endpoint(bo)
+
+    # BMC response ERROR_UNSUPPORTED_CMD to Prepare for Discovery
+    rsp = await bo.send_control(mctpd.network.mctp_socket, MCTPControlCommand(True, 0, 0x0B))
+    assert rsp.hex(' ') == '00 0b 05'