net: remove spin::Once from LinkRegistry, simplify to Mutex

LinkRegistry was using spin::Once<spin::Mutex<Vec<...>>> but the
Once layer is unnecessary — the registry is initialized empty at
static construction and only modified during single-threaded init.
All access methods are simplified to direct self.devices.lock().

This also eliminates the batch-init pattern: devices are now pushed
one at a time via LINK_REGISTRY.push(), matching the per-device
registration pattern in iface_list::register().

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>

Author: xuchang-vivo

kernel/src/net/iface_list.rs

@@ -22,20 +22,28 @@
 use alloc::{sync::Arc, vec::Vec};
 use spin::RwLock;
 
-use crate::net::smoltcp::iface::NetIface;
+use crate::net::{
+    link::{LinkLayer, LINK_REGISTRY},
+    smoltcp::iface::NetIface,
+};
 
 /// Global list of network interfaces.
 static NET_IFACE_LIST: RwLock<Vec<Arc<NetIface>>> = RwLock::new(Vec::new());
 
 /// Default interface (the last registered non-loopback interface, or loopback).
 static DEFAULT_IFACE: RwLock<Option<Arc<NetIface>>> = RwLock::new(None);
 
-/// Register a NetIface into the global list.
+/// Register a NetIface and its corresponding LinkLayer into the global registries.
+///
+/// This is the **single entry point** for all interface+link registration.
+/// Both `NET_IFACE_LIST` and `LINK_REGISTRY` are updated atomically (per call).
+/// The caller *must* already have populated `LINK_REGISTRY` via `LINK_REGISTRY.init()`
+/// before calling this function for the first time.
 ///
 /// If `set_default` is true, this interface becomes the default.
