refactor: 移除网络重构分支中,use xxx::*的内容 (#1117)

Signed-off-by: longjin <longjin@DragonOS.org>

kernel/src/filesystem/vfs/file.rs

@@ -21,7 +21,7 @@ use crate::{
     libs::{rwlock::RwLock, spinlock::SpinLock},
     net::{
         event_poll::{EPollItem, EPollPrivateData, EventPoll},
-        socket::Inode as SocketInode,
+        socket::SocketInode,
     },
     process::{cred::Cred, ProcessManager},
 };

kernel/src/net/posix.rs

@@ -38,16 +38,16 @@ impl PosixArgsSocketType {
 use alloc::string::String;
 use alloc::sync::Arc;
 use core::ffi::CStr;
-use unix::ns::abs::{alloc_abs_addr, look_up_abs_addr};
+use system_error::SystemError;
 
 use crate::{
     filesystem::vfs::{FileType, IndexNode, ROOT_INODE, VFS_MAX_FOLLOW_SYMLINK_TIMES},
     mm::{verify_area, VirtAddr},
-    net::socket::*,
+    net::socket::unix::ns::abs::{alloc_abs_addr, look_up_abs_addr},
     process::ProcessManager,
 };
-use smoltcp;
-use system_error::SystemError::{self};
+
+use super::socket::{endpoint::Endpoint, AddressFamily};
 
 // 参考资料： https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/netinet_in.h.html#tag_13_32
 #[repr(C)]

kernel/src/net/socket/base.rs

@@ -1,15 +1,20 @@
-#![allow(unused_variables)]
-
-use crate::net::posix::MsgHdr;
-use crate::net::socket::*;
+use crate::{libs::wait_queue::WaitQueue, net::posix::MsgHdr};
 use alloc::sync::Arc;
 use core::any::Any;
 use core::fmt::Debug;
-use system_error::SystemError::{self, *};
+use system_error::SystemError;
+
+use super::{
+    common::shutdown::ShutdownTemp,
+    endpoint::Endpoint,
+    posix::{PMSG, PSOL},
+    SocketInode,
+};
 
 /// # `Socket` methods
 /// ## Reference
 /// - [Posix standard](https://pubs.opengroup.org/onlinepubs/9699919799/)
+#[allow(unused_variables)]
 pub trait Socket: Sync + Send + Debug + Any {
     /// # `wait_queue`
     /// 获取socket的wait queue
@@ -24,13 +29,13 @@ pub trait Socket: Sync + Send + Debug + Any {
     /// 接受连接，仅用于listening stream socket
     /// ## Block
     /// 如果没有连接到来，会阻塞
-    fn accept(&self) -> Result<(Arc<Inode>, Endpoint), SystemError> {
-        Err(ENOSYS)
+    fn accept(&self) -> Result<(Arc<SocketInode>, Endpoint), SystemError> {
+        Err(SystemError::ENOSYS)
     }
     /// # `bind`
     /// 对应于POSIX的bind函数，用于绑定到本机指定的端点
     fn bind(&self, endpoint: Endpoint) -> Result<(), SystemError> {
-        Err(ENOSYS)
+        Err(SystemError::ENOSYS)
     }
     /// # `close`
     /// 关闭socket
@@ -40,7 +45,7 @@ pub trait Socket: Sync + Send + Debug + Any {
     /// # `connect`
     /// 对应于POSIX的connect函数，用于连接到指定的远程服务器端点
     fn connect(&self, endpoint: Endpoint) -> Result<(), SystemError> {
-        Err(ENOSYS)
+        Err(SystemError::ENOSYS)
     }
     // fnctl
     // freeaddrinfo
@@ -49,12 +54,12 @@ pub trait Socket: Sync + Send + Debug + Any {
     /// # `get_peer_name`
     /// 获取对端的地址
     fn get_peer_name(&self) -> Result<Endpoint, SystemError> {
-        Err(ENOSYS)
+        Err(SystemError::ENOSYS)
     }
     /// # `get_name`
     /// 获取socket的地址
     fn get_name(&self) -> Result<Endpoint, SystemError> {
-        Err(ENOSYS)
+        Err(SystemError::ENOSYS)
     }
     /// # `get_option`
     /// 对应于 Posix `getsockopt` ，获取socket选项
@@ -65,7 +70,7 @@ pub trait Socket: Sync + Send + Debug + Any {
     /// # `listen`
     /// 监听socket，仅用于stream socket
     fn listen(&self, backlog: usize) -> Result<(), SystemError> {
-        Err(ENOSYS)
+        Err(SystemError::ENOSYS)
     }
     // poll
     // pselect
@@ -76,7 +81,7 @@ pub trait Socket: Sync + Send + Debug + Any {
     /// # `recv`
     /// 接收数据，`read` = `recv` with flags = 0
     fn recv(&self, buffer: &mut [u8], flags: PMSG) -> Result<usize, SystemError> {
-        Err(ENOSYS)
+        Err(SystemError::ENOSYS)
     }
     /// # `recv_from`
     fn recv_from(
@@ -85,24 +90,24 @@ pub trait Socket: Sync + Send + Debug + Any {
         flags: PMSG,
         address: Option<Endpoint>,
     ) -> Result<(usize, Endpoint), SystemError> {
-        Err(ENOSYS)
+        Err(SystemError::ENOSYS)
     }
     /// # `recv_msg`
     fn recv_msg(&self, msg: &mut MsgHdr, flags: PMSG) -> Result<usize, SystemError> {
-        Err(ENOSYS)
+        Err(SystemError::ENOSYS)
     }
     // select
     /// # `send`
     fn send(&self, buffer: &[u8], flags: PMSG) -> Result<usize, SystemError> {
-        Err(ENOSYS)
+        Err(SystemError::ENOSYS)
     }
     /// # `send_msg`
     fn send_msg(&self, msg: &MsgHdr, flags: PMSG) -> Result<usize, SystemError> {
-        Err(ENOSYS)
+        Err(SystemError::ENOSYS)
     }
     /// # `send_to`
     fn send_to(&self, buffer: &[u8], flags: PMSG, address: Endpoint) -> Result<usize, SystemError> {
-        Err(ENOSYS)
+        Err(SystemError::ENOSYS)
     }
     /// # `set_option`
     /// Posix `setsockopt` ，设置socket选项
@@ -120,7 +125,7 @@ pub trait Socket: Sync + Send + Debug + Any {
     fn shutdown(&self, how: ShutdownTemp) -> Result<(), SystemError> {
         // TODO 构建shutdown系统调用
         // set shutdown bit
-        Err(ENOSYS)
+        Err(SystemError::ENOSYS)
     }
     // sockatmark
     // socket

kernel/src/net/socket/endpoint.rs

@@ -12,7 +12,7 @@ pub enum Endpoint {
     /// 网络层端点
     Ip(IpEndpoint),
     /// inode端点,Unix实际保存的端点
-    Inode((Arc<socket::Inode>, String)),
+    Inode((Arc<socket::SocketInode>, String)),
     /// Unix传递id索引和path所用的端点
     Unixpath((InodeId, String)),
     /// Unix抽象端点

kernel/src/net/socket/family.rs

@@ -114,9 +114,11 @@ impl core::convert::TryFrom<u16> for AddressFamily {
 use crate::net::socket;
 use alloc::sync::Arc;
 
+use super::PSOCK;
+
 pub trait Family {
     fn socket(
-        stype: socket::PSOCK,
+        stype: PSOCK,
         protocol: u32,
-    ) -> Result<Arc<socket::Inode>, system_error::SystemError>;
+    ) -> Result<Arc<socket::SocketInode>, system_error::SystemError>;
 }

kernel/src/net/socket/inet/common/mod.rs

@@ -1,9 +1,9 @@
 use crate::net::{Iface, NET_DEVICES};
 use alloc::sync::Arc;
-use system_error::SystemError::{self, *};
 
 pub mod port;
 pub use port::PortManager;
+use system_error::SystemError;
 
 #[allow(dead_code)]
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -56,7 +56,7 @@ impl BoundInner {
             let handle = iface.sockets().lock_irqsave().add(socket);
             return Ok(Self { handle, iface });
         } else {
-            let iface = get_iface_to_bind(address).ok_or(ENODEV)?;
+            let iface = get_iface_to_bind(address).ok_or(SystemError::ENODEV)?;
             let handle = iface.sockets().lock_irqsave().add(socket);
             return Ok(Self { handle, iface });
         }

kernel/src/net/socket/inet/datagram/inner.rs

@@ -1,5 +1,5 @@
 use smoltcp;
-use system_error::SystemError::{self, *};
+use system_error::SystemError;
 
 use crate::{
     libs::spinlock::SpinLock,
@@ -118,7 +118,7 @@ impl BoundUdp {
                     return Ok((size, metadata.endpoint));
                 }
             }
-            return Err(EAGAIN_OR_EWOULDBLOCK);
+            return Err(SystemError::EAGAIN_OR_EWOULDBLOCK);
         })
     }
 
@@ -127,13 +127,13 @@ impl BoundUdp {
         buf: &[u8],
         to: Option<smoltcp::wire::IpEndpoint>,
     ) -> Result<usize, SystemError> {
-        let remote = to.or(*self.remote.lock()).ok_or(ENOTCONN)?;
+        let remote = to.or(*self.remote.lock()).ok_or(SystemError::ENOTCONN)?;
         let result = self.with_mut_socket(|socket| {
             if socket.can_send() && socket.send_slice(buf, remote).is_ok() {
                 log::debug!("send {} bytes", buf.len());
                 return Ok(buf.len());
             }
-            return Err(ENOBUFS);
+            return Err(SystemError::ENOBUFS);
         });
         return result;
     }

kernel/src/net/socket/inet/datagram/mod.rs

@@ -1,17 +1,18 @@
-use inet::InetSocket;
+use inner::{UdpInner, UnboundUdp};
 use smoltcp;
-use system_error::SystemError::{self, *};
+use system_error::SystemError;
 
-use crate::libs::rwlock::RwLock;
+use crate::libs::wait_queue::WaitQueue;
 use crate::net::event_poll::EPollEventType;
 use crate::net::net_core::poll_ifaces;
-use crate::net::socket::*;
+use crate::net::socket::{Socket, PMSG};
+use crate::{libs::rwlock::RwLock, net::socket::endpoint::Endpoint};
 use alloc::sync::{Arc, Weak};
 use core::sync::atomic::AtomicBool;
 
-pub mod inner;
+use super::InetSocket;
 
-use inner::*;
+pub mod inner;
 
 type EP = EPollEventType;
 
@@ -51,7 +52,7 @@ impl UdpSocket {
             *inner = Some(UdpInner::Bound(bound));
             return Ok(());
         }
-        return Err(EINVAL);
+        return Err(SystemError::EINVAL);
     }
 
     pub fn bind_emphemeral(&self, remote: smoltcp::wire::IpAddress) -> Result<(), SystemError> {
@@ -91,7 +92,7 @@ impl UdpSocket {
                 poll_ifaces();
                 ret
             }
-            _ => Err(ENOTCONN),
+            _ => Err(SystemError::ENOTCONN),
         }
     }
 
@@ -116,7 +117,7 @@ impl UdpSocket {
             let inner = match inner_guard.take().expect("Udp Inner is None") {
                 UdpInner::Bound(bound) => bound,
                 UdpInner::Unbound(unbound) => {
-                    unbound.bind_ephemeral(to.ok_or(EADDRNOTAVAIL)?.addr)?
+                    unbound.bind_ephemeral(to.ok_or(SystemError::EADDRNOTAVAIL)?.addr)?
                 }
             };
             // size = inner.try_send(buf, to)?;
@@ -125,7 +126,7 @@ impl UdpSocket {
         // Optimize: 拿两次锁的平均效率是否比一次长时间的读锁效率要高？
         let result = match self.inner.read().as_ref().expect("Udp Inner is None") {
             UdpInner::Bound(bound) => bound.try_send(buf, to),
-            _ => Err(ENOTCONN),
+            _ => Err(SystemError::ENOTCONN),
         };
         poll_ifaces();
         return result;
@@ -167,7 +168,7 @@ impl Socket for UdpSocket {
         if let Endpoint::Ip(local_endpoint) = local_endpoint {
             return self.do_bind(local_endpoint);
         }
-        Err(EAFNOSUPPORT)
+        Err(SystemError::EAFNOSUPPORT)
     }
 
     fn send_buffer_size(&self) -> usize {
@@ -197,7 +198,7 @@ impl Socket for UdpSocket {
                 panic!("");
             }
         }
-        return Err(EAFNOSUPPORT);
+        return Err(SystemError::EAFNOSUPPORT);
     }
 
     fn send(&self, buffer: &[u8], flags: PMSG) -> Result<usize, SystemError> {
@@ -217,7 +218,7 @@ impl Socket for UdpSocket {
             return self.try_send(buffer, Some(remote));
         }
 
-        return Err(EINVAL);
+        return Err(SystemError::EINVAL);
     }
 
     fn recv(&self, buffer: &mut [u8], flags: PMSG) -> Result<usize, SystemError> {
@@ -228,7 +229,7 @@ impl Socket for UdpSocket {
         } else {
             loop {
                 match self.try_recv(buffer) {
-                    Err(EAGAIN_OR_EWOULDBLOCK) => {
+                    Err(SystemError::EAGAIN_OR_EWOULDBLOCK) => {
                         wq_wait_event_interruptible!(self.wait_queue, self.can_recv(), {})?;
                     }
                     result => break result,
@@ -255,7 +256,7 @@ impl Socket for UdpSocket {
         } else {
             loop {
                 match self.try_recv(buffer) {
-                    Err(EAGAIN_OR_EWOULDBLOCK) => {
+                    Err(SystemError::EAGAIN_OR_EWOULDBLOCK) => {
                         wq_wait_event_interruptible!(self.wait_queue, self.can_recv(), {})?;
                         log::debug!("UdpSocket::recv_from: wake up");
                     }

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

@@ -11,12 +11,17 @@ pub use common::BoundInner;
 pub use common::Types;
 // pub use raw::RawSocket;
 pub use datagram::UdpSocket;
+
+use smoltcp::wire::IpAddress;
+use smoltcp::wire::IpEndpoint;
+use smoltcp::wire::Ipv4Address;
+use smoltcp::wire::Ipv6Address;
+
 pub use stream::TcpSocket;
 pub use syscall::Inet;
 
 use super::Socket;
 
-use smoltcp::wire::*;
 /// A local endpoint, which indicates that the local endpoint is unspecified.
 ///
 /// According to the Linux man pages and the Linux implementation, `getsockname()` will _not_ fail

kernel/src/net/socket/inet/stream/inner.rs

@@ -6,7 +6,8 @@ use crate::net::socket::{self, inet::Types};
 use alloc::boxed::Box;
 use alloc::vec::Vec;
 use smoltcp;
-use system_error::SystemError::{self, *};
+use smoltcp::socket::tcp;
+use system_error::SystemError;
 
 // pub const DEFAULT_METADATA_BUF_SIZE: usize = 1024;
 pub const DEFAULT_RX_BUF_SIZE: usize = 512 * 1024;
@@ -68,7 +69,7 @@ impl Init {
             }
             Init::Bound(_) => {
                 log::debug!("Already Bound");
-                Err(EINVAL)
+                Err(SystemError::EINVAL)
             }
         }
     }
@@ -89,7 +90,7 @@ impl Init {
                 let endpoint = smoltcp::wire::IpEndpoint::new(address, bound_port);
                 Ok((bound, endpoint))
             }
-            Init::Bound(_) => Err((self, EINVAL)),
+            Init::Bound(_) => Err((self, SystemError::EINVAL)),
         }
     }
 
@@ -102,7 +103,7 @@ impl Init {
             Init::Bound(inner) => inner,
         };
         if local.addr.is_unspecified() {
-            return Err((Init::Bound((inner, local)), EINVAL));
+            return Err((Init::Bound((inner, local)), SystemError::EINVAL));
         }
         let result = inner.with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
             socket
@@ -111,7 +112,7 @@ impl Init {
                     remote_endpoint,
                     local,
                 )
-                .map_err(|_| ECONNREFUSED)
+                .map_err(|_| SystemError::ECONNREFUSED)
         });
         match result {
             Ok(_) => Ok(Connecting::new(inner)),
@@ -123,7 +124,7 @@ impl Init {
     pub(super) fn listen(self, backlog: usize) -> Result<Listening, (Self, SystemError)> {
         let (inner, local) = match self {
             Init::Unbound(_) => {
-                return Err((self, EINVAL));
+                return Err((self, SystemError::EINVAL));
             }
             Init::Bound(inner) => inner,
         };
@@ -154,7 +155,9 @@ impl Init {
         }
 
         if let Err(err) = inner.with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
-            socket.listen(listen_addr).map_err(|_| ECONNREFUSED)
+            socket
+                .listen(listen_addr)
+                .map_err(|_| SystemError::ECONNREFUSED)
         }) {
             return Err((Init::Bound((inner, local)), err));
         }
@@ -208,15 +211,20 @@ impl Connecting {
     }
 
     pub fn into_result(self) -> (Inner, Result<(), SystemError>) {
-        use ConnectResult::*;
         let result = *self.result.read_irqsave();
         match result {
-            Connecting => (Inner::Connecting(self), Err(EAGAIN_OR_EWOULDBLOCK)),
-            Connected => (
+            ConnectResult::Connecting => (
+                Inner::Connecting(self),
+                Err(SystemError::EAGAIN_OR_EWOULDBLOCK),
+            ),
+            ConnectResult::Connected => (
                 Inner::Established(Established { inner: self.inner }),
                 Ok(()),
             ),
-            Refused => (Inner::Init(Init::new_bound(self.inner)), Err(ECONNREFUSED)),
+            ConnectResult::Refused => (
+                Inner::Init(Init::new_bound(self.inner)),
+                Err(SystemError::ECONNREFUSED),
+            ),
         }
     }
 
@@ -294,7 +302,7 @@ impl Listening {
             .unwrap();
 
         if connected.with::<smoltcp::socket::tcp::Socket, _, _>(|socket| !socket.is_active()) {
-            return Err(EAGAIN_OR_EWOULDBLOCK);
+            return Err(SystemError::EAGAIN_OR_EWOULDBLOCK);
         }
 
         let remote_endpoint = connected.with::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
@@ -354,7 +362,7 @@ impl Listening {
     }
 
     pub fn close(&self) {
-        log::debug!("Close Listening Socket");
+        // log::debug!("Close Listening Socket");
         let port = self.get_name().port;
         for inner in self.inners.iter() {
             inner.with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| socket.close());
@@ -410,18 +418,17 @@ impl Established {
     pub fn recv_slice(&self, buf: &mut [u8]) -> Result<usize, SystemError> {
         self.inner
             .with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
-                use smoltcp::socket::tcp::RecvError::*;
                 if socket.can_send() {
                     match socket.recv_slice(buf) {
                         Ok(size) => Ok(size),
-                        Err(InvalidState) => {
+                        Err(tcp::RecvError::InvalidState) => {
                             log::error!("TcpSocket::try_recv: InvalidState");
-                            Err(ENOTCONN)
+                            Err(SystemError::ENOTCONN)
                         }
-                        Err(Finished) => Ok(0),
+                        Err(tcp::RecvError::Finished) => Ok(0),
                     }
                 } else {
-                    Err(ENOBUFS)
+                    Err(SystemError::ENOBUFS)
                 }
             })
     }
@@ -430,9 +437,11 @@ impl Established {
         self.inner
             .with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
                 if socket.can_send() {
-                    socket.send_slice(buf).map_err(|_| ECONNABORTED)
+                    socket
+                        .send_slice(buf)
+                        .map_err(|_| SystemError::ECONNABORTED)
                 } else {
-                    Err(ENOBUFS)
+                    Err(SystemError::ENOBUFS)
                 }
             })
     }

kernel/src/net/socket/inet/stream/mod.rs

@@ -1,24 +1,27 @@
 use alloc::sync::{Arc, Weak};
 use core::sync::atomic::{AtomicBool, AtomicUsize};
-use system_error::SystemError::{self, *};
+use system_error::SystemError;
 
-use crate::libs::rwlock::RwLock;
+use crate::libs::wait_queue::WaitQueue;
 use crate::net::event_poll::EPollEventType;
-use crate::net::socket::*;
+use crate::net::socket::common::shutdown::{ShutdownBit, ShutdownTemp};
+use crate::net::socket::endpoint::Endpoint;
+use crate::net::socket::{Socket, SocketInode, PMSG, PSOL};
 use crate::sched::SchedMode;
-use inet::{InetSocket, UNSPECIFIED_LOCAL_ENDPOINT_V4, UNSPECIFIED_LOCAL_ENDPOINT_V6};
+use crate::{libs::rwlock::RwLock, net::socket::common::shutdown::Shutdown};
 use smoltcp;
 
 mod inner;
-use inner::*;
 
 mod option;
 pub use option::Options as TcpOption;
 
+use super::{InetSocket, UNSPECIFIED_LOCAL_ENDPOINT_V4, UNSPECIFIED_LOCAL_ENDPOINT_V6};
+
 type EP = EPollEventType;
 #[derive(Debug)]
 pub struct TcpSocket {
-    inner: RwLock<Option<Inner>>,
+    inner: RwLock<Option<inner::Inner>>,
     #[allow(dead_code)]
     shutdown: Shutdown, // TODO set shutdown status
     nonblock: AtomicBool,
@@ -30,7 +33,7 @@ pub struct TcpSocket {
 impl TcpSocket {
     pub fn new(_nonblock: bool, ver: smoltcp::wire::IpVersion) -> Arc<Self> {
         Arc::new_cyclic(|me| Self {
-            inner: RwLock::new(Some(Inner::Init(Init::new(ver)))),
+            inner: RwLock::new(Some(inner::Inner::Init(inner::Init::new(ver)))),
             shutdown: Shutdown::new(),
             nonblock: AtomicBool::new(false),
             wait_queue: WaitQueue::default(),
@@ -39,9 +42,9 @@ impl TcpSocket {
         })
     }
 
-    pub fn new_established(inner: Established, nonblock: bool) -> Arc<Self> {
+    pub fn new_established(inner: inner::Established, nonblock: bool) -> Arc<Self> {
         Arc::new_cyclic(|me| Self {
-            inner: RwLock::new(Some(Inner::Established(inner))),
+            inner: RwLock::new(Some(inner::Inner::Established(inner))),
             shutdown: Shutdown::new(),
             nonblock: AtomicBool::new(nonblock),
             wait_queue: WaitQueue::default(),
@@ -56,38 +59,38 @@ impl TcpSocket {
 
     pub fn do_bind(&self, local_endpoint: smoltcp::wire::IpEndpoint) -> Result<(), SystemError> {
         let mut writer = self.inner.write();
-        match writer.take().expect("Tcp Inner is None") {
-            Inner::Init(inner) => {
+        match writer.take().expect("Tcp inner::Inner is None") {
+            inner::Inner::Init(inner) => {
                 let bound = inner.bind(local_endpoint)?;
-                if let Init::Bound((ref bound, _)) = bound {
+                if let inner::Init::Bound((ref bound, _)) = bound {
                     bound
                         .iface()
                         .common()
                         .bind_socket(self.self_ref.upgrade().unwrap());
                 }
-                writer.replace(Inner::Init(bound));
+                writer.replace(inner::Inner::Init(bound));
                 Ok(())
             }
             any => {
                 writer.replace(any);
                 log::error!("TcpSocket::do_bind: not Init");
-                Err(EINVAL)
+                Err(SystemError::EINVAL)
             }
         }
     }
 
     pub fn do_listen(&self, backlog: usize) -> Result<(), SystemError> {
         let mut writer = self.inner.write();
-        let inner = writer.take().expect("Tcp Inner is None");
+        let inner = writer.take().expect("Tcp inner::Inner is None");
         let (listening, err) = match inner {
-            Inner::Init(init) => {
+            inner::Inner::Init(init) => {
                 let listen_result = init.listen(backlog);
                 match listen_result {
-                    Ok(listening) => (Inner::Listening(listening), None),
-                    Err((init, err)) => (Inner::Init(init), Some(err)),
+                    Ok(listening) => (inner::Inner::Listening(listening), None),
+                    Err((init, err)) => (inner::Inner::Init(init), Some(err)),
                 }
             }
-            _ => (inner, Some(EINVAL)),
+            _ => (inner, Some(SystemError::EINVAL)),
         };
         writer.replace(listening);
         drop(writer);
@@ -99,14 +102,19 @@ impl TcpSocket {
     }
 
     pub fn try_accept(&self) -> Result<(Arc<TcpSocket>, smoltcp::wire::IpEndpoint), SystemError> {
-        match self.inner.write().as_mut().expect("Tcp Inner is None") {
-            Inner::Listening(listening) => listening.accept().map(|(stream, remote)| {
+        match self
+            .inner
+            .write()
+            .as_mut()
+            .expect("Tcp inner::Inner is None")
+        {
+            inner::Inner::Listening(listening) => listening.accept().map(|(stream, remote)| {
                 (
                     TcpSocket::new_established(stream, self.is_nonblock()),
                     remote,
                 )
             }),
-            _ => Err(EINVAL),
+            _ => Err(SystemError::EINVAL),
         }
     }
 
@@ -116,32 +124,37 @@ impl TcpSocket {
         remote_endpoint: smoltcp::wire::IpEndpoint,
     ) -> Result<(), SystemError> {
         let mut writer = self.inner.write();
-        let inner = writer.take().expect("Tcp Inner is None");
+        let inner = writer.take().expect("Tcp inner::Inner is None");
         let (init, result) = match inner {
-            Inner::Init(init) => {
+            inner::Inner::Init(init) => {
                 let conn_result = init.connect(remote_endpoint);
                 match conn_result {
                     Ok(connecting) => (
-                        Inner::Connecting(connecting),
+                        inner::Inner::Connecting(connecting),
                         if !self.is_nonblock() {
                             Ok(())
                         } else {
-                            Err(EINPROGRESS)
+                            Err(SystemError::EINPROGRESS)
                         },
                     ),
-                    Err((init, err)) => (Inner::Init(init), Err(err)),
+                    Err((init, err)) => (inner::Inner::Init(init), Err(err)),
                 }
             }
-            Inner::Connecting(connecting) if self.is_nonblock() => {
-                (Inner::Connecting(connecting), Err(EALREADY))
+            inner::Inner::Connecting(connecting) if self.is_nonblock() => (
+                inner::Inner::Connecting(connecting),
+                Err(SystemError::EALREADY),
+            ),
+            inner::Inner::Connecting(connecting) => (inner::Inner::Connecting(connecting), Ok(())),
+            inner::Inner::Listening(inner) => {
+                (inner::Inner::Listening(inner), Err(SystemError::EISCONN))
+            }
+            inner::Inner::Established(inner) => {
+                (inner::Inner::Established(inner), Err(SystemError::EISCONN))
             }
-            Inner::Connecting(connecting) => (Inner::Connecting(connecting), Ok(())),
-            Inner::Listening(inner) => (Inner::Listening(inner), Err(EISCONN)),
-            Inner::Established(inner) => (Inner::Established(inner), Err(EISCONN)),
         };
 
         match result {
-            Ok(()) | Err(EINPROGRESS) => {
+            Ok(()) | Err(SystemError::EINPROGRESS) => {
                 init.iface().unwrap().poll();
             }
             _ => {}
@@ -154,9 +167,10 @@ impl TcpSocket {
     // for irq use
     pub fn finish_connect(&self) -> Result<(), SystemError> {
         let mut writer = self.inner.write();
-        let Inner::Connecting(conn) = writer.take().expect("Tcp Inner is None") else {
+        let inner::Inner::Connecting(conn) = writer.take().expect("Tcp inner::Inner is None")
+        else {
             log::error!("TcpSocket::finish_connect: not Connecting");
-            return Err(EINVAL);
+            return Err(SystemError::EINVAL);
         };
 
         let (inner, result) = conn.into_result();
@@ -169,16 +183,16 @@ impl TcpSocket {
     pub fn check_connect(&self) -> Result<(), SystemError> {
         self.update_events();
         let mut write_state = self.inner.write();
-        let inner = write_state.take().expect("Tcp Inner is None");
+        let inner = write_state.take().expect("Tcp inner::Inner is None");
         let (replace, result) = match inner {
-            Inner::Connecting(conn) => conn.into_result(),
-            Inner::Established(es) => {
+            inner::Inner::Connecting(conn) => conn.into_result(),
+            inner::Inner::Established(es) => {
                 log::warn!("TODO: check new established");
-                (Inner::Established(es), Ok(()))
+                (inner::Inner::Established(es), Ok(()))
             } // TODO check established
             _ => {
                 log::warn!("TODO: connecting socket error options");
-                (inner, Err(EINVAL))
+                (inner, Err(SystemError::EINVAL))
             } // TODO socket error options
         };
         write_state.replace(replace);
@@ -192,8 +206,8 @@ impl TcpSocket {
             .map(|inner| {
                 inner.iface().unwrap().poll();
                 let result = match inner {
-                    Inner::Established(inner) => inner.recv_slice(buf),
-                    _ => Err(EINVAL),
+                    inner::Inner::Established(inner) => inner.recv_slice(buf),
+                    _ => Err(SystemError::EINVAL),
                 };
                 inner.iface().unwrap().poll();
                 result
@@ -203,23 +217,33 @@ impl TcpSocket {
 
     pub fn try_send(&self, buf: &[u8]) -> Result<usize, SystemError> {
         // TODO: add nonblock check of connecting socket
-        let sent = match self.inner.read().as_ref().expect("Tcp Inner is None") {
-            Inner::Established(inner) => inner.send_slice(buf),
-            _ => Err(EINVAL),
+        let sent = match self
+            .inner
+            .read()
+            .as_ref()
+            .expect("Tcp inner::Inner is None")
+        {
+            inner::Inner::Established(inner) => inner.send_slice(buf),
+            _ => Err(SystemError::EINVAL),
         };
         self.inner.read().as_ref().unwrap().iface().unwrap().poll();
         sent
     }
 
     fn update_events(&self) -> bool {
-        match self.inner.read().as_ref().expect("Tcp Inner is None") {
-            Inner::Init(_) => false,
-            Inner::Connecting(connecting) => connecting.update_io_events(),
-            Inner::Established(established) => {
+        match self
+            .inner
+            .read()
+            .as_ref()
+            .expect("Tcp inner::Inner is None")
+        {
+            inner::Inner::Init(_) => false,
+            inner::Inner::Connecting(connecting) => connecting.update_io_events(),
+            inner::Inner::Established(established) => {
                 established.update_io_events(&self.pollee);
                 false
             }
-            Inner::Listening(listening) => {
+            inner::Inner::Listening(listening) => {
                 listening.update_io_events(&self.pollee);
                 false
             }
@@ -237,24 +261,34 @@ impl Socket for TcpSocket {
     }
 
     fn get_name(&self) -> Result<Endpoint, SystemError> {
-        match self.inner.read().as_ref().expect("Tcp Inner is None") {
-            Inner::Init(Init::Unbound((_, ver))) => Ok(Endpoint::Ip(match ver {
+        match self
+            .inner
+            .read()
+            .as_ref()
+            .expect("Tcp inner::Inner is None")
+        {
+            inner::Inner::Init(inner::Init::Unbound((_, ver))) => Ok(Endpoint::Ip(match ver {
                 smoltcp::wire::IpVersion::Ipv4 => UNSPECIFIED_LOCAL_ENDPOINT_V4,
                 smoltcp::wire::IpVersion::Ipv6 => UNSPECIFIED_LOCAL_ENDPOINT_V6,
             })),
-            Inner::Init(Init::Bound((_, local))) => Ok(Endpoint::Ip(*local)),
-            Inner::Connecting(connecting) => Ok(Endpoint::Ip(connecting.get_name())),
-            Inner::Established(established) => Ok(Endpoint::Ip(established.get_name())),
-            Inner::Listening(listening) => Ok(Endpoint::Ip(listening.get_name())),
+            inner::Inner::Init(inner::Init::Bound((_, local))) => Ok(Endpoint::Ip(*local)),
+            inner::Inner::Connecting(connecting) => Ok(Endpoint::Ip(connecting.get_name())),
+            inner::Inner::Established(established) => Ok(Endpoint::Ip(established.get_name())),
+            inner::Inner::Listening(listening) => Ok(Endpoint::Ip(listening.get_name())),
         }
     }
 
     fn get_peer_name(&self) -> Result<Endpoint, SystemError> {
-        match self.inner.read().as_ref().expect("Tcp Inner is None") {
-            Inner::Init(_) => Err(ENOTCONN),
-            Inner::Connecting(connecting) => Ok(Endpoint::Ip(connecting.get_peer_name())),
-            Inner::Established(established) => Ok(Endpoint::Ip(established.get_peer_name())),
-            Inner::Listening(_) => Err(ENOTCONN),
+        match self
+            .inner
+            .read()
+            .as_ref()
+            .expect("Tcp inner::Inner is None")
+        {
+            inner::Inner::Init(_) => Err(SystemError::ENOTCONN),
+            inner::Inner::Connecting(connecting) => Ok(Endpoint::Ip(connecting.get_peer_name())),
+            inner::Inner::Established(established) => Ok(Endpoint::Ip(established.get_peer_name())),
+            inner::Inner::Listening(_) => Err(SystemError::ENOTCONN),
         }
     }
 
@@ -263,19 +297,19 @@ impl Socket for TcpSocket {
             return self.do_bind(addr);
         }
         log::debug!("TcpSocket::bind: invalid endpoint");
-        return Err(EINVAL);
+        return Err(SystemError::EINVAL);
     }
 
     fn connect(&self, endpoint: Endpoint) -> Result<(), SystemError> {
         let Endpoint::Ip(endpoint) = endpoint else {
             log::debug!("TcpSocket::connect: invalid endpoint");
-            return Err(EINVAL);
+            return Err(SystemError::EINVAL);
         };
         self.start_connect(endpoint)?; // Only Nonblock or error will return error.
 
         return loop {
             match self.check_connect() {
-                Err(EAGAIN_OR_EWOULDBLOCK) => {}
+                Err(SystemError::EAGAIN_OR_EWOULDBLOCK) => {}
                 result => break result,
             }
         };
@@ -289,20 +323,20 @@ impl Socket for TcpSocket {
         self.do_listen(backlog)
     }
 
-    fn accept(&self) -> Result<(Arc<Inode>, Endpoint), SystemError> {
+    fn accept(&self) -> Result<(Arc<SocketInode>, Endpoint), SystemError> {
         if self.is_nonblock() {
             self.try_accept()
         } else {
             loop {
                 match self.try_accept() {
-                    Err(EAGAIN_OR_EWOULDBLOCK) => {
+                    Err(SystemError::EAGAIN_OR_EWOULDBLOCK) => {
                         wq_wait_event_interruptible!(self.wait_queue, self.incoming(), {})?;
                     }
                     result => break result,
                 }
             }
         }
-        .map(|(inner, endpoint)| (Inode::new(inner), Endpoint::Ip(endpoint)))
+        .map(|(inner, endpoint)| (SocketInode::new(inner), Endpoint::Ip(endpoint)))
     }
 
     fn recv(&self, buffer: &mut [u8], _flags: PMSG) -> Result<usize, SystemError> {
@@ -317,7 +351,7 @@ impl Socket for TcpSocket {
         self.inner
             .read()
             .as_ref()
-            .expect("Tcp Inner is None")
+            .expect("Tcp inner::Inner is None")
             .send_buffer_size()
     }
 
@@ -325,7 +359,7 @@ impl Socket for TcpSocket {
         self.inner
             .read()
             .as_ref()
-            .expect("Tcp Inner is None")
+            .expect("Tcp inner::Inner is None")
             .recv_buffer_size()
     }
 
@@ -361,20 +395,20 @@ impl Socket for TcpSocket {
 
         match inner {
             // complete connecting socket close logic
-            Inner::Connecting(conn) => {
+            inner::Inner::Connecting(conn) => {
                 let conn = unsafe { conn.into_established() };
                 conn.close();
                 conn.release();
             }
-            Inner::Established(es) => {
+            inner::Inner::Established(es) => {
                 es.close();
                 es.release();
             }
-            Inner::Listening(ls) => {
+            inner::Inner::Listening(ls) => {
                 ls.close();
                 ls.release();
             }
-            Inner::Init(init) => {
+            inner::Inner::Init(init) => {
                 init.close();
             }
         };
@@ -384,7 +418,7 @@ impl Socket for TcpSocket {
 
     fn set_option(&self, level: PSOL, name: usize, val: &[u8]) -> Result<(), SystemError> {
         if level != PSOL::TCP {
-            // return Err(EINVAL);
+            // return Err(SystemError::EINVAL);
             log::debug!("TcpSocket::set_option: not TCP");
             return Ok(());
         }
@@ -395,62 +429,62 @@ impl Socket for TcpSocket {
             NoDelay => {
                 let nagle_enabled = val[0] != 0;
                 let mut writer = self.inner.write();
-                let inner = writer.take().expect("Tcp Inner is None");
+                let inner = writer.take().expect("Tcp inner::Inner is None");
                 match inner {
-                    Inner::Established(established) => {
+                    inner::Inner::Established(established) => {
                         established.with_mut(|socket| {
                             socket.set_nagle_enabled(nagle_enabled);
                         });
-                        writer.replace(Inner::Established(established));
+                        writer.replace(inner::Inner::Established(established));
                     }
                     _ => {
                         writer.replace(inner);
-                        return Err(EINVAL);
+                        return Err(SystemError::EINVAL);
                     }
                 }
             }
             KeepIntvl => {
                 if val.len() == 4 {
                     let mut writer = self.inner.write();
-                    let inner = writer.take().expect("Tcp Inner is None");
+                    let inner = writer.take().expect("Tcp inner::Inner is None");
                     match inner {
-                        Inner::Established(established) => {
+                        inner::Inner::Established(established) => {
                             let interval = u32::from_ne_bytes([val[0], val[1], val[2], val[3]]);
                             established.with_mut(|socket| {
                                 socket.set_keep_alive(Some(smoltcp::time::Duration::from_secs(
                                     interval as u64,
                                 )));
                             });
-                            writer.replace(Inner::Established(established));
+                            writer.replace(inner::Inner::Established(established));
                         }
                         _ => {
                             writer.replace(inner);
-                            return Err(EINVAL);
+                            return Err(SystemError::EINVAL);
                         }
                     }
                 } else {
-                    return Err(EINVAL);
+                    return Err(SystemError::EINVAL);
                 }
             }
             KeepCnt => {
                 // if val.len() == 4 {
                 //     let mut writer = self.inner.write();
-                //     let inner = writer.take().expect("Tcp Inner is None");
+                //     let inner = writer.take().expect("Tcp inner::Inner is None");
                 //     match inner {
-                //         Inner::Established(established) => {
+                //         inner::Inner::Established(established) => {
                 //             let count = u32::from_ne_bytes([val[0], val[1], val[2], val[3]]);
                 //             established.with_mut(|socket| {
                 //                 socket.set_keep_alive_count(count);
                 //             });
-                //             writer.replace(Inner::Established(established));
+                //             writer.replace(inner::Inner::Established(established));
                 //         }
                 //         _ => {
                 //             writer.replace(inner);
-                //             return Err(EINVAL);
+                //             return Err(SystemError::EINVAL);
                 //         }
                 //     }
                 // } else {
-                //     return Err(EINVAL);
+                //     return Err(SystemError::EINVAL);
                 // }
             }
             KeepIdle => {}

kernel/src/net/socket/inet/syscall.rs

@@ -1,68 +1,66 @@
 use alloc::sync::Arc;
-use smoltcp;
-use system_error::SystemError::{self, *};
+use smoltcp::{self, wire::IpProtocol};
+use system_error::SystemError;
 
-use inet::{TcpSocket, UdpSocket};
-
-// use crate::net::syscall_util::SysArgSocketType;
-use crate::net::socket::*;
+use crate::net::socket::{
+    family,
+    inet::{TcpSocket, UdpSocket},
+    Socket, SocketInode, PSOCK,
+};
 
 fn create_inet_socket(
     version: smoltcp::wire::IpVersion,
     socket_type: PSOCK,
     protocol: smoltcp::wire::IpProtocol,
 ) -> Result<Arc<dyn Socket>, SystemError> {
-    log::debug!("type: {:?}, protocol: {:?}", socket_type, protocol);
-    use smoltcp::wire::IpProtocol::*;
+    // log::debug!("type: {:?}, protocol: {:?}", socket_type, protocol);
     match socket_type {
         PSOCK::Datagram => match protocol {
-            HopByHop | Udp => {
-                log::debug!("create udp socket");
-                // return Err(EPROTONOSUPPORT);
+            IpProtocol::HopByHop | IpProtocol::Udp => {
                 return Ok(UdpSocket::new(false));
             }
             _ => {
-                return Err(EPROTONOSUPPORT);
+                return Err(SystemError::EPROTONOSUPPORT);
             }
         },
         PSOCK::Stream => match protocol {
-            HopByHop | Tcp => {
+            IpProtocol::HopByHop | IpProtocol::Tcp => {
                 log::debug!("create tcp socket");
                 return Ok(TcpSocket::new(false, version));
             }
             _ => {
-                return Err(EPROTONOSUPPORT);
+                return Err(SystemError::EPROTONOSUPPORT);
             }
         },
         PSOCK::Raw => {
             todo!("raw")
         }
         _ => {
-            return Err(EPROTONOSUPPORT);
+            return Err(SystemError::EPROTONOSUPPORT);
         }
     }
 }
 
 pub struct Inet;
 impl family::Family for Inet {
-    fn socket(stype: PSOCK, protocol: u32) -> Result<Arc<Inode>, SystemError> {
+    fn socket(stype: PSOCK, protocol: u32) -> Result<Arc<SocketInode>, SystemError> {
         let socket = create_inet_socket(
             smoltcp::wire::IpVersion::Ipv4,
             stype,
             smoltcp::wire::IpProtocol::from(protocol as u8),
         )?;
-        Ok(Inode::new(socket))
+        Ok(SocketInode::new(socket))
     }
 }
 
 pub struct Inet6;
 impl family::Family for Inet6 {
-    fn socket(stype: PSOCK, protocol: u32) -> Result<Arc<Inode>, SystemError> {
+    fn socket(stype: PSOCK, protocol: u32) -> Result<Arc<SocketInode>, SystemError> {
         let socket = create_inet_socket(
             smoltcp::wire::IpVersion::Ipv6,
             stype,
             smoltcp::wire::IpProtocol::from(protocol as u8),
         )?;
-        Ok(Inode::new(socket))
+        Ok(SocketInode::new(socket))
     }
 }

kernel/src/net/socket/inode.rs

@@ -2,15 +2,20 @@ use crate::filesystem::vfs::IndexNode;
 use alloc::sync::Arc;
 use system_error::SystemError;
 
-use crate::net::socket::*;
+use super::{
+    common::shutdown::ShutdownTemp,
+    endpoint::Endpoint,
+    posix::{PMSG, PSOL},
+    EPollItems, Socket,
+};
 
 #[derive(Debug)]
-pub struct Inode {
+pub struct SocketInode {
     inner: Arc<dyn Socket>,
     epoll_items: EPollItems,
 }
 
-impl IndexNode for Inode {
+impl IndexNode for SocketInode {
     fn read_at(
         &self,
         _offset: usize,
@@ -78,7 +83,7 @@ impl IndexNode for Inode {
     }
 }
 
-impl Inode {
+impl SocketInode {
     // pub fn wait_queue(&self) -> WaitQueue {
     //     self.inner.wait_queue()
     // }

kernel/src/net/socket/mod.rs

@@ -1,7 +1,7 @@
 mod base;
 mod buffer;
 mod common;
-mod endpoint;
+pub mod endpoint;
 mod family;
 pub mod inet;
 mod inode;
@@ -12,16 +12,16 @@ mod utils;
 use crate::libs::wait_queue::WaitQueue;
 pub use base::Socket;
 
+pub use crate::net::event_poll::EPollEventType;
 pub use common::{
-    shutdown::*,
     // poll_unit::{EPollItems, WaitQueue},
     EPollItems,
 };
-pub use endpoint::*;
 pub use family::{AddressFamily, Family};
-pub use inode::Inode;
-pub use posix::*;
+pub use inode::SocketInode;
+pub use posix::PMSG;
+pub use posix::PSO;
+pub use posix::PSOCK;
+pub use posix::PSOL;
 pub use utils::create_socket;
-
-pub use crate::net::event_poll::EPollEventType;
 // pub use crate::net::sys

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

@@ -9,4 +9,4 @@ mod types;
 pub use msg_flag::MessageFlag as PMSG; // Socket message flags MSG_*
 pub use option::Options as PSO; // Socket options SO_*
 pub use option_level::OptionLevel as PSOL; // Socket options level SOL_*
-pub use types::Type as PSOCK; // Socket types SOCK_*
+pub use types::PSOCK; // Socket types SOCK_*

kernel/src/net/socket/posix/types.rs

@@ -1,5 +1,5 @@
 #[derive(Debug, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive)]
-pub enum Type {
+pub enum PSOCK {
     Stream = 1,
     Datagram = 2,
     Raw = 3,
@@ -10,7 +10,7 @@ pub enum Type {
 }
 
 use crate::net::posix::PosixArgsSocketType;
-impl TryFrom<PosixArgsSocketType> for Type {
+impl TryFrom<PosixArgsSocketType> for PSOCK {
     type Error = system_error::SystemError;
     fn try_from(x: PosixArgsSocketType) -> Result<Self, Self::Error> {
         use num_traits::FromPrimitive;

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

@@ -1,33 +1,37 @@
 pub mod ns;
 pub(crate) mod seqpacket;
 pub mod stream;
-use crate::{filesystem::vfs::InodeId, libs::rwlock::RwLock, net::socket::*};
+use crate::{filesystem::vfs::InodeId, libs::rwlock::RwLock};
 use alloc::sync::Arc;
 use hashbrown::HashMap;
-use system_error::SystemError::{self, *};
+use system_error::SystemError;
+
+use super::{endpoint::Endpoint, Family, SocketInode, PSOCK};
 pub struct Unix;
 
 lazy_static! {
     pub static ref INODE_MAP: RwLock<HashMap<InodeId, Endpoint>> = RwLock::new(HashMap::new());
 }
 
-fn create_unix_socket(sock_type: PSOCK) -> Result<Arc<Inode>, SystemError> {
+fn create_unix_socket(sock_type: PSOCK) -> Result<Arc<SocketInode>, SystemError> {
     match sock_type {
         PSOCK::Stream | PSOCK::Datagram => stream::StreamSocket::new_inode(),
         PSOCK::SeqPacket => seqpacket::SeqpacketSocket::new_inode(false),
-        _ => Err(EPROTONOSUPPORT),
+        _ => Err(SystemError::EPROTONOSUPPORT),
     }
 }
 
-impl family::Family for Unix {
-    fn socket(stype: PSOCK, _protocol: u32) -> Result<Arc<Inode>, SystemError> {
+impl Family for Unix {
+    fn socket(stype: PSOCK, _protocol: u32) -> Result<Arc<SocketInode>, SystemError> {
         let socket = create_unix_socket(stype)?;
         Ok(socket)
     }
 }
 
 impl Unix {
-    pub fn new_pairs(socket_type: PSOCK) -> Result<(Arc<Inode>, Arc<Inode>), SystemError> {
+    pub fn new_pairs(
+        socket_type: PSOCK,
+    ) -> Result<(Arc<SocketInode>, Arc<SocketInode>), SystemError> {
         // log::debug!("socket_type {:?}", socket_type);
         match socket_type {
             PSOCK::SeqPacket => seqpacket::SeqpacketSocket::new_pairs(),

kernel/src/net/socket/unix/ns/abs.rs

@@ -1,7 +1,6 @@
 use core::fmt;
 
-use crate::libs::spinlock::SpinLock;
-use crate::net::socket::Endpoint;
+use crate::{libs::spinlock::SpinLock, net::socket::endpoint::Endpoint};
 use alloc::string::String;
 use hashbrown::HashMap;
 use ida::IdAllocator;

kernel/src/net/socket/unix/seqpacket/inner.rs

@@ -3,11 +3,12 @@ use alloc::{collections::VecDeque, sync::Arc};
 use core::sync::atomic::{AtomicUsize, Ordering};
 
 use super::SeqpacketSocket;
+use crate::net::socket::common::shutdown::ShutdownTemp;
 use crate::{
     libs::mutex::Mutex,
-    net::socket::{buffer::Buffer, endpoint::Endpoint, Inode, ShutdownTemp},
+    net::socket::{buffer::Buffer, endpoint::Endpoint, SocketInode},
 };
-use system_error::SystemError::{self, *};
+use system_error::SystemError;
 
 #[derive(Debug)]
 pub(super) struct Init {
@@ -22,11 +23,11 @@ impl Init {
     pub(super) fn bind(&mut self, epoint_to_bind: Endpoint) -> Result<(), SystemError> {
         if self.inode.is_some() {
             log::error!("the socket is already bound");
-            return Err(EINVAL);
+            return Err(SystemError::EINVAL);
         }
         match epoint_to_bind {
             Endpoint::Inode(_) => self.inode = Some(epoint_to_bind),
-            _ => return Err(EINVAL),
+            _ => return Err(SystemError::EINVAL),
         }
 
         return Ok(());
@@ -35,7 +36,7 @@ impl Init {
     pub fn bind_path(&mut self, sun_path: String) -> Result<Endpoint, SystemError> {
         if self.inode.is_none() {
             log::error!("the socket is not bound");
-            return Err(EINVAL);
+            return Err(SystemError::EINVAL);
         }
         if let Some(Endpoint::Inode((inode, mut path))) = self.inode.take() {
             path = sun_path;
@@ -56,7 +57,7 @@ impl Init {
 pub(super) struct Listener {
     inode: Endpoint,
     backlog: AtomicUsize,
-    incoming_conns: Mutex<VecDeque<Arc<Inode>>>,
+    incoming_conns: Mutex<VecDeque<Arc<SocketInode>>>,
 }
 
 impl Listener {
@@ -73,7 +74,7 @@ impl Listener {
         return &self.inode;
     }
 
-    pub(super) fn try_accept(&self) -> Result<(Arc<Inode>, Endpoint), SystemError> {
+    pub(super) fn try_accept(&self) -> Result<(Arc<SocketInode>, Endpoint), SystemError> {
         let mut incoming_conns = self.incoming_conns.lock();
         log::debug!(" incom len {}", incoming_conns.len());
         let conn = incoming_conns
@@ -86,7 +87,7 @@ impl Listener {
             _ => return Err(SystemError::ENOTCONN),
         };
 
-        return Ok((Inode::new(socket), peer));
+        return Ok((SocketInode::new(socket), peer));
     }
 
     pub(super) fn listen(&self, backlog: usize) -> Result<(), SystemError> {
@@ -105,7 +106,7 @@ impl Listener {
         }
 
         let new_server = SeqpacketSocket::new(false);
-        let new_inode = Inode::new(new_server.clone());
+        let new_inode = SocketInode::new(new_server.clone());
         // log::debug!("new inode {:?},client_epoint {:?}",new_inode,client_epoint);
         let path = match &self.inode {
             Endpoint::Inode((_, path)) => path.clone(),

kernel/src/net/socket/unix/seqpacket/mod.rs

@@ -4,19 +4,33 @@ use alloc::{
     sync::{Arc, Weak},
 };
 use core::sync::atomic::{AtomicBool, Ordering};
-use unix::ns::abs::{remove_abs_addr, ABS_INODE_MAP};
 
-use crate::sched::SchedMode;
-use crate::{libs::rwlock::RwLock, net::socket::*};
-use inner::*;
+use crate::{
+    libs::{rwlock::RwLock, wait_queue::WaitQueue},
+    net::socket::{EPollEventType, Socket, SocketInode, PMSG},
+};
+use crate::{
+    net::{
+        posix::MsgHdr,
+        socket::{
+            common::shutdown::{Shutdown, ShutdownTemp},
+            endpoint::Endpoint,
+        },
+    },
+    sched::SchedMode,
+};
+
 use system_error::SystemError;
 
-use super::INODE_MAP;
+use super::{
+    ns::abs::{remove_abs_addr, ABS_INODE_MAP},
+    INODE_MAP,
+};
 
 type EP = EPollEventType;
 #[derive(Debug)]
 pub struct SeqpacketSocket {
-    inner: RwLock<Inner>,
+    inner: RwLock<inner::Inner>,
     shutdown: Shutdown,
     is_nonblocking: AtomicBool,
     wait_queue: WaitQueue,
@@ -32,7 +46,7 @@ impl SeqpacketSocket {
 
     pub fn new(is_nonblocking: bool) -> Arc<Self> {
         Arc::new_cyclic(|me| Self {
-            inner: RwLock::new(Inner::Init(Init::new())),
+            inner: RwLock::new(inner::Inner::Init(inner::Init::new())),
             shutdown: Shutdown::new(),
             is_nonblocking: AtomicBool::new(is_nonblocking),
             wait_queue: WaitQueue::default(),
@@ -40,21 +54,23 @@ impl SeqpacketSocket {
         })
     }
 
-    pub fn new_inode(is_nonblocking: bool) -> Result<Arc<Inode>, SystemError> {
+    pub fn new_inode(is_nonblocking: bool) -> Result<Arc<SocketInode>, SystemError> {
         let socket = SeqpacketSocket::new(is_nonblocking);
-        let inode = Inode::new(socket.clone());
+        let inode = SocketInode::new(socket.clone());
         // 建立时绑定自身为后续能正常获取本端地址
         let _ = match &mut *socket.inner.write() {
-            Inner::Init(init) => init.bind(Endpoint::Inode((inode.clone(), String::from("")))),
+            inner::Inner::Init(init) => {
+                init.bind(Endpoint::Inode((inode.clone(), String::from(""))))
+            }
             _ => return Err(SystemError::EINVAL),
         };
         return Ok(inode);
     }
 
     #[allow(dead_code)]
-    pub fn new_connected(connected: Connected, is_nonblocking: bool) -> Arc<Self> {
+    pub fn new_connected(connected: inner::Connected, is_nonblocking: bool) -> Arc<Self> {
         Arc::new_cyclic(|me| Self {
-            inner: RwLock::new(Inner::Connected(connected)),
+            inner: RwLock::new(inner::Inner::Connected(connected)),
             shutdown: Shutdown::new(),
             is_nonblocking: AtomicBool::new(is_nonblocking),
             wait_queue: WaitQueue::default(),
@@ -62,25 +78,25 @@ impl SeqpacketSocket {
         })
     }
 
-    pub fn new_pairs() -> Result<(Arc<Inode>, Arc<Inode>), SystemError> {
+    pub fn new_pairs() -> Result<(Arc<SocketInode>, Arc<SocketInode>), SystemError> {
         let socket0 = SeqpacketSocket::new(false);
         let socket1 = SeqpacketSocket::new(false);
-        let inode0 = Inode::new(socket0.clone());
-        let inode1 = Inode::new(socket1.clone());
+        let inode0 = SocketInode::new(socket0.clone());
+        let inode1 = SocketInode::new(socket1.clone());
 
-        let (conn_0, conn_1) = Connected::new_pair(
+        let (conn_0, conn_1) = inner::Connected::new_pair(
             Some(Endpoint::Inode((inode0.clone(), String::from("")))),
             Some(Endpoint::Inode((inode1.clone(), String::from("")))),
         );
-        *socket0.inner.write() = Inner::Connected(conn_0);
-        *socket1.inner.write() = Inner::Connected(conn_1);
+        *socket0.inner.write() = inner::Inner::Connected(conn_0);
+        *socket1.inner.write() = inner::Inner::Connected(conn_1);
 
         return Ok((inode0, inode1));
     }
 
-    fn try_accept(&self) -> Result<(Arc<Inode>, Endpoint), SystemError> {
+    fn try_accept(&self) -> Result<(Arc<SocketInode>, Endpoint), SystemError> {
         match &*self.inner.read() {
-            Inner::Listen(listen) => listen.try_accept() as _,
+            inner::Inner::Listen(listen) => listen.try_accept() as _,
             _ => {
                 log::error!("the socket is not listening");
                 return Err(SystemError::EINVAL);
@@ -90,7 +106,7 @@ impl SeqpacketSocket {
 
     fn is_acceptable(&self) -> bool {
         match &*self.inner.read() {
-            Inner::Listen(listen) => listen.is_acceptable(),
+            inner::Inner::Listen(listen) => listen.is_acceptable(),
             _ => {
                 panic!("the socket is not listening");
             }
@@ -111,7 +127,7 @@ impl SeqpacketSocket {
 
     fn can_recv(&self) -> Result<bool, SystemError> {
         let can = match &*self.inner.read() {
-            Inner::Connected(connected) => connected.can_recv(),
+            inner::Inner::Connected(connected) => connected.can_recv(),
             _ => return Err(SystemError::ENOTCONN),
         };
         Ok(can)
@@ -163,29 +179,29 @@ impl Socket for SeqpacketSocket {
             .map_err(|_| SystemError::EINVAL)?;
 
         let client_epoint = match &mut *self.inner.write() {
-            Inner::Init(init) => match init.endpoint().cloned() {
+            inner::Inner::Init(init) => match init.endpoint().cloned() {
                 Some(end) => {
-                    log::debug!("bind when connect");
+                    log::trace!("bind when connect");
                     Some(end)
                 }
                 None => {
-                    log::debug!("not bind when connect");
-                    let inode = Inode::new(self.self_ref.upgrade().unwrap().clone());
+                    log::trace!("not bind when connect");
+                    let inode = SocketInode::new(self.self_ref.upgrade().unwrap().clone());
                     let epoint = Endpoint::Inode((inode.clone(), String::from("")));
                     let _ = init.bind(epoint.clone());
                     Some(epoint)
                 }
             },
-            Inner::Listen(_) => return Err(SystemError::EINVAL),
-            Inner::Connected(_) => return Err(SystemError::EISCONN),
+            inner::Inner::Listen(_) => return Err(SystemError::EINVAL),
+            inner::Inner::Connected(_) => return Err(SystemError::EISCONN),
         };
         // ***阻塞与非阻塞处理还未实现
         // 客户端与服务端建立连接将服务端inode推入到自身的listen_incom队列中，
         // accept时从中获取推出对应的socket
         match &*remote_socket.inner.read() {
-            Inner::Listen(listener) => match listener.push_incoming(client_epoint) {
+            inner::Inner::Listen(listener) => match listener.push_incoming(client_epoint) {
                 Ok(connected) => {
-                    *self.inner.write() = Inner::Connected(connected);
+                    *self.inner.write() = inner::Inner::Connected(connected);
                     log::debug!("try to wake up");
 
                     remote_socket.wait_queue.wakeup(None);
@@ -194,11 +210,11 @@ impl Socket for SeqpacketSocket {
                 // ***错误处理
                 Err(_) => todo!(),
             },
-            Inner::Init(_) => {
+            inner::Inner::Init(_) => {
                 log::debug!("init einval");
                 return Err(SystemError::EINVAL);
             }
-            Inner::Connected(_) => return Err(SystemError::EISCONN),
+            inner::Inner::Connected(_) => return Err(SystemError::EISCONN),
         };
     }
 
@@ -207,7 +223,7 @@ impl Socket for SeqpacketSocket {
         match endpoint {
             Endpoint::Unixpath((inodeid, path)) => {
                 let inode = match &mut *self.inner.write() {
-                    Inner::Init(init) => init.bind_path(path)?,
+                    inner::Inner::Init(init) => init.bind_path(path)?,
                     _ => {
                         log::error!("socket has listen or connected");
                         return Err(SystemError::EINVAL);
@@ -219,7 +235,7 @@ impl Socket for SeqpacketSocket {
             }
             Endpoint::Abspath((abshandle, path)) => {
                 let inode = match &mut *self.inner.write() {
-                    Inner::Init(init) => init.bind_path(path)?,
+                    inner::Inner::Init(init) => init.bind_path(path)?,
                     _ => {
                         log::error!("socket has listen or connected");
                         return Err(SystemError::EINVAL);
@@ -235,7 +251,7 @@ impl Socket for SeqpacketSocket {
     fn shutdown(&self, how: ShutdownTemp) -> Result<(), SystemError> {
         log::debug!("seqpacket shutdown");
         match &*self.inner.write() {
-            Inner::Connected(connected) => connected.shutdown(how),
+            inner::Inner::Connected(connected) => connected.shutdown(how),
             _ => Err(SystemError::EINVAL),
         }
     }
@@ -244,21 +260,21 @@ impl Socket for SeqpacketSocket {
         let mut state = self.inner.write();
         log::debug!("listen into socket");
         let epoint = match &*state {
-            Inner::Init(init) => init.endpoint().ok_or(SystemError::EINVAL)?.clone(),
-            Inner::Listen(listener) => return listener.listen(backlog),
-            Inner::Connected(_) => {
+            inner::Inner::Init(init) => init.endpoint().ok_or(SystemError::EINVAL)?.clone(),
+            inner::Inner::Listen(listener) => return listener.listen(backlog),
+            inner::Inner::Connected(_) => {
                 log::error!("the socket is connected");
                 return Err(SystemError::EINVAL);
             }
         };
 
-        let listener = Listener::new(epoint, backlog);
-        *state = Inner::Listen(listener);
+        let listener = inner::Listener::new(epoint, backlog);
+        *state = inner::Inner::Listen(listener);
 
         Ok(())
     }
 
-    fn accept(&self) -> Result<(Arc<Inode>, Endpoint), SystemError> {
+    fn accept(&self) -> Result<(Arc<SocketInode>, Endpoint), SystemError> {
         if !self.is_nonblocking() {
             loop {
                 wq_wait_event_interruptible!(self.wait_queue, self.is_acceptable(), {})?;
@@ -339,7 +355,7 @@ impl Socket for SeqpacketSocket {
             }
         }
 
-        *self.inner.write() = Inner::Init(Init::new());
+        *self.inner.write() = inner::Inner::Init(inner::Init::new());
         self.wait_queue.wakeup(None);
 
         let _ = remove_abs_addr(path);
@@ -350,7 +366,7 @@ impl Socket for SeqpacketSocket {
     fn get_peer_name(&self) -> Result<Endpoint, SystemError> {
         // 获取对端地址
         let endpoint = match &*self.inner.read() {
-            Inner::Connected(connected) => connected.peer_endpoint().cloned(),
+            inner::Inner::Connected(connected) => connected.peer_endpoint().cloned(),
             _ => return Err(SystemError::ENOTCONN),
         };
 
@@ -364,9 +380,9 @@ impl Socket for SeqpacketSocket {
     fn get_name(&self) -> Result<Endpoint, SystemError> {
         // 获取本端地址
         let endpoint = match &*self.inner.read() {
-            Inner::Init(init) => init.endpoint().cloned(),
-            Inner::Listen(listener) => Some(listener.endpoint().clone()),
-            Inner::Connected(connected) => connected.endpoint().cloned(),
+            inner::Inner::Init(init) => init.endpoint().cloned(),
+            inner::Inner::Listen(listener) => Some(listener.endpoint().clone()),
+            inner::Inner::Connected(connected) => connected.endpoint().cloned(),
         };
 
         if let Some(endpoint) = endpoint {
@@ -407,7 +423,7 @@ impl Socket for SeqpacketSocket {
                 )?;
                 // connect锁和flag判断顺序不正确，应该先判断在
                 match &*self.inner.write() {
-                    Inner::Connected(connected) => match connected.try_read(buffer) {
+                    inner::Inner::Connected(connected) => match connected.try_read(buffer) {
                         Ok(usize) => {
                             log::debug!("recv from successfully");
                             return Ok(usize);
@@ -427,7 +443,7 @@ impl Socket for SeqpacketSocket {
 
     fn recv_msg(
         &self,
-        _msg: &mut crate::net::syscall::MsgHdr,
+        _msg: &mut MsgHdr,
         _flags: crate::net::socket::PMSG,
     ) -> Result<usize, SystemError> {
         Err(SystemError::ENOSYS)
@@ -443,7 +459,7 @@ impl Socket for SeqpacketSocket {
         if !flags.contains(PMSG::DONTWAIT) {
             loop {
                 match &*self.inner.write() {
-                    Inner::Connected(connected) => match connected.try_write(buffer) {
+                    inner::Inner::Connected(connected) => match connected.try_write(buffer) {
                         Ok(usize) => {
                             log::debug!("send successfully");
                             return Ok(usize);
@@ -463,7 +479,7 @@ impl Socket for SeqpacketSocket {
 
     fn send_msg(
         &self,
-        _msg: &crate::net::syscall::MsgHdr,
+        _msg: &MsgHdr,
         _flags: crate::net::socket::PMSG,
     ) -> Result<usize, SystemError> {
         Err(SystemError::ENOSYS)
@@ -492,7 +508,7 @@ impl Socket for SeqpacketSocket {
                 )?;
                 // connect锁和flag判断顺序不正确，应该先判断在
                 match &*self.inner.write() {
-                    Inner::Connected(connected) => match connected.recv_slice(buffer) {
+                    inner::Inner::Connected(connected) => match connected.recv_slice(buffer) {
                         Ok(usize) => {
                             // log::debug!("recvs from successfully");
                             return Ok((usize, connected.peer_endpoint().unwrap().clone()));
@@ -535,7 +551,7 @@ impl Socket for SeqpacketSocket {
             mask |= EP::EPOLLRDHUP | EP::EPOLLIN | EP::EPOLLRDNORM;
         }
         match &*self.inner.read() {
-            Inner::Connected(connected) => {
+            inner::Inner::Connected(connected) => {
                 if connected.can_recv() {
                     mask |= EP::EPOLLIN | EP::EPOLLRDNORM;
                 }
@@ -552,8 +568,8 @@ impl Socket for SeqpacketSocket {
                     }
                 }
             }
-            Inner::Listen(_) => mask |= EP::EPOLLIN,
-            Inner::Init(_) => mask |= EP::EPOLLOUT,
+            inner::Inner::Listen(_) => mask |= EP::EPOLLIN,
+            inner::Inner::Init(_) => mask |= EP::EPOLLOUT,
         }
         mask.bits() as usize
     }

kernel/src/net/socket/unix/stream/inner.rs

@@ -5,8 +5,10 @@ use system_error::SystemError;
 
 use crate::libs::mutex::Mutex;
 use crate::net::socket::buffer::Buffer;
+use crate::net::socket::common::shutdown::ShutdownTemp;
+use crate::net::socket::endpoint::Endpoint;
 use crate::net::socket::unix::stream::StreamSocket;
-use crate::net::socket::{Endpoint, Inode, ShutdownTemp};
+use crate::net::socket::SocketInode;
 
 use alloc::collections::VecDeque;
 use alloc::{string::String, sync::Arc};
@@ -183,7 +185,7 @@ impl Connected {
 #[derive(Debug)]
 pub struct Listener {
     addr: Option<Endpoint>,
-    incoming_connects: Mutex<VecDeque<Arc<Inode>>>,
+    incoming_connects: Mutex<VecDeque<Arc<SocketInode>>>,
     backlog: AtomicUsize,
 }
 
@@ -201,7 +203,7 @@ impl Listener {
         return Ok(());
     }
 
-    pub fn push_incoming(&self, server_inode: Arc<Inode>) -> Result<(), SystemError> {
+    pub fn push_incoming(&self, server_inode: Arc<SocketInode>) -> Result<(), SystemError> {
         let mut incoming_connects = self.incoming_connects.lock();
 
         if incoming_connects.len() >= self.backlog.load(Ordering::Relaxed) {
@@ -215,7 +217,7 @@ impl Listener {
     }
 
     #[allow(dead_code)]
-    pub fn pop_incoming(&self) -> Option<Arc<Inode>> {
+    pub fn pop_incoming(&self) -> Option<Arc<SocketInode>> {
         let mut incoming_connects = self.incoming_connects.lock();
 
         return incoming_connects.pop_front();
@@ -229,7 +231,7 @@ impl Listener {
         return self.incoming_connects.lock().len() != 0;
     }
 
-    pub(super) fn try_accept(&self) -> Result<(Arc<Inode>, Endpoint), SystemError> {
+    pub(super) fn try_accept(&self) -> Result<(Arc<SocketInode>, Endpoint), SystemError> {
         let mut incoming_connecteds = self.incoming_connects.lock();
         debug!("incom len {}", incoming_connecteds.len());
         let connected = incoming_connecteds
@@ -242,6 +244,6 @@ impl Listener {
             _ => return Err(SystemError::ENOTCONN),
         };
         debug!("server accept!");
-        return Ok((Inode::new(socket), peer));
+        return Ok((SocketInode::new(socket), peer));
     }
 }

kernel/src/net/socket/unix/stream/mod.rs

@@ -1,4 +1,13 @@
-use crate::sched::SchedMode;
+use crate::{
+    net::{
+        posix::MsgHdr,
+        socket::{
+            common::shutdown::{Shutdown, ShutdownTemp},
+            endpoint::Endpoint,
+        },
+    },
+    sched::SchedMode,
+};
 use alloc::{
     string::String,
     sync::{Arc, Weak},
@@ -46,11 +55,11 @@ impl StreamSocket {
         })
     }
 
-    pub fn new_pairs() -> Result<(Arc<Inode>, Arc<Inode>), SystemError> {
+    pub fn new_pairs() -> Result<(Arc<SocketInode>, Arc<SocketInode>), SystemError> {
         let socket0 = StreamSocket::new();
         let socket1 = StreamSocket::new();
-        let inode0 = Inode::new(socket0.clone());
-        let inode1 = Inode::new(socket1.clone());
+        let inode0 = SocketInode::new(socket0.clone());
+        let inode1 = SocketInode::new(socket1.clone());
 
         let (conn_0, conn_1) = Connected::new_pair(
             Some(Endpoint::Inode((inode0.clone(), String::from("")))),
@@ -72,9 +81,9 @@ impl StreamSocket {
         })
     }
 
-    pub fn new_inode() -> Result<Arc<Inode>, SystemError> {
+    pub fn new_inode() -> Result<Arc<SocketInode>, SystemError> {
         let socket = StreamSocket::new();
-        let inode = Inode::new(socket.clone());
+        let inode = SocketInode::new(socket.clone());
 
         let _ = match &mut *socket.inner.write() {
             Inner::Init(init) => init.bind(Endpoint::Inode((inode.clone(), String::from("")))),
@@ -93,7 +102,7 @@ impl StreamSocket {
         }
     }
 
-    pub fn try_accept(&self) -> Result<(Arc<Inode>, Endpoint), SystemError> {
+    pub fn try_accept(&self) -> Result<(Arc<SocketInode>, Endpoint), SystemError> {
         match &*self.inner.read() {
             Inner::Listener(listener) => listener.try_accept() as _,
             _ => {
@@ -135,7 +144,7 @@ impl Socket for StreamSocket {
                 }
                 None => {
                     debug!("not bind when connected");
-                    let inode = Inode::new(self.self_ref.upgrade().unwrap().clone());
+                    let inode = SocketInode::new(self.self_ref.upgrade().unwrap().clone());
                     let epoint = Endpoint::Inode((inode.clone(), String::from("")));
                     let _ = init.bind(epoint.clone());
                     Some(epoint)
@@ -186,7 +195,7 @@ impl Socket for StreamSocket {
 
         //创建新的对端socket
         let new_server_socket = StreamSocket::new();
-        let new_server_inode = Inode::new(new_server_socket.clone());
+        let new_server_inode = SocketInode::new(new_server_socket.clone());
         let new_server_endpoint = Some(Endpoint::Inode((new_server_inode.clone(), sun_path)));
         //获取connect pair
         let (client_conn, server_conn) =
@@ -258,7 +267,7 @@ impl Socket for StreamSocket {
         return Ok(());
     }
 
-    fn accept(&self) -> Result<(Arc<socket::Inode>, Endpoint), SystemError> {
+    fn accept(&self) -> Result<(Arc<socket::SocketInode>, Endpoint), SystemError> {
         debug!("stream server begin accept");
         //目前只实现了阻塞式实现
         loop {
@@ -490,11 +499,7 @@ impl Socket for StreamSocket {
         }
     }
 
-    fn recv_msg(
-        &self,
-        _msg: &mut crate::net::syscall::MsgHdr,
-        _flags: socket::PMSG,
-    ) -> Result<usize, SystemError> {
+    fn recv_msg(&self, _msg: &mut MsgHdr, _flags: socket::PMSG) -> Result<usize, SystemError> {
         Err(SystemError::ENOSYS)
     }
 
@@ -523,11 +528,7 @@ impl Socket for StreamSocket {
         }
     }
 
-    fn send_msg(
-        &self,
-        _msg: &crate::net::syscall::MsgHdr,
-        _flags: socket::PMSG,
-    ) -> Result<usize, SystemError> {
+    fn send_msg(&self, _msg: &MsgHdr, _flags: socket::PMSG) -> Result<usize, SystemError> {
         todo!()
     }
 

kernel/src/net/socket/utils.rs

@@ -9,7 +9,7 @@ pub fn create_socket(
     protocol: u32,
     is_nonblock: bool,
     is_close_on_exec: bool,
-) -> Result<Arc<socket::Inode>, SystemError> {
+) -> Result<Arc<socket::SocketInode>, SystemError> {
     type AF = socket::AddressFamily;
     let inode = match family {
         AF::INet => socket::inet::Inet::socket(socket_type, protocol)?,

kernel/src/net/syscall.rs

@@ -1,6 +1,6 @@
 use alloc::sync::Arc;
 use log::debug;
-use system_error::SystemError::{self, *};
+use system_error::SystemError;
 
 use crate::{
     filesystem::vfs::file::{File, FileMode},
@@ -8,9 +8,10 @@ use crate::{
     syscall::Syscall,
 };
 
-use super::socket::{self, unix::Unix, AddressFamily as AF, Endpoint};
-
-pub use super::posix::*;
+use super::{
+    posix::{MsgHdr, PosixArgsSocketType, SockAddr},
+    socket::{self, endpoint::Endpoint, unix::Unix, AddressFamily},
+};
 
 /// Flags for socket, socketpair, accept4
 const SOCK_CLOEXEC: FileMode = FileMode::O_CLOEXEC;
@@ -72,7 +73,7 @@ impl Syscall {
         protocol: usize,
         fds: &mut [i32],
     ) -> Result<usize, SystemError> {
-        let address_family = AF::try_from(address_family as u16)?;
+        let address_family = AddressFamily::try_from(address_family as u16)?;
         let socket_type = PosixArgsSocketType::from_bits_truncate(socket_type as u32);
         let stype = socket::PSOCK::try_from(socket_type)?;
 
@@ -80,7 +81,7 @@ impl Syscall {
         let mut fd_table_guard = binding.write();
 
         // check address family, only support AF_UNIX
-        if address_family != AF::Unix {
+        if address_family != AddressFamily::Unix {
             log::warn!(
                 "only support AF_UNIX, {:?} with protocol {:?} is not supported",
                 address_family,
@@ -113,7 +114,7 @@ impl Syscall {
         optval: &[u8],
     ) -> Result<usize, SystemError> {
         let sol = socket::PSOL::try_from(level as u32)?;
-        let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
+        let socket: Arc<socket::SocketInode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
         debug!("setsockopt: level = {:?} ", sol);
@@ -138,16 +139,16 @@ impl Syscall {
     ) -> Result<usize, SystemError> {
         // 获取socket
         let optval = optval as *mut u32;
-        let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
+        let socket: Arc<socket::SocketInode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
-            .ok_or(EBADF)?;
+            .ok_or(SystemError::EBADF)?;
 
         use socket::{PSO, PSOL};
 
         let level = PSOL::try_from(level as u32)?;
 
         if matches!(level, PSOL::SOCKET) {
-            let optname = PSO::try_from(optname as u32).map_err(|_| ENOPROTOOPT)?;
+            let optname = PSO::try_from(optname as u32).map_err(|_| SystemError::ENOPROTOOPT)?;
             match optname {
                 PSO::SNDBUF => {
                     // 返回发送缓冲区大小
@@ -166,7 +167,7 @@ impl Syscall {
                     return Ok(0);
                 }
                 _ => {
-                    return Err(ENOPROTOOPT);
+                    return Err(SystemError::ENOPROTOOPT);
                 }
             }
         }
@@ -180,15 +181,16 @@ impl Syscall {
 
         if matches!(level, PSOL::TCP) {
             use socket::inet::stream::TcpOption;
-            let optname = TcpOption::try_from(optname as i32).map_err(|_| ENOPROTOOPT)?;
+            let optname =
+                TcpOption::try_from(optname as i32).map_err(|_| SystemError::ENOPROTOOPT)?;
             match optname {
                 TcpOption::Congestion => return Ok(0),
                 _ => {
-                    return Err(ENOPROTOOPT);
+                    return Err(SystemError::ENOPROTOOPT);
                 }
             }
         }
-        return Err(ENOPROTOOPT);
+        return Err(SystemError::ENOPROTOOPT);
     }
 
     /// @brief sys_connect系统调用的实际执行函数
@@ -200,7 +202,7 @@ impl Syscall {
     /// @return 成功返回0，失败返回错误码
     pub fn connect(fd: usize, addr: *const SockAddr, addrlen: u32) -> Result<usize, SystemError> {
         let endpoint: Endpoint = SockAddr::to_endpoint(addr, addrlen)?;
-        let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
+        let socket = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
         socket.connect(endpoint)?;
@@ -223,7 +225,7 @@ impl Syscall {
         //     addrlen
         // );
         let endpoint: Endpoint = SockAddr::to_endpoint(addr, addrlen)?;
-        let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
+        let socket: Arc<socket::SocketInode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
         // log::debug!("bind: socket={:?}", socket);
@@ -255,7 +257,7 @@ impl Syscall {
 
         let flags = socket::PMSG::from_bits_truncate(flags);
 
-        let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
+        let socket: Arc<socket::SocketInode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
 
@@ -282,7 +284,7 @@ impl Syscall {
         addr: *mut SockAddr,
         addr_len: *mut u32,
     ) -> Result<usize, SystemError> {
-        let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
+        let socket: Arc<socket::SocketInode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
         let flags = socket::PMSG::from_bits_truncate(flags);
@@ -293,7 +295,7 @@ impl Syscall {
         }
 
         // address is not null
-        let address = unsafe { addr.as_ref() }.ok_or(EINVAL)?;
+        let address = unsafe { addr.as_ref() }.ok_or(SystemError::EINVAL)?;
 
         if unsafe { address.is_empty() } {
             let (recv_len, endpoint) = socket.recv_from(buf, flags, None)?;
@@ -304,7 +306,7 @@ impl Syscall {
             return Ok(recv_len);
         } else {
             // 从socket中读取数据
-            let addr_len = *unsafe { addr_len.as_ref() }.ok_or(EINVAL)?;
+            let addr_len = *unsafe { addr_len.as_ref() }.ok_or(SystemError::EINVAL)?;
             let address = SockAddr::to_endpoint(addr, addr_len)?;
             let (recv_len, _) = socket.recv_from(buf, flags, Some(address))?;
             return Ok(recv_len);
@@ -324,7 +326,7 @@ impl Syscall {
             crate::filesystem::vfs::syscall::IoVecs::from_user(msg.msg_iov, msg.msg_iovlen, true)?
         };
 
-        let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
+        let socket: Arc<socket::SocketInode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
 
@@ -348,7 +350,7 @@ impl Syscall {
     ///
     /// @return 成功返回0，失败返回错误码
     pub fn listen(fd: usize, backlog: usize) -> Result<usize, SystemError> {
-        let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
+        let socket: Arc<socket::SocketInode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
         socket.listen(backlog).map(|_| 0)
@@ -361,7 +363,7 @@ impl Syscall {
     ///
     /// @return 成功返回0，失败返回错误码
     pub fn shutdown(fd: usize, how: usize) -> Result<usize, SystemError> {
-        let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
+        let socket: Arc<socket::SocketInode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
         socket.shutdown(how.try_into()?)?;
@@ -420,7 +422,7 @@ impl Syscall {
         addrlen: *mut u32,
         flags: u32,
     ) -> Result<usize, SystemError> {
-        let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
+        let socket: Arc<socket::SocketInode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
 
@@ -501,7 +503,7 @@ impl Syscall {
             return Err(SystemError::EINVAL);
         }
 
-        let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
+        let socket: Arc<socket::SocketInode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
 

kernel/src/process/mod.rs

@@ -54,7 +54,7 @@ use crate::{
         VirtAddr,
     },
     namespaces::{mnt_namespace::FsStruct, pid_namespace::PidStrcut, NsProxy},
-    net::socket::Inode as SocketInode,
+    net::socket::SocketInode,
     sched::{
         completion::Completion, cpu_rq, fair::FairSchedEntity, prio::MAX_PRIO, DequeueFlag,
         EnqueueFlag, OnRq, SchedMode, WakeupFlags, __schedule,

kernel/src/syscall/mod.rs

@@ -9,7 +9,7 @@ use crate::{
     ipc::shm::{ShmCtlCmd, ShmFlags, ShmId, ShmKey},
     libs::{futex::constant::FutexFlag, rand::GRandFlags},
     mm::{page::PAGE_4K_SIZE, syscall::MremapFlags},
-    net::syscall::MsgHdr,
+    net::posix::{MsgHdr, SockAddr},
     process::{
         fork::KernelCloneArgs,
         resource::{RLimit64, RUsage},
@@ -33,7 +33,6 @@ use crate::{
     },
     libs::align::page_align_up,
     mm::{verify_area, MemoryManagementArch, VirtAddr},
-    net::syscall::SockAddr,
     process::{fork::CloneFlags, syscall::PosixOldUtsName, Pid},
     time::{
         syscall::{PosixTimeZone, PosixTimeval},