Update minhook requirement from 0.6 to 0.7

.github/workflows/ci-preemptive.sh

@@ -7,7 +7,7 @@ if [ "${CROSS}" = "1" ]; then
     export CARGO_NET_RETRY=5
     export CARGO_NET_TIMEOUT=10
 
-    cargo install cross --git https://github.com/cross-rs/cross --rev 4090beca3cfffa44371a5bba524de3a578aa46c3
+    cargo install cross --git https://github.com/cross-rs/cross --rev c7dee4d008475ce1c140773cbcd6078f4b86c2aa
     CARGO=cross
 fi
 

.github/workflows/ci.sh

@@ -7,7 +7,7 @@ if [ "${CROSS}" = "1" ]; then
     export CARGO_NET_RETRY=5
     export CARGO_NET_TIMEOUT=10
 
-    cargo install cross --git https://github.com/cross-rs/cross --rev 4090beca3cfffa44371a5bba524de3a578aa46c3
+    cargo install cross --git https://github.com/cross-rs/cross --rev c7dee4d008475ce1c140773cbcd6078f4b86c2aa
     CARGO=cross
 fi
 

Cargo.toml

@@ -45,7 +45,7 @@ windows-sys = "0.59"
 anyhow = "1.0"
 slab = "0.4"
 backtrace = "0.3"
-minhook = "0.6"
+minhook = "0.7"
 psm = "0.1"
 
 once_cell = "1"

core/docs/en/coroutine.md

@@ -54,7 +54,7 @@ The above is excerpted from [corosensei](https://github.com/Amanieu/corosensei).
 | switch efficiency | ✅ Higher      | ❌ High  |
 | memory usage      | ✅ Bytes/KB/MB | ❌ KB/MB |
 | scheduled by OS   | ❌             | ✅       |
-| stack grow        | ✅             | ❌       |
+| grow stack        | ✅             | ❌       |
 
 ## Stackfull VS Stackless
 

core/src/co_pool/mod.rs

@@ -221,10 +221,7 @@ impl<'p> CoroutinePool<'p> {
         match self.state() {
             PoolState::Running => {}
             PoolState::Stopping | PoolState::Stopped => {
-                return Err(Error::new(
-                    ErrorKind::Other,
-                    "The coroutine pool is stopping or stopped !",
-                ))
+                return Err(Error::other("The coroutine pool is stopping or stopped !"))
             }
         }
         let name = name.unwrap_or(format!("{}@{}", self.name(), uuid::Uuid::new_v4()));
@@ -292,12 +289,11 @@ impl<'p> CoroutinePool<'p> {
         let (lock, cvar) = &*arc;
         drop(
             cvar.wait_timeout_while(
-                lock.lock()
-                    .map_err(|e| Error::new(ErrorKind::Other, format!("{e}")))?,
+                lock.lock().map_err(|e| Error::other(format!("{e}")))?,
                 wait_time,
                 |&mut pending| pending,
             )
-            .map_err(|e| Error::new(ErrorKind::Other, format!("{e}")))?,
+            .map_err(|e| Error::other(format!("{e}")))?,
         );
         if let Some(r) = self.try_take_task_result(key) {
             self.notify(key);
@@ -372,8 +368,7 @@ impl<'p> CoroutinePool<'p> {
                 "The coroutine pool:{} has reached its maximum size !",
                 self.name()
             );
-            return Err(Error::new(
-                ErrorKind::Other,
+            return Err(Error::other(
                 "The coroutine pool has reached its maximum size !",
             ));
         }
@@ -447,12 +442,7 @@ impl<'p> CoroutinePool<'p> {
             PoolState::Running | PoolState::Stopping => {
                 drop(self.try_grow());
             }
-            PoolState::Stopped => {
-                return Err(Error::new(
-                    ErrorKind::Other,
-                    "The coroutine pool is stopped !",
-                ))
-            }
+            PoolState::Stopped => return Err(Error::other("The coroutine pool is stopped !")),
         }
         Self::init_current(self);
         let r = self.try_timeout_schedule(timeout_time);

core/src/co_pool/state.rs

@@ -1,6 +1,6 @@
 use crate::co_pool::CoroutinePool;
 use crate::common::constants::PoolState;
-use std::io::{Error, ErrorKind};
+use std::io::Error;
 
 impl CoroutinePool<'_> {
     /// running -> stopping
@@ -37,10 +37,11 @@ impl CoroutinePool<'_> {
             assert_eq!(old_state, self.state.replace(new_state));
             return Ok(old_state);
         }
-        Err(Error::new(
-            ErrorKind::Other,
-            format!("{} unexpected {current}->{:?}", self.name(), new_state),
-        ))
+        Err(Error::other(format!(
+            "{} unexpected {current}->{:?}",
+            self.name(),
+            new_state
+        )))
     }
 }
 

core/src/coroutine/korosensei.rs

@@ -11,7 +11,7 @@ use std::cell::{Cell, RefCell, UnsafeCell};
 use std::collections::VecDeque;
 use std::ffi::c_longlong;
 use std::fmt::Debug;
-use std::io::{Error, ErrorKind};
+use std::io::Error;
 
 cfg_if::cfg_if! {
     if #[cfg(unix)] {
@@ -452,10 +452,10 @@ where
                     CoroutineState::Syscall(y, syscall, state) => {
                         Ok(CoroutineState::Syscall(y, syscall, state))
                     }
-                    _ => Err(Error::new(
-                        ErrorKind::Other,
-                        format!("{} unexpected state {current}", self.name()),
-                    )),
+                    _ => Err(Error::other(format!(
+                        "{} unexpected state {current}",
+                        self.name()
+                    ))),
                 }
             }
             CoroutineResult::Return(result) => {

core/src/coroutine/state.rs

@@ -4,7 +4,7 @@ use crate::coroutine::listener::Listener;
 use crate::coroutine::Coroutine;
 use crate::{error, info};
 use std::fmt::Debug;
-use std::io::{Error, ErrorKind};
+use std::io::Error;
 
 impl<Param, Yield, Return> Coroutine<'_, Param, Yield, Return>
 where
@@ -45,14 +45,11 @@ where
             }
             _ => {}
         }
