regulate naming to posix

kernel/src/net/socket/base.rs

@@ -60,7 +60,7 @@ pub trait Socket: Sync + Send + Debug + Any {
     /// 对应于 Posix `getsockopt` ，获取socket选项
     fn get_option(
         &self,
-        level: OptionLevel,
+        level: PSOL,
         name: usize,
         value: &mut [u8],
     ) -> Result<usize, SystemError> {
@@ -76,40 +76,40 @@ pub trait Socket: Sync + Send + Debug + Any {
     // pselect
     /// # `read`
     fn read(&self, buffer: &mut [u8]) -> Result<usize, SystemError> {
-        self.recv(buffer, MessageFlag::empty())
+        self.recv(buffer, PMSG::empty())
     }
     /// # `recv`
     /// 接收数据，`read` = `recv` with flags = 0
-    fn recv(&self, buffer: &mut [u8], flags: MessageFlag) -> Result<usize, SystemError> {
+    fn recv(&self, buffer: &mut [u8], flags: PMSG) -> Result<usize, SystemError> {
         Err(ENOSYS)
     }
     /// # `recv_from`
     fn recv_from(
         &self,
         buffer: &mut [u8],
-        flags: MessageFlag,
+        flags: PMSG,
         address: Option<Endpoint>,
     ) -> Result<(usize, Endpoint), SystemError> {
         Err(ENOSYS)
     }
     /// # `recv_msg`
-    fn recv_msg(&self, msg: &mut MsgHdr, flags: MessageFlag) -> Result<usize, SystemError> {
+    fn recv_msg(&self, msg: &mut MsgHdr, flags: PMSG) -> Result<usize, SystemError> {
         Err(ENOSYS)
     }
     // select
     /// # `send`
-    fn send(&self, buffer: &[u8], flags: MessageFlag) -> Result<usize, SystemError> {
+    fn send(&self, buffer: &[u8], flags: PMSG) -> Result<usize, SystemError> {
         Err(ENOSYS)
     }
     /// # `send_msg`
-    fn send_msg(&self, msg: &MsgHdr, flags: MessageFlag) -> Result<usize, SystemError> {
+    fn send_msg(&self, msg: &MsgHdr, flags: PMSG) -> Result<usize, SystemError> {
         Err(ENOSYS)
     }
     /// # `send_to`
     fn send_to(
         &self,
         buffer: &[u8],
-        flags: MessageFlag,
+        flags: PMSG,
         address: Endpoint,
     ) -> Result<usize, SystemError> {
         Err(ENOSYS)
@@ -122,7 +122,7 @@ pub trait Socket: Sync + Send + Debug + Any {
     /// - value 选项的值
     /// ## Reference
     /// https://code.dragonos.org.cn/s?refs=sk_setsockopt&project=linux-6.6.21
-    fn set_option(&self, level: OptionLevel, name: usize, val: &[u8]) -> Result<(), SystemError> {
+    fn set_option(&self, level: PSOL, name: usize, val: &[u8]) -> Result<(), SystemError> {
         log::warn!("setsockopt is not implemented");
         Ok(())
     }
@@ -135,7 +135,7 @@ pub trait Socket: Sync + Send + Debug + Any {
     // socketpair
     /// # `write`
     fn write(&self, buffer: &[u8]) -> Result<usize, SystemError> {
-        self.send(buffer, MessageFlag::empty())
+        self.send(buffer, PMSG::empty())
     }
     // fn write_buffer(&self, _buf: &[u8]) -> Result<usize, SystemError> {
     //     todo!()

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

@@ -1,10 +0,0 @@
-// socket definitions
-mod msg_flag;
-mod option;
-mod option_level;
-mod types;
-
-pub use msg_flag::MessageFlag; // Socket message flags MSG_*
-pub use option::Options; // Socket options SO_*
-pub use option_level::OptionLevel; // Socket options level SOL_*
-pub use types::Type; // Socket types SOCK_*

kernel/src/net/socket/family.rs

@@ -117,5 +117,5 @@ use crate::net::socket;
 use alloc::sync::Arc;
 
 pub trait Family {
-    fn socket(stype: socket::Type, protocol: u32) -> Result<Arc<socket::Inode>, SystemError>;
+    fn socket(stype: socket::PSOCK, protocol: u32) -> Result<Arc<socket::Inode>, SystemError>;
 }

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

@@ -207,8 +207,8 @@ impl Socket for UdpSocket {
         return Err(EAFNOSUPPORT);
     }
 
-    fn send(&self, buffer: &[u8], flags: MessageFlag) -> Result<usize, SystemError> {
-        if flags.contains(MessageFlag::DONTWAIT) {
+    fn send(&self, buffer: &[u8], flags: PMSG) -> Result<usize, SystemError> {
+        if flags.contains(PMSG::DONTWAIT) {
             log::warn!("Nonblock send is not implemented yet");
         }
 
@@ -218,10 +218,10 @@ impl Socket for UdpSocket {
     fn send_to(
         &self,
         buffer: &[u8],
-        flags: MessageFlag,
+        flags: PMSG,
         address: Endpoint,
     ) -> Result<usize, SystemError> {
-        if flags.contains(MessageFlag::DONTWAIT) {
+        if flags.contains(PMSG::DONTWAIT) {
             log::warn!("Nonblock send is not implemented yet");
         }
 
@@ -232,10 +232,10 @@ impl Socket for UdpSocket {
         return Err(EINVAL);
     }
 
-    fn recv(&self, buffer: &mut [u8], flags: MessageFlag) -> Result<usize, SystemError> {
+    fn recv(&self, buffer: &mut [u8], flags: PMSG) -> Result<usize, SystemError> {
         use crate::sched::SchedMode;
 
-        return if self.is_nonblock() || flags.contains(MessageFlag::DONTWAIT) {
+        return if self.is_nonblock() || flags.contains(PMSG::DONTWAIT) {
             self.try_recv(buffer)
         } else {
             loop {
@@ -253,7 +253,7 @@ impl Socket for UdpSocket {
     fn recv_from(
         &self,
         buffer: &mut [u8],
-        flags: MessageFlag,
+        flags: PMSG,
         address: Option<Endpoint>,
     ) -> Result<(usize, Endpoint), SystemError> {
         use crate::sched::SchedMode;
@@ -262,7 +262,7 @@ impl Socket for UdpSocket {
             self.connect(endpoint)?;
         }
 
-        return if self.is_nonblock() || flags.contains(MessageFlag::DONTWAIT) {
+        return if self.is_nonblock() || flags.contains(PMSG::DONTWAIT) {
             self.try_recv(buffer)
         } else {
             loop {

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

@@ -278,11 +278,11 @@ impl Socket for TcpSocket {
         .map(|(inner, endpoint)| (Inode::new(inner), Endpoint::Ip(endpoint)))
     }
 
-    fn recv(&self, buffer: &mut [u8], _flags: MessageFlag) -> Result<usize, SystemError> {
+    fn recv(&self, buffer: &mut [u8], _flags: PMSG) -> Result<usize, SystemError> {
         self.try_recv(buffer)
     }
 
-    fn send(&self, buffer: &[u8], _flags: MessageFlag) -> Result<usize, SystemError> {
+    fn send(&self, buffer: &[u8], _flags: PMSG) -> Result<usize, SystemError> {
         self.try_send(buffer)
     }
 

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

@@ -8,14 +8,13 @@ use inet::{TcpSocket, UdpSocket};
 use crate::net::socket::*;
 
 fn create_inet_socket(
-    socket_type: Type,
+    socket_type: PSOCK,
     protocol: smoltcp::wire::IpProtocol,
 ) -> Result<Arc<dyn Socket>, SystemError> {
     // log::debug!("type: {:?}, protocol: {:?}", socket_type, protocol);
     use smoltcp::wire::IpProtocol::*;
-    use Type::*;
     match socket_type {
-        Datagram => {
+        PSOCK::Datagram => {
             match protocol {
                 HopByHop | Udp => {
                     return Ok(UdpSocket::new(false));
@@ -29,7 +28,7 @@ fn create_inet_socket(
             // }
             // return Ok(UdpSocket::new(false));
         }
-        Stream => match protocol {
+        PSOCK::Stream => match protocol {
             HopByHop | Tcp => {
                 return Ok(TcpSocket::new(false));
             }
@@ -37,7 +36,7 @@ fn create_inet_socket(
                 return Err(EPROTONOSUPPORT);
             }
         },
-        Raw => {
+        PSOCK::Raw => {
             todo!("raw")
         }
         _ => {
@@ -48,7 +47,7 @@ fn create_inet_socket(
 
 pub struct Inet;
 impl family::Family for Inet {
-    fn socket(stype: Type, protocol: u32) -> Result<Arc<Inode>, SystemError> {
+    fn socket(stype: PSOCK, protocol: u32) -> Result<Arc<Inode>, SystemError> {
         let socket = create_inet_socket(stype, smoltcp::wire::IpProtocol::from(protocol as u8))?;
         Ok(Inode::new(socket))
     }

kernel/src/net/socket/inode.rs

@@ -101,7 +101,7 @@ impl Inode {
 
     pub fn set_option(
         &self,
-        level: OptionLevel,
+        level: PSOL,
         name: usize,
         value: &[u8],
     ) -> Result<(), SystemError> {
@@ -110,7 +110,7 @@ impl Inode {
 
     pub fn get_option(
         &self,
-        level: OptionLevel,
+        level: PSOL,
         name: usize,
         value: &mut [u8],
     ) -> Result<usize, SystemError> {
@@ -125,16 +125,16 @@ impl Inode {
         &self,
         buffer: &[u8],
         address: Endpoint,
-        flags: MessageFlag,
+        flags: PMSG,
     ) -> Result<usize, SystemError> {
         self.inner.send_to(buffer, flags, address)
     }
 
-    pub fn send(&self, buffer: &[u8], flags: MessageFlag) -> Result<usize, SystemError> {
+    pub fn send(&self, buffer: &[u8], flags: PMSG) -> Result<usize, SystemError> {
         self.inner.send(buffer, flags)
     }
 
-    pub fn recv(&self, buffer: &mut [u8], flags: MessageFlag) -> Result<usize, SystemError> {
+    pub fn recv(&self, buffer: &mut [u8], flags: PMSG) -> Result<usize, SystemError> {
         self.inner.recv(buffer, flags)
     }
 
@@ -142,7 +142,7 @@ impl Inode {
     pub fn recv_from(
         &self,
         buffer: &mut [u8],
-        flags: MessageFlag,
+        flags: PMSG,
         address: Option<Endpoint>,
     ) -> Result<(usize, Endpoint), SystemError> {
         self.inner.recv_from(buffer, flags, address)

kernel/src/net/socket/mod.rs

@@ -1,7 +1,7 @@
 mod base;
 mod buffer;
 mod common;
-mod definition;
+mod posix;
 mod endpoint;
 mod family;
 pub mod inet;
@@ -17,7 +17,7 @@ pub use common::{
     // poll_unit::{EPollItems, WaitQueue},
     EPollItems,
 };
-pub use definition::*;
+pub use posix::*;
 pub use endpoint::*;
 pub use family::{AddressFamily, Family};
 pub use inode::Inode;

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

@@ -0,0 +1,12 @@
+// posix socket and arguments definitions
+// now all posix definitions are with P front like MSG -> PMSG, 
+// for better understanding and avoiding conflicts with other definitions
+mod msg_flag;
+mod option;
+mod option_level;
+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_*

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

@@ -9,10 +9,10 @@ pub enum Type {
     Packet = 10,
 }
 
-use crate::net::syscall_util::SysArgSocketType;
-impl TryFrom<SysArgSocketType> for Type {
+use crate::net::syscall_util::PosixArgsSocketType;
+impl TryFrom<PosixArgsSocketType> for Type {
     type Error = system_error::SystemError;
-    fn try_from(x: SysArgSocketType) -> Result<Self, Self::Error> {
+    fn try_from(x: PosixArgsSocketType) -> Result<Self, Self::Error> {
         use num_traits::FromPrimitive;
         return <Self as FromPrimitive>::from_u32(x.types().bits())
             .ok_or(system_error::SystemError::EINVAL);

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

@@ -10,27 +10,27 @@ lazy_static! {
     pub static ref INODE_MAP: RwLock<HashMap<InodeId, Endpoint>> = RwLock::new(HashMap::new());
 }
 
-fn create_unix_socket(sock_type: Type) -> Result<Arc<Inode>, SystemError> {
+fn create_unix_socket(sock_type: PSOCK) -> Result<Arc<Inode>, SystemError> {
     match sock_type {
-        Type::Stream | Type::Datagram => stream::StreamSocket::new_inode(),
-        Type::SeqPacket => seqpacket::SeqpacketSocket::new_inode(false),
+        PSOCK::Stream | PSOCK::Datagram => stream::StreamSocket::new_inode(),
+        PSOCK::SeqPacket => seqpacket::SeqpacketSocket::new_inode(false),
         _ => Err(EPROTONOSUPPORT),
     }
 }
 
 impl family::Family for Unix {
-    fn socket(stype: Type, _protocol: u32) -> Result<Arc<Inode>, SystemError> {
+    fn socket(stype: PSOCK, _protocol: u32) -> Result<Arc<Inode>, SystemError> {
         let socket = create_unix_socket(stype)?;
         Ok(socket)
     }
 }
 
 impl Unix {
-    pub fn new_pairs(socket_type: Type) -> Result<(Arc<Inode>, Arc<Inode>), SystemError> {
+    pub fn new_pairs(socket_type: PSOCK) -> Result<(Arc<Inode>, Arc<Inode>), SystemError> {
         // log::debug!("socket_type {:?}", socket_type);
         match socket_type {
-            Type::SeqPacket => seqpacket::SeqpacketSocket::new_pairs(),
-            Type::Stream | Type::Datagram => stream::StreamSocket::new_pairs(),
+            PSOCK::SeqPacket => seqpacket::SeqpacketSocket::new_pairs(),
+            PSOCK::Stream | PSOCK::Datagram => stream::StreamSocket::new_pairs(),
             _ => todo!(),
         }
     }

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

@@ -244,7 +244,7 @@ impl Socket for SeqpacketSocket {
 
     fn set_option(
         &self,
-        _level: crate::net::socket::OptionLevel,
+        _level: crate::net::socket::PSOL,
         _optname: usize,
         _optval: &[u8],
     ) -> Result<(), SystemError> {
@@ -294,7 +294,7 @@ impl Socket for SeqpacketSocket {
 
     fn get_option(
         &self,
-        _level: crate::net::socket::OptionLevel,
+        _level: crate::net::socket::PSOL,
         _name: usize,
         _value: &mut [u8],
     ) -> Result<usize, SystemError> {
@@ -303,18 +303,18 @@ impl Socket for SeqpacketSocket {
     }
 
     fn read(&self, buffer: &mut [u8]) -> Result<usize, SystemError> {
-        self.recv(buffer, crate::net::socket::MessageFlag::empty())
+        self.recv(buffer, crate::net::socket::PMSG::empty())
     }
 
     fn recv(
         &self,
         buffer: &mut [u8],
-        flags: crate::net::socket::MessageFlag,
+        flags: crate::net::socket::PMSG,
     ) -> Result<usize, SystemError> {
-        if flags.contains(MessageFlag::OOB) {
+        if flags.contains(PMSG::OOB) {
             return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
         }
-        if !flags.contains(MessageFlag::DONTWAIT) {
+        if !flags.contains(PMSG::DONTWAIT) {
             loop {
                 wq_wait_event_interruptible!(
                     self.wait_queue,
@@ -344,7 +344,7 @@ impl Socket for SeqpacketSocket {
     fn recv_msg(
         &self,
         _msg: &mut crate::net::syscall::MsgHdr,
-        _flags: crate::net::socket::MessageFlag,
+        _flags: crate::net::socket::PMSG,
     ) -> Result<usize, SystemError> {
         Err(SystemError::ENOSYS)
     }
@@ -352,15 +352,15 @@ impl Socket for SeqpacketSocket {
     fn send(
         &self,
         buffer: &[u8],
-        flags: crate::net::socket::MessageFlag,
+        flags: crate::net::socket::PMSG,
     ) -> Result<usize, SystemError> {
-        if flags.contains(MessageFlag::OOB) {
+        if flags.contains(PMSG::OOB) {
             return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
         }
         if self.is_peer_shutdown()? {
             return Err(SystemError::EPIPE);
         }
-        if !flags.contains(MessageFlag::DONTWAIT) {
+        if !flags.contains(PMSG::DONTWAIT) {
             loop {
                 match &*self.inner.write() {
                     Inner::Connected(connected) => match connected.try_write(buffer) {
@@ -384,26 +384,26 @@ impl Socket for SeqpacketSocket {
     fn send_msg(
         &self,
         _msg: &crate::net::syscall::MsgHdr,
-        _flags: crate::net::socket::MessageFlag,
+        _flags: crate::net::socket::PMSG,
     ) -> Result<usize, SystemError> {
         Err(SystemError::ENOSYS)
     }
 
     fn write(&self, buffer: &[u8]) -> Result<usize, SystemError> {
-        self.send(buffer, crate::net::socket::MessageFlag::empty())
+        self.send(buffer, crate::net::socket::PMSG::empty())
     }
 
     fn recv_from(
         &self,
         buffer: &mut [u8],
-        flags: MessageFlag,
+        flags: PMSG,
         _address: Option<Endpoint>,
     ) -> Result<(usize, Endpoint), SystemError> {
         // log::debug!("recvfrom flags {:?}", flags);
-        if flags.contains(MessageFlag::OOB) {
+        if flags.contains(PMSG::OOB) {
             return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
         }
-        if !flags.contains(MessageFlag::DONTWAIT) {
+        if !flags.contains(PMSG::DONTWAIT) {
             loop {
                 wq_wait_event_interruptible!(
                     self.wait_queue,

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

@@ -243,7 +243,7 @@ impl Socket for StreamSocket {
 
     fn set_option(
         &self,
-        _level: OptionLevel,
+        _level: PSOL,
         _optname: usize,
         _optval: &[u8],
     ) -> Result<(), SystemError> {
@@ -329,7 +329,7 @@ impl Socket for StreamSocket {
 
     fn get_option(
         &self,
-        _level: OptionLevel,
+        _level: PSOL,
         _name: usize,
         _value: &mut [u8],
     ) -> Result<usize, SystemError> {
@@ -338,11 +338,11 @@ impl Socket for StreamSocket {
     }
 
     fn read(&self, buffer: &mut [u8]) -> Result<usize, SystemError> {
-        self.recv(buffer, socket::MessageFlag::empty())
+        self.recv(buffer, socket::PMSG::empty())
     }
 
-    fn recv(&self, buffer: &mut [u8], flags: socket::MessageFlag) -> Result<usize, SystemError> {
-        if !flags.contains(MessageFlag::DONTWAIT) {
+    fn recv(&self, buffer: &mut [u8], flags: socket::PMSG) -> Result<usize, SystemError> {
+        if !flags.contains(PMSG::DONTWAIT) {
             loop {
                 log::debug!("socket try recv");
                 wq_wait_event_interruptible!(
@@ -373,13 +373,13 @@ impl Socket for StreamSocket {
     fn recv_from(
         &self,
         buffer: &mut [u8],
-        flags: socket::MessageFlag,
+        flags: socket::PMSG,
         _address: Option<Endpoint>,
     ) -> Result<(usize, Endpoint), SystemError> {
-        if flags.contains(MessageFlag::OOB) {
+        if flags.contains(PMSG::OOB) {
             return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
         }
-        if !flags.contains(MessageFlag::DONTWAIT) {
+        if !flags.contains(PMSG::DONTWAIT) {
             loop {
                 log::debug!("socket try recv from");
 
@@ -413,16 +413,16 @@ impl Socket for StreamSocket {
     fn recv_msg(
         &self,
         _msg: &mut crate::net::syscall::MsgHdr,
-        _flags: socket::MessageFlag,
+        _flags: socket::PMSG,
     ) -> Result<usize, SystemError> {
         Err(SystemError::ENOSYS)
     }
 
-    fn send(&self, buffer: &[u8], flags: socket::MessageFlag) -> Result<usize, SystemError> {
+    fn send(&self, buffer: &[u8], flags: socket::PMSG) -> Result<usize, SystemError> {
         if self.is_peer_shutdown()? {
             return Err(SystemError::EPIPE);
         }
-        if !flags.contains(MessageFlag::DONTWAIT) {
+        if !flags.contains(PMSG::DONTWAIT) {
             loop {
                 match &*self.inner.write() {
                     Inner::Connected(connected) => match connected.try_send(buffer) {
@@ -446,7 +446,7 @@ impl Socket for StreamSocket {
     fn send_msg(
         &self,
         _msg: &crate::net::syscall::MsgHdr,
-        _flags: socket::MessageFlag,
+        _flags: socket::PMSG,
     ) -> Result<usize, SystemError> {
         todo!()
     }
@@ -454,14 +454,14 @@ impl Socket for StreamSocket {
     fn send_to(
         &self,
         _buffer: &[u8],
-        _flags: socket::MessageFlag,
+        _flags: socket::PMSG,
         _address: Endpoint,
     ) -> Result<usize, SystemError> {
         Err(SystemError::ENOSYS)
     }
 
     fn write(&self, buffer: &[u8]) -> Result<usize, SystemError> {
-        self.send(buffer, socket::MessageFlag::empty())
+        self.send(buffer, socket::PMSG::empty())
     }
 
     fn send_buffer_size(&self) -> usize {

kernel/src/net/socket/utils.rs

@@ -5,7 +5,7 @@ use system_error::SystemError;
 
 pub fn create_socket(
     family: socket::AddressFamily,
-    socket_type: socket::Type,
+    socket_type: socket::PSOCK,
     protocol: u32,
     is_nonblock: bool,
     is_close_on_exec: bool,

kernel/src/net/syscall.rs

@@ -35,10 +35,10 @@ impl Syscall {
         //     protocol
         // );
         let address_family = socket::AddressFamily::try_from(address_family as u16)?;
-        let type_arg = SysArgSocketType::from_bits_truncate(socket_type as u32);
+        let type_arg = PosixArgsSocketType::from_bits_truncate(socket_type as u32);
         let is_nonblock = type_arg.is_nonblock();
         let is_close_on_exec = type_arg.is_cloexec();
-        let stype = socket::Type::try_from(type_arg)?;
+        let stype = socket::PSOCK::try_from(type_arg)?;
         // log::debug!("type_arg {:?}  stype {:?}", type_arg, stype);
 
         let inode = socket::create_socket(
@@ -73,8 +73,8 @@ impl Syscall {
         fds: &mut [i32],
     ) -> Result<usize, SystemError> {
         let address_family = AF::try_from(address_family as u16)?;
-        let socket_type = SysArgSocketType::from_bits_truncate(socket_type as u32);
-        let stype = socket::Type::try_from(socket_type)?;
+        let socket_type = PosixArgsSocketType::from_bits_truncate(socket_type as u32);
+        let stype = socket::PSOCK::try_from(socket_type)?;
 
         let binding = ProcessManager::current_pcb().fd_table();
         let mut fd_table_guard = binding.write();
@@ -112,7 +112,7 @@ impl Syscall {
         optname: usize,
         optval: &[u8],
     ) -> Result<usize, SystemError> {
-        let sol = socket::OptionLevel::try_from(level as u32)?;
+        let sol = socket::PSOL::try_from(level as u32)?;
         let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
@@ -142,14 +142,14 @@ impl Syscall {
             .get_socket(fd as i32)
             .ok_or(EBADF)?;
 
-        let level = socket::OptionLevel::try_from(level as u32)?;
+        use socket::{PSOL, PSO};
 
-        use socket::OptionLevel as SOL;
-        use socket::Options as SO;
-        if matches!(level, SOL::SOCKET) {
-            let optname = SO::try_from(optname as u32).map_err(|_| ENOPROTOOPT)?;
+        let level = PSOL::try_from(level as u32)?;
+
+        if matches!(level, PSOL::SOCKET) {
+            let optname = PSO::try_from(optname as u32).map_err(|_| ENOPROTOOPT)?;
             match optname {
-                SO::SNDBUF => {
+                PSO::SNDBUF => {
                     // 返回发送缓冲区大小
                     unsafe {
                         *optval = socket.send_buffer_size() as u32;
@@ -157,7 +157,7 @@ impl Syscall {
                     }
                     return Ok(0);
                 }
-                SO::RCVBUF => {
+                PSO::RCVBUF => {
                     // 返回默认的接收缓冲区大小
                     unsafe {
                         *optval = socket.recv_buffer_size() as u32;
@@ -178,7 +178,7 @@ impl Syscall {
         // to be interpreted by the TCP protocol, level should be set to the
         // protocol number of TCP.
 
-        if matches!(level, SOL::TCP) {
+        if matches!(level, PSOL::TCP) {
             use socket::inet::stream::TcpOption;
             let optname = TcpOption::try_from(optname as i32).map_err(|_| ENOPROTOOPT)?;
             match optname {
@@ -253,7 +253,7 @@ impl Syscall {
             Some(SockAddr::to_endpoint(addr, addrlen)?)
         };
 
-        let flags = socket::MessageFlag::from_bits_truncate(flags);
+        let flags = socket::PMSG::from_bits_truncate(flags);
 
         let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
@@ -285,7 +285,7 @@ impl Syscall {
         let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
-        let flags = socket::MessageFlag::from_bits_truncate(flags);
+        let flags = socket::PMSG::from_bits_truncate(flags);
 
         if addr.is_null() {
             let (n, _) = socket.recv_from(buf, flags, None)?;
@@ -327,7 +327,7 @@ impl Syscall {
         //     .get_socket(fd as i32)
         //     .ok_or(SystemError::EBADF)?;
 
-        // let flags = socket::MessageFlag::from_bits_truncate(flags as u32);
+        // let flags = socket::PMSG::from_bits_truncate(flags as u32);
 
         // let mut buf = iovs.new_buf(true);
         // // 从socket中读取数据

kernel/src/net/syscall_util.rs

@@ -1,6 +1,6 @@
 bitflags::bitflags! {
     // #[derive(PartialEq, Eq, Debug, Clone, Copy)]
-    pub struct SysArgSocketType: u32 {
+    pub struct PosixArgsSocketType: u32 {
         const DGRAM     = 1;    // 0b0000_0001
         const STREAM    = 2;    // 0b0000_0010
         const RAW       = 3;    // 0b0000_0011
@@ -14,20 +14,20 @@ bitflags::bitflags! {
     }
 }
 
-impl SysArgSocketType {
+impl PosixArgsSocketType {
     #[inline(always)]
-    pub fn types(&self) -> SysArgSocketType {
-        SysArgSocketType::from_bits(self.bits() & 0b_1111).unwrap()
+    pub fn types(&self) -> PosixArgsSocketType {
+        PosixArgsSocketType::from_bits(self.bits() & 0b_1111).unwrap()
     }
 
     #[inline(always)]
     pub fn is_nonblock(&self) -> bool {
-        self.contains(SysArgSocketType::NONBLOCK)
+        self.contains(PosixArgsSocketType::NONBLOCK)
     }
 
     #[inline(always)]
     pub fn is_cloexec(&self) -> bool {
-        self.contains(SysArgSocketType::CLOEXEC)
+        self.contains(PosixArgsSocketType::CLOEXEC)
     }
 }