html-to-markdown 2.27.2 → 2.27.3

data/rust-vendor/tokio/src/net/tcp/stream.rs

@@ -1256,9 +1256,10 @@ impl TcpStream {
         /// Reads the linger duration for this socket by getting the `SO_LINGER`
         /// option.
         ///
-        /// For more information about this option, see [`set_linger`].
+        /// For more information about this option, see [`set_zero_linger`] and [`set_linger`].
         ///
         /// [`set_linger`]: TcpStream::set_linger
+        /// [`set_zero_linger`]: TcpStream::set_zero_linger
         ///
         /// # Examples
         ///
@@ -1295,6 +1296,11 @@ impl TcpStream {
         /// >
         /// > From [The ultimate `SO_LINGER` page, or: why is my tcp not reliable](https://blog.netherlabs.nl/articles/2009/01/18/the-ultimate-so_linger-page-or-why-is-my-tcp-not-reliable)
         ///
+        /// Although this method is deprecated, it will not be removed from Tokio.
+        ///
+        /// Note that the special case of setting `SO_LINGER` to zero does not lead to blocking.
+        /// Tokio provides [`set_zero_linger`](Self::set_zero_linger) for this purpose.
+        ///
         /// # Examples
         ///
         /// ```no_run
@@ -1312,6 +1318,39 @@ impl TcpStream {
         pub fn set_linger(&self, dur: Option<Duration>) -> io::Result<()> {
             socket2::SockRef::from(self).set_linger(dur)
         }
+
+        /// Sets a linger duration of zero on this socket by setting the `SO_LINGER` option.
+        ///
+        /// This causes the connection to be forcefully aborted ("abortive close") when the socket
+        /// is dropped or closed. Instead of the normal TCP shutdown handshake (`FIN`/`ACK`), a TCP
+        /// `RST` (reset) segment is sent to the peer, and the socket immediately discards any
+        /// unsent data residing in the socket send buffer. This prevents the socket from entering
+        /// the `TIME_WAIT` state after closing it.
+        ///
+        /// This is a destructive action. Any data currently buffered by the OS but not yet
+        /// transmitted will be lost. The peer will likely receive a "Connection Reset" error
+        /// rather than a clean end-of-stream.
+        ///
+        /// See the documentation for [`set_linger`](Self::set_linger) for additional details on
+        /// how `SO_LINGER` works.
+        ///
+        /// # Examples
+        ///
+        /// ```no_run
+        /// use std::time::Duration;
+        /// use tokio::net::TcpStream;
+        ///
+        /// # async fn dox() -> Result<(), Box<dyn std::error::Error>> {
+        /// let stream = TcpStream::connect("127.0.0.1:8080").await?;
+        ///
+        /// stream.set_zero_linger()?;
+        /// assert_eq!(stream.linger()?, Some(Duration::ZERO));
+        /// # Ok(())
+        /// # }
+        /// ```
+        pub fn set_zero_linger(&self) -> io::Result<()> {
+            socket2::SockRef::from(self).set_linger(Some(Duration::ZERO))
+        }
     }
 
     /// Gets the value of the `IP_TTL` option for this socket.

data/rust-vendor/tokio/src/process/unix/pidfd_reaper.rs

@@ -4,7 +4,6 @@ use crate::{
         imp::{orphan::Wait, OrphanQueue},
         kill::Kill,
     },
-    util::error::RUNTIME_SHUTTING_DOWN_ERROR,
 };
 
 use libc::{syscall, SYS_pidfd_open, ENOSYS, PIDFD_NONBLOCK};
@@ -95,45 +94,6 @@ where
     pidfd: PollEvented<Pidfd>,
 }
 
