Split the UMEM fd out of SocketAddrXdp. (#1349)

Remove `SocketAddrXdp`'s shared umem field. Add a new
`SocketAddrXdpWithSharedUmem` which pairs a `SocketAddrXdp` with a
`BorrowedFd` for passing to `bind`.

While here, rename `SockaddrXdpFlags` to `SocketAddrXdpFlags` for
consistency with the other `SocketAddr*` types.

This fixes the `SocketAddrXdp` side of #1001.

Author: sunfishcode

CHANGES.md

@@ -245,5 +245,14 @@ pointer provenance.
 [`rustix::io_uring::getevents_arg`]: https://docs.rs/rustix/1.0.0/rustix/io_uring/struct.io_uring_getevents_arg.html
 [`rustix::io_uring::io_uring_ptr`]: https://docs.rs/rustix/1.0.0-prerelease.0/rustix/io_uring/struct.io_uring_ptr.html
 
+[`SocketAddrXdp`] no longer has a shared umem field. A new
+[`SocketAddrXdpWithSharedUmem`] is added for the purpose of calling `bind` and
+passing it an XDP address with a shared UMEM fd. And `SockaddrXdpFlags` is
+renamed to [`SocketAddrXdpFlags`].
+
+[`SocketAddrXdp`]: https://docs.rs/rustix/1.0.0/rustix/net/xdp/struct.SocketAddrXdp.html
+[`SocketAddrXdpWithSharedUmem`]: https://docs.rs/rustix/1.0.0/rustix/net/xdp/struct.SocketAddrXdpWithSharedUmem.html
+[`SocketAddrXdpFlags`]: https://docs.rs/rustix/1.0.0/rustix/net/xdp/struct.SocketAddrXdpFlags.html
+
 All explicitly deprecated functions and types have been removed. Their
 deprecation messages will have identified alternatives.

src/backend/libc/net/read_sockaddr.rs

@@ -12,7 +12,7 @@ use crate::net::addr::SocketAddrLen;
 #[cfg(linux_kernel)]
 use crate::net::netlink::SocketAddrNetlink;
 #[cfg(target_os = "linux")]
-use crate::net::xdp::{SockaddrXdpFlags, SocketAddrXdp};
+use crate::net::xdp::{SocketAddrXdp, SocketAddrXdpFlags};
 use crate::net::{AddressFamily, Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrV4, SocketAddrV6};
 use core::mem::size_of;
 
@@ -239,11 +239,14 @@ pub(crate) fn read_sockaddr_xdp(addr: &SocketAddrAny) -> Result<SocketAddrXdp, E
     }
     assert!(addr.addr_len() as usize >= size_of::<c::sockaddr_xdp>());
     let decode = unsafe { &*addr.as_ptr().cast::<c::sockaddr_xdp>() };
+
+    // This ignores the `sxdp_shared_umem_fd` field, which is only expected to
+    // be significant in `bind` calls, and not returned from `acceptfrom` or
+    // `recvmsg` or similar.
     Ok(SocketAddrXdp::new(
-        SockaddrXdpFlags::from_bits_retain(decode.sxdp_flags),
+        SocketAddrXdpFlags::from_bits_retain(decode.sxdp_flags),
         u32::from_be(decode.sxdp_ifindex),
         u32::from_be(decode.sxdp_queue_id),
-        u32::from_be(decode.sxdp_shared_umem_fd),
     ))
 }
 

src/backend/linux_raw/net/read_sockaddr.rs

@@ -7,7 +7,7 @@ use crate::io::Errno;
 use crate::net::addr::SocketAddrLen;
 use crate::net::netlink::SocketAddrNetlink;
 #[cfg(target_os = "linux")]
-use crate::net::xdp::{SockaddrXdpFlags, SocketAddrXdp};
+use crate::net::xdp::{SocketAddrXdp, SocketAddrXdpFlags};
 use crate::net::{
     AddressFamily, Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrUnix, SocketAddrV4, SocketAddrV6,
 };
@@ -133,11 +133,14 @@ pub(crate) fn read_sockaddr_xdp(addr: &SocketAddrAny) -> Result<SocketAddrXdp, E
     }
     assert!(addr.addr_len() as usize >= size_of::<c::sockaddr_xdp>());
     let decode = unsafe { &*addr.as_ptr().cast::<c::sockaddr_xdp>() };
+
+    // This ignores the `sxdp_shared_umem_fd` field, which is only expected to
+    // be significant in `bind` calls, and not returned from `acceptfrom` or
+    // `recvmsg` or similar.
     Ok(SocketAddrXdp::new(
-        SockaddrXdpFlags::from_bits_retain(decode.sxdp_flags),
+        SocketAddrXdpFlags::from_bits_retain(decode.sxdp_flags),
         u32::from_be(decode.sxdp_ifindex),
         u32::from_be(decode.sxdp_queue_id),
-        u32::from_be(decode.sxdp_shared_umem_fd),
     ))
 }
 

src/net/types.rs

