[review] Update based on review feedback + dump_m2p addition

This aligns us with the current updates on master, addresses
reviewer feedback, and adds dump_m2p ioctl (which is needed
in Omicron, as I've been working on that code).

Author: zeeshanlakhani

.cargo/config.toml

@@ -1,7 +1,6 @@
 [alias]
 xtask = "run --package xtask --"
 ubench = "bench --package opte-bench --bench userland --profile release-lto --"
-mbench = "bench --package opte-bench --bench multicast --profile release-lto --"
 kbench = "bench --package opte-bench --bench xde --"
 
 [env]

.github/buildomat/jobs/bench.sh

@@ -114,7 +114,6 @@ pfexec add_drv xde
 banner "bench"
 cargo kbench local
 cargo ubench
-cargo mbench
 
 cp -r target/criterion $OUT_DIR
 cp -r target/xde-bench $OUT_DIR

bench/Cargo.toml

@@ -42,6 +42,3 @@ harness = false
 name = "xde"
 harness = false
 
-[[bench]]
-name = "multicast"
-harness = false

bench/benches/multicast.rs

@@ -8,6 +8,7 @@
 
 use criterion::BenchmarkId;
 use criterion::Criterion;
+use criterion::Throughput;
 use criterion::criterion_group;
 use criterion::criterion_main;
 use opte::engine::packet::Packet;
@@ -24,6 +25,11 @@ use opte_bench::packet::TestCase;
 use opte_bench::packet::ULP_FAST_PATH;
 use opte_bench::packet::ULP_SLOW_PATH;
 use opte_test_utils::*;
+use oxide_vpc::api::IpAddr;
+use oxide_vpc::api::Ipv4Addr;
+use oxide_vpc::api::Ipv6Addr;
+use oxide_vpc::api::SourceFilter;
+use std::collections::BTreeSet;
 use std::hint::black_box;
 
 // Top level runner. Specifies packet classes.
@@ -218,7 +224,116 @@ pub fn test_handle<M: MeasurementInfo + 'static>(
     );
 }
 
