[multicast] Wire softnpu backend to multicast management protocol

## Changes

This connect dendrite's AsicMulticastOps implementation for the softnpu
backend to softnpu's multicast management messages. Previously, all
four operations (mc_group_create, mc_group_destroy, mc_port_add,
mc_port_remove) returned OperationUnsupported or were silent no-ops,
as softnpu wasn't hooked up as of yet.

We wire each method through mgmt::write using the corresponding
ManagementRequest variant (MulticastGroupCreate, MulticastGroupRemove,
MulticastPortAdd, MulticastPortRemove).

Query methods (mc_domains, mc_port_count, mc_groups_count) now issue
a MulticastGroupList round-trip to softnpu for accurate state rather
than returning placeholder port counts.

We also update mgmt::read to return a typed ManagementResponse instead
of a raw String, and fix the existing RadixRequest caller to match.

## Deps

This PR points the softnpu-lib dependency to the zl/multicast branch which
provides the multicast management message types.

Author: zeeshanlakhani

Cargo.lock

@@ -54,7 +54,7 @@ oximeter-instruments = { git = "https://github.com/oxidecomputer/omicron", branc
 oxnet = { version = "0.1.4", default-features = false, features = ["schemars", "serde"] }
 propolis = { git = "https://github.com/oxidecomputer/propolis" }
 smf = { git = "https://github.com/illumos/smf-rs" }
-softnpu-lib = { git = "https://github.com/oxidecomputer/softnpu" , package = "softnpu" , branch = "main"}
+softnpu-lib = { git = "https://github.com/oxidecomputer/softnpu" , package = "softnpu" , branch = "zl/multicast"}
 tofino = { git = "https://github.com/oxidecomputer/tofino", branch = "main" }
 transceiver-controller = { git = "https://github.com/oxidecomputer/transceiver-control", branch = "main" }
 

Cargo.toml

@@ -9,7 +9,7 @@ use std::io::Read;
 use std::io::Write;
 
 use propolis::hw::virtio::softnpu::{MANAGEMENT_MESSAGE_PREAMBLE, SOFTNPU_TTY};
-use softnpu_lib::ManagementRequest;
+use softnpu_lib::{ManagementRequest, ManagementResponse};
 use std::os::unix::net::UnixDatagram;
 
 type ParseError = &'static str;
@@ -56,12 +56,16 @@ pub fn write(msg: ManagementRequest, config: &ManagementConfig) {
     }
 }
 
