Add FreeBSD support

dof/src/dof_bindings.rs

@@ -446,6 +446,10 @@ pub struct dof_helper {
     pub dofhp_mod: [::std::os::raw::c_char; 64usize],
     pub dofhp_addr: u64,
     pub dofhp_dof: u64,
+    #[cfg(target_os = "freebsd")]
+    pub dofhp_pid: i32,
+    #[cfg(target_os = "freebsd")]
+    pub dofhp_gen: ::std::os::raw::c_int
 }
 impl Default for dof_helper {
     fn default() -> Self {

usdt-impl/build.rs

@@ -27,20 +27,43 @@ enum Backend {
     NoOp,
 }
 
+fn have_link_dead_code_check() -> bool {
+    match env::var_os("CARGO_ENCODED_RUSTFLAGS").as_deref() {
+      Some(rustflags) => {
+          let mut atoms = rustflags.to_str().unwrap_or("").split(' ');
+          let mut link_dead_code = false;
+          // check if the last link-dead-code is n or no
+          while let Some(atom) = atoms.next() {
+              if atom.starts_with("-C") && atom.contains("link-dead-code") {
+                  link_dead_code = !atom.contains("link-dead-code=n")
+              }
+          }
+          link_dead_code
+      }
+      _ => false
+    }
+}
+
 fn main() {
     println!("cargo:rerun-if-changed=build.rs");
 
     // `asm` feature was stabilized in 1.59
     let have_stable_asm = version_check::is_min_version("1.59").unwrap_or(false);
     // XXX: `asm_sym` feature is not yet stable
     let have_stable_asm_sym = false;
+    let have_stable_used_with_arg = false;
 
     // Are we being built with a compiler which allows feature flags (nightly)
     let is_nightly = version_check::is_feature_flaggable().unwrap_or(false);
 
     let feat_asm = env::var_os("CARGO_FEATURE_ASM").is_some();
     let feat_strict_asm = env::var_os("CARGO_FEATURE_STRICT_ASM").is_some();
 
+    // Check if upstream have enabled link-dead-code, which in those cases we can
+    // enable standard backend for FreeBSD. We check this by finding the last
+    // -C link-dead-code* flag, and check if it is a negation of link-dead-code
+    let have_link_dead_code = have_link_dead_code_check();
+
     let backend = match env::var("CARGO_CFG_TARGET_OS").ok().as_deref() {
         Some("macos") if feat_asm => {
             if have_stable_asm && have_stable_asm_sym {
@@ -67,6 +90,24 @@ fn main() {
                 Backend::NoOp
             }
         }
+        Some("freebsd") if feat_asm => {
+            // FreeBSD require used(linker) to preserve __(start|stop)_set_dtrace_probes
+            // without explicit "link-dead-code" by consumer
+            if have_link_dead_code || have_stable_used_with_arg || is_nightly {
+               if !have_stable_used_with_arg && is_nightly {
+                   println!("cargo:rustc-cfg=usdt_need_used_with_arg");
+               }
+               if have_stable_asm {
+                   Backend::Standard
+               } else if feat_strict_asm || is_nightly {
+                   Backend::Standard
+               } else {
+                   Backend::NoOp
+               }
+            } else {
+                Backend::NoOp
+            }
+        }
         _ => Backend::NoOp,
     };
 

usdt-impl/src/lib.rs

@@ -16,6 +16,7 @@
 
 #![cfg_attr(usdt_need_feat_asm, feature(asm))]
 #![cfg_attr(usdt_need_feat_asm_sym, feature(asm_sym))]
+#![cfg_attr(usdt_need_feat_used_with_arg, feature(used_with_arg))]
 
 use serde::Deserialize;
 use std::cell::RefCell;

usdt-impl/src/no-linker.rs

@@ -130,9 +130,10 @@ fn extract_probe_records_from_section() -> Result<Section, crate::Error> {
     // writable (to implement one-time registration), so an immutable variable here
     // leads to _two_ sections, one writable and one read-only. A mutable variable
     // here ensures this ends up in a mutable section, the same as the probe records.
-    #[cfg(target_os = "illumos")]
+    #[cfg(any(target_os = "illumos", target_os = "freebsd"))]
     #[link_section = "set_dtrace_probes"]
-    #[used]
+    #[cfg_attr(usdt_need_feat_used_with_arg, used(linker))]
+    #[cfg_attr(not(usdt_need_feat_used_with_arg), used)]
     static mut FORCE_LOAD: [u64; 0] = [];
 
     let data = unsafe {
@@ -170,9 +171,23 @@ fn ioctl_section(buf: &[u8], modname: [std::os::raw::c_char; 64]) -> Result<(),
         dofhp_mod: modname,
         dofhp_addr: buf.as_ptr() as u64,
         dofhp_dof: buf.as_ptr() as u64,
+        #[cfg(target_os = "freebsd")]
+        dofhp_pid: std::process::id() as i32,
+        #[cfg(target_os = "freebsd")]
+        dofhp_gen: 0
     };
     let data = &helper as *const _;
+    #[cfg(target_os = "illumos")]
     let cmd: i32 = 0x64746803;
+    #[cfg(target_os = "freebsd")]
+    let cmd: u64 = {
+        const DOFHELPER_SIZE: u64 = std::mem::size_of::<dof::dof_bindings::dof_helper>() as u64;
+        const IOCPARM_SHIFT: u64 = 13;
+        const IOCPARM_MASK: u64  = (1 << IOCPARM_SHIFT) - 1;
+        const IOC_INOUT: u64     = 0xc0000000;
+        IOC_INOUT | ((DOFHELPER_SIZE & IOCPARM_MASK) << 16) | 0x7a << 8 | 0x3
+    };
+
     let file = OpenOptions::new()
         .read(true)
         .write(true)

usdt-impl/src/record.rs

@@ -71,10 +71,15 @@ pub(crate) fn addr_to_info(addr: u64) -> (Option<String>, Option<String>) {
         if libc::dladdr(addr as *const c_void, &mut info as *mut _) == 0 {
             (None, None)
         } else {
-            (
-                Some(CStr::from_ptr(info.dli_sname).to_string_lossy().to_string()),
-                Some(CStr::from_ptr(info.dli_fname).to_string_lossy().to_string()),
-            )
+            unsafe fn to_str_if_not_null(ptr: *const std::os::raw::c_char) -> Option<String> {
+              if ptr == null() {
+                  None
+              } else {
+                 Some(CStr::from_ptr(ptr).to_string_lossy().to_string())
+              }
+            }
+
+            (to_str_if_not_null(info.dli_sname), to_str_if_not_null(info.dli_fname))
         }
     }
 }
@@ -213,7 +218,10 @@ impl<'a> ReadCstrExt<'a> for &'a [u8] {
 // Construct the ASM record for a probe. If `types` is `None`, then is is an is-enabled probe.
 #[allow(dead_code)]
 pub(crate) fn emit_probe_record(prov: &str, probe: &str, types: Option<&[DataType]>) -> String {
+    #[cfg(not(target_os = "freebsd"))]
     let section_ident = r#"set_dtrace_probes,"aw","progbits""#;
+    #[cfg(target_os = "freebsd")]
+    let section_ident = r#"set_dtrace_probes,"awR","progbits""#;
     let is_enabled = types.is_none();
     let n_args = types.map_or(0, |typ| typ.len());
     let arguments = types.map_or_else(String::new, |types| {