Port to FreeBSD

Closes #223

Author: Thomasdezeeuw

.cirrus.yml

@@ -0,0 +1,19 @@
+freebsd_instance:
+  image: freebsd-15-0-release-amd64-zfs
+
+env:
+  RUST_BACKTRACE: full
+
+task:
+  name: FreeBSD
+  setup_script:
+    - fetch https://sh.rustup.rs -o rustup.sh
+    - sh rustup.sh -y --profile minimal
+  cargo_cache:
+    folder: $HOME/.cargo/registry
+  test_script:
+    - . $HOME/.cargo/env
+    - cargo test
+    - cargo test --release
+  before_cache_script:
+    - rm -rf $HOME/.cargo/registry/index

src/fs.rs

@@ -327,9 +327,13 @@ impl AsyncFd {
 
     /// Manipulate file space.
     ///
-    /// Manipulate the allocated disk space for the file referred for the byte
+    /// Ensures that disk space is allocated for the file for the bytes in the
     /// range starting at `offset` and continuing for `length` bytes.
+    ///
+    /// If the size of the file is less than `offset` + `size`, then the file is
+    /// increased to this size; otherwise the file size is left unchanged.
     #[doc = man_link!(fallocate(2))]
+    #[doc = man_link!(posix_fallocate(3))]
     #[doc(alias = "fallocate")]
     #[doc(alias = "posix_fallocate")]
     #[cfg(any(
@@ -339,17 +343,8 @@ impl AsyncFd {
         target_os = "linux",
         target_os = "netbsd",
     ))]
-    pub fn allocate<'fd>(
-        &'fd self,
-        offset: u64,
-        length: u32,
-        mode: Option<AllocateFlag>,
-    ) -> Allocate<'fd> {
-        let mode = match mode {
-            Some(mode) => mode,
-            None => AllocateFlag(0),
-        };
-        Allocate::new(self, (), (offset, length, mode))
+    pub fn allocate<'fd>(&'fd self, offset: u64, length: u32) -> Allocate<'fd> {
+        Allocate::new(self, (), (offset, length, AllocateMode(0)))
     }
 
     /// Truncate the file to `length`.
@@ -423,8 +418,10 @@ new_flag!(
         DONT_NEED = libc::POSIX_FADV_DONTNEED,
     }
 