-        Err(Error::new(
-            ErrorKind::Other,
-            format!(
-                "{} unexpected {current}->{:?}",
-                self.name(),
-                CoroutineState::<Yield, Return>::Ready
-            ),
-        ))
+        Err(Error::other(format!(
+            "{} unexpected {current}->{:?}",
+            self.name(),
+            CoroutineState::<Yield, Return>::Ready
+        )))
     }
 
     /// ready -> running
@@ -87,14 +84,11 @@ where
             }
             _ => {}
         }
-        Err(Error::new(
-            ErrorKind::Other,
-            format!(
-                "{} unexpected {current}->{:?}",
-                self.name(),
-                CoroutineState::<Yield, Return>::Running
-            ),
-        ))
+        Err(Error::other(format!(
+            "{} unexpected {current}->{:?}",
+            self.name(),
+            CoroutineState::<Yield, Return>::Running
+        )))
     }
 
     /// running -> suspend
@@ -109,14 +103,11 @@ where
             self.on_suspend(self, old_state);
             return Ok(());
         }
-        Err(Error::new(
-            ErrorKind::Other,
-            format!(
-                "{} unexpected {current}->{:?}",
-                self.name(),
-                CoroutineState::<Yield, Return>::Suspend(val, timestamp)
-            ),
-        ))
+        Err(Error::other(format!(
+            "{} unexpected {current}->{:?}",
+            self.name(),
+            CoroutineState::<Yield, Return>::Suspend(val, timestamp)
+        )))
     }
 
     /// running -> syscall
@@ -148,14 +139,11 @@ where
             }
             _ => {}
         }
-        Err(Error::new(
-            ErrorKind::Other,
-            format!(
-                "{} unexpected {current}->{:?}",
-                self.name(),
-                CoroutineState::<Yield, Return>::Syscall(val, syscall, syscall_state)
-            ),
-        ))
+        Err(Error::other(format!(
+            "{} unexpected {current}->{:?}",
+            self.name(),
+            CoroutineState::<Yield, Return>::Syscall(val, syscall, syscall_state)
+        )))
     }
 
     /// running -> complete
@@ -170,14 +158,11 @@ where
             self.on_complete(self, old_state, val);
             return Ok(());
         }
-        Err(Error::new(
-            ErrorKind::Other,
-            format!(
-                "{} unexpected {current}->{:?}",
-                self.name(),
-                CoroutineState::<Yield, Return>::Complete(val)
-            ),
-        ))
+        Err(Error::other(format!(
+            "{} unexpected {current}->{:?}",
+            self.name(),
+            CoroutineState::<Yield, Return>::Complete(val)
+        )))
     }
 
     /// running -> error
