CI check clippy (#324)

loongs-zhang · web-flow · commit 5ee597c01cd1 · 2024-11-14T18:03:09.000+08:00
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -21,11 +21,22 @@ jobs:
           toolchain: ${{ matrix.target == 'i686-pc-windows-gnu' && format('{0}-i686-pc-windows-gnu', matrix.channel) || matrix.channel }}
           target: ${{ matrix.target }}
           override: true
-          components: rustfmt
-      - uses: actions-rs/cargo@v1
+          components: rustfmt, clippy
+      - name: Check code format
+        uses: actions-rs/cargo@v1
         with:
           command: fmt
           args: --all -- --check
+      - name: Check clippy with default features
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --all -- -D warnings
+      - name: Check clippy with all features
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --all --all-features -- -D warnings
       - name: Run cargo deny
         if: ${{ contains(matrix.os, 'ubuntu') }}
         uses: EmbarkStudios/cargo-deny-action@v2
diff --git a/core/src/common/constants.rs b/core/src/common/constants.rs
@@ -125,6 +125,8 @@ pub enum Syscall {
     SetFilePointerEx,
     #[cfg(windows)]
     WaitOnAddress,
+    #[cfg(windows)]
+    WSAPoll,
 }
 
 impl Syscall {
diff --git a/core/src/coroutine/local.rs b/core/src/coroutine/local.rs
@@ -16,7 +16,7 @@ impl<'c> CoroutineLocal<'c> {
     pub fn put<V>(&self, key: &'c str, val: V) -> Option<V> {
         let v = Box::leak(Box::new(val));
         self.0
-            .insert(key, std::ptr::from_mut::<V>(v) as usize)
+            .insert(key, std::ptr::from_mut(v) as usize)
             .map(|ptr| unsafe { *Box::from_raw((ptr as *mut c_void).cast::<V>()) })
     }
 
diff --git a/core/src/net/event_loop.rs b/core/src/net/event_loop.rs
@@ -123,7 +123,7 @@ impl<'e> EventLoop<'e> {
             let syscall_mask = <Syscall as Into<&str>>::into(syscall).as_ptr() as usize;
             let token = thread_id as usize ^ syscall_mask;
             if Syscall::nio() != syscall {
-                eprintln!("{syscall} {token}");
+                eprintln!("generate token:{token} for {syscall}");
             }
             token
         }
@@ -255,8 +255,7 @@ impl<'e> EventLoop<'e> {
                         continue;
                     }
                     // resolve completed read/write tasks
-                    let result = cqe.result() as c_longlong;
-                    eprintln!("io_uring finish {token} {result}");
+                    let result = c_longlong::from(cqe.result());
                     if let Some((_, pair)) = self.syscall_wait_table.remove(&token) {
                         let (lock, cvar) = &*pair;
                         let mut pending = lock.lock().expect("lock failed");
diff --git a/core/src/net/mod.rs b/core/src/net/mod.rs
@@ -11,19 +11,23 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Condvar, Mutex};
 use std::time::Duration;
 
-/// 做C兼容时会用到
-pub type UserFunc = extern "C" fn(usize) -> usize;
-
 cfg_if::cfg_if! {
     if #[cfg(all(target_os = "linux", feature = "io_uring"))] {
         use libc::{epoll_event, iovec, msghdr, off_t, size_t, sockaddr, socklen_t};
         use std::ffi::{c_longlong, c_void};
     }
 }
 
+/// 做C兼容时会用到
+pub type UserFunc = extern "C" fn(usize) -> usize;
+
 mod selector;
 
-#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+#[allow(
+    clippy::cast_possible_truncation,
+    clippy::cast_sign_loss,
+    clippy::too_many_arguments
+)]
 #[cfg(all(target_os = "linux", feature = "io_uring"))]
 mod operator;
 
