[softnpu, mcast] wire up the softnpu backend for multicast table ops

Cargo.toml

@@ -57,7 +57,7 @@ oxnet = { version = "0.1.6", default-features = false, features = ["schemars", "
 propolis = { git = "https://github.com/oxidecomputer/propolis" }
 smf = { git = "https://github.com/illumos/smf-rs" }
 slog-error-chain = { git = "https://github.com/oxidecomputer/slog-error-chain", branch = "main" }
-softnpu-lib = { git = "https://github.com/oxidecomputer/softnpu" , package = "softnpu" , branch = "main"}
+softnpu-lib = { git = "https://github.com/oxidecomputer/softnpu" , package = "softnpu" , branch = "zl/table-clear"}
 tofino = { git = "https://github.com/oxidecomputer/tofino", branch = "main" }
 transceiver-controller = { git = "https://github.com/oxidecomputer/transceiver-control", branch = "main" }
 

asic/src/chaos/fault.rs

@@ -46,31 +46,32 @@ pub(super) struct Fault {
     calls: u64,
     /// The call numbers that fail.
     range: CallRange,
+    /// The error returned by a failing execution.
+    err: fn(String) -> AsicError,
 }
 
 impl Fault {
     pub(super) fn new(range: CallRange) -> Self {
-        Self { calls: 0, range }
+        Self { calls: 0, range, err: AsicError::Synthetic }
     }
 }
 
 impl Handle {
     pub(super) fn check_mc_fault(&self, op: McOp) -> AsicResult<()> {
-        if self.config.mc_config.unsupported.contains(&op) {
-            return Err(AsicError::OperationUnsupported);
-        }
-
         let failed_call = {
             let mut faults = self.mc_faults.lock().unwrap();
             faults.get_mut(&op).and_then(|fault| {
                 fault.calls += 1;
-                fault.range.contains(fault.calls).then_some(fault.calls)
+                fault
+                    .range
+                    .contains(fault.calls)
+                    .then_some((fault.calls, fault.err))
             })
         };
 
-        if let Some(call) = failed_call {
-            slog::error!(self.log, "chaos error: {} (call {})", op, call);
-            return Err(AsicError::Synthetic(op.to_string()));
+        if let Some((call, err)) = failed_call {
+            slog::error!(self.log, "chaos error: {op} (call {call})");
+            return Err(err(op.to_string()));
         }
 
         self.config.mc_config.chaos(op).unfurled(&self.log, &op.to_string())
@@ -93,20 +94,20 @@ impl Handle {
             let mut faults = self.table_faults.lock().unwrap();
             faults.get_mut(&(table, op)).and_then(|fault| {
                 fault.calls += 1;
-                fault.range.contains(fault.calls).then_some(fault.calls)
+                fault
+                    .range
+                    .contains(fault.calls)
+                    .then_some((fault.calls, fault.err))
             })
         };
 
         match failed_call {
-            Some(call) => {
+            Some((call, err)) => {
                 slog::error!(
                     self.log,
-                    "chaos table error: {} on {} (call {})",
-                    op,
-                    table,
-                    call
+                    "chaos table error: {op} on {table} (call {call})"
                 );
-                Err(AsicError::Synthetic(op.to_string()))
+                Err(err(op.to_string()))
             }
             None => Ok(()),
         }
@@ -117,11 +118,10 @@ impl Handle {
         table: TableType,
         op: TableOp,
         range: CallRange,
+        error: fn(String) -> AsicError,
     ) {
-        self.table_faults
-            .lock()
-            .unwrap()
-            .insert((table, op), Fault::new(range));
+        let fault = Fault { err: error, ..Fault::new(range) };
+        self.table_faults.lock().unwrap().insert((table, op), fault);
     }
 
     pub fn clear_table_faults(&self, table: TableType, op: TableOp) {

asic/src/chaos/mod.rs

@@ -63,7 +63,7 @@ impl Chaos {
     /// Return a chaos error according to the underlying probability value.
     pub fn unfurled(&self, log: &Logger, message: &str) -> AsicResult<()> {
         if self.value > random() {
-            slog::error!(log, "chaos error: {}", message);
+            slog::error!(log, "chaos error: {message}");
             return Err(AsicError::Synthetic(message.into()));
         }
         Ok(())
@@ -150,7 +150,7 @@ impl TableChaos {
         if let Some(value) = self.values.get(&id)
             && *value > random()
         {
-            slog::error!(log, "chaos table error: {}", message);
+            slog::error!(log, "chaos table error: {message}");
             return Err(AsicError::Synthetic(message.into()));
         }
         Ok(())
@@ -201,6 +201,7 @@ pub enum TableOp {
     EntryAdd,
     EntryUpdate,
     EntryDel,
+    EntryList,
 }
 
 impl fmt::Display for TableOp {
@@ -209,6 +210,7 @@ impl fmt::Display for TableOp {
             Self::EntryAdd => "table_entry_add",
             Self::EntryUpdate => "table_entry_update",
             Self::EntryDel => "table_entry_del",
+            Self::EntryList => "table_entry_list",
         })
     }
 }
@@ -226,8 +228,6 @@ pub struct AsicMulticastConfig {
     pub mc_port_list: Chaos,
     #[serde(default)]
     pub faults: BTreeMap<McOp, CallRange>,
-    #[serde(default)]
-    pub unsupported: BTreeSet<McOp>,
 }
 
 impl AsicMulticastConfig {
@@ -316,7 +316,6 @@ impl AsicConfig {
                 mc_set_max_nodes: Chaos::new(v),
                 mc_port_list: Chaos::new(v),
                 faults: BTreeMap::new(),
-                unsupported: BTreeSet::new(),
             },
         }
     }

asic/src/chaos/table.rs

@@ -112,9 +112,10 @@ impl TableOps<Handle> for Table {
 
     fn get_entries<M: MatchParse, A: ActionParse>(
         &self,
-        _hdl: &Handle,
+        hdl: &Handle,
         _from_hardware: bool,
     ) -> AsicResult<Vec<(M, A)>> {
+        hdl.check_table_fault(self.type_, TableOp::EntryList)?;
         self.keys
             .lock()
             .unwrap()