feat(net): implement PACKET_ADD_MEMBERSHIP / PACKET_DROP_MEMBERSHIP (#2132)

sparkzky · fslongjin · web-flow · commit 37a5f06369d8 · 2026-07-18T01:32:14.000+08:00
* feat(net): implement PACKET_ADD_MEMBERSHIP / PACKET_DROP_MEMBERSHIP Implement multicast membership management for AF_PACKET sockets, supporting all four mr_type values: PACKET_MR_PROMISC, PACKET_MR_ALLMULTI, PACKET_MR_MULTICAST, PACKET_MR_UNICAST. Changes: - New module kernel/src/net/socket/packet/mreq.rs: per-socket membership list with add/drop/revert-on-close - IfaceCommon: promiscuity/allmulti AtomicI32 refcounts with atomic fetch_or/fetch_and flag transitions (IFF_PROMISC/IFF_ALLMULTI) - PacketSocket: mreq_list field - sockopt.rs: replace no-op stub with real handlers - close_binding: revert all memberships before unregistering socket - Tests: EINVAL for invalid mr_type, ENODEV for unknown ifindex Refs #2033 Signed-off-by: sparkzky <sparkhhhhhhhhhh@outlook.com> * fix(net): align packet memberships with Linux Signed-off-by: longjin <longjin@dragonos.org> --------- Signed-off-by: sparkzky <sparkhhhhhhhhhh@outlook.com> Signed-off-by: longjin <longjin@dragonos.org> Co-authored-by: longjin <longjin@dragonos.org>
diff --git a/kernel/src/driver/net/mod.rs b/kernel/src/driver/net/mod.rs
@@ -251,6 +251,20 @@ fn register_netdevice(dev: Arc<dyn Iface>) -> Result<(), SystemError> {
     return Ok(());
 }
 
+#[derive(Debug)]
+struct ReceiveModeState {
+    configured_flags: u32,
+    packet_promiscuity: u32,
+    packet_allmulti: u32,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct LinkFlagsSnapshot {
+    pub configured: InterfaceFlags,
+    pub promiscuity: u32,
+    pub allmulti: u32,
+}
+
 pub struct IfaceCommon {
     iface_id: usize,
     name: RwLock<String>,
@@ -279,6 +293,8 @@ pub struct IfaceCommon {
     /// TCP listener/backlog 语义辅助（Linux-like 丢 SYN 等）。
     tcp_listener_backlog: crate::net::tcp_listener_backlog::TcpListenerBacklog,
     ipv4_multicast_refcnt: Mutex<Vec<(smoltcp::wire::Ipv4Address, usize)>>,
+    /// Serializes configured receive-mode flags with AF_PACKET references.
+    receive_mode: Mutex<ReceiveModeState>,
 }
 
 impl fmt::Debug for IfaceCommon {
@@ -323,6 +339,11 @@ impl IfaceCommon {
             tcp_close_defer: crate::net::tcp_close_defer::TcpCloseDefer::new(),
             tcp_listener_backlog: crate::net::tcp_listener_backlog::TcpListenerBacklog::new(),
             ipv4_multicast_refcnt: Mutex::new(Vec::new()),
+            receive_mode: Mutex::new(ReceiveModeState {
+                configured_flags: flags.bits(),
+                packet_promiscuity: 0,
+                packet_allmulti: 0,
+            }),
         }
     }
 
@@ -668,11 +689,46 @@ impl IfaceCommon {
     }
 
     pub fn flags(&self) -> InterfaceFlags {
-        InterfaceFlags::from_bits_truncate(self.flags.load(Ordering::Relaxed))
+        InterfaceFlags::from_bits_truncate(self.flags.load(Ordering::Acquire))
     }
 
-    pub fn set_flags(&self, flags: InterfaceFlags) {
-        self.flags.store(flags.bits(), Ordering::Relaxed);
+    pub fn update_configured_flags(
+        &self,
+        requested: InterfaceFlags,
+        change_mask: InterfaceFlags,
+    ) -> Result<InterfaceFlags, SystemError> {
+        let mut state = self.receive_mode.lock();
+        let configured = (state.configured_flags & !change_mask.bits())
+            | (requested.bits() & change_mask.bits());
+
+        Self::total_receive_mode_count(
+            state.packet_promiscuity,
+            configured & InterfaceFlags::PROMISC.bits() != 0,
+        )?;
+        Self::total_receive_mode_count(
+            state.packet_allmulti,
+            configured & InterfaceFlags::ALLMULTI.bits() != 0,
+        )?;
+
+        state.configured_flags = configured;
+        self.publish_effective_flags(&state);
+        Ok(InterfaceFlags::from_bits_truncate(configured))
+    }
+
+    pub fn link_flags_snapshot(&self) -> Result<LinkFlagsSnapshot, SystemError> {
+        let state = self.receive_mode.lock();
+        let configured = InterfaceFlags::from_bits_truncate(state.configured_flags);
+        Ok(LinkFlagsSnapshot {
+            configured,
+            promiscuity: Self::total_receive_mode_count(
+                state.packet_promiscuity,
+                configured.contains(InterfaceFlags::PROMISC),
+            )?,
+            allmulti: Self::total_receive_mode_count(
+                state.packet_allmulti,
+                configured.contains(InterfaceFlags::ALLMULTI),
+            )?,
+        })
     }
 
     pub fn type_(&self) -> InterfaceType {
@@ -755,4 +811,55 @@ impl IfaceCommon {
         neighbors.retain(|existing| existing.ip_addr != ip_addr);
         neighbors.len() != before
     }
+
+    pub fn adjust_promiscuity(&self, inc: i32) -> Result<(), SystemError> {
+        self.adjust_receive_mode(InterfaceFlags::PROMISC, inc)
+    }
+
+    pub fn adjust_allmulti(&self, inc: i32) -> Result<(), SystemError> {
+        self.adjust_receive_mode(InterfaceFlags::ALLMULTI, inc)
+    }
+
+    fn adjust_receive_mode(&self, flag: InterfaceFlags, inc: i32) -> Result<(), SystemError> {
+        let mut state = self.receive_mode.lock();
+        let old = if flag == InterfaceFlags::PROMISC {
+            state.packet_promiscuity
+        } else if flag == InterfaceFlags::ALLMULTI {
+            state.packet_allmulti
+        } else {
+            return Err(SystemError::EINVAL);
+        };
+        let new = match inc {
+            1 => old.checked_add(1).ok_or(SystemError::EOVERFLOW)?,
+            -1 => old.checked_sub(1).ok_or(SystemError::EINVAL)?,
+            _ => return Err(SystemError::EINVAL),
+        };
+        let configured = state.configured_flags & flag.bits() != 0;
+        Self::total_receive_mode_count(new, configured)?;
+
+        if flag == InterfaceFlags::PROMISC {
+            state.packet_promiscuity = new;
+        } else {
+            state.packet_allmulti = new;
+        }
+        self.publish_effective_flags(&state);
+        Ok(())
+    }
+
+    fn total_receive_mode_count(packet: u32, configured: bool) -> Result<u32, SystemError> {
+        packet
+            .checked_add(u32::from(configured))
+            .ok_or(SystemError::EOVERFLOW)
+    }
+
+    fn publish_effective_flags(&self, state: &ReceiveModeState) {
+        let mut effective = state.configured_flags;
+        if state.packet_promiscuity != 0 {
+            effective |= InterfaceFlags::PROMISC.bits();
+        }
+        if state.packet_allmulti != 0 {
+            effective |= InterfaceFlags::ALLMULTI.bits();
+        }
+        self.flags.store(effective, Ordering::Release);
+    }
 }
diff --git a/kernel/src/net/socket/netlink/mod.rs b/kernel/src/net/socket/netlink/mod.rs
@@ -53,3 +53,7 @@ pub fn create_netlink_socket(
 
     Ok(inode)
 }
+
+pub(crate) fn notify_link_change(iface: &Arc<dyn crate::driver::net::Iface>) {
+    route::kern::notify_link_change(iface);
+}
diff --git a/kernel/src/net/socket/netlink/route/kern/link.rs b/kernel/src/net/socket/netlink/route/kern/link.rs
@@ -134,6 +134,7 @@ fn iface_to_link_message(
     msg_type: CSegmentType,
     iface: &Arc<dyn Iface>,
 ) -> Result<LinkSegment, SystemError> {
+    let flags = iface.common().link_flags_snapshot()?;
     let header = CMsgSegHdr {
         len: 0,
         type_: msg_type as _,
@@ -146,7 +147,7 @@ fn iface_to_link_message(
         family: AddressFamily::Unspecified,
         type_: iface.type_(),
         index: NonZero::new(iface.nic_id() as u32),
-        flags: iface.flags(),
+        flags: flags.configured,
         change: LinkMessageFlags::empty(),
         pad: None,
     };
@@ -155,11 +156,31 @@ fn iface_to_link_message(
         LinkAttr::Address(iface.mac().as_bytes().to_vec()),
         LinkAttr::Name(CString::new(iface.name()).map_err(|_| SystemError::EINVAL)?),
         LinkAttr::Mtu(iface.mtu() as u32),
+        LinkAttr::Promiscuity(flags.promiscuity),
+        LinkAttr::Allmulti(flags.allmulti),
     ];
 
     Ok(LinkSegment::new(header, link_message, attrs))
 }
 
+pub(crate) fn notify_link_change(iface: &Arc<dyn Iface>) {
+    let Some(netns) = iface.net_namespace() else {
+        return;
+    };
+    let segment = iface_to_link_message(
+        &kernel_notify_header(CSegmentType::NEWLINK),
+        CSegmentType::NEWLINK,
+        iface,
+    );
+    match segment {
+        Ok(segment) => multicast_notify(netns, RTMGRP_LINK, RouteNlSegment::NewLink(segment)),
+        Err(err) => log::warn!(
+            "netlink route: failed to build link notification: {:?}",
+            err
+        ),
+    }
+}
+
 pub(super) fn do_del_link(
     request_segment: &LinkSegment,
     netns: Arc<NetNamespace>,
@@ -188,15 +209,11 @@ pub(super) fn do_set_link(
         }
     }
 
-    let current_flags = iface.flags();
     let change_mask = InterfaceFlags::from_bits_truncate(request_segment.body().change.bits());
     let requested_flags = InterfaceFlags::from_bits_truncate(request_segment.body().flags.bits());
-    let new_flags = InterfaceFlags::from_bits_truncate(
-        (current_flags.bits() & !change_mask.bits())
-            | (requested_flags.bits() & change_mask.bits()),
-    );
-
-    iface.common().set_flags(new_flags);
+    let new_flags = iface
+        .common()
+        .update_configured_flags(requested_flags, change_mask)?;
 
     if change_mask.contains(InterfaceFlags::UP) {
         let operstate = if new_flags.contains(InterfaceFlags::UP) {
@@ -215,15 +232,7 @@ pub(super) fn do_set_link(
         iface.common().set_mtu(mtu as usize);
     }
 
-    multicast_notify(
-        netns,
-        RTMGRP_LINK,
-        RouteNlSegment::NewLink(iface_to_link_message(
-            &kernel_notify_header(CSegmentType::NEWLINK),
-            CSegmentType::NEWLINK,
-            &iface,
-        )?),
-    );
+    notify_link_change(&iface);
 
     Ok(Vec::new())
 }
@@ -298,7 +307,11 @@ fn validate_setlink_request(
                     updates.mtu = Some(*mtu);
                 }
             }
-            LinkAttr::TxqLen(_) | LinkAttr::LinkMode(_) | LinkAttr::ExtMask(_) => {}
+            LinkAttr::Allmulti(_) => return Err(SystemError::EINVAL),
+            LinkAttr::Promiscuity(_)
+            | LinkAttr::TxqLen(_)
+            | LinkAttr::LinkMode(_)
+            | LinkAttr::ExtMask(_) => {}
             _ => return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP),
         }
     }
diff --git a/kernel/src/net/socket/netlink/route/kern/mod.rs b/kernel/src/net/socket/netlink/route/kern/mod.rs
@@ -25,6 +25,8 @@ mod neigh;
 mod route;
 mod utils;
 
+pub(crate) use link::notify_link_change;
+
 /// 负责处理 Netlink 路由相关的内核模块
 /// 每个 net namespace 都有一个独立的 NetlinkRouteKernelSocket
 #[derive(Debug)]
diff --git a/kernel/src/net/socket/netlink/route/message/attr/link.rs b/kernel/src/net/socket/netlink/route/message/attr/link.rs
@@ -77,6 +77,11 @@ enum LinkAttrClass {
     PROTO_DOWN_REASON = 55,
     PARENT_DEV_NAME = 56,
     PARENT_DEV_BUS_NAME = 57,
+    GRO_MAX_SIZE = 58,
+    TSO_MAX_SIZE = 59,
+    TSO_MAX_SEGS = 60,
+    /// All-multicast count: > 0 means acts ALLMULTI.
+    ALLMULTI = 61,
 }
 
 impl TryFrom<u16> for LinkAttrClass {
@@ -92,6 +97,8 @@ pub enum LinkAttr {
     Address(Vec<u8>),
     Name(CString),
     Mtu(u32),
+    Promiscuity(u32),
+    Allmulti(u32),
     TxqLen(u32),
     LinkMode(u8),
     ExtMask(RtExtFilter),
@@ -103,6 +110,8 @@ impl LinkAttr {
             LinkAttr::Address(_) => LinkAttrClass::ADDRESS,
             LinkAttr::Name(_) => LinkAttrClass::IFNAME,
             LinkAttr::Mtu(_) => LinkAttrClass::MTU,
+            LinkAttr::Promiscuity(_) => LinkAttrClass::PROMISCUITY,
+            LinkAttr::Allmulti(_) => LinkAttrClass::ALLMULTI,
             LinkAttr::TxqLen(_) => LinkAttrClass::TXQLEN,
             LinkAttr::LinkMode(_) => LinkAttrClass::LINKMODE,
             LinkAttr::ExtMask(_) => LinkAttrClass::EXT_MASK,
@@ -134,6 +143,9 @@ impl Attribute for LinkAttr {
             LinkAttr::Mtu(mtu) => unsafe {
                 core::slice::from_raw_parts(mtu as *const u32 as *const u8, 4)
             },
+            LinkAttr::Promiscuity(count) | LinkAttr::Allmulti(count) => unsafe {
+                core::slice::from_raw_parts(count as *const u32 as *const u8, 4)
+            },
             LinkAttr::TxqLen(txq_len) => unsafe {
                 core::slice::from_raw_parts(txq_len as *const u32 as *const u8, 4)
             },
@@ -169,6 +181,14 @@ impl Attribute for LinkAttr {
                 let data = convert_one_from_raw_buf::<u32>(buf)?;
                 Self::Mtu(*data)
             }
+            (LinkAttrClass::PROMISCUITY, 4) => {
+                let data = convert_one_from_raw_buf::<u32>(buf)?;
+                Self::Promiscuity(*data)
+            }
+            (LinkAttrClass::ALLMULTI, 4) => {
+                let data = convert_one_from_raw_buf::<u32>(buf)?;
+                Self::Allmulti(*data)
+            }
             (LinkAttrClass::TXQLEN, 4) => {
                 let data = convert_one_from_raw_buf::<u32>(buf)?;
                 Self::TxqLen(*data)
@@ -185,6 +205,8 @@ impl Attribute for LinkAttr {
             (
                 LinkAttrClass::IFNAME
                 | LinkAttrClass::MTU
+                | LinkAttrClass::PROMISCUITY
+                | LinkAttrClass::ALLMULTI
                 | LinkAttrClass::TXQLEN
                 | LinkAttrClass::LINKMODE
                 | LinkAttrClass::EXT_MASK,
diff --git a/kernel/src/net/socket/packet/binding.rs b/kernel/src/net/socket/packet/binding.rs
@@ -78,6 +78,7 @@ impl PacketSocket {
 
     pub(super) fn close_binding(&self) -> Result<(), SystemError> {
         let _guard = self.bind_lock.lock();
+        self.revert_all_memberships();
         self.netns.unregister_packet_socket(&self.self_ref);
         *self.bound_iface.write() = None;
         self.binding.store(0, 0);
diff --git a/kernel/src/net/socket/packet/mod.rs b/kernel/src/net/socket/packet/mod.rs
@@ -1,6 +1,7 @@
 //! AF_PACKET sockets.
 
 mod binding;
+mod mreq;
 mod rx;
 mod sockopt;
 mod tx;
@@ -109,6 +110,7 @@ pub struct PacketSocket {
     pub(super) send_timeout_ticks: AtomicU64,
     pub(super) recv_timeout_ticks: AtomicU64,
     pub(super) wait_queue: WaitQueue,
+    memberships: Mutex<mreq::PacketMembershipState>,
     inode_id: InodeId,
     open_files: AtomicUsize,
     pub(super) self_ref: Weak<Self>,
@@ -151,6 +153,7 @@ impl PacketSocket {
             send_timeout_ticks: AtomicU64::new(crate::net::socket::common::INFINITE_TIMEOUT_TICKS),
             recv_timeout_ticks: AtomicU64::new(crate::net::socket::common::INFINITE_TIMEOUT_TICKS),
             wait_queue: WaitQueue::default(),
+            memberships: Mutex::new(mreq::PacketMembershipState::default()),
             inode_id: generate_inode_id(),
             open_files: AtomicUsize::new(0),
             self_ref: me.clone(),
diff --git a/kernel/src/net/socket/packet/mreq.rs b/kernel/src/net/socket/packet/mreq.rs
diff --git a/kernel/src/net/socket/packet/sockopt.rs b/kernel/src/net/socket/packet/sockopt.rs
diff --git a/user/apps/tests/dunitest/suites/normal/af_packet_mcast.cc b/user/apps/tests/dunitest/suites/normal/af_packet_mcast.cc

Original file line number	Diff line number	Diff line change
`@@ -53,3 +53,7 @@ pub fn create_netlink_socket(`
`53`	`53`
`54`	`54`	`Ok(inode)`
`55`	`55`	`}`
	`56`	`+`
	`57`	`+pub(crate) fn notify_link_change(iface: &Arc<dyn crate::driver::net::Iface>) {`
	`58`	`+ route::kern::notify_link_change(iface);`
	`59`	`+}`