test: Set version-dependent skips based on header defines

When there are additions or updates that are made that are only
available with newer platform versions, we don't have a great way to
handle testing. The only thing we can really do is unconditionally skip
anything that doesn't pass on the oldest versions we have on CI.

Check these versions using an expand-only compiler invocation;

Author: tgross35

libc-test/build.rs

@@ -11,11 +11,18 @@ use std::path::{
     Path,
     PathBuf,
 };
+use std::process::{
+    Command,
+    Stdio,
+};
+use std::sync::LazyLock;
 use std::{
     env,
     io,
 };
 
+use regex::Regex;
+
 fn do_cc() {
     let target = env::var("TARGET").unwrap();
     if cfg!(unix) || target.contains("cygwin") {
@@ -176,6 +183,8 @@ fn process_semver_file<W: Write, P: AsRef<Path>>(output: &mut W, path: &mut Path
 fn main() {
     // Avoid unnecessary re-building.
     println!("cargo:rerun-if-changed=build.rs");
+    // Ensure version checking works, even if we don't use it.
+    LazyLock::force(&VERSIONS);
 
     do_cc();
     do_ctest();
@@ -1201,10 +1210,7 @@ fn test_netbsd(target: &str) {
     let mut cfg = ctest_cfg();
 
     // Assume netbsd10 but check for netbsd9 for test config.
-    let netbsd9 = match try_command_output("uname", &["-sr"]) {
-        Some(s) if s.starts_with("NetBSD 9.") => true,
-        _ => false,
-    };
+    let netbsd9 = matches!(VERSIONS.netbsd, Some((9, _)));
 
     cfg.flag("-Wno-deprecated-declarations");
     cfg.define("_NETBSD_SOURCE", Some("1"));
@@ -3731,6 +3737,8 @@ fn test_linux(target: &str) {
     let mips = target.contains("mips");
     let mips64 = target.contains("mips64");
     let mips32 = mips && !mips64;
+    let kernel = VERSIONS.linux.unwrap_or((0, 0));
+    println!("cargo:warning=kernel version: {kernel:?}");
 
     let musl_v1_2_3 = env::var("RUST_LIBC_UNSTABLE_MUSL_V1_2_3").is_ok();
     if musl_v1_2_3 {
@@ -4183,13 +4191,13 @@ fn test_linux(target: &str) {
             "sched_attr" => true,
 
             // FIXME(linux): Requires >= 6.9 kernel headers.
-            "epoll_params" => true,
+            "epoll_params" => kernel < (6,9),
 
             // FIXME(linux): Requires >= 6.12 kernel headers.
-            "dmabuf_cmsg" | "dmabuf_token" => true,
+            "dmabuf_cmsg" | "dmabuf_token" => kernel < (6, 12),
 
             // FIXME(linux): Requires >= 6.12 kernel headers.
-            "mnt_ns_info" => true,
+            "mnt_ns_info" => kernel < (6,12),
 
             // FIXME(musl): Struct has changed for new musl versions
             "tcp_info" if musl => true,
@@ -4596,7 +4604,7 @@ fn test_linux(target: &str) {
             "PIDFD_THREAD"
             | "PIDFD_SIGNAL_THREAD"
             | "PIDFD_SIGNAL_THREAD_GROUP"
-            | "PIDFD_SIGNAL_PROCESS_GROUP" => true,
+            | "PIDFD_SIGNAL_PROCESS_GROUP" => kernel < (6, 9),
             // Linux >= 6.11
             "PIDFD_GET_CGROUP_NAMESPACE"
             | "PIDFD_GET_IPC_NAMESPACE"
@@ -4607,15 +4615,15 @@ fn test_linux(target: &str) {
             | "PIDFD_GET_TIME_NAMESPACE"
             | "PIDFD_GET_TIME_FOR_CHILDREN_NAMESPACE"
             | "PIDFD_GET_USER_NAMESPACE"
-            | "PIDFD_GET_UTS_NAMESPACE" => true,
+            | "PIDFD_GET_UTS_NAMESPACE" => kernel < (6, 11),
             // Linux >= 6.13
             "PIDFD_GET_INFO"
             | "PIDFD_INFO_PID"
             | "PIDFD_INFO_CREDS"
             | "PIDFD_INFO_CGROUPID"
-            | "PIDFD_INFO_SIZE_VER0" => true,
+            | "PIDFD_INFO_SIZE_VER0" => kernel < (6, 13),
             // Linux >= 6.15
-            "PIDFD_INFO_EXIT" | "PIDFD_SELF" | "PIDFD_SELF_PROCESS" => true,
+            "PIDFD_INFO_EXIT" | "PIDFD_SELF" | "PIDFD_SELF_PROCESS" => kernel < (6, 15),
 
             // is a private value for kernel usage normally
             "FUSE_SUPER_MAGIC" => true,
@@ -4635,13 +4643,13 @@ fn test_linux(target: &str) {
             "NF_NETDEV_NUMHOOKS" | "RLIM_NLIMITS" | "NFT_MSG_MAX" if uclibc => true,
 
             // kernel 6.9 minimum
-            "RWF_NOAPPEND" => true,
+            "RWF_NOAPPEND" => kernel < (6, 9),
 
             // kernel 6.11 minimum
-            "RWF_ATOMIC" => true,
+            "RWF_ATOMIC" => kernel < (6, 11),
 
             // kernel 6.14 minimum
-            "RWF_DONTCACHE" => true,
+            "RWF_DONTCACHE" => kernel < (6, 14),
 
             // musl doesn't use <linux/fanotify.h> in <sys/fanotify.h>
             "FAN_REPORT_PIDFD"
@@ -4659,7 +4667,7 @@ fn test_linux(target: &str) {
             }
 
             // FIXME(linux32): Requires >= 6.6 kernel headers.
-            "XDP_USE_SG" | "XDP_PKT_CONTD" if pointer_width == 32 => true,
+            "XDP_USE_SG" | "XDP_PKT_CONTD" if pointer_width == 32 => kernel < (6, 6),
 
             // FIXME(linux): Missing only on this platform for some reason
             "PR_MDWE_NO_INHERIT" if gnueabihf => true,
@@ -4672,25 +4680,25 @@ fn test_linux(target: &str) {
             | "XDP_TX_METADATA"
                 if musl || pointer_width == 32 =>
             {
-                true
+                musl || kernel < (6, 8)
             }
 
             // FIXME(linux): Requires >= 6.11 kernel headers.
-            "XDP_UMEM_TX_METADATA_LEN" => true,
+            "XDP_UMEM_TX_METADATA_LEN" => kernel < (6, 11),
 
             // FIXME(linux): Requires >= 6.11 kernel headers.
             "NS_GET_MNTNS_ID"
             | "NS_GET_PID_FROM_PIDNS"
             | "NS_GET_TGID_FROM_PIDNS"
             | "NS_GET_PID_IN_PIDNS"
-            | "NS_GET_TGID_IN_PIDNS" => true,
+            | "NS_GET_TGID_IN_PIDNS" => kernel < (6, 11),
             // FIXME(linux): Requires >= 6.12 kernel headers.
             "MNT_NS_INFO_SIZE_VER0" | "NS_MNT_GET_INFO" | "NS_MNT_GET_NEXT" | "NS_MNT_GET_PREV" => {
-                true
+                kernel < (6, 12)
             }
 
             // FIXME(linux): Requires >= 6.10 kernel headers.
-            "SYS_mseal" => true,
+            "SYS_mseal" => kernel < (6, 10),
 
             // FIXME(linux): seems to not be available all the time (from <include/linux/sched.h>:
             "PF_VCPU" | "PF_IDLE" | "PF_EXITING" | "PF_POSTCOREDUMP" | "PF_IO_WORKER"
@@ -4702,42 +4710,42 @@ fn test_linux(target: &str) {
             | "PF_BLOCK_TS" | "PF_SUSPEND_TASK" => true,
 
             // FIXME(linux): Requires >= 6.9 kernel headers.
-            "EPIOCSPARAMS" | "EPIOCGPARAMS" => true,
+            "EPIOCSPARAMS" | "EPIOCGPARAMS" => kernel < (6, 9),
 
             // FIXME(linux): Requires >= 6.11 kernel headers.
-            "MAP_DROPPABLE" => true,
+            "MAP_DROPPABLE" => kernel < (6, 11),
 
             // FIXME(linux): Requires >= 6.12 kernel headers.
-            "SOF_TIMESTAMPING_OPT_RX_FILTER" => true,
+            "SOF_TIMESTAMPING_OPT_RX_FILTER" => kernel < (6, 12),
 
             // FIXME(linux): Requires >= 6.12 kernel headers.
             "SO_DEVMEM_LINEAR" | "SO_DEVMEM_DMABUF" | "SO_DEVMEM_DONTNEED"
-            | "SCM_DEVMEM_LINEAR" | "SCM_DEVMEM_DMABUF" => true,
+            | "SCM_DEVMEM_LINEAR" | "SCM_DEVMEM_DMABUF" => kernel < (6, 12),
 
             // FIXME(linux): Requires >= 6.14 kernel headers.
             "SECBIT_EXEC_DENY_INTERACTIVE"
             | "SECBIT_EXEC_DENY_INTERACTIVE_LOCKED"
             | "SECBIT_EXEC_RESTRICT_FILE"
             | "SECBIT_EXEC_RESTRICT_FILE_LOCKED"
-            | "SECURE_ALL_UNPRIVILEGED" => true,
+            | "SECURE_ALL_UNPRIVILEGED" => kernel < (6, 14),
 
             // FIXME(linux): Value changed in 6.14
-            "SECURE_ALL_BITS" | "SECURE_ALL_LOCKS" => true,
+            "SECURE_ALL_BITS" | "SECURE_ALL_LOCKS" => kernel < (6, 14),
 
             // FIXME(linux): Requires >= 6.9 kernel headers.
-            "AT_HWCAP3" | "AT_HWCAP4" => true,
+            "AT_HWCAP3" | "AT_HWCAP4" => kernel < (6, 9),
 
             // Linux 6.14
-            "AT_EXECVE_CHECK" => true,
+            "AT_EXECVE_CHECK" => kernel < (6, 14),
 
             // FIXME(linux):  Requires >= 6.16 kernel headers.
-            "PTRACE_SET_SYSCALL_INFO" => true,
+            "PTRACE_SET_SYSCALL_INFO" => kernel < (6, 16),
 
             // FIXME(linux): Requires >= 6.13 kernel headers.
-            "AT_HANDLE_CONNECTABLE" => true,
+            "AT_HANDLE_CONNECTABLE" => kernel < (6, 13),
 
             // FIXME(linux): Requires >= 6.12 kernel headers.
-            "AT_HANDLE_MNT_ID_UNIQUE" => true,
+            "AT_HANDLE_MNT_ID_UNIQUE" => kernel < (6, 12),
 
             // FIXME(musl): This value is not yet in musl.
             // eabihf targets are tested using an older version of glibc
@@ -6091,10 +6099,139 @@ fn test_qurt(target: &str) {
     ctest::generate_test(&mut cfg, "../src/lib.rs", "ctest_output.rs").unwrap();
 }
 
+/// Platform versions for checking expected support. These are extracted from headers so should be
+/// accurate for the target we are building, rather than the host (which `uname` would provide).
+static VERSIONS: LazyLock<Versions> = LazyLock::new(Versions::init_from_cc);
+
+#[derive(Clone, Copy, Debug, Default)]
+struct Versions {
+    linux: Option<(u32, u32)>,
+    glibc: Option<(u32, u32)>,
+    freebsd: Option<(u32, u32)>,
+    openbsd: Option<(u32, u32)>,
+    netbsd: Option<(u32, u32)>,
+    macos: Option<(u32, u32)>,
+}
+
+impl Versions {
+    fn init_from_cc() -> Self {
+        let src = r#"
+            #ifdef __linux__
+            /* Defines LINUX_VERSION_MAJOR, LINUX_VERSION_PATCHLEVEL (integers) */
+            #include "linux/version.h"
+            #endif
+
+            /* Including a libc header will define __GLIBC__ */
+            #include <stdio.h>
+
+            #ifdef __GLIBC__
+            /* Provides __GLIBC__, __GLIBC_MINOR__ (integers) */
+            #include "gnu/libc-version.h"
+            #endif
+
+            #if defined(__FreeBSD__) \
+                || defined(__NetBSD__) \
+                || defined(__OpenBSD__) \
+                || defined(__APPLE__)
+            /* FreeBSD: __FreeBSD_version (MMmmRxx string, e.g. 1600018)
+             * NetBSD: __NetBSD_Version__ (MMmmrrpp00 string, e.g. 1001000000)
+             * OpenBSD: OpenBSD (release date, e.g. 202510) and OpenBSDM_m (e.g. OpenBSD7_8)
+             * Apple: __MAC_OS_X_VERSION_MAX_ALLOWED __MAC_M_m (e.g. __MAC_26_5)
+             */
+            #include "sys/param.h"
+            #endif
+        "#;
+
+        let mut ret = Versions::default();
+
+        let compiler = cc::Build::new().get_compiler();
+
+        println!("cargo:warning={compiler:?}");
+
+        if !compiler.is_like_gnu() {
+            println!("cargo:warning=non-gcc-like compiler, skipping versions");
+            return ret;
+        }
+
+        // `-dM -E` invokes the preprocessor and prints all `#define`s. `cc` automatically
+        // sets target-specific flags.
+        let mut cmd = compiler.to_command();
+        cmd.stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .args(["-dM", "-E", "-"]);
+
+        println!("cargo:warning=invocation: {cmd:?}");
+        let mut child = cmd.spawn().expect("failed to spawn compiler");
+        child
+            .stdin
+            .take()
+            .unwrap()
+            .write_all(src.as_bytes())
+            .expect("failed to send stdin");
+        let out = child.wait_with_output().expect("failed to wait on child");
+        let out = String::from_utf8_lossy(&out.stdout);
+
+        // Allow spaces everywhere so we match things like `\n  # define foo bar \n`.
+        let re = Regex::new(r"^\s*#\s*define\s+(\w+)\s+(.*?)\s*$").unwrap();
+        let obsd_re = Regex::new(r"^OpenBSD(\d+)_(\d+)$").unwrap();
+        let mac_re = Regex::new(r"^__MAC_(\d+)_(\d+)").unwrap();
+
+        for line in out.lines() {
+            let Some(caps) = re.captures(line) else {
+                continue;
+            };
+            let name = &caps[1];
+            let value = &caps[2];
+            println!("cargo:warning=#define {name} {value}");
+
+            match name {
+                "LINUX_VERSION_MAJOR" => {
+                    ret.linux.get_or_insert_default().0 = value.parse().unwrap()
+                }
+                "LINUX_VERSION_PATCHLEVEL" => {
+                    ret.linux.get_or_insert_default().1 = value.parse().unwrap()
+                }
+                "__GLIBC__" => ret.glibc.get_or_insert_default().0 = value.parse().unwrap(),
+                "__GLIBC_MINOR__" => ret.glibc.get_or_insert_default().0 = value.parse().unwrap(),
+                "__MAC_OS_X_VERSION_MAX_ALLOWED" => {
+                    let caps = mac_re.captures(value).unwrap();
+                    let major: u32 = caps[1].parse().unwrap();
+                    let minor: u32 = caps[2].parse().unwrap();
+                    ret.macos = Some((major, minor));
+                }
+                "__FreeBSD_version" => {
+                    // Format: MmmRxx where M is major (possibly multi-digit), mm is minor, R
+                    // indicates release status, xx is some sequence.
+                    let major: u32 = value[..(value.len() - 5)].parse().unwrap();
+                    let minor: u32 = value[(value.len() - 5)..(value.len() - 3)].parse().unwrap();
+                    ret.freebsd = Some((major, minor));
+                }
+                "__NetBSD_Version__" => {
+                    // Format: MMmmrrpp00 where M is major (possibly multi-digit), mm is minor, r
+                    // and p are patch level.
+                    let major: u32 = value[..(value.len() - 8)].parse().unwrap();
+                    let minor: u32 = value[(value.len() - 8)..(value.len() - 6)].parse().unwrap();
+                    ret.netbsd = Some((major, minor));
+                }
+                x if obsd_re.is_match(x) => {
+                    let caps = obsd_re.captures(name).expect("is_match checked");
+                    let major: u32 = caps[1].parse().unwrap();
+                    let minor: u32 = caps[2].parse().unwrap();
+                    ret.openbsd = Some((major, minor));
+                }
+                _ => (),
+            }
+        }
+
+        println!("cargo:warning=detected versions: {ret:?}");
+        ret
+    }
+}
+
 /// Attempt to execute a command and collect its output, If the command fails for whatever
 /// reason, return `None`.
 fn try_command_output(cmd: &str, args: &[&str]) -> Option<String> {
-    let output = std::process::Command::new(cmd).args(args).output().ok()?;
+    let output = Command::new(cmd).args(args).output().ok()?;
 
     if !output.status.success() {
         return None;