Fix false positive GSO detection

quinn-udp/src/unix.rs

@@ -1,5 +1,7 @@
 #[cfg(not(any(apple, target_os = "openbsd", solarish)))]
 use std::ptr;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use std::sync::OnceLock;
 use std::{
     io::{self, IoSliceMut},
     mem::{self, MaybeUninit},
@@ -794,6 +796,91 @@ pub(crate) const BATCH_SIZE: usize = 32;
 #[cfg(apple_slow)]
 pub(crate) const BATCH_SIZE: usize = 1;
 
+#[cfg(any(target_os = "linux", target_os = "android"))]
+mod linux {
+    pub(crate) fn kernel_version_string() -> Result<String, libc::c_int> {
+        let mut n = unsafe { std::mem::zeroed() };
+        let r = unsafe { libc::uname(&mut n) };
+        if r != 0 {
+            return Err(r);
+        }
+        Ok(unsafe {
+            std::ffi::CStr::from_ptr(n.release[..].as_ptr())
+                .to_string_lossy()
+                .into_owned()
+        })
+    }
+
+    // https://www.linfo.org/kernel_version_numbering.html
+    #[derive(Eq, PartialEq, Ord, PartialOrd, Debug)]
+    pub(crate) struct KernelVersion {
+        version: u8,
+        major_revision: u8,
+    }
+
+    impl KernelVersion {
+        pub(crate) const fn new(version: u8, major_revision: u8) -> Self {
+            Self {
+                version,
+                major_revision,
+            }
+        }
+
+        pub(crate) fn from_str(release: &str) -> Result<Self, String> {
+            let mut split = release
+                .split_once('-')
+                .map(|pair| pair.0)
+                .unwrap_or(release)
+                .split('.');
+
+            let Some(version) = split.next().and_then(|s| s.parse().ok()) else {
+                return Err(format!("Failed to parse kernel version from {release:?}"));
+            };
+            let Some(major_revision) = split.next().and_then(|s| s.parse().ok()) else {
+                return Err(format!(
+                    "Failed to parse kernel major revision from {release:?}"
+                ));
+            };
+
+            Ok(Self {
+                version,
+                major_revision,
+            })
+        }
+    }
+
+    #[cfg(test)]
+    mod test {
+        use super::*;
+
+        #[test]
+        fn parse_current_kernel_version_release_string() {
+            let release = kernel_version_string().unwrap();
+            KernelVersion::from_str(&release).unwrap();
+        }
+
+        #[test]
+        fn parse_kernel_version_release_string() {
+            assert_eq!(
+                KernelVersion::from_str("4.14"),
+                Ok(KernelVersion::new(4, 14))
+            );
+            assert_eq!(
+                KernelVersion::from_str("4.18"),
+                Ok(KernelVersion::new(4, 18))
+            );
+            assert_eq!(
+                KernelVersion::from_str("4.14.186-27095505"),
+                Ok(KernelVersion::new(4, 14))
+            );
+            assert_eq!(
+                KernelVersion::from_str("6.8.0-59-generic"),
+                Ok(KernelVersion::new(6, 8))
+            );
+        }
+    }
+}
+
 #[cfg(any(target_os = "linux", target_os = "android"))]
 mod gso {
     use super::*;
@@ -803,12 +890,21 @@ mod gso {
     #[cfg(target_os = "android")]
     // TODO: Add this to libc
     const UDP_SEGMENT: libc::c_int = 103;
-
-    /// Checks whether GSO support is available by setting the UDP_SEGMENT
-    /// option on a socket
+    // Support for UDP GSO has been added to linux kernel in version 4.18
+    // https://github.com/torvalds/linux/commit/cb586c63e3fc5b227c51fd8c4cb40b34d3750645
+    const SUPPORTED_SINCE: linux::KernelVersion = linux::KernelVersion::new(4, 18);
+    // Avoid calling `supported_by_current_kernel` for each socket by using `OnceLock`.
+    static SUPPORTED_BY_CURRENT_KERNEL: OnceLock<bool> = OnceLock::new();
+
+    /// Checks whether GSO support is available by checking the kernel version followed by setting
+    /// the UDP_SEGMENT option on a socket
     pub(crate) fn max_gso_segments() -> usize {
         const GSO_SIZE: libc::c_int = 1500;
 
+        if !SUPPORTED_BY_CURRENT_KERNEL.get_or_init(supported_by_current_kernel) {
+            return 1;
+        }
+
         let socket = match std::net::UdpSocket::bind("[::]:0")
             .or_else(|_| std::net::UdpSocket::bind((Ipv4Addr::LOCALHOST, 0)))
         {
@@ -830,6 +926,36 @@ mod gso {
         }
     }
 
+    fn supported_by_current_kernel() -> bool {
+        let kernel_version_string = match linux::kernel_version_string() {
+            Ok(kernel_version_string) => kernel_version_string,
+            Err(_errno) => {
+                crate::log::warn!(
+                    "Failed to retrieve kernel version string, GSO not enabled ({_errno})"
+                );
+                return false;
+            }
+        };
+
+        let kernel_version = match linux::KernelVersion::from_str(&kernel_version_string) {
+            Ok(kernel_version) => kernel_version,
+            Err(_reason) => {
+                crate::log::warn!("GSO not enabled: {}", _reason);
+                return false;
+            }
+        };
+
+        if kernel_version < SUPPORTED_SINCE {
+            crate::log::info!(
+                "GSO supported on Linux kernels 4.18+, current is {:?}",
+                kernel_version_string
+            );
+            false
+        } else {
+            true
+        }
+    }
+
     pub(crate) fn set_segment_size(encoder: &mut cmsg::Encoder<libc::msghdr>, segment_size: u16) {
         encoder.push(libc::SOL_UDP, UDP_SEGMENT, segment_size);
     }