rustix: on Linux, support a build without linux-raw-sys (#1478)

* rustix: on Android, support a build without linux-raw-sys

Rustix support was added to Mesa3D recently, but it only works
with the linux-raw-sys backend.  On Linux, even the libc
backend, there is a dependency on linux-raw-sys for certain ABI
definitions.

When updating rustix in Android to support this, I realized only
the libc backend is supported in Android.  This is because
Android as a platform wants to discourage raw syscalls, and to
be able to globally update libc.

Features like fdtrack would not work with the linux-raw-sys backend:

https://android.googlesource.com/platform/bionic/+/HEAD/docs/fdtrack.md

Given Android wants to incentize use of libc only, this MR introduces
the concept of "linux-raw-dep".  This means that linux-raw-sys is
present as a dependency for the user.  This will be on by default
even for the libc backend, but will be turned off for Android (this
is reflected in the build.rs script).

This will also help others who don't need all the features rustix
offers on Linux, so they have one less dependency to maintain.  They
may append "--cfg=rustix_no_linux_raw" to Rust flags skip building
the linux raw backend.  Mesa3D will use this.

Tested via:

cargo build --target arm-linux-androideabi --features=use-libc,net,std,alloc,event,fs,mm,param,pipe,use-libc-auxv,libc_errno

and on Linux with the proper RUSTFLAGS set.  The Github workflows have
been modified to only use the current subset of features using in AOSP:

https://android.googlesource.com/platform/external/rust/android-crates-io/+/refs/heads/main/crates/rustix/Android.bp

That is the source of truth for an Android integration and the CI only
needs to test that.  Additional features may be added as needed in the
future.

* rustix: fixes for Android musl build

Android doesn't only have a bionic toolchain, but musl
toolchain for components built on the build workstation.

---------

Co-authored-by: Gurchetan Singh <[email protected]>

Author: gurchetansingh

.github/workflows/main.yml

@@ -104,8 +104,8 @@ jobs:
     - run: cargo check --workspace --release -vv --target=x86_64-unknown-linux-musl --features=all-apis --all-targets
     - run: cargo check --workspace --release -vv --target=x86_64-unknown-linux-musl --features=use-libc,all-apis --all-targets
     - run: cargo check --workspace --release -vv --target=x86_64-unknown-linux-gnux32 --features=all-apis --all-targets
-    - run: cargo check --workspace --release -vv --target=x86_64-linux-android --features=all-apis --all-targets
-    - run: cargo check --workspace --release -vv --target=i686-linux-android --features=all-apis --all-targets
+    - run: cargo check --workspace --release -vv --target=x86_64-linux-android --features=use-libc,net,std,alloc,event,fs,mm,param,pipe,use-libc-auxv,libc_errno --all-targets
+    - run: cargo check --workspace --release -vv --target=i686-linux-android --features=use-libc,net,std,alloc,event,fs,mm,param,pipe,use-libc-auxv,libc_errno --all-targets
     - run: cargo check --workspace --release -vv --target=x86_64-apple-darwin --features=all-apis --all-targets
     - run: cargo check --workspace --release -vv --target=x86_64-unknown-freebsd --features=all-apis --all-targets
     - run: cargo check --workspace --release -vv --target=x86_64-unknown-netbsd --features=all-apis --all-targets
@@ -132,11 +132,11 @@ jobs:
     - run: cargo check --workspace --release -vv --target=powerpc64le-unknown-linux-gnu --features=all-apis --all-targets
     - run: cargo check --workspace --release -vv --target=armv5te-unknown-linux-gnueabi --features=all-apis --all-targets
     - run: cargo check --workspace --release -vv --target=s390x-unknown-linux-gnu --features=all-apis --all-targets
-    - run: cargo check --workspace --release -vv --target=arm-linux-androideabi --features=all-apis --all-targets
+    - run: cargo check --workspace --release -vv --target=arm-linux-androideabi --features=use-libc,net,std,alloc,event,fs,mm,param,pipe,use-libc-auxv,libc_errno --all-targets
     - run: cargo check --workspace --release -vv --target=sparc64-unknown-linux-gnu --features=all-apis --all-targets
     - run: cargo check --workspace --release -vv --target=sparcv9-sun-solaris --features=all-apis --all-targets
     - run: cargo check --workspace --release -vv --target=aarch64-apple-ios --features=all-apis --all-targets
-    - run: cargo check --workspace --release -vv --target=aarch64-linux-android --features=all-apis --all-targets
+    - run: cargo check --workspace --release -vv --target=aarch64-linux-android --features=use-libc,net,std,alloc,event,fs,mm,param,pipe,use-libc-auxv,libc_errno --all-targets
     - run: cargo check --workspace --release -vv --target=i686-pc-windows-msvc --features=all-apis --all-targets
 
   check_no_default_features:

Cargo.toml

@@ -45,7 +45,7 @@ libc = { version = "0.2.171", default-features = false }
 #
 # Some syscalls do not have libc wrappers, such as in `io_uring`. For these,
 # the libc backend uses the linux-raw-sys ABI and `libc::syscall`.
-[target.'cfg(all(any(target_os = "android", target_os = "linux"), any(rustix_use_libc, miri, not(all(target_os = "linux", any(target_endian = "little", any(target_arch = "s390x", target_arch = "powerpc")), any(target_arch = "arm", all(target_arch = "aarch64", target_pointer_width = "64"), target_arch = "riscv64", all(rustix_use_experimental_asm, target_arch = "powerpc"), all(rustix_use_experimental_asm, target_arch = "powerpc64"), all(rustix_use_experimental_asm, target_arch = "s390x"), all(rustix_use_experimental_asm, target_arch = "mips"), all(rustix_use_experimental_asm, target_arch = "mips32r6"), all(rustix_use_experimental_asm, target_arch = "mips64"), all(rustix_use_experimental_asm, target_arch = "mips64r6"), target_arch = "x86", all(target_arch = "x86_64", target_pointer_width = "64")))))))'.dependencies]
+[target.'cfg(all(any(target_os = "linux"), any(rustix_use_libc, miri, not(all(target_os = "linux", any(target_endian = "little", any(target_arch = "s390x", target_arch = "powerpc")), any(target_arch = "arm", all(target_arch = "aarch64", target_pointer_width = "64"), target_arch = "riscv64", all(rustix_use_experimental_asm, target_arch = "powerpc"), all(rustix_use_experimental_asm, target_arch = "powerpc64"), all(rustix_use_experimental_asm, target_arch = "s390x"), all(rustix_use_experimental_asm, target_arch = "mips"), all(rustix_use_experimental_asm, target_arch = "mips32r6"), all(rustix_use_experimental_asm, target_arch = "mips64"), all(rustix_use_experimental_asm, target_arch = "mips64r6"), target_arch = "x86", all(target_arch = "x86_64", target_pointer_width = "64")))))))'.dependencies]
 linux-raw-sys = { version = "0.9.2", default-features = false, features = ["general", "ioctl", "no_std"] }
 
 # For the libc backend on Windows, use the Winsock API in windows-sys.
@@ -256,6 +256,7 @@ check-cfg = [
     'cfg(linux_kernel)',
     'cfg(linux_like)',
     'cfg(linux_raw)',
+    'cfg(linux_raw_dep)',
     'cfg(lower_upper_exp_for_non_zero)',
     'cfg(netbsdlike)',
     'cfg(rustc_attrs)',

build.rs

@@ -35,6 +35,10 @@ fn main() {
     // enable the libc backend even if rustix is depended on transitively.
     let cfg_use_libc = var("CARGO_CFG_RUSTIX_USE_LIBC").is_ok();
 
+    // Check for `RUSTFLAGS=--cfg=rustix_no_linux_raw`. This allows Linux users to
+    // enable the libc backend without the linux raw dependency.
+    let cfg_no_linux_raw = var("CARGO_CFG_RUSTIX_NO_LINUX_RAW").is_ok();
+
     // Check for `--features=rustc-dep-of-std`.
     let rustc_dep_of_std = var("CARGO_FEATURE_RUSTC_DEP_OF_STD").is_ok();
 
@@ -108,10 +112,15 @@ fn main() {
             || arch.starts_with("mips"))
             && !rustix_use_experimental_asm);
     if libc {
+        if os != "android" && os == "linux" && !cfg_no_linux_raw {
+            use_feature("linux_raw_dep");
+        }
+
         // Use the libc backend.
         use_feature("libc");
     } else {
         // Use the linux_raw backend.
+        use_feature("linux_raw_dep");
         use_feature("linux_raw");
         if rustix_use_experimental_asm {
             use_feature("asm_experimental_arch");

src/backend/libc/c.rs

@@ -19,49 +19,49 @@ pub(crate) const NFS_SUPER_MAGIC: u32 = 0x0000_6969;
 pub(crate) const EXIT_SIGNALED_SIGABRT: c_int = 128 + SIGABRT as c_int;
 
 // TODO: Upstream these.
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_TSN: c_int = linux_raw_sys::if_ether::ETH_P_TSN as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_ERSPAN2: c_int = linux_raw_sys::if_ether::ETH_P_ERSPAN2 as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_ERSPAN: c_int = linux_raw_sys::if_ether::ETH_P_ERSPAN as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_PROFINET: c_int = linux_raw_sys::if_ether::ETH_P_PROFINET as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_REALTEK: c_int = linux_raw_sys::if_ether::ETH_P_REALTEK as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_ETHERCAT: c_int = linux_raw_sys::if_ether::ETH_P_ETHERCAT as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_PREAUTH: c_int = linux_raw_sys::if_ether::ETH_P_PREAUTH as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_LLDP: c_int = linux_raw_sys::if_ether::ETH_P_LLDP as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_MRP: c_int = linux_raw_sys::if_ether::ETH_P_MRP as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_NCSI: c_int = linux_raw_sys::if_ether::ETH_P_NCSI as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_CFM: c_int = linux_raw_sys::if_ether::ETH_P_CFM as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_IBOE: c_int = linux_raw_sys::if_ether::ETH_P_IBOE as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_HSR: c_int = linux_raw_sys::if_ether::ETH_P_HSR as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_NSH: c_int = linux_raw_sys::if_ether::ETH_P_NSH as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_DSA_8021Q: c_int = linux_raw_sys::if_ether::ETH_P_DSA_8021Q as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_DSA_A5PSW: c_int = linux_raw_sys::if_ether::ETH_P_DSA_A5PSW as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_IFE: c_int = linux_raw_sys::if_ether::ETH_P_IFE as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_CAN: c_int = linux_raw_sys::if_ether::ETH_P_CAN as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_CANXL: c_int = linux_raw_sys::if_ether::ETH_P_CANXL as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_XDSA: c_int = linux_raw_sys::if_ether::ETH_P_XDSA as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_MAP: c_int = linux_raw_sys::if_ether::ETH_P_MAP as _;
-#[cfg(all(linux_kernel, feature = "net"))]
+#[cfg(all(linux_raw_dep, feature = "net"))]
 pub(crate) const ETH_P_MCTP: c_int = linux_raw_sys::if_ether::ETH_P_MCTP as _;
 
 #[cfg(all(
@@ -89,7 +89,7 @@ pub(crate) const MSG_DONTWAIT: c_int = MSG_NONBLOCK;
 // `O_LARGEFILE` can be automatically set by the kernel on Linux:
 // <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/open.c?h=v6.13#n1423>
 // so libc implementations may leave it undefined or defined to zero.
-#[cfg(linux_kernel)]
+#[cfg(linux_raw_dep)]
 pub(crate) const O_LARGEFILE: c_int = linux_raw_sys::general::O_LARGEFILE as _;
 
 // Gated under `_LARGEFILE_SOURCE` but automatically set by the kernel.
@@ -489,7 +489,8 @@ pub(super) use readwrite_pv64v2::{preadv64v2 as preadv2, pwritev64v2 as pwritev2
 #[cfg(feature = "fs")]
 #[cfg(all(
     linux_like,
-    not(any(target_os = "android", target_os = "emscripten", target_env = "gnu"))
+    linux_raw_dep,
+    not(any(target_os = "emscripten", target_env = "gnu"))
 ))]
 mod statx_flags {
     pub(crate) use linux_raw_sys::general::{
@@ -507,18 +508,15 @@ mod statx_flags {
 #[cfg(feature = "fs")]
 #[cfg(all(
     linux_like,
-    not(any(target_os = "android", target_os = "emscripten", target_env = "gnu"))
+    linux_raw_dep,
+    not(any(target_os = "emscripten", target_env = "gnu"))
 ))]
 pub(crate) use statx_flags::*;
 
 #[cfg(feature = "fs")]
 #[cfg(target_os = "android")]
 pub(crate) use __fsid_t as fsid_t;
 
-#[cfg(feature = "mm")]
-#[cfg(target_os = "android")]
-pub(crate) const MAP_DROPPABLE: c_int = bitcast!(linux_raw_sys::general::MAP_DROPPABLE);
-
 // FreeBSD added `timerfd_*` in FreeBSD 14. NetBSD added then in NetBSD 10.
 #[cfg(all(feature = "time", any(target_os = "freebsd", target_os = "netbsd")))]
 syscall!(pub(crate) fn timerfd_create(

src/backend/libc/fs/mod.rs

@@ -16,9 +16,12 @@ pub(crate) mod syscalls;
 pub(crate) mod types;
 
 // TODO: Fix linux-raw-sys to define ioctl codes for sparc.
-#[cfg(all(linux_kernel, any(target_arch = "sparc", target_arch = "sparc64")))]
+#[cfg(all(linux_raw_dep, any(target_arch = "sparc", target_arch = "sparc64")))]
 pub(crate) const EXT4_IOC_RESIZE_FS: crate::ioctl::Opcode = 0x8008_6610;
 
-#[cfg(all(linux_kernel, not(any(target_arch = "sparc", target_arch = "sparc64"))))]
+#[cfg(all(
+    linux_raw_dep,
+    not(any(target_arch = "sparc", target_arch = "sparc64"))
+))]
 pub(crate) const EXT4_IOC_RESIZE_FS: crate::ioctl::Opcode =
     linux_raw_sys::ioctl::EXT4_IOC_RESIZE_FS as crate::ioctl::Opcode;

src/backend/libc/fs/syscalls.rs

@@ -1840,7 +1840,7 @@ pub(crate) fn memfd_create(name: &CStr, flags: MemfdFlags) -> io::Result<OwnedFd
     unsafe { ret_owned_fd(memfd_create(c_str(name), bitflags_bits!(flags))) }
 }
 