@@ -1620,6 +1620,7 @@ bitflags! {
 #[cfg(target_os = "linux")]
 pub mod xdp {
     use crate::backend::net::read_sockaddr::read_sockaddr_xdp;
+    use crate::fd::{AsRawFd, BorrowedFd};
     use crate::net::addr::{call_with_sockaddr, SocketAddrArg, SocketAddrLen, SocketAddrOpaque};
     use crate::net::SocketAddrAny;
 
@@ -1644,7 +1645,7 @@ pub mod xdp {
         /// `XDP_*` constants for use in [`SocketAddrXdp`].
         #[repr(transparent)]
         #[derive(Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Debug)]
-        pub struct SockaddrXdpFlags: u16 {
+        pub struct SocketAddrXdpFlags: u16 {
             /// `XDP_SHARED_UMEM`
             const XDP_SHARED_UMEM = bitcast!(c::XDP_SHARED_UMEM as u16);
             /// `XDP_COPY`
@@ -1683,46 +1684,40 @@ pub mod xdp {
     ///
     /// Used to bind to XDP socket.
     ///
-    /// Not ABI compatible with `struct sockaddr_xdp`
+    /// Not ABI compatible with `struct sockaddr_xdp`.
+    ///
+    /// To add a shared UMEM file descriptor, use [`SocketAddrXdpWithSharedUmem`].
     // <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/if_xdp.h?h=v6.13#n48>
     #[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Debug)]
     pub struct SocketAddrXdp {
         /// Flags.
-        sxdp_flags: SockaddrXdpFlags,
+        sxdp_flags: SocketAddrXdpFlags,
         /// Interface index.
         sxdp_ifindex: u32,
         /// Queue ID.
         sxdp_queue_id: u32,
-        /// Shared UMEM file descriptor.
-        sxdp_shared_umem_fd: u32,
     }
 
     impl SocketAddrXdp {
         /// Construct a new XDP address.
         #[inline]
-        pub fn new(
-            flags: SockaddrXdpFlags,
-            interface_index: u32,
-            queue_id: u32,
-            share_umem_fd: u32,
-        ) -> Self {
+        pub fn new(flags: SocketAddrXdpFlags, interface_index: u32, queue_id: u32) -> Self {
             Self {
                 sxdp_flags: flags,
                 sxdp_ifindex: interface_index,
                 sxdp_queue_id: queue_id,
-                sxdp_shared_umem_fd: share_umem_fd,
             }
         }
 
         /// Return flags.
         #[inline]
-        pub fn flags(&self) -> SockaddrXdpFlags {
+        pub fn flags(&self) -> SocketAddrXdpFlags {
             self.sxdp_flags
         }
 
         /// Set flags.
         #[inline]
-        pub fn set_flags(&mut self, flags: SockaddrXdpFlags) {
+        pub fn set_flags(&mut self, flags: SocketAddrXdpFlags) {
             self.sxdp_flags = flags;
         }
 
@@ -1749,18 +1744,6 @@ pub mod xdp {
         pub fn set_queue_id(&mut self, queue_id: u32) {
             self.sxdp_queue_id = queue_id;
         }
-
-        /// Return shared UMEM file descriptor.
-        #[inline]
-        pub fn shared_umem_fd(&self) -> u32 {
-            self.sxdp_shared_umem_fd
-        }
-
-        /// Set shared UMEM file descriptor.
-        #[inline]
-        pub fn set_shared_umem_fd(&mut self, shared_umem_fd: u32) {
-            self.sxdp_shared_umem_fd = shared_umem_fd;
-        }
     }
 
     #[allow(unsafe_code)]
@@ -1776,7 +1759,7 @@ pub mod xdp {
                 sxdp_flags: self.flags().bits(),
                 sxdp_ifindex: self.interface_index(),
                 sxdp_queue_id: self.queue_id(),
-                sxdp_shared_umem_fd: self.shared_umem_fd(),
+                sxdp_shared_umem_fd: !0,
             };
 
             call_with_sockaddr(&addr, f)
@@ -1798,6 +1781,39 @@ pub mod xdp {
         }
     }
 
+    /// An XDP socket address with a shared UMEM file descriptor.
+    ///
+    /// This implements `SocketAddrArg` so that it can be passed to [`bind`].
+    ///
+    /// [`bind`]: crate::net::bind
+    #[derive(Debug)]
+    pub struct SocketAddrXdpWithSharedUmem<'a> {
+        /// XDP address.
+        pub addr: SocketAddrXdp,
+        /// Shared UMEM file descriptor.
+        pub shared_umem_fd: BorrowedFd<'a>,
+    }
+
+    #[allow(unsafe_code)]
+    // SAFETY: `with_sockaddr` calls `f` using `call_with_sockaddr`, which
+    // handles calling `f` with the needed preconditions.
+    unsafe impl<'a> SocketAddrArg for SocketAddrXdpWithSharedUmem<'a> {
+        unsafe fn with_sockaddr<R>(
+            &self,
+            f: impl FnOnce(*const SocketAddrOpaque, SocketAddrLen) -> R,
+        ) -> R {
+            let addr = c::sockaddr_xdp {
+                sxdp_family: c::AF_XDP as _,
+                sxdp_flags: self.addr.flags().bits(),
+                sxdp_ifindex: self.addr.interface_index(),
+                sxdp_queue_id: self.addr.queue_id(),
+                sxdp_shared_umem_fd: self.shared_umem_fd.as_raw_fd() as u32,
+            };
+
+            call_with_sockaddr(&addr, f)
+        }
+    }
+
     /// XDP ring offset.
     ///
     /// Used to mmap rings from kernel.