-fn display_eq(d: impl std::fmt::Display, s: &str) -> bool {
-    use std::fmt::Write;
-
-    struct FormatEq<'r> {
-        remainder: &'r str,
-        unequal: bool,
-    }
-
-    impl<'r> Write for FormatEq<'r> {
-        fn write_str(&mut self, s: &str) -> std::fmt::Result {
-            if !self.unequal {
-                if let Some(new_remainder) = self.remainder.strip_prefix(s) {
-                    self.remainder = new_remainder;
-                } else {
-                    self.unequal = true;
-                }
-            }
-            Ok(())
-        }
-    }
-
-    let mut fmt_eq = FormatEq {
-        remainder: s,
-        unequal: false,
-    };
-    let _ = write!(fmt_eq, "{d}");
-    fmt_eq.remainder.is_empty() && !fmt_eq.unequal
-}
-
-fn is_rt_shutdown_err(err: &io::Error) -> bool {
-    if let Some(inner) = err.get_ref() {
-        err.kind() == io::ErrorKind::Other
-            && inner.source().is_none()
-            && display_eq(inner, RUNTIME_SHUTTING_DOWN_ERROR)
-    } else {
-        false
-    }
-}
-
 impl<W> Future for PidfdReaperInner<W>
 where
     W: Wait + Unpin,
@@ -150,7 +110,7 @@ where
                 }
                 this.pidfd.registration().clear_readiness(evt);
             }
-            Poll::Ready(Err(err)) if is_rt_shutdown_err(&err) => {}
+            Poll::Ready(Err(err)) if crate::runtime::is_rt_shutdown_err(&err) => {}
             Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
             Poll::Pending => return Poll::Pending,
         };

data/rust-vendor/tokio/src/runtime/blocking/pool.rs