-#[cfg(linux_kernel)]
+#[cfg(linux_raw_dep)]
 pub(crate) fn openat2(
     dirfd: BorrowedFd<'_>,
     path: &CStr,
@@ -2053,9 +2053,9 @@ pub(crate) fn statx(
     // doesn't represent all the known flags.
     //
     // [it's deprecated]: https://patchwork.kernel.org/project/linux-fsdevel/patch/[email protected]/
-    #[cfg(not(any(target_os = "android", target_env = "musl")))]
+    #[cfg(any(not(linux_raw_dep), not(target_env = "musl")))]
     const STATX__RESERVED: u32 = c::STATX__RESERVED as u32;
-    #[cfg(any(target_os = "android", target_env = "musl"))]
+    #[cfg(target_env = "musl")]
     const STATX__RESERVED: u32 = linux_raw_sys::general::STATX__RESERVED;
     if (mask.bits() & STATX__RESERVED) == STATX__RESERVED {
         return Err(io::Errno::INVAL);

src/backend/libc/io/syscalls.rs

@@ -13,7 +13,7 @@ use crate::fd::{AsFd as _, BorrowedFd, OwnedFd, RawFd};
     target_os = "wasi"
 )))]
 use crate::io::DupFlags;
-#[cfg(linux_kernel)]
+#[cfg(all(linux_kernel, not(target_os = "android")))]
 use crate::io::ReadWriteFlags;
 use crate::io::{self, FdFlags};
 use crate::ioctl::{IoctlOutput, Opcode};