-criterion_group!(wall, parse_and_process);
+/// Generate a source IP address for filter testing (10.0.0.x).
+fn make_src_v4(i: u32) -> IpAddr {
+    IpAddr::Ip4(Ipv4Addr::from(0x0a000000u32 + i))
+}
+
+/// Generate a source IP address for filter testing (fd00::x).
+fn make_src_v6(i: u32) -> IpAddr {
+    let mut bytes = [0u8; 16];
+    bytes[0..4].copy_from_slice(&[0xfd, 0x00, 0x00, 0x00]);
+    bytes[12..16].copy_from_slice(&i.to_be_bytes());
+    IpAddr::Ip6(Ipv6Addr::from(bytes))
+}
+
+/// Benchmark [`SourceFilter::allows`] for various filter configurations.
+fn source_filter_allows(c: &mut Criterion) {
+    let mut group = c.benchmark_group("source_filter/allows");
+    group.throughput(Throughput::Elements(1));
+
+    let src_v4 = make_src_v4(100); // Not in any source list
+    let src_v6 = make_src_v6(100);
+
+    // Fast path: EXCLUDE() with empty sources (*, G)
+    let filter_any = SourceFilter::default();
+    group.bench_function("exclude_empty_v4", |b| {
+        b.iter(|| black_box(filter_any.allows(black_box(src_v4))))
+    });
+    group.bench_function("exclude_empty_v6", |b| {
+        b.iter(|| black_box(filter_any.allows(black_box(src_v6))))
+    });
+
+    // EXCLUDE with sources: "Miss" case where source is not in exclusion list
+    for size in [1, 5, 10, 50, 100] {
+        let sources_v4: BTreeSet<_> = (0..size).map(make_src_v4).collect();
+        let filter_v4 =
+            SourceFilter::Exclude(sources_v4);
+        group.bench_with_input(
+            BenchmarkId::new("exclude_miss_v4", size),
+            &filter_v4,
+            |b, f| b.iter(|| black_box(f.allows(black_box(src_v4)))),
+        );
+        let src_in_list_v4 = make_src_v4(0);
+        group.bench_with_input(
+            BenchmarkId::new("exclude_hit_v4", size),
+            &filter_v4,
+            |b, f| b.iter(|| black_box(f.allows(black_box(src_in_list_v4)))),
+        );
+
+        let sources_v6: BTreeSet<_> = (0..size).map(make_src_v6).collect();
+        let filter_v6 =
+            SourceFilter::Exclude(sources_v6);
+        group.bench_with_input(
+            BenchmarkId::new("exclude_miss_v6", size),
+            &filter_v6,
+            |b, f| b.iter(|| black_box(f.allows(black_box(src_v6)))),
+        );
+        let src_in_list_v6 = make_src_v6(0);
+        group.bench_with_input(
+            BenchmarkId::new("exclude_hit_v6", size),
+            &filter_v6,
+            |b, f| b.iter(|| black_box(f.allows(black_box(src_in_list_v6)))),
+        );
+    }
+
+    // INCLUDE with sources: "Hit" case where source is in inclusion list
+    for size in [1, 5, 10, 50, 100] {
+        let sources_v4: BTreeSet<_> = (0..size).map(make_src_v4).collect();
+        let filter_v4 =
+            SourceFilter::Include(sources_v4);
+        let src_in_list_v4 = make_src_v4(0);
+        group.bench_with_input(
+            BenchmarkId::new("include_hit_v4", size),
+            &filter_v4,
+            |b, f| b.iter(|| black_box(f.allows(black_box(src_in_list_v4)))),
+        );
+        group.bench_with_input(
+            BenchmarkId::new("include_miss_v4", size),
+            &filter_v4,
+            |b, f| b.iter(|| black_box(f.allows(black_box(src_v4)))),
+        );
+
+        let sources_v6: BTreeSet<_> = (0..size).map(make_src_v6).collect();
+        let filter_v6 =
+            SourceFilter::Include(sources_v6);
+        let src_in_list_v6 = make_src_v6(0);
+        group.bench_with_input(
+            BenchmarkId::new("include_hit_v6", size),
+            &filter_v6,
+            |b, f| b.iter(|| black_box(f.allows(black_box(src_in_list_v6)))),
+        );
+        group.bench_with_input(
+            BenchmarkId::new("include_miss_v6", size),
+            &filter_v6,
+            |b, f| b.iter(|| black_box(f.allows(black_box(src_v6)))),
+        );
+    }
+
+    // INCLUDE() empty, rejecting all
+    let filter_none =
+        SourceFilter::Include(BTreeSet::new());
+    group.bench_function("include_empty_v4", |b| {
+        b.iter(|| black_box(filter_none.allows(black_box(src_v4))))
+    });
+    group.bench_function("include_empty_v6", |b| {
+        b.iter(|| black_box(filter_none.allows(black_box(src_v6))))
+    });
+
+    group.finish();
+}
+
+criterion_group!(wall, parse_and_process, source_filter_allows);
 criterion_group!(
     name = alloc;
     config = new_crit(Allocs);

bench/benches/userland.rs

@@ -68,6 +68,7 @@ use oxide_vpc::api::SetVirt2PhysReq;
 use oxide_vpc::api::SourceFilter;
 use oxide_vpc::api::TunnelEndpoint;
 use oxide_vpc::api::VpcCfg;
+use oxide_vpc::print::print_m2p;
 use oxide_vpc::print::print_mcast_fwd;
 use oxide_vpc::print::print_mcast_subs;
 use oxide_vpc::print::print_v2b;
@@ -310,6 +311,9 @@ enum Command {
     /// Dump multicast subscriptions (group -> ports on this sled)
     DumpMcastSubs,
 
+    /// Dump M2P (multicast group -> underlay multicast) mappings
+    DumpM2p,
+
     /// Subscribe a port to a multicast group
     ///
     /// Allows a port to receive multicast traffic for the specified group.
@@ -986,6 +990,10 @@ fn main() -> anyhow::Result<()> {
             print_mcast_subs(&hdl.dump_mcast_subs()?)?;
         }
 
+        Command::DumpM2p => {
+            print_m2p(&hdl.dump_m2p()?)?;
+        }
+
         Command::McastSubscribe { port, group } => {
             let req = McastSubscribeReq {
                 port_name: port,

bin/opteadm/src/bin/opteadm.rs

@@ -114,6 +114,8 @@ pub enum OpteCmd {
     DumpMcastSubscriptions = 107,
     /// Unsubscribe all ports from a multicast group.
     McastUnsubscribeAll = 108,
+    /// Read out all M2P (multicast group -> underlay multicast) mappings.
+    DumpMcast2Phys = 109,
 }
 
 impl TryFrom<c_int> for OpteCmd {
@@ -155,6 +157,7 @@ impl TryFrom<c_int> for OpteCmd {
             106 => Ok(Self::ClearMcast2Phys),
             107 => Ok(Self::DumpMcastSubscriptions),
             108 => Ok(Self::McastUnsubscribeAll),
+            109 => Ok(Self::DumpMcast2Phys),
             _ => Err(()),
         }
     }