diff --git a/core/src/net/operator/linux/mod.rs b/core/src/net/operator/linux/mod.rs
@@ -574,7 +574,6 @@ impl Operator<'_> {
         )
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub(crate) fn sendto(
         &self,
         user_data: usize,
diff --git a/core/src/syscall/unix/connect.rs b/core/src/syscall/unix/connect.rs
@@ -74,14 +74,14 @@ impl<I: ConnectSyscall> ConnectSyscall for NioConnectSyscall<I> {
                 {
                     break;
                 }
-                let mut err: c_int = 0;
+                let mut err = 0;
                 unsafe {
                     let mut len: socklen_t = std::mem::zeroed();
                     r = libc::getsockopt(
                         fd,
                         libc::SOL_SOCKET,
                         libc::SO_ERROR,
-                        (std::ptr::addr_of_mut!(err)).cast::<c_void>(),
+                        std::ptr::addr_of_mut!(err).cast::<c_void>(),
                         &mut len,
                     );
                 }
diff --git a/core/src/syscall/unix/mod.rs b/core/src/syscall/unix/mod.rs
@@ -23,7 +23,8 @@ macro_rules! impl_facade {
                     let new_state = $crate::common::constants::SyscallState::Executing;
                     if co.syscall((), syscall, new_state).is_err() {
                         $crate::error!("{} change to syscall {} {} failed !",
-                            co.name(), syscall, new_state);
+                            co.name(), syscall, new_state
+                        );
                     }
                 }
                 let r = self.inner.$syscall(fn_ptr, $($arg, )*);
@@ -32,7 +33,7 @@ macro_rules! impl_facade {
                         $crate::error!("{} change to running state failed !", co.name());
                     }
                 }
-                $crate::info!("exit syscall {}", syscall);
+                $crate::info!("exit syscall {} {:?}", syscall, r);
                 r
             }
         }
@@ -66,9 +67,7 @@ macro_rules! impl_io_uring {
                             if co.syscall((), syscall, new_state).is_err() {
                                 $crate::error!(
                                     "{} change to syscall {} {} failed !",
-                                    co.name(),
-                                    syscall,
-                                    new_state
+                                    co.name(), syscall, new_state
                                 );
                             }
                         }
@@ -84,9 +83,7 @@ macro_rules! impl_io_uring {
                             if co.syscall((), syscall, new_state).is_err() {
                                 $crate::error!(
                                     "{} change to syscall {} {} failed !",
-                                    co.name(),
-                                    syscall,
-                                    new_state
+                                    co.name(), syscall, new_state
                                 );
                             }
                         }