@@ -192,14 +177,11 @@ where
             self.on_error(self, old_state, msg);
             return Ok(());
         }
-        Err(Error::new(
-            ErrorKind::Other,
-            format!(
-                "{} unexpected {current}->{:?}",
-                self.name(),
-                CoroutineState::<Yield, Return>::Error(msg)
-            ),
-        ))
+        Err(Error::other(format!(
+            "{} unexpected {current}->{:?}",
+            self.name(),
+            CoroutineState::<Yield, Return>::Error(msg)
+        )))
     }
 }
 

core/src/net/operator/windows/mod.rs

@@ -239,7 +239,7 @@ impl<'o> Operator<'o> {
                 &mut sock_info_len,
             ) != 0
             {
-                return Err(Error::new(ErrorKind::Other, "get socket info failed"));
+                return Err(Error::other("get socket info failed"));
             }
             self.add_handle(fd as HANDLE)?;
             let socket = WSASocketW(
@@ -251,10 +251,7 @@ impl<'o> Operator<'o> {
                 WSA_FLAG_OVERLAPPED,
             );
             if INVALID_SOCKET == socket {
-                return Err(Error::new(
-                    ErrorKind::Other,
-                    format!("add {syscall_name} operation failed"),
-                ));
+                return Err(Error::other(format!("add {syscall_name} operation failed")));
             }
             let size = size_of::<SOCKADDR_IN>()
                 .saturating_add(16)
@@ -370,10 +367,9 @@ impl<'o> Operator<'o> {
             {
                 let errno = WSAGetLastError();
                 if WSA_IO_PENDING != errno {
-                    return Err(Error::new(
-                        ErrorKind::Other,
-                        format!("add {syscall_name} operation failed with {errno}"),
-                    ));
+                    return Err(Error::other(format!(
+                        "add {syscall_name} operation failed with {errno}"
+                    )));
                 }
             }
             eprintln!("add {syscall_name} operation:{overlapped}");
@@ -464,10 +460,9 @@ impl<'o> Operator<'o> {
             {
                 let errno = WSAGetLastError();
                 if WSA_IO_PENDING != errno {
-                    return Err(Error::new(
-                        ErrorKind::Other,
-                        format!("add {syscall_name} operation failed with {errno}"),
-                    ));
+                    return Err(Error::other(format!(
+                        "add {syscall_name} operation failed with {errno}"
+                    )));
                 }
             }
             eprintln!("add {syscall_name} operation:{overlapped}");

core/src/scheduler.rs

@@ -9,7 +9,7 @@ use crate::{co, impl_current_for, impl_display_by_debug, impl_for_named};
 use dashmap::DashMap;
 use std::collections::{BinaryHeap, HashMap, VecDeque};
 use std::ffi::c_longlong;
-use std::io::{Error, ErrorKind};
+use std::io::Error;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::Duration;
 
@@ -318,8 +318,7 @@ impl<'s> Scheduler<'s> {
                         );
                     }
                     _ => {
-                        return Err(Error::new(
-                            ErrorKind::Other,
+                        return Err(Error::other(
                             "try_timeout_schedule should never execute to here",
                         ));
                     }

core/tests/coroutine.rs

@@ -23,10 +23,7 @@ fn coroutine_panic() -> std::io::Result<()> {
     })?;
     match coroutine.resume()? {
         CoroutineState::Error(_) => Ok(()),
-        _ => Err(std::io::Error::new(
-            std::io::ErrorKind::Other,
-            "The coroutine should panic",
-        )),
+        _ => Err(std::io::Error::other("The coroutine should panic")),
     }
 }
 
@@ -233,8 +230,7 @@ fn coroutine_preemptive() -> std::io::Result<()> {
         )
         .unwrap();
     if result.1.timed_out() {
-        Err(std::io::Error::new(
-            std::io::ErrorKind::Other,
+        Err(std::io::Error::other(
             "The monitor should send signals to coroutines in running state",
         ))
     } else {
@@ -279,8 +275,7 @@ fn coroutine_syscall_not_preemptive() -> std::io::Result<()> {
     if result.1.timed_out() {
         Ok(())
     } else {
-        Err(std::io::Error::new(
-            std::io::ErrorKind::Other,
+        Err(std::io::Error::other(
             "The monitor should not send signals to coroutines in syscall state",
         ))
     }