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

turn off syscall printing, remove unused imports and make fmt

Browse Source
This commit is contained in:
Samuka007 2024-11-13 17:59:03 +08:00
parent d6755136f8
commit aaf9a5f2e6
10 changed files with 68 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
kernel/src/arch/x86_64/syscall/nr.rs
View File

@ -732,4 +732,4 @@ impl From<SysCall> for usize {
fn from(value: SysCall) -> Self { fn from(value: SysCall) -> Self {
<SysCall as ToPrimitive>::to_usize(&value).unwrap() <SysCall as ToPrimitive>::to_usize(&value).unwrap()
} }
} }

8
kernel/src/driver/net/loopback.rs
View File

@ -52,7 +52,7 @@ impl phy::RxToken for LoopbackRxToken {
/// 返回函数 `f` 在 `self.buffer` 上的调用结果。 /// 返回函数 `f` 在 `self.buffer` 上的调用结果。
fn consume<R, F>(self, f: F) -> R fn consume<R, F>(self, f: F) -> R
where where
F: FnOnce(&[u8]) -> R F: FnOnce(&[u8]) -> R,
{ {
f(self.buffer.as_slice()) f(self.buffer.as_slice())
} }
@ -277,7 +277,7 @@ impl LoopbackInterface {
/// 返回一个 `Arc<Self>`，即一个指向新创建的 `LoopbackInterface` 实例的智能指针。 /// 返回一个 `Arc<Self>`，即一个指向新创建的 `LoopbackInterface` 实例的智能指针。
pub fn new(mut driver: LoopbackDriver) -> Arc<Self> { pub fn new(mut driver: LoopbackDriver) -> Arc<Self> {
let iface_id = generate_iface_id(); let iface_id = generate_iface_id();
let hardware_addr = HardwareAddress::Ethernet(smoltcp::wire::EthernetAddress([ let hardware_addr = HardwareAddress::Ethernet(smoltcp::wire::EthernetAddress([
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
])); ]));
@ -296,9 +296,7 @@ impl LoopbackInterface {
//设置网卡地址为127.0.0.1 //设置网卡地址为127.0.0.1
iface.update_ip_addrs(|ip_addrs| { iface.update_ip_addrs(|ip_addrs| {
ip_addrs ip_addrs.push(cidr).expect("Push ipCidr failed: full");
.push(cidr)
.expect("Push ipCidr failed: full");
}); });
iface.routes_mut().update(|routes_map| { iface.routes_mut().update(|routes_map| {

6
kernel/src/driver/net/mod.rs
View File

@ -211,9 +211,9 @@ impl IfaceCommon {
let (has_events, poll_at) = { let (has_events, poll_at) = {
( (
matches!( matches!(
interface.poll(timestamp, device, &mut sockets), interface.poll(timestamp, device, &mut sockets),
smoltcp::iface::PollResult::SocketStateChanged smoltcp::iface::PollResult::SocketStateChanged
), ),
loop { loop {
let poll_at = interface.poll_at(timestamp, &sockets); let poll_at = interface.poll_at(timestamp, &sockets);
let Some(instant) = poll_at else { let Some(instant) = poll_at else {
@ -222,7 +222,7 @@ impl IfaceCommon {
if instant > timestamp { if instant > timestamp {
break poll_at; break poll_at;
} }
} },
) )
}; };

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

@ -232,7 +232,7 @@ impl SockAddr {
}; };
return Ok(Endpoint::Unixpath((inode.metadata()?.inode_id, path))); return Ok(Endpoint::Unixpath((inode.metadata()?.inode_id, path)));
}, }
_ => { _ => {
log::warn!("not support address family {:?}", addr.family); log::warn!("not support address family {:?}", addr.family);
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);

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

@ -1,6 +1,5 @@
use crate::net::{Iface, NET_DEVICES}; use crate::net::{Iface, NET_DEVICES};
use alloc::sync::Arc; use alloc::sync::Arc;
use alloc::vec::Vec;
use system_error::SystemError::{self, *}; use system_error::SystemError::{self, *};
pub mod port; pub mod port;

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

@ -32,10 +32,7 @@ impl UnboundUdp {
return Self { socket }; return Self { socket };
} }
pub fn bind( pub fn bind(self, local_endpoint: smoltcp::wire::IpEndpoint) -> Result<BoundUdp, SystemError> {
self,
local_endpoint: smoltcp::wire::IpEndpoint,
) -> Result<BoundUdp, SystemError> {
// let (addr, port) = (local_endpoint.addr, local_endpoint.port); // let (addr, port) = (local_endpoint.addr, local_endpoint.port);
// if self.socket.bind(local_endpoint).is_err() { // if self.socket.bind(local_endpoint).is_err() {
// log::debug!("bind failed!"); // log::debug!("bind failed!");
@ -44,25 +41,25 @@ impl UnboundUdp {
let inner = BoundInner::bind(self.socket, &local_endpoint.addr)?; let inner = BoundInner::bind(self.socket, &local_endpoint.addr)?;
let bind_addr = local_endpoint.addr; let bind_addr = local_endpoint.addr;
let bind_port = if local_endpoint.port == 0 { let bind_port = if local_endpoint.port == 0 {
inner inner.port_manager().bind_ephemeral_port(InetTypes::Udp)?
.port_manager()
.bind_ephemeral_port(InetTypes::Udp)?
} else { } else {
local_endpoint.port local_endpoint.port
}; };
if bind_addr.is_unspecified() { if bind_addr.is_unspecified() {
if inner.with_mut::<smoltcp::socket::udp::Socket,_,_>(|socket| { if inner
socket.bind(bind_port) .with_mut::<smoltcp::socket::udp::Socket, _, _>(|socket| socket.bind(bind_port))
}).is_err() { .is_err()
{
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);
} }
} else { } else if inner
if inner.with_mut::<smoltcp::socket::udp::Socket,_,_>(|socket| { .with_mut::<smoltcp::socket::udp::Socket, _, _>(|socket| {
socket.bind(smoltcp::wire::IpEndpoint::new(bind_addr, bind_port)) socket.bind(smoltcp::wire::IpEndpoint::new(bind_addr, bind_port))
}).is_err() { })
return Err(SystemError::EINVAL); .is_err()
} {
return Err(SystemError::EINVAL);
} }
Ok(BoundUdp { Ok(BoundUdp {
inner, inner,

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

@ -8,8 +8,6 @@ use alloc::vec::Vec;
use smoltcp; use smoltcp;
use system_error::SystemError::{self, *}; use system_error::SystemError::{self, *};
use super::inet::UNSPECIFIED_LOCAL_ENDPOINT_V4;
// 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;
pub const DEFAULT_TX_BUF_SIZE: usize = 512 * 1024; pub const DEFAULT_TX_BUF_SIZE: usize = 512 * 1024;
@ -31,7 +29,12 @@ where
#[derive(Debug)] #[derive(Debug)]
pub enum Init { pub enum Init {
Unbound((Box<smoltcp::socket::tcp::Socket<'static>>, smoltcp::wire::IpVersion)), Unbound(
(
Box<smoltcp::socket::tcp::Socket<'static>>,
smoltcp::wire::IpVersion,
),
),
Bound((socket::inet::BoundInner, smoltcp::wire::IpEndpoint)), Bound((socket::inet::BoundInner, smoltcp::wire::IpEndpoint)),
} }
@ -136,9 +139,12 @@ impl Init {
// -1 because the first one is already bound // -1 because the first one is already bound
let new_listen = socket::inet::BoundInner::bind( let new_listen = socket::inet::BoundInner::bind(
new_listen_smoltcp_socket(listen_addr), new_listen_smoltcp_socket(listen_addr),
listen_addr.addr.as_ref().unwrap_or( listen_addr
&smoltcp::wire::IpAddress::from(smoltcp::wire::Ipv4Address::UNSPECIFIED) .addr
), .as_ref()
.unwrap_or(&smoltcp::wire::IpAddress::from(
smoltcp::wire::Ipv4Address::UNSPECIFIED,
)),
)?; )?;
inners.push(new_listen); inners.push(new_listen);
} }
@ -272,20 +278,22 @@ impl Listening {
return Err(EAGAIN_OR_EWOULDBLOCK); return Err(EAGAIN_OR_EWOULDBLOCK);
} }
let remote_endpoint = connected let remote_endpoint = connected.with::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
.with::<smoltcp::socket::tcp::Socket, _, _>(|socket| { socket
socket .remote_endpoint()
.remote_endpoint() .expect("A Connected Tcp With No Remote Endpoint")
.expect("A Connected Tcp With No Remote Endpoint") });
});
// log::debug!("local at {:?}", local_endpoint); // log::debug!("local at {:?}", local_endpoint);
let mut new_listen = socket::inet::BoundInner::bind( let mut new_listen = socket::inet::BoundInner::bind(
new_listen_smoltcp_socket(self.listen_addr), new_listen_smoltcp_socket(self.listen_addr),
self.listen_addr.addr.as_ref().unwrap_or( self.listen_addr
&smoltcp::wire::IpAddress::from(smoltcp::wire::Ipv4Address::UNSPECIFIED), .addr
), .as_ref()
.unwrap_or(&smoltcp::wire::IpAddress::from(
smoltcp::wire::Ipv4Address::UNSPECIFIED,
)),
)?; )?;
// swap the connected socket with the new_listen socket // swap the connected socket with the new_listen socket
@ -318,9 +326,14 @@ impl Listening {
} }
pub fn get_name(&self) -> smoltcp::wire::IpEndpoint { pub fn get_name(&self) -> smoltcp::wire::IpEndpoint {
smoltcp::wire::IpEndpoint::new(self.listen_addr.addr.unwrap_or( smoltcp::wire::IpEndpoint::new(
smoltcp::wire::IpAddress::from(smoltcp::wire::Ipv4Address::UNSPECIFIED), self.listen_addr
), self.listen_addr.port) .addr
.unwrap_or(smoltcp::wire::IpAddress::from(
smoltcp::wire::Ipv4Address::UNSPECIFIED,
)),
self.listen_addr.port,
)
} }
pub fn close(&self) { pub fn close(&self) {

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

@ -2,7 +2,7 @@ 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::{self, *};
use crate::{arch::init, libs::rwlock::RwLock}; use crate::libs::rwlock::RwLock;
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::*;
@ -234,12 +234,10 @@ 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.read().as_ref().expect("Tcp Inner is None") {
Inner::Init(Init::Unbound((_, ver))) => { Inner::Init(Init::Unbound((_, ver))) => Ok(Endpoint::Ip(match 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::Init(Init::Bound((_, local))) => Ok(Endpoint::Ip(*local)),
Inner::Connecting(connecting) => Ok(Endpoint::Ip(connecting.get_name())), Inner::Connecting(connecting) => Ok(Endpoint::Ip(connecting.get_name())),
Inner::Established(established) => Ok(Endpoint::Ip(established.local_endpoint())), Inner::Established(established) => Ok(Endpoint::Ip(established.local_endpoint())),
@ -330,7 +328,7 @@ impl Socket for TcpSocket {
Inner::Init(init) => { Inner::Init(init) => {
init.close(); init.close();
Ok(()) Ok(())
}, }
}) })
.unwrap_or(Ok(())) .unwrap_or(Ok(()))
} }
@ -361,7 +359,7 @@ impl Socket for TcpSocket {
return Err(EINVAL); return Err(EINVAL);
} }
} }
}, }
KeepIntvl => { KeepIntvl => {
if val.len() == 4 { if val.len() == 4 {
let mut writer = self.inner.write(); let mut writer = self.inner.write();
@ -370,7 +368,9 @@ impl Socket for TcpSocket {
Inner::Established(established) => { 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(interval as u64))); socket.set_keep_alive(Some(smoltcp::time::Duration::from_secs(
interval as u64,
)));
}); });
writer.replace(Inner::Established(established)); writer.replace(Inner::Established(established));
} }
@ -382,7 +382,7 @@ impl Socket for TcpSocket {
} else { } else {
return Err(EINVAL); return Err(EINVAL);
} }
}, }
KeepCnt => { KeepCnt => {
// if val.len() == 4 { // if val.len() == 4 {
// let mut writer = self.inner.write(); // let mut writer = self.inner.write();
@ -403,10 +403,8 @@ impl Socket for TcpSocket {
// } else { // } else {
// return Err(EINVAL); // return Err(EINVAL);
// } // }
}, }
KeepIdle => { KeepIdle => {}
},
_ => { _ => {
log::debug!("TcpSocket::set_option: not supported"); log::debug!("TcpSocket::set_option: not supported");
// return Err(ENOPROTOOPT); // return Err(ENOPROTOOPT);

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

@ -47,9 +47,9 @@ 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<Inode>, 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(Inode::new(socket))
} }

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

@ -7,7 +7,7 @@ use inner::{Connected, Init, Inner, Listener};
use log::debug; use log::debug;
use system_error::SystemError; use system_error::SystemError;
use unix::{ use unix::{
ns::abs::{remove_abs_addr, ABSHANDLE_MAP, ABS_INODE_MAP}, ns::abs::{remove_abs_addr, ABS_INODE_MAP},
INODE_MAP, INODE_MAP,
}; };