turn off syscall printing, remove unused imports and make fmt

kernel/src/arch/x86_64/syscall/nr.rs

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

kernel/src/driver/net/loopback.rs

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

kernel/src/driver/net/mod.rs

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

kernel/src/net/posix.rs

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

kernel/src/net/socket/inet/common/mod.rs

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

kernel/src/net/socket/inet/datagram/inner.rs

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

kernel/src/net/socket/inet/stream/inner.rs

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

kernel/src/net/socket/inet/stream/mod.rs

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

kernel/src/net/socket/inet/syscall.rs

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

kernel/src/net/socket/unix/stream/mod.rs

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