DragonOS-Community/DragonOS
1
1
Fork 0
mirror of https://github.com/DragonOS-Community/DragonOS.git synced 2025-06-08 22:36:48 +00:00
Code Issues Releases Wiki Activity

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

Browse Source 
Signed-off-by: longjin <longjin@DragonOS.org>
This commit is contained in:
LoGin 2025-03-27 20:32:09 +08:00 committed by GitHub
parent 870c34c6f2
commit 8fef80f8ed
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
26 changed files with 400 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
kernel/src/filesystem/vfs/file.rs
View File

@ -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},
};

8
kernel/src/net/posix.rs
View File

@ -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)]

43
kernel/src/net/socket/base.rs
View File

@ -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

2
kernel/src/net/socket/endpoint.rs
View File

@ -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抽象端点

6
kernel/src/net/socket/family.rs
View File

@ -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>;
}

4
kernel/src/net/socket/inet/common/mod.rs
View File

@ -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 });
}

8
kernel/src/net/socket/inet/datagram/inner.rs
View File

@ -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;
}

31
kernel/src/net/socket/inet/datagram/mod.rs
View File

@ -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");
}

7
kernel/src/net/socket/inet/mod.rs
View File

@ -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

49
kernel/src/net/socket/inet/stream/inner.rs
View File

@ -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)
}
})
}

210
kernel/src/net/socket/inet/stream/mod.rs
View File

@ -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 => {}

36
kernel/src/net/socket/inet/syscall.rs
View File

@ -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))
}
}

13
kernel/src/net/socket/inode.rs
View File

@ -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()
// }

14
kernel/src/net/socket/mod.rs
View File

@ -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

2
kernel/src/net/socket/posix/mod.rs
View File

@ -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_*

4
kernel/src/net/socket/posix/types.rs
View File

@ -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;

18
kernel/src/net/socket/unix/mod.rs
View File

@ -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(),

3
kernel/src/net/socket/unix/ns/abs.rs
View File

@ -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;

19
kernel/src/net/socket/unix/seqpacket/inner.rs
View File

@ -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(),

124
kernel/src/net/socket/unix/seqpacket/mod.rs
View File

@ -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
}

14
kernel/src/net/socket/unix/stream/inner.rs
View File

@ -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));
}
}

41
kernel/src/net/socket/unix/stream/mod.rs
View File

@ -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!()
}

2
kernel/src/net/socket/utils.rs
View File

@ -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)?,

52
kernel/src/net/syscall.rs
View File

@ -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)?;

2
kernel/src/process/mod.rs
View File

@ -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,

3
kernel/src/syscall/mod.rs
View File

@ -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},