-/// (The driver should call this once per interface during boot.)
-pub fn register(iface: Arc<NetIface>, set_default: bool) {
+pub fn register(iface: Arc<NetIface>, link: Arc<spin::RwLock<dyn LinkLayer>>, set_default: bool) {
     NET_IFACE_LIST.write().push(iface.clone());
+    LINK_REGISTRY.push(link);
     if set_default {
         DEFAULT_IFACE.write().replace(iface);
     }
@@ -69,4 +77,4 @@ pub fn len() -> usize {
 /// Check whether the list is empty.
 pub fn is_empty() -> bool {
     NET_IFACE_LIST.read().is_empty()
-}
+}

kernel/src/net/link/loopback.rs

@@ -25,8 +25,10 @@ use smoltcp::{
     wire::{HardwareAddress, IpAddress, IpCidr},
 };
 
-use crate::net::link::{HwAddr, LinkKind, LinkLayer, Medium};
-use crate::net::smoltcp::link::SmoltcpDevice;
+use crate::net::{
+    link::{HwAddr, LinkKind, LinkLayer, Medium},
+    smoltcp::link::SmoltcpDevice,
+};
 
 /// Loopback link-layer device.
 pub struct LoopbackLink {
@@ -126,4 +128,4 @@ impl SmoltcpDevice for LoopbackLink {
     fn poll_smoltcp(&mut self, timestamp: Instant, iface: &mut Interface, sockets: &mut SocketSet) {
         iface.poll(timestamp, &mut self.inner, sockets);
     }
-}
+}

kernel/src/net/link/mod.rs

@@ -48,8 +48,10 @@ use spin;
 
 pub(crate) use self::{link_kind::LinkKind, medium::Medium};
 
-use crate::net::iface::{InterfaceFlags, NetIfaceControl, NetIfaceError, NetIfaceResult};
-use crate::net::link::{ethernet_ops::EthernetOps, wifi_ops::WifiOps};
+use crate::net::{
+    iface::{InterfaceFlags, NetIfaceControl, NetIfaceError, NetIfaceResult},
+    link::{ethernet_ops::EthernetOps, wifi_ops::WifiOps},
+};
 
 /// A hardware address (MAC or similar).
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -133,44 +135,43 @@ impl dyn LinkLayer {
 
 /// Global registry of link-layer devices.
 ///
-/// # Safety
-///
-/// All devices must be registered during `net::init()`, before the network
-/// thread starts. After that, the registry is immutable — no further `register()`
-/// calls are allowed. This eliminates locking overhead for reads.
-///
-/// `init()` panics if called more than once.
+/// All devices are registered during `net::init()` (single-threaded, before the
+/// network thread starts). After that, the registry is logically immutable —
+/// no further `push()` calls are made, so `Mutex` contention is zero at runtime.
 pub(crate) struct LinkRegistry {
-    devices: spin::Once<Vec<Arc<spin::RwLock<dyn LinkLayer>>>>,
+    devices: spin::Mutex<Vec<Arc<spin::RwLock<dyn LinkLayer>>>>,
 }
 
 impl LinkRegistry {
     pub const fn new() -> Self {
         LinkRegistry {
-            devices: spin::Once::new(),
+            devices: spin::Mutex::new(Vec::new()),
         }
     }
 
-    /// Initialize the registry with all devices. Must be called exactly once
-    /// during `net::init()` before the network thread starts.
-    pub fn init(&self, devices: Vec<Arc<spin::RwLock<dyn LinkLayer>>>) {
-        self.devices.call_once(|| devices);
+    /// Push a single device into the registry during init.
+    pub fn push(&self, device: Arc<spin::RwLock<dyn LinkLayer>>) {
+        self.devices.lock().push(device);
     }
 
     pub fn get(&self, index: usize) -> Option<Arc<spin::RwLock<dyn LinkLayer>>> {
-        self.devices.get()?.get(index).cloned()
+        self.devices.lock().get(index).cloned()
     }
 
     pub fn iter(&self) -> Vec<Arc<spin::RwLock<dyn LinkLayer>>> {
-        self.devices.get().cloned().unwrap_or_default()
+        self.devices.lock().clone()
     }
 
     pub fn len(&self) -> usize {
-        self.devices.get().map_or(0, Vec::len)
+        self.devices.lock().len()
     }
 
     pub fn find_by_name(&self, name: &str) -> Option<Arc<spin::RwLock<dyn LinkLayer>>> {
-        self.devices.get()?.iter().find(|d| d.read().name() == name).cloned()
+        self.devices
+            .lock()
+            .iter()
+            .find(|dev| dev.read().name() == name)
+            .cloned()
     }
 }
 
@@ -205,4 +206,3 @@ pub(crate) fn handle_control(cmd: NetIfaceControl) -> Result<NetIfaceResult, Net
         _ => Err(NetIfaceError::NotSupported),
     }
 }
-

kernel/src/net/link/virtio.rs

@@ -27,8 +27,10 @@ use smoltcp::{
 
 use crate::{
     devices::net::virtio_net_device::{VirtIONetDevice, VirtIONetRxToken, VirtIONetTxToken},
-    net::link::{HwAddr, LinkKind, LinkLayer, Medium},
-    net::smoltcp::link::SmoltcpDevice,
+    net::{
+        link::{HwAddr, LinkKind, LinkLayer, Medium},
+        smoltcp::link::SmoltcpDevice,
+    },
 };
 
 /// VirtIO link-layer device.
@@ -142,4 +144,4 @@ impl SmoltcpDevice for VirtioLink {
     fn poll_smoltcp(&mut self, timestamp: Instant, iface: &mut Interface, sockets: &mut SocketSet) {
         iface.poll(timestamp, &mut self.inner, sockets);
     }
-}
+}

kernel/src/net/smoltcp/iface/mod.rs

@@ -28,7 +28,9 @@
 //! (which IS dyn-compatible) for both control operations and smoltcp
 //! poll dispatch.
 
-pub(crate) use crate::net::iface::control::{InterfaceFlags, NetIfaceControl, NetIfaceError, NetIfaceResult};
+pub(crate) use crate::net::iface::control::{
+    InterfaceFlags, NetIfaceControl, NetIfaceError, NetIfaceResult,
+};
 use alloc::{rc::Rc, string::String, sync::Arc, vec::Vec};
 use core::cell::RefCell;
 use smoltcp::{
@@ -38,9 +40,11 @@ use smoltcp::{
 };
 use spin::RwLock;
 
-use crate::net::link::{HwAddr, Medium};
-use crate::net::smoltcp::link::SmoltcpDevice;
-use crate::net::socket::socket_err::SocketError;
+use crate::net::{
+    link::{HwAddr, Medium},
+    smoltcp::link::SmoltcpDevice,
+    socket::socket_err::SocketError,
+};
 
 /// L3 network interface.
 ///
@@ -253,4 +257,4 @@ impl core::fmt::Display for NetIface {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "NetIface({})", self.name)
     }
-}
+}

kernel/src/net/smoltcp/link/mod.rs

@@ -30,7 +30,12 @@ use crate::net::link::LinkLayer;
 /// (GATs on `RxToken`/`TxToken`).
 pub trait SmoltcpDevice: LinkLayer + 'static {
     /// Create a smoltcp Interface and SocketSet for this device.
-    fn create_smoltcp_iface(&mut self) -> (smoltcp::iface::Interface, smoltcp::iface::SocketSet<'static>);
+    fn create_smoltcp_iface(
+        &mut self,
+    ) -> (
+        smoltcp::iface::Interface,
+        smoltcp::iface::SocketSet<'static>,
+    );
 
     /// Poll the smoltcp Interface using this device's concrete Device impl.
     fn poll_smoltcp(
@@ -46,4 +51,4 @@ impl dyn SmoltcpDevice {
     pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
         (self as &dyn Any).downcast_ref::<T>()
     }
-}
+}

kernel/src/net/smoltcp/mod.rs

@@ -25,21 +25,18 @@ pub(crate) mod iface;
 pub(crate) mod link;
 pub(crate) mod socket;
 
-use alloc::rc::Rc;
-use alloc::sync::Arc;
-use alloc::string::ToString;
-use alloc::vec::Vec;
+use alloc::{rc::Rc, string::ToString, sync::Arc, vec::Vec};
 use core::cell::RefCell;
 use smoltcp::wire::IpAddress;
 use spin;
 
