DragonOS-Community/DragonOS
1
1
Fork 0
mirror of https://github.com/DragonOS-Community/DragonOS.git synced 2025-06-08 18:26: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}, libs::{rwlock::RwLock, spinlock::SpinLock},
net::{ net::{
event_poll::{EPollItem, EPollPrivateData, EventPoll}, event_poll::{EPollItem, EPollPrivateData, EventPoll},
socket::Inode as SocketInode, socket::SocketInode,
}, },
process::{cred::Cred, ProcessManager}, process::{cred::Cred, ProcessManager},
}; };

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

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

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

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

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

@ -12,7 +12,7 @@ pub enum Endpoint {
/// 网络层端点 /// 网络层端点
Ip(IpEndpoint), Ip(IpEndpoint),
/// inode端点,Unix实际保存的端点 /// inode端点,Unix实际保存的端点
Inode((Arc<socket::Inode>, String)), Inode((Arc<socket::SocketInode>, String)),
/// Unix传递id索引和path所用的端点 /// Unix传递id索引和path所用的端点
Unixpath((InodeId, String)), Unixpath((InodeId, String)),
/// Unix抽象端点 /// 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 crate::net::socket;
use alloc::sync::Arc; use alloc::sync::Arc;
use super::PSOCK;
pub trait Family { pub trait Family {
fn socket( fn socket(
stype: socket::PSOCK, stype: PSOCK,
protocol: u32, 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 crate::net::{Iface, NET_DEVICES};
use alloc::sync::Arc; use alloc::sync::Arc;
use system_error::SystemError::{self, *};
pub mod port; pub mod port;
pub use port::PortManager; pub use port::PortManager;
use system_error::SystemError;
#[allow(dead_code)] #[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq)] #[derive(Debug, Clone, Copy, PartialEq)]
@ -56,7 +56,7 @@ impl BoundInner {
let handle = iface.sockets().lock_irqsave().add(socket); let handle = iface.sockets().lock_irqsave().add(socket);
return Ok(Self { handle, iface }); return Ok(Self { handle, iface });
} else { } 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); let handle = iface.sockets().lock_irqsave().add(socket);
return Ok(Self { handle, iface }); return Ok(Self { handle, iface });
} }

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

@ -1,5 +1,5 @@
use smoltcp; use smoltcp;
use system_error::SystemError::{self, *}; use system_error::SystemError;
use crate::{ use crate::{
libs::spinlock::SpinLock, libs::spinlock::SpinLock,
@ -118,7 +118,7 @@ impl BoundUdp {
return Ok((size, metadata.endpoint)); return Ok((size, metadata.endpoint));
} }
} }
return Err(EAGAIN_OR_EWOULDBLOCK); return Err(SystemError::EAGAIN_OR_EWOULDBLOCK);
}) })
} }
@ -127,13 +127,13 @@ impl BoundUdp {
buf: &[u8], buf: &[u8],
to: Option<smoltcp::wire::IpEndpoint>, to: Option<smoltcp::wire::IpEndpoint>,
) -> Result<usize, SystemError> { ) -> 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| { let result = self.with_mut_socket(|socket| {
if socket.can_send() && socket.send_slice(buf, remote).is_ok() { if socket.can_send() && socket.send_slice(buf, remote).is_ok() {
log::debug!("send {} bytes", buf.len()); log::debug!("send {} bytes", buf.len());
return Ok(buf.len()); return Ok(buf.len());
} }
return Err(ENOBUFS); return Err(SystemError::ENOBUFS);
}); });
return result; 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 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::event_poll::EPollEventType;
use crate::net::net_core::poll_ifaces; 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 alloc::sync::{Arc, Weak};
use core::sync::atomic::AtomicBool; use core::sync::atomic::AtomicBool;
pub mod inner; use super::InetSocket;
use inner::*; pub mod inner;
type EP = EPollEventType; type EP = EPollEventType;
@ -51,7 +52,7 @@ impl UdpSocket {
*inner = Some(UdpInner::Bound(bound)); *inner = Some(UdpInner::Bound(bound));
return Ok(()); return Ok(());
} }
return Err(EINVAL); return Err(SystemError::EINVAL);
} }
pub fn bind_emphemeral(&self, remote: smoltcp::wire::IpAddress) -> Result<(), SystemError> { pub fn bind_emphemeral(&self, remote: smoltcp::wire::IpAddress) -> Result<(), SystemError> {
@ -91,7 +92,7 @@ impl UdpSocket {
poll_ifaces(); poll_ifaces();
ret ret
} }
_ => Err(ENOTCONN), _ => Err(SystemError::ENOTCONN),
} }
} }
@ -116,7 +117,7 @@ impl UdpSocket {
let inner = match inner_guard.take().expect("Udp Inner is None") { let inner = match inner_guard.take().expect("Udp Inner is None") {
UdpInner::Bound(bound) => bound, UdpInner::Bound(bound) => bound,
UdpInner::Unbound(unbound) => { 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)?; // size = inner.try_send(buf, to)?;
@ -125,7 +126,7 @@ impl UdpSocket {
// Optimize: 拿两次锁的平均效率是否比一次长时间的读锁效率要高？ // Optimize: 拿两次锁的平均效率是否比一次长时间的读锁效率要高？
let result = match self.inner.read().as_ref().expect("Udp Inner is None") { let result = match self.inner.read().as_ref().expect("Udp Inner is None") {
UdpInner::Bound(bound) => bound.try_send(buf, to), UdpInner::Bound(bound) => bound.try_send(buf, to),
_ => Err(ENOTCONN), _ => Err(SystemError::ENOTCONN),
}; };
poll_ifaces(); poll_ifaces();
return result; return result;
@ -167,7 +168,7 @@ impl Socket for UdpSocket {
if let Endpoint::Ip(local_endpoint) = local_endpoint { if let Endpoint::Ip(local_endpoint) = local_endpoint {
return self.do_bind(local_endpoint); return self.do_bind(local_endpoint);
} }
Err(EAFNOSUPPORT) Err(SystemError::EAFNOSUPPORT)
} }
fn send_buffer_size(&self) -> usize { fn send_buffer_size(&self) -> usize {
@ -197,7 +198,7 @@ impl Socket for UdpSocket {
panic!(""); panic!("");
} }
} }
return Err(EAFNOSUPPORT); return Err(SystemError::EAFNOSUPPORT);
} }
fn send(&self, buffer: &[u8], flags: PMSG) -> Result<usize, SystemError> { 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 self.try_send(buffer, Some(remote));
} }
return Err(EINVAL); return Err(SystemError::EINVAL);
} }
fn recv(&self, buffer: &mut [u8], flags: PMSG) -> Result<usize, SystemError> { fn recv(&self, buffer: &mut [u8], flags: PMSG) -> Result<usize, SystemError> {
@ -228,7 +229,7 @@ impl Socket for UdpSocket {
} else { } else {
loop { loop {
match self.try_recv(buffer) { match self.try_recv(buffer) {
Err(EAGAIN_OR_EWOULDBLOCK) => { Err(SystemError::EAGAIN_OR_EWOULDBLOCK) => {
wq_wait_event_interruptible!(self.wait_queue, self.can_recv(), {})?; wq_wait_event_interruptible!(self.wait_queue, self.can_recv(), {})?;
} }
result => break result, result => break result,
@ -255,7 +256,7 @@ impl Socket for UdpSocket {
} else { } else {
loop { loop {
match self.try_recv(buffer) { match self.try_recv(buffer) {
Err(EAGAIN_OR_EWOULDBLOCK) => { Err(SystemError::EAGAIN_OR_EWOULDBLOCK) => {
wq_wait_event_interruptible!(self.wait_queue, self.can_recv(), {})?; wq_wait_event_interruptible!(self.wait_queue, self.can_recv(), {})?;
log::debug!("UdpSocket::recv_from: wake up"); 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 common::Types;
// pub use raw::RawSocket; // pub use raw::RawSocket;
pub use datagram::UdpSocket; 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 stream::TcpSocket;
pub use syscall::Inet; pub use syscall::Inet;
use super::Socket; use super::Socket;
use smoltcp::wire::*;
/// A local endpoint, which indicates that the local endpoint is unspecified. /// 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 /// 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::boxed::Box;
use alloc::vec::Vec; use alloc::vec::Vec;
use smoltcp; 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_METADATA_BUF_SIZE: usize = 1024;
pub const DEFAULT_RX_BUF_SIZE: usize = 512 * 1024; pub const DEFAULT_RX_BUF_SIZE: usize = 512 * 1024;
@ -68,7 +69,7 @@ impl Init {
} }
Init::Bound(_) => { Init::Bound(_) => {
log::debug!("Already 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); let endpoint = smoltcp::wire::IpEndpoint::new(address, bound_port);
Ok((bound, endpoint)) Ok((bound, endpoint))
} }
Init::Bound(_) => Err((self, EINVAL)), Init::Bound(_) => Err((self, SystemError::EINVAL)),
} }
} }
@ -102,7 +103,7 @@ impl Init {
Init::Bound(inner) => inner, Init::Bound(inner) => inner,
}; };
if local.addr.is_unspecified() { 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| { let result = inner.with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
socket socket
@ -111,7 +112,7 @@ impl Init {
remote_endpoint, remote_endpoint,
local, local,
) )
.map_err(|_| ECONNREFUSED) .map_err(|_| SystemError::ECONNREFUSED)
}); });
match result { match result {
Ok(_) => Ok(Connecting::new(inner)), Ok(_) => Ok(Connecting::new(inner)),
@ -123,7 +124,7 @@ impl Init {
pub(super) fn listen(self, backlog: usize) -> Result<Listening, (Self, SystemError)> { pub(super) fn listen(self, backlog: usize) -> Result<Listening, (Self, SystemError)> {
let (inner, local) = match self { let (inner, local) = match self {
Init::Unbound(_) => { Init::Unbound(_) => {
return Err((self, EINVAL)); return Err((self, SystemError::EINVAL));
} }
Init::Bound(inner) => inner, Init::Bound(inner) => inner,
}; };
@ -154,7 +155,9 @@ impl Init {
} }
if let Err(err) = inner.with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| { 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)); return Err((Init::Bound((inner, local)), err));
} }
@ -208,15 +211,20 @@ impl Connecting {
} }
pub fn into_result(self) -> (Inner, Result<(), SystemError>) { pub fn into_result(self) -> (Inner, Result<(), SystemError>) {
use ConnectResult::*;
let result = *self.result.read_irqsave(); let result = *self.result.read_irqsave();
match result { match result {
Connecting => (Inner::Connecting(self), Err(EAGAIN_OR_EWOULDBLOCK)), ConnectResult::Connecting => (
Connected => ( Inner::Connecting(self),
Err(SystemError::EAGAIN_OR_EWOULDBLOCK),
),
ConnectResult::Connected => (
Inner::Established(Established { inner: self.inner }), Inner::Established(Established { inner: self.inner }),
Ok(()), 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(); .unwrap();
if connected.with::<smoltcp::socket::tcp::Socket, _, _>(|socket| !socket.is_active()) { 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| { let remote_endpoint = connected.with::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
@ -354,7 +362,7 @@ impl Listening {
} }
pub fn close(&self) { pub fn close(&self) {
log::debug!("Close Listening Socket"); // log::debug!("Close Listening Socket");
let port = self.get_name().port; let port = self.get_name().port;
for inner in self.inners.iter() { for inner in self.inners.iter() {
inner.with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| socket.close()); 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> { pub fn recv_slice(&self, buf: &mut [u8]) -> Result<usize, SystemError> {
self.inner self.inner
.with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| { .with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
use smoltcp::socket::tcp::RecvError::*;
if socket.can_send() { if socket.can_send() {
match socket.recv_slice(buf) { match socket.recv_slice(buf) {
Ok(size) => Ok(size), Ok(size) => Ok(size),
Err(InvalidState) => { Err(tcp::RecvError::InvalidState) => {
log::error!("TcpSocket::try_recv: InvalidState"); log::error!("TcpSocket::try_recv: InvalidState");
Err(ENOTCONN) Err(SystemError::ENOTCONN)
} }
Err(Finished) => Ok(0), Err(tcp::RecvError::Finished) => Ok(0),
} }
} else { } else {
Err(ENOBUFS) Err(SystemError::ENOBUFS)
} }
}) })
} }
@ -430,9 +437,11 @@ impl Established {
self.inner self.inner
.with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| { .with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
if socket.can_send() { if socket.can_send() {
socket.send_slice(buf).map_err(|_| ECONNABORTED) socket
.send_slice(buf)
.map_err(|_| SystemError::ECONNABORTED)
} else { } 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 alloc::sync::{Arc, Weak};
use core::sync::atomic::{AtomicBool, AtomicUsize}; 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::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 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; use smoltcp;
mod inner; mod inner;
use inner::*;
mod option; mod option;
pub use option::Options as TcpOption; pub use option::Options as TcpOption;
use super::{InetSocket, UNSPECIFIED_LOCAL_ENDPOINT_V4, UNSPECIFIED_LOCAL_ENDPOINT_V6};
type EP = EPollEventType; type EP = EPollEventType;
#[derive(Debug)] #[derive(Debug)]
pub struct TcpSocket { pub struct TcpSocket {
inner: RwLock<Option<Inner>>, inner: RwLock<Option<inner::Inner>>,
#[allow(dead_code)] #[allow(dead_code)]
shutdown: Shutdown, // TODO set shutdown status shutdown: Shutdown, // TODO set shutdown status
nonblock: AtomicBool, nonblock: AtomicBool,
@ -30,7 +33,7 @@ pub struct TcpSocket {
impl TcpSocket { impl TcpSocket {
pub fn new(_nonblock: bool, ver: smoltcp::wire::IpVersion) -> Arc<Self> { pub fn new(_nonblock: bool, ver: smoltcp::wire::IpVersion) -> Arc<Self> {
Arc::new_cyclic(|me| 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(), shutdown: Shutdown::new(),
nonblock: AtomicBool::new(false), nonblock: AtomicBool::new(false),
wait_queue: WaitQueue::default(), 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 { Arc::new_cyclic(|me| Self {
inner: RwLock::new(Some(Inner::Established(inner))), inner: RwLock::new(Some(inner::Inner::Established(inner))),
shutdown: Shutdown::new(), shutdown: Shutdown::new(),
nonblock: AtomicBool::new(nonblock), nonblock: AtomicBool::new(nonblock),
wait_queue: WaitQueue::default(), wait_queue: WaitQueue::default(),
@ -56,38 +59,38 @@ impl TcpSocket {
pub fn do_bind(&self, local_endpoint: smoltcp::wire::IpEndpoint) -> Result<(), SystemError> { pub fn do_bind(&self, local_endpoint: smoltcp::wire::IpEndpoint) -> Result<(), SystemError> {
let mut writer = self.inner.write(); let mut writer = self.inner.write();
match writer.take().expect("Tcp Inner is None") { match writer.take().expect("Tcp inner::Inner is None") {
Inner::Init(inner) => { inner::Inner::Init(inner) => {
let bound = inner.bind(local_endpoint)?; let bound = inner.bind(local_endpoint)?;
if let Init::Bound((ref bound, _)) = bound { if let inner::Init::Bound((ref bound, _)) = bound {
bound bound
.iface() .iface()
.common() .common()
.bind_socket(self.self_ref.upgrade().unwrap()); .bind_socket(self.self_ref.upgrade().unwrap());
} }
writer.replace(Inner::Init(bound)); writer.replace(inner::Inner::Init(bound));
Ok(()) Ok(())
} }
any => { any => {
writer.replace(any); writer.replace(any);
log::error!("TcpSocket::do_bind: not Init"); log::error!("TcpSocket::do_bind: not Init");
Err(EINVAL) Err(SystemError::EINVAL)
} }
} }
} }
pub fn do_listen(&self, backlog: usize) -> Result<(), SystemError> { pub fn do_listen(&self, backlog: usize) -> Result<(), SystemError> {
let mut writer = self.inner.write(); 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 { let (listening, err) = match inner {
Inner::Init(init) => { inner::Inner::Init(init) => {
let listen_result = init.listen(backlog); let listen_result = init.listen(backlog);
match listen_result { match listen_result {
Ok(listening) => (Inner::Listening(listening), None), Ok(listening) => (inner::Inner::Listening(listening), None),
Err((init, err)) => (Inner::Init(init), Some(err)), Err((init, err)) => (inner::Inner::Init(init), Some(err)),
} }
} }
_ => (inner, Some(EINVAL)), _ => (inner, Some(SystemError::EINVAL)),
}; };
writer.replace(listening); writer.replace(listening);
drop(writer); drop(writer);
@ -99,14 +102,19 @@ impl TcpSocket {
} }
pub fn try_accept(&self) -> Result<(Arc<TcpSocket>, smoltcp::wire::IpEndpoint), SystemError> { pub fn try_accept(&self) -> Result<(Arc<TcpSocket>, smoltcp::wire::IpEndpoint), SystemError> {
match self.inner.write().as_mut().expect("Tcp Inner is None") { match self
Inner::Listening(listening) => listening.accept().map(|(stream, remote)| { .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()), TcpSocket::new_established(stream, self.is_nonblock()),
remote, remote,
) )
}), }),
_ => Err(EINVAL), _ => Err(SystemError::EINVAL),
} }
} }
@ -116,32 +124,37 @@ impl TcpSocket {
remote_endpoint: smoltcp::wire::IpEndpoint, remote_endpoint: smoltcp::wire::IpEndpoint,
) -> Result<(), SystemError> { ) -> Result<(), SystemError> {
let mut writer = self.inner.write(); 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 { let (init, result) = match inner {
Inner::Init(init) => { inner::Inner::Init(init) => {
let conn_result = init.connect(remote_endpoint); let conn_result = init.connect(remote_endpoint);
match conn_result { match conn_result {
Ok(connecting) => ( Ok(connecting) => (
Inner::Connecting(connecting), inner::Inner::Connecting(connecting),
if !self.is_nonblock() { if !self.is_nonblock() {
Ok(()) Ok(())
} else { } 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::Inner::Connecting(connecting) if self.is_nonblock() => (
(Inner::Connecting(connecting), Err(EALREADY)) 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 { match result {
Ok(()) | Err(EINPROGRESS) => { Ok(()) | Err(SystemError::EINPROGRESS) => {
init.iface().unwrap().poll(); init.iface().unwrap().poll();
} }
_ => {} _ => {}
@ -154,9 +167,10 @@ impl TcpSocket {
// for irq use // for irq use
pub fn finish_connect(&self) -> Result<(), SystemError> { pub fn finish_connect(&self) -> Result<(), SystemError> {
let mut writer = self.inner.write(); 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"); log::error!("TcpSocket::finish_connect: not Connecting");
return Err(EINVAL); return Err(SystemError::EINVAL);
}; };
let (inner, result) = conn.into_result(); let (inner, result) = conn.into_result();
@ -169,16 +183,16 @@ impl TcpSocket {
pub fn check_connect(&self) -> Result<(), SystemError> { pub fn check_connect(&self) -> Result<(), SystemError> {
self.update_events(); self.update_events();
let mut write_state = self.inner.write(); 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 { let (replace, result) = match inner {
Inner::Connecting(conn) => conn.into_result(), inner::Inner::Connecting(conn) => conn.into_result(),
Inner::Established(es) => { inner::Inner::Established(es) => {
log::warn!("TODO: check new established"); log::warn!("TODO: check new established");
(Inner::Established(es), Ok(())) (inner::Inner::Established(es), Ok(()))
} // TODO check established } // TODO check established
_ => { _ => {
log::warn!("TODO: connecting socket error options"); log::warn!("TODO: connecting socket error options");
(inner, Err(EINVAL)) (inner, Err(SystemError::EINVAL))
} // TODO socket error options } // TODO socket error options
}; };
write_state.replace(replace); write_state.replace(replace);
@ -192,8 +206,8 @@ impl TcpSocket {
.map(|inner| { .map(|inner| {
inner.iface().unwrap().poll(); inner.iface().unwrap().poll();
let result = match inner { let result = match inner {
Inner::Established(inner) => inner.recv_slice(buf), inner::Inner::Established(inner) => inner.recv_slice(buf),
_ => Err(EINVAL), _ => Err(SystemError::EINVAL),
}; };
inner.iface().unwrap().poll(); inner.iface().unwrap().poll();
result result
@ -203,23 +217,33 @@ impl TcpSocket {
pub fn try_send(&self, buf: &[u8]) -> Result<usize, SystemError> { pub fn try_send(&self, buf: &[u8]) -> Result<usize, SystemError> {
// TODO: add nonblock check of connecting socket // TODO: add nonblock check of connecting socket
let sent = match self.inner.read().as_ref().expect("Tcp Inner is None") { let sent = match self
Inner::Established(inner) => inner.send_slice(buf), .inner
_ => Err(EINVAL), .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(); self.inner.read().as_ref().unwrap().iface().unwrap().poll();
sent sent
} }
fn update_events(&self) -> bool { fn update_events(&self) -> bool {
match self.inner.read().as_ref().expect("Tcp Inner is None") { match self
Inner::Init(_) => false, .inner
Inner::Connecting(connecting) => connecting.update_io_events(), .read()
Inner::Established(established) => { .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); established.update_io_events(&self.pollee);
false false
} }
Inner::Listening(listening) => { inner::Inner::Listening(listening) => {
listening.update_io_events(&self.pollee); listening.update_io_events(&self.pollee);
false false
} }
@ -237,24 +261,34 @@ impl Socket for TcpSocket {
} }
fn get_name(&self) -> Result<Endpoint, SystemError> { fn get_name(&self) -> Result<Endpoint, SystemError> {
match self.inner.read().as_ref().expect("Tcp Inner is None") { match self
Inner::Init(Init::Unbound((_, ver))) => Ok(Endpoint::Ip(match ver { .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::Ipv4 => UNSPECIFIED_LOCAL_ENDPOINT_V4,
smoltcp::wire::IpVersion::Ipv6 => UNSPECIFIED_LOCAL_ENDPOINT_V6, smoltcp::wire::IpVersion::Ipv6 => UNSPECIFIED_LOCAL_ENDPOINT_V6,
})), })),
Inner::Init(Init::Bound((_, local))) => Ok(Endpoint::Ip(*local)), inner::Inner::Init(inner::Init::Bound((_, local))) => Ok(Endpoint::Ip(*local)),
Inner::Connecting(connecting) => Ok(Endpoint::Ip(connecting.get_name())), inner::Inner::Connecting(connecting) => Ok(Endpoint::Ip(connecting.get_name())),
Inner::Established(established) => Ok(Endpoint::Ip(established.get_name())), inner::Inner::Established(established) => Ok(Endpoint::Ip(established.get_name())),
Inner::Listening(listening) => Ok(Endpoint::Ip(listening.get_name())), inner::Inner::Listening(listening) => Ok(Endpoint::Ip(listening.get_name())),
} }
} }
fn get_peer_name(&self) -> Result<Endpoint, SystemError> { fn get_peer_name(&self) -> Result<Endpoint, SystemError> {
match self.inner.read().as_ref().expect("Tcp Inner is None") { match self
Inner::Init(_) => Err(ENOTCONN), .inner
Inner::Connecting(connecting) => Ok(Endpoint::Ip(connecting.get_peer_name())), .read()
Inner::Established(established) => Ok(Endpoint::Ip(established.get_peer_name())), .as_ref()
Inner::Listening(_) => Err(ENOTCONN), .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); return self.do_bind(addr);
} }
log::debug!("TcpSocket::bind: invalid endpoint"); log::debug!("TcpSocket::bind: invalid endpoint");
return Err(EINVAL); return Err(SystemError::EINVAL);
} }
fn connect(&self, endpoint: Endpoint) -> Result<(), SystemError> { fn connect(&self, endpoint: Endpoint) -> Result<(), SystemError> {
let Endpoint::Ip(endpoint) = endpoint else { let Endpoint::Ip(endpoint) = endpoint else {
log::debug!("TcpSocket::connect: invalid endpoint"); log::debug!("TcpSocket::connect: invalid endpoint");
return Err(EINVAL); return Err(SystemError::EINVAL);
}; };
self.start_connect(endpoint)?; // Only Nonblock or error will return error. self.start_connect(endpoint)?; // Only Nonblock or error will return error.
return loop { return loop {
match self.check_connect() { match self.check_connect() {
Err(EAGAIN_OR_EWOULDBLOCK) => {} Err(SystemError::EAGAIN_OR_EWOULDBLOCK) => {}
result => break result, result => break result,
} }
}; };
@ -289,20 +323,20 @@ impl Socket for TcpSocket {
self.do_listen(backlog) self.do_listen(backlog)
} }
fn accept(&self) -> Result<(Arc<Inode>, Endpoint), SystemError> { fn accept(&self) -> Result<(Arc<SocketInode>, Endpoint), SystemError> {
if self.is_nonblock() { if self.is_nonblock() {
self.try_accept() self.try_accept()
} else { } else {
loop { loop {
match self.try_accept() { match self.try_accept() {
Err(EAGAIN_OR_EWOULDBLOCK) => { Err(SystemError::EAGAIN_OR_EWOULDBLOCK) => {
wq_wait_event_interruptible!(self.wait_queue, self.incoming(), {})?; wq_wait_event_interruptible!(self.wait_queue, self.incoming(), {})?;
} }
result => break result, 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> { fn recv(&self, buffer: &mut [u8], _flags: PMSG) -> Result<usize, SystemError> {
@ -317,7 +351,7 @@ impl Socket for TcpSocket {
self.inner self.inner
.read() .read()
.as_ref() .as_ref()
.expect("Tcp Inner is None") .expect("Tcp inner::Inner is None")
.send_buffer_size() .send_buffer_size()
} }
@ -325,7 +359,7 @@ impl Socket for TcpSocket {
self.inner self.inner
.read() .read()
.as_ref() .as_ref()
.expect("Tcp Inner is None") .expect("Tcp inner::Inner is None")
.recv_buffer_size() .recv_buffer_size()
} }
@ -361,20 +395,20 @@ impl Socket for TcpSocket {
match inner { match inner {
// complete connecting socket close logic // complete connecting socket close logic
Inner::Connecting(conn) => { inner::Inner::Connecting(conn) => {
let conn = unsafe { conn.into_established() }; let conn = unsafe { conn.into_established() };
conn.close(); conn.close();
conn.release(); conn.release();
} }
Inner::Established(es) => { inner::Inner::Established(es) => {
es.close(); es.close();
es.release(); es.release();
} }
Inner::Listening(ls) => { inner::Inner::Listening(ls) => {
ls.close(); ls.close();
ls.release(); ls.release();
} }
Inner::Init(init) => { inner::Inner::Init(init) => {
init.close(); init.close();
} }
}; };
@ -384,7 +418,7 @@ impl Socket for TcpSocket {
fn set_option(&self, level: PSOL, name: usize, val: &[u8]) -> Result<(), SystemError> { fn set_option(&self, level: PSOL, name: usize, val: &[u8]) -> Result<(), SystemError> {
if level != PSOL::TCP { if level != PSOL::TCP {
// return Err(EINVAL); // return Err(SystemError::EINVAL);
log::debug!("TcpSocket::set_option: not TCP"); log::debug!("TcpSocket::set_option: not TCP");
return Ok(()); return Ok(());
} }
@ -395,62 +429,62 @@ impl Socket for TcpSocket {
NoDelay => { NoDelay => {
let nagle_enabled = val[0] != 0; let nagle_enabled = val[0] != 0;
let mut writer = self.inner.write(); 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 { match inner {
Inner::Established(established) => { inner::Inner::Established(established) => {
established.with_mut(|socket| { established.with_mut(|socket| {
socket.set_nagle_enabled(nagle_enabled); socket.set_nagle_enabled(nagle_enabled);
}); });
writer.replace(Inner::Established(established)); writer.replace(inner::Inner::Established(established));
} }
_ => { _ => {
writer.replace(inner); writer.replace(inner);
return Err(EINVAL); return Err(SystemError::EINVAL);
} }
} }
} }
KeepIntvl => { KeepIntvl => {
if val.len() == 4 { if val.len() == 4 {
let mut writer = self.inner.write(); 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 { match inner {
Inner::Established(established) => { inner::Inner::Established(established) => {
let interval = u32::from_ne_bytes([val[0], val[1], val[2], val[3]]); let interval = u32::from_ne_bytes([val[0], val[1], val[2], val[3]]);
established.with_mut(|socket| { established.with_mut(|socket| {
socket.set_keep_alive(Some(smoltcp::time::Duration::from_secs( socket.set_keep_alive(Some(smoltcp::time::Duration::from_secs(
interval as u64, interval as u64,
))); )));
}); });
writer.replace(Inner::Established(established)); writer.replace(inner::Inner::Established(established));
} }
_ => { _ => {
writer.replace(inner); writer.replace(inner);
return Err(EINVAL); return Err(SystemError::EINVAL);
} }
} }
} else { } else {
return Err(EINVAL); return Err(SystemError::EINVAL);
} }
} }
KeepCnt => { KeepCnt => {
// if val.len() == 4 { // if val.len() == 4 {
// let mut writer = self.inner.write(); // 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 { // match inner {
// Inner::Established(established) => { // inner::Inner::Established(established) => {
// let count = u32::from_ne_bytes([val[0], val[1], val[2], val[3]]); // let count = u32::from_ne_bytes([val[0], val[1], val[2], val[3]]);
// established.with_mut(|socket| { // established.with_mut(|socket| {
// socket.set_keep_alive_count(count); // socket.set_keep_alive_count(count);
// }); // });
// writer.replace(Inner::Established(established)); // writer.replace(inner::Inner::Established(established));
// } // }
// _ => { // _ => {
// writer.replace(inner); // writer.replace(inner);
// return Err(EINVAL); // return Err(SystemError::EINVAL);
// } // }
// } // }
// } else { // } else {
// return Err(EINVAL); // return Err(SystemError::EINVAL);
// } // }
} }
KeepIdle => {} KeepIdle => {}

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

@ -1,68 +1,66 @@
use alloc::sync::Arc; use alloc::sync::Arc;
use smoltcp; use smoltcp::{self, wire::IpProtocol};
use system_error::SystemError::{self, *}; use system_error::SystemError;
use inet::{TcpSocket, UdpSocket}; use crate::net::socket::{
family,
// use crate::net::syscall_util::SysArgSocketType; inet::{TcpSocket, UdpSocket},
use crate::net::socket::*; Socket, SocketInode, PSOCK,
};
fn create_inet_socket( fn create_inet_socket(
version: smoltcp::wire::IpVersion, version: smoltcp::wire::IpVersion,
socket_type: PSOCK, socket_type: PSOCK,
protocol: smoltcp::wire::IpProtocol, protocol: smoltcp::wire::IpProtocol,
) -> Result<Arc<dyn Socket>, SystemError> { ) -> Result<Arc<dyn Socket>, SystemError> {
log::debug!("type: {:?}, protocol: {:?}", socket_type, protocol); // log::debug!("type: {:?}, protocol: {:?}", socket_type, protocol);
use smoltcp::wire::IpProtocol::*;
match socket_type { match socket_type {
PSOCK::Datagram => match protocol { PSOCK::Datagram => match protocol {
HopByHop | Udp => { IpProtocol::HopByHop | IpProtocol::Udp => {
log::debug!("create udp socket");
// return Err(EPROTONOSUPPORT);
return Ok(UdpSocket::new(false)); return Ok(UdpSocket::new(false));
} }
_ => { _ => {
return Err(EPROTONOSUPPORT); return Err(SystemError::EPROTONOSUPPORT);
} }
}, },
PSOCK::Stream => match protocol { PSOCK::Stream => match protocol {
HopByHop | Tcp => { IpProtocol::HopByHop | IpProtocol::Tcp => {
log::debug!("create tcp socket"); log::debug!("create tcp socket");
return Ok(TcpSocket::new(false, version)); return Ok(TcpSocket::new(false, version));
} }
_ => { _ => {
return Err(EPROTONOSUPPORT); return Err(SystemError::EPROTONOSUPPORT);
} }
}, },
PSOCK::Raw => { PSOCK::Raw => {
todo!("raw") todo!("raw")
} }
_ => { _ => {
return Err(EPROTONOSUPPORT); return Err(SystemError::EPROTONOSUPPORT);
} }
} }
} }
pub struct Inet; pub struct Inet;
impl family::Family for 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( let socket = create_inet_socket(
smoltcp::wire::IpVersion::Ipv4, smoltcp::wire::IpVersion::Ipv4,
stype, stype,
smoltcp::wire::IpProtocol::from(protocol as u8), smoltcp::wire::IpProtocol::from(protocol as u8),
)?; )?;
Ok(Inode::new(socket)) Ok(SocketInode::new(socket))
} }
} }
pub struct Inet6; pub struct Inet6;
impl family::Family for 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( let socket = create_inet_socket(
smoltcp::wire::IpVersion::Ipv6, smoltcp::wire::IpVersion::Ipv6,
stype, stype,
smoltcp::wire::IpProtocol::from(protocol as u8), 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 alloc::sync::Arc;
use system_error::SystemError; use system_error::SystemError;
use crate::net::socket::*; use super::{
common::shutdown::ShutdownTemp,
endpoint::Endpoint,
posix::{PMSG, PSOL},
EPollItems, Socket,
};
#[derive(Debug)] #[derive(Debug)]
pub struct Inode { pub struct SocketInode {
inner: Arc<dyn Socket>, inner: Arc<dyn Socket>,
epoll_items: EPollItems, epoll_items: EPollItems,
} }
impl IndexNode for Inode { impl IndexNode for SocketInode {
fn read_at( fn read_at(
&self, &self,
_offset: usize, _offset: usize,
@ -78,7 +83,7 @@ impl IndexNode for Inode {
} }
} }
impl Inode { impl SocketInode {
// pub fn wait_queue(&self) -> WaitQueue { // pub fn wait_queue(&self) -> WaitQueue {
// self.inner.wait_queue() // self.inner.wait_queue()
// } // }

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

@ -1,7 +1,7 @@
mod base; mod base;
mod buffer; mod buffer;
mod common; mod common;
mod endpoint; pub mod endpoint;
mod family; mod family;
pub mod inet; pub mod inet;
mod inode; mod inode;
@ -12,16 +12,16 @@ mod utils;
use crate::libs::wait_queue::WaitQueue; use crate::libs::wait_queue::WaitQueue;
pub use base::Socket; pub use base::Socket;
pub use crate::net::event_poll::EPollEventType;
pub use common::{ pub use common::{
shutdown::*,
// poll_unit::{EPollItems, WaitQueue}, // poll_unit::{EPollItems, WaitQueue},
EPollItems, EPollItems,
}; };
pub use endpoint::*;
pub use family::{AddressFamily, Family}; pub use family::{AddressFamily, Family};
pub use inode::Inode; pub use inode::SocketInode;
pub use posix::*; pub use posix::PMSG;
pub use posix::PSO;
pub use posix::PSOCK;
pub use posix::PSOL;
pub use utils::create_socket; pub use utils::create_socket;
pub use crate::net::event_poll::EPollEventType;
// pub use crate::net::sys // 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 msg_flag::MessageFlag as PMSG; // Socket message flags MSG_*
pub use option::Options as PSO; // Socket options SO_* pub use option::Options as PSO; // Socket options SO_*
pub use option_level::OptionLevel as PSOL; // Socket options level SOL_* 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)] #[derive(Debug, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive)]
pub enum Type { pub enum PSOCK {
Stream = 1, Stream = 1,
Datagram = 2, Datagram = 2,
Raw = 3, Raw = 3,
@ -10,7 +10,7 @@ pub enum Type {
} }
use crate::net::posix::PosixArgsSocketType; use crate::net::posix::PosixArgsSocketType;
impl TryFrom<PosixArgsSocketType> for Type { impl TryFrom<PosixArgsSocketType> for PSOCK {
type Error = system_error::SystemError; type Error = system_error::SystemError;
fn try_from(x: PosixArgsSocketType) -> Result<Self, Self::Error> { fn try_from(x: PosixArgsSocketType) -> Result<Self, Self::Error> {
use num_traits::FromPrimitive; use num_traits::FromPrimitive;

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

@ -1,33 +1,37 @@
pub mod ns; pub mod ns;
pub(crate) mod seqpacket; pub(crate) mod seqpacket;
pub mod stream; 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 alloc::sync::Arc;
use hashbrown::HashMap; use hashbrown::HashMap;
use system_error::SystemError::{self, *}; use system_error::SystemError;
use super::{endpoint::Endpoint, Family, SocketInode, PSOCK};
pub struct Unix; pub struct Unix;
lazy_static! { lazy_static! {
pub static ref INODE_MAP: RwLock<HashMap<InodeId, Endpoint>> = RwLock::new(HashMap::new()); 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 { match sock_type {
PSOCK::Stream | PSOCK::Datagram => stream::StreamSocket::new_inode(), PSOCK::Stream | PSOCK::Datagram => stream::StreamSocket::new_inode(),
PSOCK::SeqPacket => seqpacket::SeqpacketSocket::new_inode(false), PSOCK::SeqPacket => seqpacket::SeqpacketSocket::new_inode(false),
_ => Err(EPROTONOSUPPORT), _ => Err(SystemError::EPROTONOSUPPORT),
} }
} }
impl family::Family for Unix { impl Family for Unix {
fn socket(stype: PSOCK, _protocol: u32) -> Result<Arc<Inode>, SystemError> { fn socket(stype: PSOCK, _protocol: u32) -> Result<Arc<SocketInode>, SystemError> {
let socket = create_unix_socket(stype)?; let socket = create_unix_socket(stype)?;
Ok(socket) Ok(socket)
} }
} }
impl Unix { 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); // log::debug!("socket_type {:?}", socket_type);
match socket_type { match socket_type {
PSOCK::SeqPacket => seqpacket::SeqpacketSocket::new_pairs(), 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 core::fmt;
use crate::libs::spinlock::SpinLock; use crate::{libs::spinlock::SpinLock, net::socket::endpoint::Endpoint};
use crate::net::socket::Endpoint;
use alloc::string::String; use alloc::string::String;
use hashbrown::HashMap; use hashbrown::HashMap;
use ida::IdAllocator; 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 core::sync::atomic::{AtomicUsize, Ordering};
use super::SeqpacketSocket; use super::SeqpacketSocket;
use crate::net::socket::common::shutdown::ShutdownTemp;
use crate::{ use crate::{
libs::mutex::Mutex, 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)] #[derive(Debug)]
pub(super) struct Init { pub(super) struct Init {
@ -22,11 +23,11 @@ impl Init {
pub(super) fn bind(&mut self, epoint_to_bind: Endpoint) -> Result<(), SystemError> { pub(super) fn bind(&mut self, epoint_to_bind: Endpoint) -> Result<(), SystemError> {
if self.inode.is_some() { if self.inode.is_some() {
log::error!("the socket is already bound"); log::error!("the socket is already bound");
return Err(EINVAL); return Err(SystemError::EINVAL);
} }
match epoint_to_bind { match epoint_to_bind {
Endpoint::Inode(_) => self.inode = Some(epoint_to_bind), Endpoint::Inode(_) => self.inode = Some(epoint_to_bind),
_ => return Err(EINVAL), _ => return Err(SystemError::EINVAL),
} }
return Ok(()); return Ok(());
@ -35,7 +36,7 @@ impl Init {
pub fn bind_path(&mut self, sun_path: String) -> Result<Endpoint, SystemError> { pub fn bind_path(&mut self, sun_path: String) -> Result<Endpoint, SystemError> {
if self.inode.is_none() { if self.inode.is_none() {
log::error!("the socket is not bound"); 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() { if let Some(Endpoint::Inode((inode, mut path))) = self.inode.take() {
path = sun_path; path = sun_path;
@ -56,7 +57,7 @@ impl Init {
pub(super) struct Listener { pub(super) struct Listener {
inode: Endpoint, inode: Endpoint,
backlog: AtomicUsize, backlog: AtomicUsize,
incoming_conns: Mutex<VecDeque<Arc<Inode>>>, incoming_conns: Mutex<VecDeque<Arc<SocketInode>>>,
} }
impl Listener { impl Listener {
@ -73,7 +74,7 @@ impl Listener {
return &self.inode; 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(); let mut incoming_conns = self.incoming_conns.lock();
log::debug!(" incom len {}", incoming_conns.len()); log::debug!(" incom len {}", incoming_conns.len());
let conn = incoming_conns let conn = incoming_conns
@ -86,7 +87,7 @@ impl Listener {
_ => return Err(SystemError::ENOTCONN), _ => 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> { pub(super) fn listen(&self, backlog: usize) -> Result<(), SystemError> {
@ -105,7 +106,7 @@ impl Listener {
} }
let new_server = SeqpacketSocket::new(false); 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); // log::debug!("new inode {:?},client_epoint {:?}",new_inode,client_epoint);
let path = match &self.inode { let path = match &self.inode {
Endpoint::Inode((_, path)) => path.clone(), 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}, sync::{Arc, Weak},
}; };
use core::sync::atomic::{AtomicBool, Ordering}; use core::sync::atomic::{AtomicBool, Ordering};
use unix::ns::abs::{remove_abs_addr, ABS_INODE_MAP};
use crate::sched::SchedMode; use crate::{
use crate::{libs::rwlock::RwLock, net::socket::*}; libs::{rwlock::RwLock, wait_queue::WaitQueue},
use inner::*; 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 system_error::SystemError;
use super::INODE_MAP; use super::{
ns::abs::{remove_abs_addr, ABS_INODE_MAP},
INODE_MAP,
};
type EP = EPollEventType; type EP = EPollEventType;
#[derive(Debug)] #[derive(Debug)]
pub struct SeqpacketSocket { pub struct SeqpacketSocket {
inner: RwLock<Inner>, inner: RwLock<inner::Inner>,
shutdown: Shutdown, shutdown: Shutdown,
is_nonblocking: AtomicBool, is_nonblocking: AtomicBool,
wait_queue: WaitQueue, wait_queue: WaitQueue,
@ -32,7 +46,7 @@ impl SeqpacketSocket {
pub fn new(is_nonblocking: bool) -> Arc<Self> { pub fn new(is_nonblocking: bool) -> Arc<Self> {
Arc::new_cyclic(|me| 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(), shutdown: Shutdown::new(),
is_nonblocking: AtomicBool::new(is_nonblocking), is_nonblocking: AtomicBool::new(is_nonblocking),
wait_queue: WaitQueue::default(), 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 socket = SeqpacketSocket::new(is_nonblocking);
let inode = Inode::new(socket.clone()); let inode = SocketInode::new(socket.clone());
// 建立时绑定自身为后续能正常获取本端地址 // 建立时绑定自身为后续能正常获取本端地址
let _ = match &mut *socket.inner.write() { 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 Err(SystemError::EINVAL),
}; };
return Ok(inode); return Ok(inode);
} }
#[allow(dead_code)] #[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 { Arc::new_cyclic(|me| Self {
inner: RwLock::new(Inner::Connected(connected)), inner: RwLock::new(inner::Inner::Connected(connected)),
shutdown: Shutdown::new(), shutdown: Shutdown::new(),
is_nonblocking: AtomicBool::new(is_nonblocking), is_nonblocking: AtomicBool::new(is_nonblocking),
wait_queue: WaitQueue::default(), 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 socket0 = SeqpacketSocket::new(false);
let socket1 = SeqpacketSocket::new(false); let socket1 = SeqpacketSocket::new(false);
let inode0 = Inode::new(socket0.clone()); let inode0 = SocketInode::new(socket0.clone());
let inode1 = Inode::new(socket1.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((inode0.clone(), String::from("")))),
Some(Endpoint::Inode((inode1.clone(), String::from("")))), Some(Endpoint::Inode((inode1.clone(), String::from("")))),
); );
*socket0.inner.write() = Inner::Connected(conn_0); *socket0.inner.write() = inner::Inner::Connected(conn_0);
*socket1.inner.write() = Inner::Connected(conn_1); *socket1.inner.write() = inner::Inner::Connected(conn_1);
return Ok((inode0, inode1)); 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() { 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"); log::error!("the socket is not listening");
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);
@ -90,7 +106,7 @@ impl SeqpacketSocket {
fn is_acceptable(&self) -> bool { fn is_acceptable(&self) -> bool {
match &*self.inner.read() { match &*self.inner.read() {
Inner::Listen(listen) => listen.is_acceptable(), inner::Inner::Listen(listen) => listen.is_acceptable(),
_ => { _ => {
panic!("the socket is not listening"); panic!("the socket is not listening");
} }
@ -111,7 +127,7 @@ impl SeqpacketSocket {
fn can_recv(&self) -> Result<bool, SystemError> { fn can_recv(&self) -> Result<bool, SystemError> {
let can = match &*self.inner.read() { let can = match &*self.inner.read() {
Inner::Connected(connected) => connected.can_recv(), inner::Inner::Connected(connected) => connected.can_recv(),
_ => return Err(SystemError::ENOTCONN), _ => return Err(SystemError::ENOTCONN),
}; };
Ok(can) Ok(can)
@ -163,29 +179,29 @@ impl Socket for SeqpacketSocket {
.map_err(|_| SystemError::EINVAL)?; .map_err(|_| SystemError::EINVAL)?;
let client_epoint = match &mut *self.inner.write() { 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) => { Some(end) => {
log::debug!("bind when connect"); log::trace!("bind when connect");
Some(end) Some(end)
} }
None => { None => {
log::debug!("not bind when connect"); log::trace!("not bind when connect");
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 epoint = Endpoint::Inode((inode.clone(), String::from("")));
let _ = init.bind(epoint.clone()); let _ = init.bind(epoint.clone());
Some(epoint) Some(epoint)
} }
}, },
Inner::Listen(_) => return Err(SystemError::EINVAL), inner::Inner::Listen(_) => return Err(SystemError::EINVAL),
Inner::Connected(_) => return Err(SystemError::EISCONN), inner::Inner::Connected(_) => return Err(SystemError::EISCONN),
}; };
// ***阻塞与非阻塞处理还未实现 // ***阻塞与非阻塞处理还未实现
// 客户端与服务端建立连接将服务端inode推入到自身的listen_incom队列中， // 客户端与服务端建立连接将服务端inode推入到自身的listen_incom队列中，
// accept时从中获取推出对应的socket // accept时从中获取推出对应的socket
match &*remote_socket.inner.read() { 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) => { Ok(connected) => {
*self.inner.write() = Inner::Connected(connected); *self.inner.write() = inner::Inner::Connected(connected);
log::debug!("try to wake up"); log::debug!("try to wake up");
remote_socket.wait_queue.wakeup(None); remote_socket.wait_queue.wakeup(None);
@ -194,11 +210,11 @@ impl Socket for SeqpacketSocket {
// ***错误处理 // ***错误处理
Err(_) => todo!(), Err(_) => todo!(),
}, },
Inner::Init(_) => { inner::Inner::Init(_) => {
log::debug!("init einval"); log::debug!("init einval");
return Err(SystemError::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 { match endpoint {
Endpoint::Unixpath((inodeid, path)) => { Endpoint::Unixpath((inodeid, path)) => {
let inode = match &mut *self.inner.write() { 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"); log::error!("socket has listen or connected");
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);
@ -219,7 +235,7 @@ impl Socket for SeqpacketSocket {
} }
Endpoint::Abspath((abshandle, path)) => { Endpoint::Abspath((abshandle, path)) => {
let inode = match &mut *self.inner.write() { 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"); log::error!("socket has listen or connected");
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);
@ -235,7 +251,7 @@ impl Socket for SeqpacketSocket {
fn shutdown(&self, how: ShutdownTemp) -> Result<(), SystemError> { fn shutdown(&self, how: ShutdownTemp) -> Result<(), SystemError> {
log::debug!("seqpacket shutdown"); log::debug!("seqpacket shutdown");
match &*self.inner.write() { match &*self.inner.write() {
Inner::Connected(connected) => connected.shutdown(how), inner::Inner::Connected(connected) => connected.shutdown(how),
_ => Err(SystemError::EINVAL), _ => Err(SystemError::EINVAL),
} }
} }
@ -244,21 +260,21 @@ impl Socket for SeqpacketSocket {
let mut state = self.inner.write(); let mut state = self.inner.write();
log::debug!("listen into socket"); log::debug!("listen into socket");
let epoint = match &*state { let epoint = match &*state {
Inner::Init(init) => init.endpoint().ok_or(SystemError::EINVAL)?.clone(), inner::Inner::Init(init) => init.endpoint().ok_or(SystemError::EINVAL)?.clone(),
Inner::Listen(listener) => return listener.listen(backlog), inner::Inner::Listen(listener) => return listener.listen(backlog),
Inner::Connected(_) => { inner::Inner::Connected(_) => {
log::error!("the socket is connected"); log::error!("the socket is connected");
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);
} }
}; };
let listener = Listener::new(epoint, backlog); let listener = inner::Listener::new(epoint, backlog);
*state = Inner::Listen(listener); *state = inner::Inner::Listen(listener);
Ok(()) Ok(())
} }
fn accept(&self) -> Result<(Arc<Inode>, Endpoint), SystemError> { fn accept(&self) -> Result<(Arc<SocketInode>, Endpoint), SystemError> {
if !self.is_nonblocking() { if !self.is_nonblocking() {
loop { loop {
wq_wait_event_interruptible!(self.wait_queue, self.is_acceptable(), {})?; 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); self.wait_queue.wakeup(None);
let _ = remove_abs_addr(path); let _ = remove_abs_addr(path);
@ -350,7 +366,7 @@ impl Socket for SeqpacketSocket {
fn get_peer_name(&self) -> Result<Endpoint, SystemError> { fn get_peer_name(&self) -> Result<Endpoint, SystemError> {
// 获取对端地址 // 获取对端地址
let endpoint = match &*self.inner.read() { 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), _ => return Err(SystemError::ENOTCONN),
}; };
@ -364,9 +380,9 @@ impl Socket for SeqpacketSocket {
fn get_name(&self) -> Result<Endpoint, SystemError> { fn get_name(&self) -> Result<Endpoint, SystemError> {
// 获取本端地址 // 获取本端地址
let endpoint = match &*self.inner.read() { let endpoint = match &*self.inner.read() {
Inner::Init(init) => init.endpoint().cloned(), inner::Inner::Init(init) => init.endpoint().cloned(),
Inner::Listen(listener) => Some(listener.endpoint().clone()), inner::Inner::Listen(listener) => Some(listener.endpoint().clone()),
Inner::Connected(connected) => connected.endpoint().cloned(), inner::Inner::Connected(connected) => connected.endpoint().cloned(),
}; };
if let Some(endpoint) = endpoint { if let Some(endpoint) = endpoint {
@ -407,7 +423,7 @@ impl Socket for SeqpacketSocket {
)?; )?;
// connect锁和flag判断顺序不正确，应该先判断在 // connect锁和flag判断顺序不正确，应该先判断在
match &*self.inner.write() { match &*self.inner.write() {
Inner::Connected(connected) => match connected.try_read(buffer) { inner::Inner::Connected(connected) => match connected.try_read(buffer) {
Ok(usize) => { Ok(usize) => {
log::debug!("recv from successfully"); log::debug!("recv from successfully");
return Ok(usize); return Ok(usize);
@ -427,7 +443,7 @@ impl Socket for SeqpacketSocket {
fn recv_msg( fn recv_msg(
&self, &self,
_msg: &mut crate::net::syscall::MsgHdr, _msg: &mut MsgHdr,
_flags: crate::net::socket::PMSG, _flags: crate::net::socket::PMSG,
) -> Result<usize, SystemError> { ) -> Result<usize, SystemError> {
Err(SystemError::ENOSYS) Err(SystemError::ENOSYS)
@ -443,7 +459,7 @@ impl Socket for SeqpacketSocket {
if !flags.contains(PMSG::DONTWAIT) { if !flags.contains(PMSG::DONTWAIT) {
loop { loop {
match &*self.inner.write() { match &*self.inner.write() {
Inner::Connected(connected) => match connected.try_write(buffer) { inner::Inner::Connected(connected) => match connected.try_write(buffer) {
Ok(usize) => { Ok(usize) => {
log::debug!("send successfully"); log::debug!("send successfully");
return Ok(usize); return Ok(usize);
@ -463,7 +479,7 @@ impl Socket for SeqpacketSocket {
fn send_msg( fn send_msg(
&self, &self,
_msg: &crate::net::syscall::MsgHdr, _msg: &MsgHdr,
_flags: crate::net::socket::PMSG, _flags: crate::net::socket::PMSG,
) -> Result<usize, SystemError> { ) -> Result<usize, SystemError> {
Err(SystemError::ENOSYS) Err(SystemError::ENOSYS)
@ -492,7 +508,7 @@ impl Socket for SeqpacketSocket {
)?; )?;
// connect锁和flag判断顺序不正确，应该先判断在 // connect锁和flag判断顺序不正确，应该先判断在
match &*self.inner.write() { match &*self.inner.write() {
Inner::Connected(connected) => match connected.recv_slice(buffer) { inner::Inner::Connected(connected) => match connected.recv_slice(buffer) {
Ok(usize) => { Ok(usize) => {
// log::debug!("recvs from successfully"); // log::debug!("recvs from successfully");
return Ok((usize, connected.peer_endpoint().unwrap().clone())); return Ok((usize, connected.peer_endpoint().unwrap().clone()));
@ -535,7 +551,7 @@ impl Socket for SeqpacketSocket {
mask |= EP::EPOLLRDHUP | EP::EPOLLIN | EP::EPOLLRDNORM; mask |= EP::EPOLLRDHUP | EP::EPOLLIN | EP::EPOLLRDNORM;
} }
match &*self.inner.read() { match &*self.inner.read() {
Inner::Connected(connected) => { inner::Inner::Connected(connected) => {
if connected.can_recv() { if connected.can_recv() {
mask |= EP::EPOLLIN | EP::EPOLLRDNORM; mask |= EP::EPOLLIN | EP::EPOLLRDNORM;
} }
@ -552,8 +568,8 @@ impl Socket for SeqpacketSocket {
} }
} }
} }
Inner::Listen(_) => mask |= EP::EPOLLIN, inner::Inner::Listen(_) => mask |= EP::EPOLLIN,
Inner::Init(_) => mask |= EP::EPOLLOUT, inner::Inner::Init(_) => mask |= EP::EPOLLOUT,
} }
mask.bits() as usize 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::libs::mutex::Mutex;
use crate::net::socket::buffer::Buffer; 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::unix::stream::StreamSocket;
use crate::net::socket::{Endpoint, Inode, ShutdownTemp}; use crate::net::socket::SocketInode;
use alloc::collections::VecDeque; use alloc::collections::VecDeque;
use alloc::{string::String, sync::Arc}; use alloc::{string::String, sync::Arc};
@ -183,7 +185,7 @@ impl Connected {
#[derive(Debug)] #[derive(Debug)]
pub struct Listener { pub struct Listener {
addr: Option<Endpoint>, addr: Option<Endpoint>,
incoming_connects: Mutex<VecDeque<Arc<Inode>>>, incoming_connects: Mutex<VecDeque<Arc<SocketInode>>>,
backlog: AtomicUsize, backlog: AtomicUsize,
} }
@ -201,7 +203,7 @@ impl Listener {
return Ok(()); 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(); let mut incoming_connects = self.incoming_connects.lock();
if incoming_connects.len() >= self.backlog.load(Ordering::Relaxed) { if incoming_connects.len() >= self.backlog.load(Ordering::Relaxed) {
@ -215,7 +217,7 @@ impl Listener {
} }
#[allow(dead_code)] #[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(); let mut incoming_connects = self.incoming_connects.lock();
return incoming_connects.pop_front(); return incoming_connects.pop_front();
@ -229,7 +231,7 @@ impl Listener {
return self.incoming_connects.lock().len() != 0; 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(); let mut incoming_connecteds = self.incoming_connects.lock();
debug!("incom len {}", incoming_connecteds.len()); debug!("incom len {}", incoming_connecteds.len());
let connected = incoming_connecteds let connected = incoming_connecteds
@ -242,6 +244,6 @@ impl Listener {
_ => return Err(SystemError::ENOTCONN), _ => return Err(SystemError::ENOTCONN),
}; };
debug!("server accept!"); 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::{ use alloc::{
string::String, string::String,
sync::{Arc, Weak}, 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 socket0 = StreamSocket::new();
let socket1 = StreamSocket::new(); let socket1 = StreamSocket::new();
let inode0 = Inode::new(socket0.clone()); let inode0 = SocketInode::new(socket0.clone());
let inode1 = Inode::new(socket1.clone()); let inode1 = SocketInode::new(socket1.clone());
let (conn_0, conn_1) = Connected::new_pair( let (conn_0, conn_1) = Connected::new_pair(
Some(Endpoint::Inode((inode0.clone(), String::from("")))), 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 socket = StreamSocket::new();
let inode = Inode::new(socket.clone()); let inode = SocketInode::new(socket.clone());
let _ = match &mut *socket.inner.write() { let _ = match &mut *socket.inner.write() {
Inner::Init(init) => init.bind(Endpoint::Inode((inode.clone(), String::from("")))), 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() { match &*self.inner.read() {
Inner::Listener(listener) => listener.try_accept() as _, Inner::Listener(listener) => listener.try_accept() as _,
_ => { _ => {
@ -135,7 +144,7 @@ impl Socket for StreamSocket {
} }
None => { None => {
debug!("not bind when connected"); 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 epoint = Endpoint::Inode((inode.clone(), String::from("")));
let _ = init.bind(epoint.clone()); let _ = init.bind(epoint.clone());
Some(epoint) Some(epoint)
@ -186,7 +195,7 @@ impl Socket for StreamSocket {
//创建新的对端socket //创建新的对端socket
let new_server_socket = StreamSocket::new(); 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))); let new_server_endpoint = Some(Endpoint::Inode((new_server_inode.clone(), sun_path)));
//获取connect pair //获取connect pair
let (client_conn, server_conn) = let (client_conn, server_conn) =
@ -258,7 +267,7 @@ impl Socket for StreamSocket {
return Ok(()); 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"); debug!("stream server begin accept");
//目前只实现了阻塞式实现 //目前只实现了阻塞式实现
loop { loop {
@ -490,11 +499,7 @@ impl Socket for StreamSocket {
} }
} }
fn recv_msg( fn recv_msg(&self, _msg: &mut MsgHdr, _flags: socket::PMSG) -> Result<usize, SystemError> {
&self,
_msg: &mut crate::net::syscall::MsgHdr,
_flags: socket::PMSG,
) -> Result<usize, SystemError> {
Err(SystemError::ENOSYS) Err(SystemError::ENOSYS)
} }
@ -523,11 +528,7 @@ impl Socket for StreamSocket {
} }
} }
fn send_msg( fn send_msg(&self, _msg: &MsgHdr, _flags: socket::PMSG) -> Result<usize, SystemError> {
&self,
_msg: &crate::net::syscall::MsgHdr,
_flags: socket::PMSG,
) -> Result<usize, SystemError> {
todo!() todo!()
} }

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

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

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

@ -54,7 +54,7 @@ use crate::{
VirtAddr, VirtAddr,
}, },
namespaces::{mnt_namespace::FsStruct, pid_namespace::PidStrcut, NsProxy}, namespaces::{mnt_namespace::FsStruct, pid_namespace::PidStrcut, NsProxy},
net::socket::Inode as SocketInode, net::socket::SocketInode,
sched::{ sched::{
completion::Completion, cpu_rq, fair::FairSchedEntity, prio::MAX_PRIO, DequeueFlag, completion::Completion, cpu_rq, fair::FairSchedEntity, prio::MAX_PRIO, DequeueFlag,
EnqueueFlag, OnRq, SchedMode, WakeupFlags, __schedule, 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}, ipc::shm::{ShmCtlCmd, ShmFlags, ShmId, ShmKey},
libs::{futex::constant::FutexFlag, rand::GRandFlags}, libs::{futex::constant::FutexFlag, rand::GRandFlags},
mm::{page::PAGE_4K_SIZE, syscall::MremapFlags}, mm::{page::PAGE_4K_SIZE, syscall::MremapFlags},
net::syscall::MsgHdr, net::posix::{MsgHdr, SockAddr},
process::{ process::{
fork::KernelCloneArgs, fork::KernelCloneArgs,
resource::{RLimit64, RUsage}, resource::{RLimit64, RUsage},
@ -33,7 +33,6 @@ use crate::{
}, },
libs::align::page_align_up, libs::align::page_align_up,
mm::{verify_area, MemoryManagementArch, VirtAddr}, mm::{verify_area, MemoryManagementArch, VirtAddr},
net::syscall::SockAddr,
process::{fork::CloneFlags, syscall::PosixOldUtsName, Pid}, process::{fork::CloneFlags, syscall::PosixOldUtsName, Pid},
time::{ time::{
syscall::{PosixTimeZone, PosixTimeval}, syscall::{PosixTimeZone, PosixTimeval},