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

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 {
<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` 上的调用结果。
fn consume<R, F>(self, f: F) -> R
where
F: FnOnce(&[u8]) -> R
F: FnOnce(&[u8]) -> R,
{
f(self.buffer.as_slice())
}
@ -277,7 +277,7 @@ impl LoopbackInterface {
/// 返回一个 `Arc<Self>`，即一个指向新创建的 `LoopbackInterface` 实例的智能指针。
pub fn new(mut driver: LoopbackDriver) -> Arc<Self> {
let iface_id = generate_iface_id();
let hardware_addr = HardwareAddress::Ethernet(smoltcp::wire::EthernetAddress([
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]));
@ -296,9 +296,7 @@ impl LoopbackInterface {
//设置网卡地址为127.0.0.1
iface.update_ip_addrs(|ip_addrs| {
ip_addrs
.push(cidr)
.expect("Push ipCidr failed: full");
ip_addrs.push(cidr).expect("Push ipCidr failed: full");
});
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) = {
(
matches!(
interface.poll(timestamp, device, &mut sockets),
interface.poll(timestamp, device, &mut sockets),
smoltcp::iface::PollResult::SocketStateChanged
),
),
loop {
let poll_at = interface.poll_at(timestamp, &sockets);
let Some(instant) = poll_at else {
@ -222,7 +222,7 @@ impl IfaceCommon {
if instant > timestamp {
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)));
},
}
_ => {
log::warn!("not support address family {:?}", addr.family);
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 alloc::sync::Arc;
use alloc::vec::Vec;
use system_error::SystemError::{self, *};
pub mod port;

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

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

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

@ -8,8 +8,6 @@ use alloc::vec::Vec;
use smoltcp;
use system_error::SystemError::{self, *};
use super::inet::UNSPECIFIED_LOCAL_ENDPOINT_V4;
// pub const DEFAULT_METADATA_BUF_SIZE: usize = 1024;
pub const DEFAULT_RX_BUF_SIZE: usize = 512 * 1024;
pub const DEFAULT_TX_BUF_SIZE: usize = 512 * 1024;
@ -31,7 +29,12 @@ where
#[derive(Debug)]
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)),
}
@ -136,9 +139,12 @@ impl Init {
// -1 because the first one is already bound
let new_listen = socket::inet::BoundInner::bind(
new_listen_smoltcp_socket(listen_addr),
listen_addr.addr.as_ref().unwrap_or(
&smoltcp::wire::IpAddress::from(smoltcp::wire::Ipv4Address::UNSPECIFIED)
),
listen_addr
.addr
.as_ref()
.unwrap_or(&smoltcp::wire::IpAddress::from(
smoltcp::wire::Ipv4Address::UNSPECIFIED,
)),
)?;
inners.push(new_listen);
}
@ -272,20 +278,22 @@ impl Listening {
return Err(EAGAIN_OR_EWOULDBLOCK);
}
let remote_endpoint = connected
.with::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
socket
.remote_endpoint()
.expect("A Connected Tcp With No Remote Endpoint")
});
let remote_endpoint = connected.with::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
socket
.remote_endpoint()
.expect("A Connected Tcp With No Remote Endpoint")
});
// log::debug!("local at {:?}", local_endpoint);
let mut new_listen = socket::inet::BoundInner::bind(
new_listen_smoltcp_socket(self.listen_addr),
self.listen_addr.addr.as_ref().unwrap_or(
&smoltcp::wire::IpAddress::from(smoltcp::wire::Ipv4Address::UNSPECIFIED),
),
self.listen_addr
.addr
.as_ref()
.unwrap_or(&smoltcp::wire::IpAddress::from(
smoltcp::wire::Ipv4Address::UNSPECIFIED,
)),
)?;
// swap the connected socket with the new_listen socket
@ -318,9 +326,14 @@ impl Listening {
}
pub fn get_name(&self) -> smoltcp::wire::IpEndpoint {
smoltcp::wire::IpEndpoint::new(self.listen_addr.addr.unwrap_or(
smoltcp::wire::IpAddress::from(smoltcp::wire::Ipv4Address::UNSPECIFIED),
), self.listen_addr.port)
smoltcp::wire::IpEndpoint::new(
self.listen_addr
.addr
.unwrap_or(smoltcp::wire::IpAddress::from(
smoltcp::wire::Ipv4Address::UNSPECIFIED,
)),
self.listen_addr.port,
)
}
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 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::net_core::poll_ifaces;
use crate::net::socket::*;
@ -234,12 +234,10 @@ impl Socket for TcpSocket {
fn get_name(&self) -> Result<Endpoint, SystemError> {
match self.inner.read().as_ref().expect("Tcp Inner is None") {
Inner::Init(Init::Unbound((_, ver))) => {
Ok(Endpoint::Ip( match ver {
smoltcp::wire::IpVersion::Ipv4 => UNSPECIFIED_LOCAL_ENDPOINT_V4,
smoltcp::wire::IpVersion::Ipv6 => UNSPECIFIED_LOCAL_ENDPOINT_V6,
}))
}
Inner::Init(Init::Unbound((_, ver))) => Ok(Endpoint::Ip(match ver {
smoltcp::wire::IpVersion::Ipv4 => UNSPECIFIED_LOCAL_ENDPOINT_V4,
smoltcp::wire::IpVersion::Ipv6 => UNSPECIFIED_LOCAL_ENDPOINT_V6,
})),
Inner::Init(Init::Bound((_, local))) => Ok(Endpoint::Ip(*local)),
Inner::Connecting(connecting) => Ok(Endpoint::Ip(connecting.get_name())),
Inner::Established(established) => Ok(Endpoint::Ip(established.local_endpoint())),
@ -330,7 +328,7 @@ impl Socket for TcpSocket {
Inner::Init(init) => {
init.close();
Ok(())
},
}
})
.unwrap_or(Ok(()))
}
@ -361,7 +359,7 @@ impl Socket for TcpSocket {
return Err(EINVAL);
}
}
},
}
KeepIntvl => {
if val.len() == 4 {
let mut writer = self.inner.write();
@ -370,7 +368,9 @@ impl Socket for TcpSocket {
Inner::Established(established) => {
let interval = u32::from_ne_bytes([val[0], val[1], val[2], val[3]]);
established.with_mut(|socket| {
socket.set_keep_alive(Some(smoltcp::time::Duration::from_secs(interval as u64)));
socket.set_keep_alive(Some(smoltcp::time::Duration::from_secs(
interval as u64,
)));
});
writer.replace(Inner::Established(established));
}
@ -382,7 +382,7 @@ impl Socket for TcpSocket {
} else {
return Err(EINVAL);
}
},
}
KeepCnt => {
// if val.len() == 4 {
// let mut writer = self.inner.write();
@ -403,10 +403,8 @@ impl Socket for TcpSocket {
// } else {
// return Err(EINVAL);
// }
},
KeepIdle => {
},
}
KeepIdle => {}
_ => {
log::debug!("TcpSocket::set_option: not supported");
// 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 {
fn socket(stype: PSOCK, protocol: u32) -> Result<Arc<Inode>, SystemError> {
let socket = create_inet_socket(
smoltcp::wire::IpVersion::Ipv4,
stype,
smoltcp::wire::IpProtocol::from(protocol as u8)
smoltcp::wire::IpVersion::Ipv4,
stype,
smoltcp::wire::IpProtocol::from(protocol as u8),
)?;
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 system_error::SystemError;
use unix::{
ns::abs::{remove_abs_addr, ABSHANDLE_MAP, ABS_INODE_MAP},
ns::abs::{remove_abs_addr, ABS_INODE_MAP},
INODE_MAP,
};