diff --git a/core/src/syscall/unix/poll.rs b/core/src/syscall/unix/poll.rs
@@ -47,7 +47,7 @@ impl<I: PollSyscall> PollSyscall for NioPollSyscall<I> {
         let mut t = if timeout < 0 { c_int::MAX } else { timeout };
         let mut x = 1;
         let mut r;
-        // just check select every x ms
+        // just check poll every x ms
         loop {
             r = self.inner.poll(fn_ptr, fds, nfds, 0);
             if r != 0 || t == 0 {
diff --git a/core/src/syscall/unix/select.rs b/core/src/syscall/unix/select.rs
@@ -35,8 +35,13 @@ trait SelectSyscall {
 }
 
 impl_facade!(SelectSyscallFacade, SelectSyscall,
-    select(nfds: c_int, readfds: *mut fd_set, writefds: *mut fd_set,
-        errorfds: *mut fd_set, timeout: *mut timeval) -> c_int
+    select(
+        nfds: c_int,
+        readfds: *mut fd_set,
+        writefds: *mut fd_set,
+        errorfds: *mut fd_set,
+        timeout: *mut timeval
+    ) -> c_int
 );
 
 #[repr(C)]
@@ -78,7 +83,7 @@ impl<I: SelectSyscall> SelectSyscall for NioSelectSyscall<I> {
         }
         let mut x = 1;
         let mut r;
-        // just check poll every x ms
+        // just check select every x ms
         loop {
             r = self
                 .inner
@@ -111,6 +116,11 @@ impl<I: SelectSyscall> SelectSyscall for NioSelectSyscall<I> {
 }
 
 impl_raw!(RawSelectSyscall, SelectSyscall,
-    select(nfds: c_int, readfds: *mut fd_set, writefds: *mut fd_set,
-        errorfds: *mut fd_set, timeout: *mut timeval) -> c_int
+    select(
+        nfds: c_int,
+        readfds: *mut fd_set,
+        writefds: *mut fd_set,
+        errorfds: *mut fd_set,
+        timeout: *mut timeval
+    ) -> c_int
 );
diff --git a/core/src/syscall/windows/WSAPoll.rs b/core/src/syscall/windows/WSAPoll.rs
@@ -0,0 +1,70 @@
+use crate::net::EventLoops;
+use once_cell::sync::Lazy;
+use std::ffi::{c_int, c_uint};
+use std::time::Duration;
+use windows_sys::Win32::Networking::WinSock::WSAPOLLFD;
+
+#[must_use]
+pub extern "system" fn WSAPoll(
+    fn_ptr: Option<&extern "system" fn(*mut WSAPOLLFD, c_uint, c_int) -> c_int>,
+    fds: *mut WSAPOLLFD,
+    nfds: c_uint,
+    timeout: c_int,
+) -> c_int {
+    static CHAIN: Lazy<PollSyscallFacade<NioPollSyscall<RawPollSyscall>>> =
+        Lazy::new(Default::default);
+    CHAIN.WSAPoll(fn_ptr, fds, nfds, timeout)
+}
+
+trait PollSyscall {
+    extern "system" fn WSAPoll(
+        &self,
+        fn_ptr: Option<&extern "system" fn(*mut WSAPOLLFD, c_uint, c_int) -> c_int>,
+        fds: *mut WSAPOLLFD,
+        nfds: c_uint,
+        timeout: c_int,
+    ) -> c_int;
+}
+
+impl_facade!(PollSyscallFacade, PollSyscall,
+    WSAPoll(fds: *mut WSAPOLLFD, nfds: c_uint, timeout: c_int) -> c_int
+);
+
+#[repr(C)]
+#[derive(Debug, Default)]
+struct NioPollSyscall<I: PollSyscall> {
+    inner: I,
+}
+
+impl<I: PollSyscall> PollSyscall for NioPollSyscall<I> {
+    extern "system" fn WSAPoll(
+        &self,
+        fn_ptr: Option<&extern "system" fn(*mut WSAPOLLFD, c_uint, c_int) -> c_int>,
+        fds: *mut WSAPOLLFD,
+        nfds: c_uint,
+        timeout: c_int,
+    ) -> c_int {
+        let mut t = if timeout < 0 { c_int::MAX } else { timeout };
+        let mut x = 1;
+        let mut r;
+        // just check poll every x ms
+        loop {
+            r = self.inner.WSAPoll(fn_ptr, fds, nfds, 0);
+            if r != 0 || t == 0 {
+                break;
+            }
+            _ = EventLoops::wait_event(Some(Duration::from_millis(t.min(x) as u64)));
+            if t != c_int::MAX {
+                t = if t > x { t - x } else { 0 };
+            }
+            if x < 16 {
+                x <<= 1;
+            }
+        }
+        r
+    }
+}
+
+impl_raw!(RawPollSyscall, PollSyscall, windows_sys::Win32::Networking::WinSock,
+    WSAPoll(fds: *mut WSAPOLLFD, nfds: c_uint, timeout: c_int) -> c_int
+);
diff --git a/core/src/syscall/windows/connect.rs b/core/src/syscall/windows/connect.rs
@@ -0,0 +1,108 @@
+use crate::net::EventLoops;
+use crate::syscall::common::{is_blocking, reset_errno, set_blocking, set_errno, set_non_blocking};
+use once_cell::sync::Lazy;
+use std::ffi::c_int;
+use std::io::Error;
+use windows_sys::Win32::Networking::WinSock::{getpeername, getsockopt, SO_ERROR, SOCKADDR, SOCKET, SOL_SOCKET, WSAEALREADY, WSAEINPROGRESS, WSAEINTR, WSAETIMEDOUT};
+
+#[must_use]
+pub extern "system" fn connect(
+    fn_ptr: Option<&extern "system" fn(SOCKET, *const SOCKADDR, c_int) -> c_int>,
+    socket: SOCKET,
+    address: *const SOCKADDR,
+    len: c_int,
+) -> c_int {
+    static CHAIN: Lazy<ConnectSyscallFacade<NioConnectSyscall<RawConnectSyscall>>> =
+        Lazy::new(Default::default);
+    CHAIN.connect(fn_ptr, socket, address, len)
+}
+
+trait ConnectSyscall {
+    extern "system" fn connect(
+        &self,
+        fn_ptr: Option<&extern "system" fn(SOCKET, *const SOCKADDR, c_int) -> c_int>,
+        fd: SOCKET,
+        address: *const SOCKADDR,
+        len: c_int,
+    ) -> c_int;
+}
+
+impl_facade!(ConnectSyscallFacade, ConnectSyscall,
+    connect(fd: SOCKET, address: *const SOCKADDR, len: c_int) -> c_int
+);
+
+#[repr(C)]
+#[derive(Debug, Default)]
+struct NioConnectSyscall<I: ConnectSyscall> {
+    inner: I,
+}
+
+impl<I: ConnectSyscall> ConnectSyscall for NioConnectSyscall<I> {
+    extern "system" fn connect(
+        &self,
+        fn_ptr: Option<&extern "system" fn(SOCKET, *const SOCKADDR, c_int) -> c_int>,
+        fd: SOCKET,
+        address: *const SOCKADDR,
+        len: c_int,
+    ) -> c_int {
+        let blocking = is_blocking(fd);
+        if blocking {
+            set_non_blocking(fd);
+        }
+        let mut r = self.inner.connect(fn_ptr, fd, address, len);
+        loop {
+            if r == 0 {
+                reset_errno();
+                break;
+            }
+            let errno = Error::last_os_error().raw_os_error();
+            if errno == Some(WSAEINPROGRESS) || errno == Some(WSAEALREADY) {
+                //阻塞，直到写事件发生
+                if EventLoops::wait_write_event(
+                    fd as _,
+                    Some(crate::common::constants::SLICE)
+                ).is_err() {
+                    break;
+                }
+                let mut err = 0;
+                unsafe {
+                    let mut len: c_int = std::mem::zeroed();
+                    r = getsockopt(
+                        fd,
+                        SOL_SOCKET,
+                        SO_ERROR,
+                        std::ptr::addr_of_mut!(err).cast::<u8>(),
+                        &mut len,
+                    );
+                }
+                if r != 0 {
+                    r = -1;
+                    break;
+                }
+                if err != 0 {
+                    set_errno(err);
+                    r = -1;
+                    break;
+                };
+                unsafe {
+                    let mut address = std::mem::zeroed();
+                    let mut address_len = std::mem::zeroed();
+                    r = getpeername(fd, &mut address, &mut address_len);
+                }
+            } else if errno != Some(WSAEINTR) {
+                break;
+            }
+        }
+        if r == -1 && Error::last_os_error().raw_os_error() == Some(WSAETIMEDOUT) {
+            set_errno(WSAEINPROGRESS.try_into().expect("overflow"));
+        }
+        if blocking {
+            set_blocking(fd);
+        }
+        r
+    }
+}
+
+impl_raw!(RawConnectSyscall, ConnectSyscall, windows_sys::Win32::Networking::WinSock,
+    connect(fd: SOCKET, address: *const SOCKADDR, len: c_int) -> c_int
+);
diff --git a/core/src/syscall/windows/mod.rs b/core/src/syscall/windows/mod.rs
diff --git a/core/src/syscall/windows/select.rs b/core/src/syscall/windows/select.rs
diff --git a/hook/src/syscall/windows.rs b/hook/src/syscall/windows.rs
diff --git a/open-coroutine/src/lib.rs b/open-coroutine/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -125,6 +125,8 @@ pub enum Syscall {`
`125`	`125`	`SetFilePointerEx,`
`126`	`126`	`#[cfg(windows)]`
`127`	`127`	`WaitOnAddress,`
	`128`	`+ #[cfg(windows)]`
	`129`	`+ WSAPoll,`
`128`	`130`	`}`
`129`	`131`
`130`	`132`	`impl Syscall {`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ impl<'c> CoroutineLocal<'c> {`
`16`	`16`	`pub fn put<V>(&self, key: &'c str, val: V) -> Option<V> {`
`17`	`17`	`let v = Box::leak(Box::new(val));`
`18`	`18`	`self.0`
`19`		`- .insert(key, std::ptr::from_mut::<V>(v) as usize)`
	`19`	`+ .insert(key, std::ptr::from_mut(v) as usize)`
`20`	`20`	`.map(\|ptr\| unsafe { Box::from_raw((ptr as mut c_void).cast::<V>()) })`
`21`	`21`	`}`
`22`	`22`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ impl<'e> EventLoop<'e> {`
`123`	`123`	`let syscall_mask = <Syscall as Into<&str>>::into(syscall).as_ptr() as usize;`
`124`	`124`	`let token = thread_id as usize ^ syscall_mask;`
`125`	`125`	`if Syscall::nio() != syscall {`
`126`		`- eprintln!("{syscall} {token}");`
	`126`	`+ eprintln!("generate token:{token} for {syscall}");`
`127`	`127`	`}`
`128`	`128`	`token`
`129`	`129`	`}`
`@@ -255,8 +255,7 @@ impl<'e> EventLoop<'e> {`
`255`	`255`	`continue;`
`256`	`256`	`}`
`257`	`257`	`// resolve completed read/write tasks`
`258`		`- let result = cqe.result() as c_longlong;`
`259`		`- eprintln!("io_uring finish {token} {result}");`
	`258`	`+ let result = c_longlong::from(cqe.result());`
`260`	`259`	`if let Some((_, pair)) = self.syscall_wait_table.remove(&token) {`
`261`	`260`	`let (lock, cvar) = &*pair;`
`262`	`261`	`let mut pending = lock.lock().expect("lock failed");`
Original file line number	Diff line number	Diff line change
`@@ -574,7 +574,6 @@ impl Operator<'_> {`
`574`	`574`	`)`
`575`	`575`	`}`
`576`	`576`
`577`		`- #[allow(clippy::too_many_arguments)]`
`578`	`577`	`pub(crate) fn sendto(`
`579`	`578`	`&self,`
`580`	`579`	`user_data: usize,`
Original file line number	Diff line number	Diff line change
`@@ -74,14 +74,14 @@ impl<I: ConnectSyscall> ConnectSyscall for NioConnectSyscall<I> {`
`74`	`74`	`{`
`75`	`75`	`break;`
`76`	`76`	`}`
`77`		`- let mut err: c_int = 0;`
	`77`	`+ let mut err = 0;`
`78`	`78`	`unsafe {`
`79`	`79`	`let mut len: socklen_t = std::mem::zeroed();`
`80`	`80`	`r = libc::getsockopt(`
`81`	`81`	`fd,`
`82`	`82`	`libc::SOL_SOCKET,`
`83`	`83`	`libc::SO_ERROR,`
`84`		`- (std::ptr::addr_of_mut!(err)).cast::<c_void>(),`
	`84`	`+ std::ptr::addr_of_mut!(err).cast::<c_void>(),`
`85`	`85`	`&mut len,`
`86`	`86`	`);`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,8 @@ macro_rules! impl_facade {`
`23`	`23`	`let new_state = $crate::common::constants::SyscallState::Executing;`
`24`	`24`	`if co.syscall((), syscall, new_state).is_err() {`
`25`	`25`	`$crate::error!("{} change to syscall {} {} failed !",`
`26`		`- co.name(), syscall, new_state);`
	`26`	`+ co.name(), syscall, new_state`
	`27`	`+ );`
`27`	`28`	`}`
`28`	`29`	`}`
`29`	`30`	`let r = self.inner.$syscall(fn_ptr, $($arg, )*);`
`@@ -32,7 +33,7 @@ macro_rules! impl_facade {`
`32`	`33`	`$crate::error!("{} change to running state failed !", co.name());`
`33`	`34`	`}`
`34`	`35`	`}`
`35`		`- $crate::info!("exit syscall {}", syscall);`
	`36`	`+ $crate::info!("exit syscall {} {:?}", syscall, r);`
`36`	`37`	`r`
`37`	`38`	`}`
`38`	`39`	`}`
`@@ -66,9 +67,7 @@ macro_rules! impl_io_uring {`
`66`	`67`	`if co.syscall((), syscall, new_state).is_err() {`
`67`	`68`	`$crate::error!(`
`68`	`69`	`"{} change to syscall {} {} failed !",`
`69`		`- co.name(),`
`70`		`- syscall,`
`71`		`- new_state`
	`70`	`+ co.name(), syscall, new_state`
`72`	`71`	`);`
`73`	`72`	`}`
`74`	`73`	`}`
`@@ -84,9 +83,7 @@ macro_rules! impl_io_uring {`
`84`	`83`	`if co.syscall((), syscall, new_state).is_err() {`
`85`	`84`	`$crate::error!(`
`86`	`85`	`"{} change to syscall {} {} failed !",`
`87`		`- co.name(),`
`88`		`- syscall,`
`89`		`- new_state`
	`86`	`+ co.name(), syscall, new_state`
`90`	`87`	`);`
`91`	`88`	`}`
`92`	`89`	`}`