From 8fef80f8ede5242432157e6d085ac7eeac24bb44 Mon Sep 17 00:00:00 2001 From: LoGin Date: Thu, 27 Mar 2025 20:32:09 +0800 Subject: [PATCH] =?UTF-8?q?refactor:=20=E7=A7=BB=E9=99=A4=E7=BD=91?= =?UTF-8?q?=E7=BB=9C=E9=87=8D=E6=9E=84=E5=88=86=E6=94=AF=E4=B8=AD,use=20xx?= =?UTF-8?q?x::*=E7=9A=84=E5=86=85=E5=AE=B9=20(#1117)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: longjin --- kernel/src/filesystem/vfs/file.rs | 2 +- kernel/src/net/posix.rs | 8 +- kernel/src/net/socket/base.rs | 43 ++-- kernel/src/net/socket/endpoint.rs | 2 +- kernel/src/net/socket/family.rs | 6 +- kernel/src/net/socket/inet/common/mod.rs | 4 +- kernel/src/net/socket/inet/datagram/inner.rs | 8 +- kernel/src/net/socket/inet/datagram/mod.rs | 31 +-- kernel/src/net/socket/inet/mod.rs | 7 +- kernel/src/net/socket/inet/stream/inner.rs | 49 ++-- kernel/src/net/socket/inet/stream/mod.rs | 210 ++++++++++-------- kernel/src/net/socket/inet/syscall.rs | 36 ++- kernel/src/net/socket/inode.rs | 13 +- kernel/src/net/socket/mod.rs | 14 +- kernel/src/net/socket/posix/mod.rs | 2 +- kernel/src/net/socket/posix/types.rs | 4 +- kernel/src/net/socket/unix/mod.rs | 18 +- kernel/src/net/socket/unix/ns/abs.rs | 3 +- kernel/src/net/socket/unix/seqpacket/inner.rs | 19 +- kernel/src/net/socket/unix/seqpacket/mod.rs | 124 ++++++----- kernel/src/net/socket/unix/stream/inner.rs | 14 +- kernel/src/net/socket/unix/stream/mod.rs | 41 ++-- kernel/src/net/socket/utils.rs | 2 +- kernel/src/net/syscall.rs | 52 ++--- kernel/src/process/mod.rs | 2 +- kernel/src/syscall/mod.rs | 3 +- 26 files changed, 400 insertions(+), 317 deletions(-) diff --git a/kernel/src/filesystem/vfs/file.rs b/kernel/src/filesystem/vfs/file.rs index 0f3a301a..66e76be5 100644 --- a/kernel/src/filesystem/vfs/file.rs +++ b/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}, }; diff --git a/kernel/src/net/posix.rs b/kernel/src/net/posix.rs index 48024211..937273de 100644 --- a/kernel/src/net/posix.rs +++ b/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)] diff --git a/kernel/src/net/socket/base.rs b/kernel/src/net/socket/base.rs index a7215d1a..a772dacc 100644 --- a/kernel/src/net/socket/base.rs +++ b/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, Endpoint), SystemError> { - Err(ENOSYS) + fn accept(&self) -> Result<(Arc, 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 { - Err(ENOSYS) + Err(SystemError::ENOSYS) } /// # `get_name` /// 获取socket的地址 fn get_name(&self) -> Result { - 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 { - 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, ) -> Result<(usize, Endpoint), SystemError> { - Err(ENOSYS) + Err(SystemError::ENOSYS) } /// # `recv_msg` fn recv_msg(&self, msg: &mut MsgHdr, flags: PMSG) -> Result { - Err(ENOSYS) + Err(SystemError::ENOSYS) } // select /// # `send` fn send(&self, buffer: &[u8], flags: PMSG) -> Result { - Err(ENOSYS) + Err(SystemError::ENOSYS) } /// # `send_msg` fn send_msg(&self, msg: &MsgHdr, flags: PMSG) -> Result { - Err(ENOSYS) + Err(SystemError::ENOSYS) } /// # `send_to` fn send_to(&self, buffer: &[u8], flags: PMSG, address: Endpoint) -> Result { - 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 diff --git a/kernel/src/net/socket/endpoint.rs b/kernel/src/net/socket/endpoint.rs index e64d048c..35fa06bd 100644 --- a/kernel/src/net/socket/endpoint.rs +++ b/kernel/src/net/socket/endpoint.rs @@ -12,7 +12,7 @@ pub enum Endpoint { /// 网络层端点 Ip(IpEndpoint), /// inode端点,Unix实际保存的端点 - Inode((Arc, String)), + Inode((Arc, String)), /// Unix传递id索引和path所用的端点 Unixpath((InodeId, String)), /// Unix抽象端点 diff --git a/kernel/src/net/socket/family.rs b/kernel/src/net/socket/family.rs index d753d25c..26200961 100644 --- a/kernel/src/net/socket/family.rs +++ b/kernel/src/net/socket/family.rs @@ -114,9 +114,11 @@ impl core::convert::TryFrom 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, system_error::SystemError>; + ) -> Result, system_error::SystemError>; } diff --git a/kernel/src/net/socket/inet/common/mod.rs b/kernel/src/net/socket/inet/common/mod.rs index 455503fb..581e1269 100644 --- a/kernel/src/net/socket/inet/common/mod.rs +++ b/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 }); } diff --git a/kernel/src/net/socket/inet/datagram/inner.rs b/kernel/src/net/socket/inet/datagram/inner.rs index d883cd14..de1c3bd6 100644 --- a/kernel/src/net/socket/inet/datagram/inner.rs +++ b/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, ) -> Result { - 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; } diff --git a/kernel/src/net/socket/inet/datagram/mod.rs b/kernel/src/net/socket/inet/datagram/mod.rs index f0e4f42c..b98b87ee 100644 --- a/kernel/src/net/socket/inet/datagram/mod.rs +++ b/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 { @@ -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 { @@ -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"); } diff --git a/kernel/src/net/socket/inet/mod.rs b/kernel/src/net/socket/inet/mod.rs index 1955234e..8c1d504a 100644 --- a/kernel/src/net/socket/inet/mod.rs +++ b/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 diff --git a/kernel/src/net/socket/inet/stream/inner.rs b/kernel/src/net/socket/inet/stream/inner.rs index 5146a913..b9252f24 100644 --- a/kernel/src/net/socket/inet/stream/inner.rs +++ b/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::(|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 { 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::(|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::(|socket| !socket.is_active()) { - return Err(EAGAIN_OR_EWOULDBLOCK); + return Err(SystemError::EAGAIN_OR_EWOULDBLOCK); } let remote_endpoint = connected.with::(|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::(|socket| socket.close()); @@ -410,18 +418,17 @@ impl Established { pub fn recv_slice(&self, buf: &mut [u8]) -> Result { self.inner .with_mut::(|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::(|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) } }) } diff --git a/kernel/src/net/socket/inet/stream/mod.rs b/kernel/src/net/socket/inet/stream/mod.rs index 97b56752..a9193ae5 100644 --- a/kernel/src/net/socket/inet/stream/mod.rs +++ b/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>, + inner: RwLock>, #[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 { 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 { + pub fn new_established(inner: inner::Established, nonblock: bool) -> Arc { 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, 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 { // 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 { - 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 { - 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, Endpoint), SystemError> { + fn accept(&self) -> Result<(Arc, 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 { @@ -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 => {} diff --git a/kernel/src/net/socket/inet/syscall.rs b/kernel/src/net/socket/inet/syscall.rs index 2cf142a0..46c3a067 100644 --- a/kernel/src/net/socket/inet/syscall.rs +++ b/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, 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, SystemError> { + fn socket(stype: PSOCK, protocol: u32) -> Result, 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, SystemError> { + fn socket(stype: PSOCK, protocol: u32) -> Result, 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)) } } diff --git a/kernel/src/net/socket/inode.rs b/kernel/src/net/socket/inode.rs index 7deb7e92..8fabf5ea 100644 --- a/kernel/src/net/socket/inode.rs +++ b/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, 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() // } diff --git a/kernel/src/net/socket/mod.rs b/kernel/src/net/socket/mod.rs index 4c8b628d..96d16c44 100644 --- a/kernel/src/net/socket/mod.rs +++ b/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 diff --git a/kernel/src/net/socket/posix/mod.rs b/kernel/src/net/socket/posix/mod.rs index 8c1f6e51..45a138bb 100644 --- a/kernel/src/net/socket/posix/mod.rs +++ b/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_* diff --git a/kernel/src/net/socket/posix/types.rs b/kernel/src/net/socket/posix/types.rs index c27552d7..78553f49 100644 --- a/kernel/src/net/socket/posix/types.rs +++ b/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 for Type { +impl TryFrom for PSOCK { type Error = system_error::SystemError; fn try_from(x: PosixArgsSocketType) -> Result { use num_traits::FromPrimitive; diff --git a/kernel/src/net/socket/unix/mod.rs b/kernel/src/net/socket/unix/mod.rs index c50d4620..ac99ba36 100644 --- a/kernel/src/net/socket/unix/mod.rs +++ b/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> = RwLock::new(HashMap::new()); } -fn create_unix_socket(sock_type: PSOCK) -> Result, SystemError> { +fn create_unix_socket(sock_type: PSOCK) -> Result, 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, SystemError> { +impl Family for Unix { + fn socket(stype: PSOCK, _protocol: u32) -> Result, SystemError> { let socket = create_unix_socket(stype)?; Ok(socket) } } impl Unix { - pub fn new_pairs(socket_type: PSOCK) -> Result<(Arc, Arc), SystemError> { + pub fn new_pairs( + socket_type: PSOCK, + ) -> Result<(Arc, Arc), SystemError> { // log::debug!("socket_type {:?}", socket_type); match socket_type { PSOCK::SeqPacket => seqpacket::SeqpacketSocket::new_pairs(), diff --git a/kernel/src/net/socket/unix/ns/abs.rs b/kernel/src/net/socket/unix/ns/abs.rs index dc7ebcd4..c62493ab 100644 --- a/kernel/src/net/socket/unix/ns/abs.rs +++ b/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; diff --git a/kernel/src/net/socket/unix/seqpacket/inner.rs b/kernel/src/net/socket/unix/seqpacket/inner.rs index b7a9c545..8294b0dc 100644 --- a/kernel/src/net/socket/unix/seqpacket/inner.rs +++ b/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 { 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>>, + incoming_conns: Mutex>>, } impl Listener { @@ -73,7 +74,7 @@ impl Listener { return &self.inode; } - pub(super) fn try_accept(&self) -> Result<(Arc, Endpoint), SystemError> { + pub(super) fn try_accept(&self) -> Result<(Arc, 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(), diff --git a/kernel/src/net/socket/unix/seqpacket/mod.rs b/kernel/src/net/socket/unix/seqpacket/mod.rs index 718cfc7f..3ad63086 100644 --- a/kernel/src/net/socket/unix/seqpacket/mod.rs +++ b/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: RwLock, shutdown: Shutdown, is_nonblocking: AtomicBool, wait_queue: WaitQueue, @@ -32,7 +46,7 @@ impl SeqpacketSocket { pub fn new(is_nonblocking: bool) -> Arc { 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, SystemError> { + pub fn new_inode(is_nonblocking: bool) -> Result, 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 { + pub fn new_connected(connected: inner::Connected, is_nonblocking: bool) -> Arc { 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, Arc), SystemError> { + pub fn new_pairs() -> Result<(Arc, Arc), 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, Endpoint), SystemError> { + fn try_accept(&self) -> Result<(Arc, 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 { 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, Endpoint), SystemError> { + fn accept(&self) -> Result<(Arc, 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 { // 获取对端地址 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 { // 获取本端地址 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 { 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 { 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 } diff --git a/kernel/src/net/socket/unix/stream/inner.rs b/kernel/src/net/socket/unix/stream/inner.rs index 7b37ee73..a10e6973 100644 --- a/kernel/src/net/socket/unix/stream/inner.rs +++ b/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, - incoming_connects: Mutex>>, + incoming_connects: Mutex>>, backlog: AtomicUsize, } @@ -201,7 +203,7 @@ impl Listener { return Ok(()); } - pub fn push_incoming(&self, server_inode: Arc) -> Result<(), SystemError> { + pub fn push_incoming(&self, server_inode: Arc) -> 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> { + pub fn pop_incoming(&self) -> Option> { 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, Endpoint), SystemError> { + pub(super) fn try_accept(&self) -> Result<(Arc, 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)); } } diff --git a/kernel/src/net/socket/unix/stream/mod.rs b/kernel/src/net/socket/unix/stream/mod.rs index 0d358dcc..4ce34fce 100644 --- a/kernel/src/net/socket/unix/stream/mod.rs +++ b/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, Arc), SystemError> { + pub fn new_pairs() -> Result<(Arc, Arc), 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, SystemError> { + pub fn new_inode() -> Result, 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, Endpoint), SystemError> { + pub fn try_accept(&self) -> Result<(Arc, 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, Endpoint), SystemError> { + fn accept(&self) -> Result<(Arc, 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 { + fn recv_msg(&self, _msg: &mut MsgHdr, _flags: socket::PMSG) -> Result { Err(SystemError::ENOSYS) } @@ -523,11 +528,7 @@ impl Socket for StreamSocket { } } - fn send_msg( - &self, - _msg: &crate::net::syscall::MsgHdr, - _flags: socket::PMSG, - ) -> Result { + fn send_msg(&self, _msg: &MsgHdr, _flags: socket::PMSG) -> Result { todo!() } diff --git a/kernel/src/net/socket/utils.rs b/kernel/src/net/socket/utils.rs index 7e14d88c..372106d4 100644 --- a/kernel/src/net/socket/utils.rs +++ b/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, SystemError> { +) -> Result, SystemError> { type AF = socket::AddressFamily; let inode = match family { AF::INet => socket::inet::Inet::socket(socket_type, protocol)?, diff --git a/kernel/src/net/syscall.rs b/kernel/src/net/syscall.rs index dd386e27..47e1e2d4 100644 --- a/kernel/src/net/syscall.rs +++ b/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 { - 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 { let sol = socket::PSOL::try_from(level as u32)?; - let socket: Arc = ProcessManager::current_pcb() + let socket: Arc = ProcessManager::current_pcb() .get_socket(fd as i32) .ok_or(SystemError::EBADF)?; debug!("setsockopt: level = {:?} ", sol); @@ -138,16 +139,16 @@ impl Syscall { ) -> Result { // 获取socket let optval = optval as *mut u32; - let socket: Arc = ProcessManager::current_pcb() + let socket: Arc = 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 { let endpoint: Endpoint = SockAddr::to_endpoint(addr, addrlen)?; - let socket: Arc = 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 = ProcessManager::current_pcb() + let socket: Arc = 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 = ProcessManager::current_pcb() + let socket: Arc = 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 { - let socket: Arc = ProcessManager::current_pcb() + let socket: Arc = 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 = ProcessManager::current_pcb() + let socket: Arc = 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 { - let socket: Arc = ProcessManager::current_pcb() + let socket: Arc = 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 { - let socket: Arc = ProcessManager::current_pcb() + let socket: Arc = 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 { - let socket: Arc = ProcessManager::current_pcb() + let socket: Arc = 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 = ProcessManager::current_pcb() + let socket: Arc = ProcessManager::current_pcb() .get_socket(fd as i32) .ok_or(SystemError::EBADF)?; diff --git a/kernel/src/process/mod.rs b/kernel/src/process/mod.rs index cab08196..d7f80057 100644 --- a/kernel/src/process/mod.rs +++ b/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, diff --git a/kernel/src/syscall/mod.rs b/kernel/src/syscall/mod.rs index d755abca..95feb754 100644 --- a/kernel/src/syscall/mod.rs +++ b/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},