-use crate::net::iface_list;
-use crate::net::link::LinkLayer;
-use crate::net::link::LINK_REGISTRY;
-use crate::net::smoltcp::iface::NetIface;
-use crate::net::socket::PosixSocket;
-use crate::net::SocketFd;
-use crate::net::smoltcp::link::SmoltcpDevice;
+use crate::net::{
+    iface_list,
+    link::LinkLayer,
+    smoltcp::{iface::NetIface, link::SmoltcpDevice},
+    socket::PosixSocket,
+    SocketFd,
+};
 
 /// Entry in the device registration list: (name, set_default, Arc<dyn SmoltcpDevice>).
 pub(crate) type DeviceEntry = (&'static str, bool, Arc<spin::RwLock<dyn SmoltcpDevice>>);
@@ -51,25 +48,18 @@ pub(crate) type DeviceEntry = (&'static str, bool, Arc<spin::RwLock<dyn SmoltcpD
 /// Each entry is `(device, name, set_default)`. Returns the created
 /// `NetIface` instances in registration order.
 pub(crate) fn init_devices(devices: &[DeviceEntry]) -> Vec<Arc<NetIface>> {
-    let link_devices: Vec<Arc<spin::RwLock<dyn LinkLayer>>> =
-        devices.iter().map(|(_, _, link)| link.clone() as Arc<spin::RwLock<dyn LinkLayer>>).collect();
-    LINK_REGISTRY.init(link_devices);
-
     let mut ifaces = Vec::new();
-    for (i, (name, set_default, _)) in devices.iter().enumerate() {
-        let link = devices[i].2.clone();
-        let iface = Arc::new(NetIface::new(name.to_string(), link, i));
-        iface_list::register(iface.clone(), *set_default);
+    for (i, (name, set_default, link)) in devices.iter().enumerate() {
+        let iface = Arc::new(NetIface::new(name.to_string(), link.clone(), i));
+        let link_layer: Arc<spin::RwLock<dyn LinkLayer>> = link.clone();
+        iface_list::register(iface.clone(), link_layer, *set_default);
         ifaces.push(iface);
     }
     ifaces
 }
 
 /// Bind a socket to the default NetIface.
-pub(crate) fn bind_default_interface(
-    socket_fd: SocketFd,
-    socket: Rc<RefCell<dyn PosixSocket>>,
-) {
+pub(crate) fn bind_default_interface(socket_fd: SocketFd, socket: Rc<RefCell<dyn PosixSocket>>) {
     if let Some(interface) = iface_list::default() {
         let mut socket = socket.borrow_mut();
         socket.bind_interface(interface.clone());
@@ -86,21 +76,20 @@ pub(crate) fn bind_interface_by_addr(
     socket: Rc<RefCell<dyn PosixSocket>>,
     binding_addr: IpAddress,
 ) {
-    iface_list::find(|iface| iface.contains_addr(binding_addr))
-        .map_or_else(
-            || {
-                if let Some(interface) = iface_list::default() {
-                    let mut socket = socket.borrow_mut();
-                    socket.bind_interface(interface.clone());
-                    log::debug!("Socket Fd={} binding to {}", socket_fd, interface);
-                } else {
-                    log::error!("Socket Fd={} binding fail, find no interface", socket_fd);
-                }
-            },
-            |iface| {
+    iface_list::find(|iface| iface.contains_addr(binding_addr)).map_or_else(
+        || {
+            if let Some(interface) = iface_list::default() {
                 let mut socket = socket.borrow_mut();
-                socket.bind_interface(iface.clone());
-                log::debug!("Socket Fd={} binding to {}", socket_fd, iface);
-            },
-        )
-}
+                socket.bind_interface(interface.clone());
+                log::debug!("Socket Fd={} binding to {}", socket_fd, interface);
+            } else {
+                log::error!("Socket Fd={} binding fail, find no interface", socket_fd);
+            }
+        },
+        |iface| {
+            let mut socket = socket.borrow_mut();
+            socket.bind_interface(iface.clone());
+            log::debug!("Socket Fd={} binding to {}", socket_fd, iface);
+        },
+    )
+}

kernel/src/net/smoltcp/socket/icmp.rs

@@ -366,4 +366,4 @@ impl PosixSocket for IcmpSocket {
     fn is_shutdown(&self) -> bool {
         self.is_shutdown.get()
     }
-}
+}

kernel/src/net/smoltcp/socket/mod.rs

@@ -17,4 +17,4 @@
 pub(crate) mod icmp;
 pub(crate) mod socket_err;
 pub(crate) mod tcp;
-pub(crate) mod udp;
+pub(crate) mod udp;

kernel/src/net/smoltcp/socket/socket_err.rs

@@ -74,4 +74,4 @@ impl From<smoltcp::socket::icmp::RecvError> for SocketError {
     fn from(err: smoltcp::socket::icmp::RecvError) -> Self {
         Self::SmoltcpIcmpRecvError(err)
     }
-}
+}