-    /// Mode for call to [`AsyncFd::allocate`].
-    pub struct AllocateFlag(u32) impl BitOr {
+    /// Mode for [`AsyncFd::allocate`].
+    ///
+    /// Set using [`Allocate::mode`].
+    pub struct AllocateMode(u32) impl BitOr {
         /// Keep the same file size.
         #[cfg(any(target_os = "android", target_os = "linux"))]
         KEEP_SIZE = libc::FALLOC_FL_KEEP_SIZE,
@@ -473,11 +470,11 @@ fd_operation!(
     pub struct Allocate(sys::fs::AllocateOp) -> io::Result<()>;
 );
 
+#[cfg(any(target_os = "android", target_os = "linux"))]
 impl<'fd> Stat<'fd> {
     /// Set which field(s) of the metadata the kernel should fill.
     ///
     /// Defaults to filling some basic fields.
-    #[cfg(any(target_os = "android", target_os = "linux"))]
     pub fn only(mut self, mask: MetadataInterest) -> Self {
         if let Some(args) = self.state.args_mut() {
             *args = mask;
@@ -486,6 +483,20 @@ impl<'fd> Stat<'fd> {
     }
 }
 
+#[cfg(any(target_os = "android", target_os = "linux"))]
+impl<'fd> Allocate<'fd> {
+    /// Manipulate the allocated disk space for the file other than allocating
+    /// space for it.
+    ///
+    /// Defaults to allocating the space.
+    pub fn mode(mut self, mode: AllocateMode) -> Self {
+        if let Some((_, _, m)) = self.state.args_mut() {
+            *m = mode;
+        }
+        self
+    }
+}
+
 /// Metadata information about a file.
 ///
 /// See [`AsyncFd::metadata`] and [`Stat`].

src/io_uring/fs.rs

@@ -5,7 +5,7 @@ use std::ptr;
 use std::time::{Duration, SystemTime};
 
 use crate::fs::{
-    AdviseFlag, AllocateFlag, FileType, Metadata, MetadataInterest, Permissions, RemoveFlag,
+    AdviseFlag, AllocateMode, FileType, Metadata, MetadataInterest, Permissions, RemoveFlag,
     SyncDataFlag, path_from_cstring,
 };
 use crate::io_uring::op::{FdOp, Op, OpExtract, OpReturn};
@@ -302,7 +302,7 @@ pub(crate) struct AllocateOp;
 impl FdOp for AllocateOp {
     type Output = ();
     type Resources = ();
-    type Args = (u64, u32, AllocateFlag); // offset, length, mode
+    type Args = (u64, u32, AllocateMode); // offset, length, mode
 
     #[allow(clippy::cast_sign_loss)]
     fn fill_submission(

src/kqueue/fs.rs

@@ -239,7 +239,7 @@ pub(crate) struct AllocateOp;
 impl DirectFdOp for AllocateOp {
     type Output = ();
     type Resources = ();
-    type Args = (u64, u32, crate::fs::AllocateFlag); // offset, length, mode
+    type Args = (u64, u32, crate::fs::AllocateMode); // offset, length, mode
 
     fn run(
         fd: &AsyncFd,

src/kqueue/mod.rs

@@ -166,6 +166,7 @@ pub(crate) struct Event(libc::kevent);
 
 impl Event {
     /// Returns an error from the event, if any.
+    #[allow(clippy::unnecessary_cast)]
     fn error(&self) -> Option<io::Error> {
         // We can't use references to packed structures (in checking the ignored
         // errors), so we need copy the data out before use.

src/kqueue/net.rs

@@ -35,7 +35,7 @@ impl DirectOp for SocketOp {
             target_os = "netbsd",
             target_os = "openbsd",
         ))]
-        let r#type = r#type.0.cast_signed() | libc::SOCK_NONBLOCK | libc::SOCK_CLOEXEC;
+        let r#type = r#type | libc::SOCK_NONBLOCK | libc::SOCK_CLOEXEC;
 
         let socket = syscall!(socket(domain.0, r#type, protocol.0.cast_signed()))?;
         // SAFETY: just created the socket above.

src/kqueue/process.rs

@@ -1,4 +1,4 @@
-use std::mem::{MaybeUninit, replace};
+use std::mem::{self, MaybeUninit, replace};
 use std::os::fd::RawFd;
 use std::task::{self, Poll};
 use std::{io, ptr};
@@ -16,6 +16,7 @@ impl crate::op::Op for WaitIdOp {
     type Args = (WaitOn, WaitOption);
     type State = EventedState<Self::Resources, Self::Args>;
 
+    #[allow(clippy::useless_conversion)]
     fn poll(
         state: &mut Self::State,
         ctx: &mut task::Context<'_>,
@@ -53,7 +54,7 @@ impl crate::op::Op for WaitIdOp {
                 };
 
                 let options = options.0.cast_signed() | libc::WNOHANG; // Don't block.
-                syscall!(waitid(id_type, pid, &raw mut info.0, options))?;
+                syscall!(waitid(id_type, pid.into(), &raw mut info.0, options))?;
 
                 if info.0.si_pid == 0 {
                     // Got polled without the process stopping, will have to
@@ -108,7 +109,7 @@ fn register_signals(kfd: RawFd, signals: &SignalSet) -> io::Result<()> {
             filter: libc::EVFILT_SIGNAL,
             flags: libc::EV_ADD,
             // SAFETY: all zeros is valid for `kevent`.
-            ..unsafe { std::mem::zeroed() }
+            ..unsafe { mem::zeroed() }
         });
         n_changes += 1;
     }
@@ -125,9 +126,20 @@ fn register_signals(kfd: RawFd, signals: &SignalSet) -> io::Result<()> {
 }
 
 fn sigaction(signals: &SignalSet, action: libc::sighandler_t) -> io::Result<()> {
+    #[cfg(any(
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "tvos",
+        target_os = "visionos",
+        target_os = "watchos",
+    ))]
+    let sa_mask = 0;
+    #[cfg(target_os = "freebsd")]
+    let sa_mask = SignalSet::empty()?.0;
+
     let action = libc::sigaction {
         sa_sigaction: action,
-        sa_mask: 0,
+        sa_mask,
         sa_flags: 0,
     };
     for signal in Signal::ALL_VALUES {

src/mem.rs

@@ -108,6 +108,26 @@ new_flag!(
         #[cfg(any(target_os = "ios", target_os = "macos", target_os = "tvos", target_os = "visionos", target_os = "watchos"))]
         ZERO = libc::MADV_ZERO,
         */
+        /// Don't flush the data associated with this map to physical backing
+        /// store unless it needs to.
+        #[cfg(target_os = "freebsd")]
+        NO_SYNC = libc::MADV_NOSYNC,
+        /// Undoes the effects of [`AdviseFlag::NO_SYNC`] for any future pages
+        /// dirtied within the address range.
+        #[cfg(target_os = "freebsd")]
+        AUTO_SYNC = libc::MADV_AUTOSYNC,
+        /// Region is not included in a core file.
+        #[cfg(target_os = "freebsd")]
+        NO_CORE = libc::MADV_NOCORE,
+        /// Include region in a core file.
+        #[cfg(target_os = "freebsd")]
+        CORE = libc::MADV_CORE,
+        /// Informs the VM system this process should not be killed when the
+        /// swap space is exhausted. The process must have superuser privileges.
+        /// This should be used judiciously in processes that must remain
+        /// running for the system to properly function.
+        #[cfg(target_os = "freebsd")]
+        PROTECT = libc::MADV_PROTECT,
     }
 );
 

src/net.rs

@@ -51,6 +51,7 @@ new_flag!(
         #[cfg(any(target_os = "android", target_os = "linux"))]
         PACKET = libc::AF_PACKET,
         /// Domain for low-level VSOCK interface.
+        #[cfg(not(target_os = "freebsd"))]
         VSOCK = libc::AF_VSOCK,
     }
 
@@ -91,12 +92,12 @@ new_flag!(
         /// User Datagram Protocol.
         UDP = libc::IPPROTO_UDP,
         /// Datagram Congestion Control Protocol.
-        #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
         DCCP = libc::IPPROTO_DCCP,
         /// Stream Control Transport Protocol.
         SCTP = libc::IPPROTO_SCTP,
         /// UDP-Lite.
-        #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
         UDPLITE = libc::IPPROTO_UDPLITE,
         /// Raw IP packets.
         RAW = libc::IPPROTO_RAW,
@@ -410,7 +411,7 @@ new_flag!(
     pub struct RecvFlag(u32) impl BitOr {
         /// Set the close-on-exec flag for the file descriptor received via a
         /// UNIX domain file descriptor using the `SCM_RIGHTS` operation.
-        #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
         CMSG_CLOEXEC = libc::MSG_CMSG_CLOEXEC,
         /// This flag specifies that queued errors should be received from the
         /// socket error queue.
@@ -538,7 +539,7 @@ new_flag!(
         #[cfg(any(target_os = "android", target_os = "linux"))]
         DETACH_BPF = libc::SO_DETACH_BPF,
         /// Domain.
-        #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
         DOMAIN = libc::SO_DOMAIN,
         /// Get and clear the pending socket error.
         ERROR = libc::SO_ERROR,
@@ -577,7 +578,7 @@ new_flag!(
         #[cfg(any(target_os = "android", target_os = "linux"))]
         PRIORITY = libc::SO_PRIORITY,
         /// Retrieves the socket protocol.
-        #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
         PROTOCOL = libc::SO_PROTOCOL,
         /// Maximum receive buffer in bytes.
         RECV_BUF = libc::SO_RCVBUF,
@@ -678,6 +679,7 @@ new_flag!(
         #[cfg(any(target_os = "android", target_os = "linux"))]
         PASS_SEC = libc::IP_PASSSEC,
         /// Collect information about this socket.
+        #[cfg(not(target_os = "freebsd"))]
         PKT_INFO = libc::IP_PKTINFO,
         /// Enable extended reliable error message passing.
         #[cfg(any(target_os = "android", target_os = "linux"))]
@@ -687,7 +689,7 @@ new_flag!(
         #[cfg(any(target_os = "android", target_os = "linux"))]
         RECV_OPTS = libc::IP_RECVOPTS,
         /// Enables the `IP_ORIGDSTADDR` ancillary message in `recvmsg(2)`.
-        #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
         RECV_ORIG_DST_ADDR = libc::IP_RECVORIGDSTADDR,
         /// Enable passing of `IP_TOS` in ancillary message with incoming
         /// packets.
@@ -783,7 +785,7 @@ new_flag!(
     #[doc = man_link!(tcp(7))]
     pub struct TcpOpt(u32) {
         /// Set the TCP congestion control algorithm to be used.
-        #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
         CONGESTION = libc::TCP_CONGESTION,
         /// Don't send out partial frames.
         #[cfg(any(target_os = "android", target_os = "linux"))]
@@ -793,14 +795,14 @@ new_flag!(
         #[cfg(any(target_os = "android", target_os = "linux"))]
         DEFER_ACCEPT = libc::TCP_DEFER_ACCEPT,
         /// Collect information about this socket.
-        #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
         INFO = libc::TCP_INFO,
         /// The maximum number of keepalive probes TCP should send before
         /// dropping the connection.
         KEEP_CNT = libc::TCP_KEEPCNT,
         /// The time (in seconds) the connection needs to remain idle before TCP
         /// starts sending keepalive probes.
-        #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
         KEEP_IDLE = libc::TCP_KEEPIDLE,
         /// The time (in seconds) between individual keepalive probes.
         KEEP_INTVL = libc::TCP_KEEPINTVL,
@@ -1597,7 +1599,7 @@ impl private::SocketAddress for unix::net::SocketAddr {
     fn into_storage(self) -> Self::Storage {
         let mut storage = libc::sockaddr_un {
             // A number of OS have `sin6_len`, but we don't use it.
-            #[cfg(not(any(target_os = "android", target_os = "linux")))]
+            #[cfg(not(any(target_os = "android", target_os = "freebsd", target_os = "linux")))]
             sun_len: 0,
             sun_family: libc::AF_UNIX as libc::sa_family_t,
             // SAFETY: all zero is valid for `sockaddr_un`.