@@ -507,6 +507,8 @@ impl Inner {
 
         let mut shared = self.shared.lock();
         let mut join_on_thread = None;
+        // is this thread currently counted in `num_idle_threads`?
+        let mut is_counted_idle;
 
         'main: loop {
             // BUSY
@@ -520,6 +522,8 @@ impl Inner {
 
             // IDLE
             self.metrics.inc_num_idle_threads();
+            // mark this thread as currently counted in `num_idle_threads`.
+            is_counted_idle = true;
 
             while !shared.shutdown {
                 let lock_result = self.condvar.wait_timeout(shared, self.keep_alive).unwrap();
@@ -532,6 +536,9 @@ impl Inner {
                     // acknowledge it by decrementing the counter
                     // and transition to the BUSY state.
                     shared.num_notify -= 1;
+                    // since this is a legitimate wakeup,
+                    // the `Spawner::spawn_task` has already decremented `num_idle_threads`.
+                    is_counted_idle = false;
                     break;
                 }
 
@@ -561,12 +568,6 @@ impl Inner {
                     shared = self.shared.lock();
                 }
 
-                // Work was produced, and we "took" it (by decrementing num_notify).
-                // This means that num_idle was decremented once for our wakeup.
-                // But, since we are exiting, we need to "undo" that, as we'll stay idle.
-                self.metrics.inc_num_idle_threads();
-                // NOTE: Technically we should also do num_notify++ and notify again,
-                // but since we're shutting down anyway, that won't be necessary.
                 break;
             }
         }
@@ -574,14 +575,17 @@ impl Inner {
         // Thread exit
         self.metrics.dec_num_threads();
 
-        // num_idle should now be tracked exactly, panic
-        // with a descriptive message if it is not the
-        // case.
-        let prev_idle = self.metrics.dec_num_idle_threads();
-        assert!(
-            prev_idle >= self.metrics.num_idle_threads(),
-            "num_idle_threads underflowed on thread exit"
-        );
+        // Is this thread currently counted in `num_idle_threads`?
+        if is_counted_idle {
+            // `num_idle_threads` should now be tracked exactly, panic
+            // with a descriptive message if it is not the
+            // case.
+            let prev_idle = self.metrics.dec_num_idle_threads();
+            assert_ne!(
+                prev_idle, 0,
+                "`num_idle_threads` underflowed on thread exit"
+            );
+        }
 
         if shared.shutdown && self.metrics.num_threads() == 0 {
             self.condvar.notify_one();

data/rust-vendor/tokio/src/runtime/builder.rs

@@ -288,7 +288,7 @@ impl Builder {
             max_blocking_threads: 512,
 
             // Default thread name
-            thread_name: std::sync::Arc::new(|| "tokio-runtime-worker".into()),
+            thread_name: std::sync::Arc::new(|| "tokio-rt-worker".into()),
 
             // Do not set a stack size by default
             thread_stack_size: None,
@@ -516,7 +516,7 @@ impl Builder {
 
     /// Sets name of threads spawned by the `Runtime`'s thread pool.
     ///
-    /// The default name is "tokio-runtime-worker".
+    /// The default name is "tokio-rt-worker".
     ///
     /// # Examples
     ///
@@ -540,7 +540,7 @@ impl Builder {
 
     /// Sets a function used to generate the name of threads spawned by the `Runtime`'s thread pool.
     ///
-    /// The default name fn is `|| "tokio-runtime-worker".into()`.
+    /// The default name fn is `|| "tokio-rt-worker".into()`.
     ///
     /// # Examples
     ///
@@ -1116,13 +1116,17 @@ impl Builder {
     /// Setting the event interval determines the effective "priority" of delivering
     /// these external events (which may wake up additional tasks), compared to
     /// executing tasks that are currently ready to run. A smaller value is useful
-    /// when tasks frequently spend a long time in polling, or frequently yield,
+    /// when tasks frequently spend a long time in polling, or infrequently yield,
     /// which can result in overly long delays picking up I/O events. Conversely,
     /// picking up new events requires extra synchronization and syscall overhead,
     /// so if tasks generally complete their polling quickly, a higher event interval
     /// will minimize that overhead while still keeping the scheduler responsive to
     /// events.
     ///
+    /// # Panics
+    ///
+    /// This function will panic if 0 is passed as an argument.
+    ///
     /// # Examples
     ///
     /// ```
@@ -1136,7 +1140,9 @@ impl Builder {
     /// # }
     /// # }
     /// ```
+    #[track_caller]
     pub fn event_interval(&mut self, val: u32) -> &mut Self {
+        assert!(val > 0, "event_interval must be greater than 0");
         self.event_interval = val;
         self
     }

data/rust-vendor/tokio/src/runtime/handle.rs

@@ -166,11 +166,12 @@ impl Handle {
     ///
     /// The provided future will start running in the background immediately
     /// when `spawn` is called, even if you don't await the returned
-    /// `JoinHandle`.
+    /// `JoinHandle` (assuming that the runtime [is running][running-runtime]).
     ///
     /// See [module level][mod] documentation for more details.
     ///
     /// [mod]: index.html
+    /// [running-runtime]: index.html#driving-the-runtime
     ///
     /// # Examples
     ///
@@ -560,7 +561,7 @@ cfg_taskdump! {
         /// You can do this by setting the `RUSTFLAGS` environment variable
         /// before invoking `cargo`; e.g.:
         /// ```bash
-        /// RUSTFLAGS="--cfg tokio_unstable cargo run --example dump
+        /// RUSTFLAGS="--cfg tokio_unstable" cargo run --example dump
         /// ```
         ///
         /// Or by [configuring][cargo-config] `rustflags` in

data/rust-vendor/tokio/src/runtime/io/driver/uring.rs

@@ -1,8 +1,7 @@
-use io_uring::{squeue::Entry, IoUring};
+use io_uring::{squeue::Entry, IoUring, Probe};
 use mio::unix::SourceFd;
 use slab::Slab;
 
-use crate::loom::sync::atomic::Ordering;
 use crate::runtime::driver::op::{Cancellable, Lifecycle};
 use crate::{io::Interest, loom::sync::Mutex};
 
@@ -13,29 +12,6 @@ use std::{io, mem, task::Waker};
 
 const DEFAULT_RING_SIZE: u32 = 256;
 
-#[repr(usize)]
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-enum State {
-    Uninitialized = 0,
-    Initialized = 1,
-    Unsupported = 2,
-}
-
-impl State {
-    fn as_usize(&self) -> usize {
-        *self as usize
-    }
-
-    fn from_usize(value: usize) -> Self {
-        match value {
-            0 => State::Uninitialized,
-            1 => State::Initialized,
-            2 => State::Unsupported,
-            _ => unreachable!("invalid Uring state: {}", value),
-        }
-    }
-}
-
 pub(crate) struct UringContext {
     pub(crate) uring: Option<io_uring::IoUring>,
     pub(crate) ops: slab::Slab<Lifecycle>,
@@ -62,13 +38,24 @@ impl UringContext {
     ///
     /// If the machine doesn't support io_uring, then this will return an
     /// `ENOSYS` error.
-    pub(crate) fn try_init(&mut self) -> io::Result<bool> {
+    pub(crate) fn try_init(&mut self, probe: &mut Probe) -> io::Result<bool> {
         if self.uring.is_some() {
             // Already initialized.
             return Ok(false);
         }
 
-        self.uring.replace(IoUring::new(DEFAULT_RING_SIZE)?);
+        let uring = IoUring::new(DEFAULT_RING_SIZE)?;
+
+        match uring.submitter().register_probe(probe) {
+            Ok(_) => {}
+            Err(e) if e.raw_os_error() == Some(libc::EINVAL) => {
+                // The kernel does not support IORING_REGISTER_PROBE.
+                return Err(io::Error::from_raw_os_error(libc::ENOSYS));
+            }
+            Err(e) => return Err(e),
+        }
+
+        self.uring.replace(uring);
 
         Ok(true)
     }
@@ -177,42 +164,46 @@ impl Handle {
         &self.uring_context
     }
 
-    fn set_uring_state(&self, state: State) {
-        self.uring_state.store(state.as_usize(), Ordering::Release);
-    }
-
     /// Check if the io_uring context is initialized. If not, it will try to initialize it.
-    pub(crate) fn check_and_init(&self) -> io::Result<bool> {
-        match State::from_usize(self.uring_state.load(Ordering::Acquire)) {
-            State::Uninitialized => match self.try_init() {
-                Ok(()) => {
-                    self.set_uring_state(State::Initialized);
-                    Ok(true)
-                }
-                // If the system doesn't support io_uring, we set the state to Unsupported.
-                Err(e) if e.raw_os_error() == Some(libc::ENOSYS) => {
-                    self.set_uring_state(State::Unsupported);
-                    Ok(false)
-                }
-                // If we get EPERM, io-uring syscalls may be blocked (for example, by seccomp).
-                // In this case, we try to fall back to spawn_blocking for this and future operations.
-                // See also: https://github.com/tokio-rs/tokio/issues/7691
-                Err(e) if e.raw_os_error() == Some(libc::EPERM) => {
-                    self.set_uring_state(State::Unsupported);
-                    Ok(false)
+    /// Then, check if the provided opcode is supported.
+    ///
+    /// If both the context initialization succeeds and the opcode is supported,
+    /// this returns `Ok(true)`.
+    /// If either io_uring is unsupported or the opcode is unsupported,
+    /// this returns `Ok(false)`.
+    /// An error is returned if an io_uring syscall returns an unexpected error value.
+    ///
+    /// TODO: This would like to be a synchronous function,
+    /// but we require `OnceLock::get_or_try_init`.
+    /// <https://github.com/rust-lang/rust/issues/109737>
+    pub(crate) async fn check_and_init(&self, opcode: u8) -> io::Result<bool> {
+        let probe = self
+            .uring_probe
+            .get_or_try_init(|| async {
+                let mut probe = Probe::new();
+                match self.try_init(&mut probe) {
+                    Ok(()) => Ok(Some(probe)),
+                    // If the system doesn't support io_uring, we set the probe to `None`.
+                    Err(e) if e.raw_os_error() == Some(libc::ENOSYS) => Ok(None),
+                    // If we get EPERM, io-uring syscalls may be blocked (for example, by seccomp).
+                    // In this case, we try to fall back to spawn_blocking for this and future operations.
+                    // See also: https://github.com/tokio-rs/tokio/issues/7691
+                    Err(e) if e.raw_os_error() == Some(libc::EPERM) => Ok(None),
+                    // For other system errors, we just return it.
+                    Err(e) => Err(e),
                 }
-                // For other system errors, we just return it.
-                Err(e) => Err(e),
-            },
-            State::Unsupported => Ok(false),
-            State::Initialized => Ok(true),
-        }
+            })
+            .await?;
+
+        Ok(probe
+            .as_ref()
+            .is_some_and(|probe| probe.is_supported(opcode)))
     }
 
     /// Initialize the io_uring context if it hasn't been initialized yet.
-    fn try_init(&self) -> io::Result<()> {
+    fn try_init(&self, probe: &mut Probe) -> io::Result<()> {
         let mut guard = self.get_uring().lock();
-        if guard.try_init()? {
+        if guard.try_init(probe)? {
             self.add_uring_source(guard.ring().as_raw_fd())?;
         }
 
@@ -230,10 +221,7 @@ impl Handle {
     /// Callers must ensure that parameters of the entry (such as buffer) are valid and will
     /// be valid for the entire duration of the operation, otherwise it may cause memory problems.
     pub(crate) unsafe fn register_op(&self, entry: Entry, waker: Waker) -> io::Result<usize> {
-        // Note: Maybe this check can be removed if upstream callers consistently use `check_and_init`.
-        if !self.check_and_init()? {
-            return Err(io::Error::from_raw_os_error(libc::ENOSYS));
-        }
+        assert!(self.uring_probe.initialized());
 
         // Uring is initialized.
 

data/rust-vendor/tokio/src/runtime/io/driver.rs

@@ -5,7 +5,7 @@ cfg_signal_internal_and_unix! {
 cfg_io_uring! {
     mod uring;
     use uring::UringContext;
-    use crate::loom::sync::atomic::AtomicUsize;
+    use crate::sync::OnceCell;
 }
 
 use crate::io::interest::Interest;
@@ -67,7 +67,7 @@ pub(crate) struct Handle {
         feature = "fs",
         target_os = "linux",
     ))]
-    pub(crate) uring_state: AtomicUsize,
+    pub(crate) uring_probe: OnceCell<Option<io_uring::Probe>>,
 }
 
 #[derive(Debug)]
@@ -150,7 +150,7 @@ impl Driver {
                 feature = "fs",
                 target_os = "linux",
             ))]
-            uring_state: AtomicUsize::new(0),
+            uring_probe: OnceCell::new(),
         };
 
         Ok((driver, handle))
@@ -296,7 +296,8 @@ impl Handle {
         source: &mut impl Source,
     ) -> io::Result<()> {
         // Deregister the source with the OS poller **first**
-        self.registry.deregister(source)?;
+        // Cleanup ALWAYS happens
+        let os_result = self.registry.deregister(source);
 
         if self
             .registrations
@@ -307,7 +308,7 @@ impl Handle {
 
         self.metrics.dec_fd_count();
 
-        Ok(())
+        os_result // Return error after cleanup
     }
 
     fn release_pending_registrations(&self) {

data/rust-vendor/tokio/src/runtime/mod.rs

@@ -205,6 +205,25 @@
 //! This is done with [`Builder::enable_io`] and [`Builder::enable_time`]. As a
 //! shorthand, [`Builder::enable_all`] enables both resource drivers.
 //!
+//! ## Driving the runtime
+//!
+//! A Tokio runtime can only execute tasks if the runtime is running. Normally
+//! this is not an issue as the default configuration of a runtime is always running,
+//! but alternate configurations such as the current-thread runtime require that
+//! [`Runtime::block_on`] is called.
+//!
+//! - A multi-threaded runtime is always running because it spawns its own worker
+//!   threads.
+//! - A current-thread runtime does not spawn any worker threads, so it can only
+//!   execute tasks when you provide a thread by calling [`Runtime::block_on`].
+//! - A [`LocalSet`](crate::task::LocalSet) only executes local tasks spawned on
+//!   it when the `LocalSet` is `.awaited` or otherwise driven using one of its
+//!   methods for this purpose.
+//!
+//! Please be aware that [`Handle::block_on`] does not drive the runtime.
+//! There must be at least one call to [`Runtime::block_on`] when using the current
+//! thread runtime. [`Handle::block_on`] is not enough.
+//!
 //! ## Lifetime of spawned threads
 //!
 //! The runtime may spawn threads depending on its configuration and usage. The
@@ -569,7 +588,7 @@ cfg_rt! {
     pub use handle::{EnterGuard, Handle, TryCurrentError};
 
     mod runtime;
-    pub use runtime::{Runtime, RuntimeFlavor};
+    pub use runtime::{Runtime, RuntimeFlavor, is_rt_shutdown_err};
 
     mod id;
     pub use id::Id;

data/rust-vendor/tokio/src/runtime/runtime.rs

@@ -3,9 +3,11 @@ use crate::runtime::blocking::BlockingPool;
 use crate::runtime::scheduler::CurrentThread;
 use crate::runtime::{context, EnterGuard, Handle};
 use crate::task::JoinHandle;
+use crate::util::error::RUNTIME_SHUTTING_DOWN_ERROR;
 use crate::util::trace::SpawnMeta;
 
 use std::future::Future;
+use std::io;
 use std::mem;
 use std::time::Duration;
 
@@ -208,11 +210,12 @@ impl Runtime {
     ///
     /// The provided future will start running in the background immediately
     /// when `spawn` is called, even if you don't await the returned
-    /// `JoinHandle`.
+    /// `JoinHandle` (assuming that the runtime [is running][running-runtime]).
     ///
     /// See [module level][mod] documentation for more details.
     ///
     /// [mod]: index.html
+    /// [running-runtime]: index.html#driving-the-runtime
     ///
     /// # Examples
     ///
@@ -513,3 +516,70 @@ impl Drop for Runtime {
 impl std::panic::UnwindSafe for Runtime {}
 
 impl std::panic::RefUnwindSafe for Runtime {}
+
+fn display_eq(d: impl std::fmt::Display, s: &str) -> bool {
+    use std::fmt::Write;
+
+    struct FormatEq<'r> {
+        remainder: &'r str,
+        unequal: bool,
+    }
+
+    impl<'r> Write for FormatEq<'r> {
+        fn write_str(&mut self, s: &str) -> std::fmt::Result {
+            if !self.unequal {
+                if let Some(new_remainder) = self.remainder.strip_prefix(s) {
+                    self.remainder = new_remainder;
+                } else {
+                    self.unequal = true;
+                }
+            }
+            Ok(())
+        }
+    }
+
+    let mut fmt_eq = FormatEq {
+        remainder: s,
+        unequal: false,
+    };
+    let _ = write!(fmt_eq, "{d}");
+    fmt_eq.remainder.is_empty() && !fmt_eq.unequal
+}
+
+/// Checks whether the given error was emitted by Tokio when shutting down its runtime.
+///
+/// # Examples
+///
+/// ```
+/// # #[cfg(not(target_family = "wasm"))]
+/// # {
+/// use tokio::runtime::Runtime;
+/// use tokio::net::TcpListener;
+///
+/// fn main() {
+///     let rt1 = Runtime::new().unwrap();
+///     let rt2 = Runtime::new().unwrap();
+///
+///     let listener = rt1.block_on(async {
+///         TcpListener::bind("127.0.0.1:0").await.unwrap()
+///     });
+///
+///     drop(rt1);
+///
+///     rt2.block_on(async {
+///         let res = listener.accept().await;
+///         assert!(res.is_err());
+///         assert!(tokio::runtime::is_rt_shutdown_err(res.as_ref().unwrap_err()));
+///     });
+/// }
+/// # }
+/// ```
+pub fn is_rt_shutdown_err(err: &io::Error) -> bool {
+    if let Some(inner) = err.get_ref() {
+        err.kind() == io::ErrorKind::Other
+            && inner.source().is_none()
+            && display_eq(inner, RUNTIME_SHUTTING_DOWN_ERROR)
+    } else {
+        false
+    }
+}