@@ -150,7 +150,7 @@ pub(crate) fn pwritev(fd: BorrowedFd<'_>, bufs: &[IoSlice<'_>], offset: u64) ->
     }
 }
 
-#[cfg(linux_kernel)]
+#[cfg(all(linux_kernel, not(target_os = "android")))]
 pub(crate) fn preadv2(
     fd: BorrowedFd<'_>,
     bufs: &mut [IoSliceMut<'_>],
@@ -170,7 +170,7 @@ pub(crate) fn preadv2(
     }
 }
 
-#[cfg(linux_kernel)]
+#[cfg(all(linux_kernel, not(target_os = "android")))]
 pub(crate) fn pwritev2(
     fd: BorrowedFd<'_>,
     bufs: &[IoSlice<'_>],

src/backend/libc/io/types.rs

@@ -17,7 +17,7 @@ bitflags! {
     }
 }
 
-#[cfg(linux_kernel)]
+#[cfg(all(linux_kernel, not(target_os = "android")))]
 bitflags! {
     /// `RWF_*` constants for use with [`preadv2`] and [`pwritev2`].
     ///
@@ -27,15 +27,15 @@ bitflags! {
     #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct ReadWriteFlags: u32 {
         /// `RWF_DSYNC` (since Linux 4.7)
-        const DSYNC = linux_raw_sys::general::RWF_DSYNC;
+        const DSYNC = libc::RWF_DSYNC as u32;
         /// `RWF_HIPRI` (since Linux 4.6)
-        const HIPRI = linux_raw_sys::general::RWF_HIPRI;
+        const HIPRI = libc::RWF_HIPRI as u32;
         /// `RWF_SYNC` (since Linux 4.7)
-        const SYNC = linux_raw_sys::general::RWF_SYNC;
+        const SYNC = libc::RWF_SYNC as u32;
         /// `RWF_NOWAIT` (since Linux 4.14)
-        const NOWAIT = linux_raw_sys::general::RWF_NOWAIT;
+        const NOWAIT = libc::RWF_NOWAIT as u32;
         /// `RWF_APPEND` (since Linux 4.16)
-        const APPEND = linux_raw_sys::general::RWF_APPEND;
+        const APPEND = libc::RWF_APPEND as u32;
 
         /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
         const _ = !0;

src/backend/libc/mm/types.rs

@@ -44,19 +44,19 @@ bitflags! {
         #[cfg(linux_kernel)]
         const GROWSDOWN = bitcast!(c::PROT_GROWSDOWN);
         /// `PROT_SEM`
-        #[cfg(linux_kernel)]
+        #[cfg(linux_raw_dep)]
         const SEM = linux_raw_sys::general::PROT_SEM;
         /// `PROT_BTI`
-        #[cfg(all(linux_kernel, target_arch = "aarch64"))]
+        #[cfg(all(linux_raw_dep, target_arch = "aarch64"))]
         const BTI = linux_raw_sys::general::PROT_BTI;
         /// `PROT_MTE`
-        #[cfg(all(linux_kernel, target_arch = "aarch64"))]
+        #[cfg(all(linux_raw_dep, target_arch = "aarch64"))]
         const MTE = linux_raw_sys::general::PROT_MTE;
         /// `PROT_SAO`
-        #[cfg(all(linux_kernel, any(target_arch = "powerpc", target_arch = "powerpc64")))]
+        #[cfg(all(linux_raw_dep, any(target_arch = "powerpc", target_arch = "powerpc64")))]
         const SAO = linux_raw_sys::general::PROT_SAO;
         /// `PROT_ADI`
-        #[cfg(all(linux_kernel, any(target_arch = "sparc", target_arch = "sparc64")))]
+        #[cfg(all(linux_raw_dep, any(target_arch = "sparc", target_arch = "sparc64")))]
         const ADI = linux_raw_sys::general::PROT_ADI;
 
         /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
@@ -252,7 +252,7 @@ bitflags! {
         #[cfg(any())]
         const UNINITIALIZED = bitcast!(c::MAP_UNINITIALIZED);
         /// `MAP_DROPPABLE`
-        #[cfg(linux_kernel)]
+        #[cfg(all(linux_kernel, not(target_os = "android")))]
         const DROPPABLE = bitcast!(c::MAP_DROPPABLE);
 
         /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>

src/backend/libc/net/sockopt.rs

@@ -76,7 +76,7 @@ use c::TCP_KEEPALIVE as TCP_KEEPIDLE;
 use c::TCP_KEEPIDLE;
 use core::mem::{size_of, MaybeUninit};
 use core::time::Duration;
-#[cfg(target_os = "linux")]
+#[cfg(linux_raw_dep)]
 use linux_raw_sys::xdp::{xdp_mmap_offsets, xdp_statistics, xdp_statistics_v1};
 
 #[inline]
@@ -1088,7 +1088,7 @@ pub(crate) fn set_xdp_rx_ring_size(fd: BorrowedFd<'_>, value: u32) -> io::Result
     setsockopt(fd, c::SOL_XDP, c::XDP_RX_RING, value)
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(linux_raw_dep)]
 #[inline]
 pub(crate) fn xdp_mmap_offsets(fd: BorrowedFd<'_>) -> io::Result<XdpMmapOffsets> {
     // The kernel will write `xdp_mmap_offsets` or `xdp_mmap_offsets_v1` to the
@@ -1175,7 +1175,7 @@ pub(crate) fn xdp_mmap_offsets(fd: BorrowedFd<'_>) -> io::Result<XdpMmapOffsets>
     }
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(linux_raw_dep)]
 #[inline]
 pub(crate) fn xdp_statistics(fd: BorrowedFd<'_>) -> io::Result<XdpStatistics> {
     let mut optlen = size_of::<xdp_statistics>().try_into().unwrap();