Add FreeBSD cargo-zigbuild remote_server support

crates/crashes/Cargo.toml

@@ -6,13 +6,17 @@ edition.workspace = true
 license = "GPL-3.0-or-later"
 
 [dependencies]
-async-process.workspace = true
-crash-handler.workspace = true
+futures.workspace = true
 log.workspace = true
-minidumper.workspace = true
 parking_lot.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+
+[target.'cfg(not(target_os = "freebsd"))'.dependencies]
+async-process.workspace = true
+crash-handler.workspace = true
+minidumper.workspace = true
+paths.workspace = true
 system_specs.workspace = true
 zstd.workspace = true
 
@@ -26,4 +30,4 @@ windows.workspace = true
 workspace = true
 
 [lib]
-path = "src/crashes.rs"
+path = "src/lib.rs"

crates/crashes/src/crashes_freebsd.rs

@@ -0,0 +1,33 @@
+use std::future::Future;
+use std::path::Path;
+
+use futures::future::BoxFuture;
+use serde::{Deserialize, Serialize};
+
+pub static REQUESTED_MINIDUMP: std::sync::atomic::AtomicBool =
+    std::sync::atomic::AtomicBool::new(false);
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct InitCrashHandler {
+    pub session_id: String,
+    pub zed_version: String,
+    pub binary: String,
+    pub release_channel: String,
+    pub commit_sha: String,
+}
+
+pub fn init<F: Future<Output = ()> + Send + Sync + 'static>(
+    _crash_init: InitCrashHandler,
+    _spawn: impl FnOnce(BoxFuture<'static, ()>),
+    _wait_timer: impl (Fn(std::time::Duration) -> F) + Send + Sync + 'static,
+) {
+    log::info!("crash handler disabled on FreeBSD");
+}
+
+pub fn crash_server(_socket: &Path) {
+    log::info!("crash server disabled on FreeBSD");
+}
+
+pub fn set_gpu_info(_specs: ()) {}
+
+pub fn set_user_info(_info: ()) {}

crates/crashes/src/lib.rs

@@ -0,0 +1,11 @@
+#[cfg(not(target_os = "freebsd"))]
+mod crashes;
+
+#[cfg(not(target_os = "freebsd"))]
+pub use crashes::*;
+
+#[cfg(target_os = "freebsd")]
+mod crashes_freebsd;
+
+#[cfg(target_os = "freebsd")]
+pub use crashes_freebsd::*;

crates/fs/src/fs.rs

@@ -451,14 +451,15 @@ impl FileHandle for std::fs::File {
         };
 
         let fd = self.as_fd();
-        let mut kif = MaybeUninit::<libc::kinfo_file>::uninit();
+        let mut kif = MaybeUninit::<libc::kinfo_file>::zeroed();
+        // SAFETY: zeroed memory is a valid initial state for kinfo_file.
+        let kif = unsafe { kif.assume_init_mut() };
         kif.kf_structsize = libc::KINFO_FILE_SIZE;
 
-        let result = unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_KINFO, kif.as_mut_ptr()) };
+        let result = unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_KINFO, kif as *mut _) };
         anyhow::ensure!(result != -1, "fcntl returned -1");
 
-        // SAFETY: `fcntl` will initialize the kif.
-        let c_str = unsafe { CStr::from_ptr(kif.assume_init().kf_path.as_ptr()) };
+        let c_str = unsafe { CStr::from_ptr(kif.kf_path.as_ptr()) };
         anyhow::ensure!(!c_str.is_empty(), "Could find a path for the file handle");
         let path = PathBuf::from(OsStr::from_bytes(c_str.to_bytes()));
         Ok(path)

crates/gpui/src/gpui.rs

@@ -39,6 +39,7 @@ pub mod profiler;
     test,
     target_os = "windows",
     target_os = "linux",
+    target_os = "freebsd",
     target_family = "wasm",
     feature = "bench"
 ))]
@@ -137,7 +138,12 @@ pub use keymap::*;
 pub use path_builder::*;
 pub use platform::*;
 pub use profiler::*;
-#[cfg(any(target_os = "windows", target_os = "linux", target_family = "wasm"))]
+#[cfg(any(
+    target_os = "windows",
+    target_os = "linux",
+    target_os = "freebsd",
+    target_family = "wasm"
+))]
 pub use queue::{PriorityQueueReceiver, PriorityQueueSender};
 pub use refineable::*;
 pub use scene::*;

crates/remote/src/remote_client.rs

@@ -57,6 +57,7 @@ pub enum RemoteOs {
     Linux,
     MacOs,
     Windows,
+    FreeBSD,
 }
 
 impl RemoteOs {
@@ -65,6 +66,7 @@ impl RemoteOs {
             RemoteOs::Linux => "linux",
             RemoteOs::MacOs => "macos",
             RemoteOs::Windows => "windows",
+            RemoteOs::FreeBSD => "freebsd",
         }
     }
 

crates/remote/src/transport.rs

@@ -32,6 +32,7 @@ fn parse_platform(output: &str) -> Result<RemotePlatform> {
     let os = match os {
         "Darwin" => RemoteOs::MacOs,
         "Linux" => RemoteOs::Linux,
+        "FreeBSD" => RemoteOs::FreeBSD,
         _ => anyhow::bail!(
             "Prebuilt remote servers are not yet available for {os:?}. See https://zed.dev/docs/remote-development"
         ),
@@ -302,6 +303,7 @@ async fn build_remote_server_from_source(
                     "unknown-linux-gnu"
                 },
             RemoteOs::MacOs => "apple-darwin",
+            RemoteOs::FreeBSD => "unknown-freebsd",
             RemoteOs::Windows if cfg!(windows) => "pc-windows-msvc",
             RemoteOs::Windows => "pc-windows-gnu",
         }
@@ -502,6 +504,10 @@ mod tests {
 
         assert!(parse_platform("Windows x86_64\n").is_err());
         assert!(parse_platform("Linux armv7l\n").is_err());
+
+        let result = parse_platform("FreeBSD x86_64\n").unwrap();
+        assert_eq!(result.os, RemoteOs::FreeBSD);
+        assert_eq!(result.arch, RemoteArch::X86_64);
     }
 
     #[test]

crates/remote_server/Cargo.toml

@@ -76,11 +76,13 @@ thiserror.workspace = true
 rayon.workspace = true
 uuid = { workspace = true, features = ["v4"] }
 
-[target.'cfg(not(windows))'.dependencies]
+[target.'cfg(not(any(target_os = "windows", target_os = "freebsd")))'.dependencies]
 crash-handler.workspace = true
+minidumper.workspace = true
+
+[target.'cfg(not(windows))'.dependencies]
 fork.workspace = true
 libc.workspace = true
-minidumper.workspace = true
 
 [target.'cfg(windows)'.dependencies]
 windows.workspace = true