-/// Read a management request response from a SoftNPU asic.
-pub fn read(msg: ManagementRequest, config: &ManagementConfig) -> String {
-    match config {
+/// Send a management request and deserialize the response.
+pub fn read(
+    msg: ManagementRequest,
+    config: &ManagementConfig,
+) -> serde_json::Result<ManagementResponse> {
+    let raw = match config {
         ManagementConfig::UART => read_uart(msg),
         ManagementConfig::UDS { socket_path } => read_uds(msg, socket_path),
-    }
+    };
+    serde_json::from_str(&raw)
 }
 
 fn write_uart(msg: ManagementRequest) {

asic/src/softnpu/mgmt.rs

@@ -25,8 +25,13 @@ use aal::{
 use common::ports::{
     PortFec, PortId, PortMedia, PortPrbsMode, PortSpeed, TxEq,
 };
+#[cfg(feature = "multicast")]
+use softnpu_lib::ManagementResponse;
 
-use softnpu_lib::ManagementRequest;
+use softnpu_lib::{
+    ManagementRequest, MulticastGroupCreate, MulticastGroupRemove,
+    MulticastPortAdd, MulticastPortRemove,
+};
 
 pub mod mgmt;
 pub mod table;
@@ -143,43 +148,80 @@ impl Handle {
     }
 
     pub fn fini(&self) {}
+
+    /// Query softnpu for the current multicast group membership table.
+    #[cfg(feature = "multicast")]
+    fn mc_group_list(&self) -> std::collections::BTreeMap<u16, Vec<u16>> {
+        match mgmt::read(
+            ManagementRequest::MulticastGroupList,
+            &self.mgmt_config,
+        ) {
+            Ok(ManagementResponse::MulticastGroupListResponse(groups)) => {
+                groups
+            }
+            _ => std::collections::BTreeMap::new(),
+        }
+    }
 }
 
 #[cfg(feature = "multicast")]
 impl AsicMulticastOps for Handle {
     fn mc_domains(&self) -> Vec<u16> {
-        let len = self.ports.lock().unwrap().len() as u16;
-        (0..len).collect()
+        let groups = self.mc_group_list();
+        groups.keys().copied().collect()
     }
 
-    fn mc_port_count(&self, _group_id: u16) -> AsicResult<usize> {
-        Ok(self.ports.lock().unwrap().len())
+    fn mc_port_count(&self, group_id: u16) -> AsicResult<usize> {
+        let groups = self.mc_group_list();
+        Ok(groups.get(&group_id).map_or(0, |ports| ports.len()))
     }
 
     fn mc_port_add(
         &self,
-        _group_id: u16,
-        _port: u16,
-        _rid: u16,
-        _level1_excl_id: u16,
+        group_id: u16,
+        port: u16,
+        rid: u16,
+        level1_excl_id: u16,
     ) -> AsicResult<()> {
-        Err(AsicError::OperationUnsupported)
+        let msg = ManagementRequest::MulticastPortAdd(MulticastPortAdd {
+            group_id,
+            port,
+            rid,
+            level1_excl_id,
+        });
+        mgmt::write(msg, &self.mgmt_config);
+        Ok(())
     }
 
-    fn mc_port_remove(&self, _group_id: u16, _port: u16) -> AsicResult<()> {
+    fn mc_port_remove(&self, group_id: u16, port: u16) -> AsicResult<()> {
+        let msg = ManagementRequest::MulticastPortRemove(MulticastPortRemove {
+            group_id,
+            port,
+        });
+        mgmt::write(msg, &self.mgmt_config);
         Ok(())
     }
 
-    fn mc_group_create(&self, _group_id: u16) -> AsicResult<()> {
-        Err(AsicError::OperationUnsupported)
+    fn mc_group_create(&self, group_id: u16) -> AsicResult<()> {
+        let msg =
+            ManagementRequest::MulticastGroupCreate(MulticastGroupCreate {
+                group_id,
+            });
+        mgmt::write(msg, &self.mgmt_config);
+        Ok(())
     }
 
-    fn mc_group_destroy(&self, _group_id: u16) -> AsicResult<()> {
+    fn mc_group_destroy(&self, group_id: u16) -> AsicResult<()> {
+        let msg =
+            ManagementRequest::MulticastGroupRemove(MulticastGroupRemove {
+                group_id,
+            });
+        mgmt::write(msg, &self.mgmt_config);
         Ok(())
     }
 
     fn mc_groups_count(&self) -> AsicResult<usize> {
-        Ok(self.ports.lock().unwrap().len())
+        Ok(self.mc_group_list().len())
     }
 
     fn mc_set_max_nodes(
@@ -354,11 +396,13 @@ impl AsicOps for Handle {
     fn get_connectors(&self) -> Vec<Connector> {
         let msg = ManagementRequest::RadixRequest;
         crate::softnpu::mgmt::write(msg, &self.mgmt_config);
-        let response = crate::softnpu::mgmt::read(
+        let radix: u16 = match crate::softnpu::mgmt::read(
             ManagementRequest::RadixRequest,
             &self.mgmt_config,
-        );
-        let radix: u16 = response.trim().parse().unwrap();
+        ) {
+            Ok(softnpu_lib::ManagementResponse::RadixResponse(r)) => r,
+            other => panic!("unexpected RadixRequest response: {other:?}"),
+        };
 
         let mut result = vec![Connector::CPU];
         for i in 1..radix + 1 {