fix formatting

Author: cheese-head

src/bindings/rust/build.rs

@@ -13,9 +13,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use os_info;
 use std::env;
 use std::path::PathBuf;
-use os_info;
 
 fn get_lib_path(nixl_root_path: &str, arch: &str) -> String {
     let os_info = os_info::get();
@@ -77,9 +77,25 @@ fn get_nixl_libs() -> Option<Vec<pkg_config::Library>> {
         pkg_config::probe_library("etcd-cpp-api"),
         pkg_config::probe_library("ucx"),
     ) {
-        (Ok(nixl), Ok(nixl_build), Ok(nixl_common), Ok(stream), Ok(serdes), Ok(ucx_utils), Ok(etcd), Ok(ucx)) => {
-            Some(vec![nixl, nixl_build, nixl_common, stream, serdes, ucx_utils, etcd, ucx])
-        }
+        (
+            Ok(nixl),
+            Ok(nixl_build),
+            Ok(nixl_common),
+            Ok(stream),
+            Ok(serdes),
+            Ok(ucx_utils),
+            Ok(etcd),
+            Ok(ucx),
+        ) => Some(vec![
+            nixl,
+            nixl_build,
+            nixl_common,
+            stream,
+            serdes,
+            ucx_utils,
+            etcd,
+            ucx,
+        ]),
         _ => None,
     }
 }
@@ -111,7 +127,10 @@ fn build_nixl(cc_builder: &mut cc::Build) {
     println!("cargo:rustc-link-search=native={}", nixl_root_path);
     println!("cargo:rustc-link-search=native={}/lib", nixl_root_path);
     println!("cargo:rustc-link-search=native={}/lib64", nixl_root_path);
-    println!("cargo:rustc-link-search=native={}/lib/x86_64-linux-gnu", nixl_root_path);
+    println!(
+        "cargo:rustc-link-search=native={}/lib/x86_64-linux-gnu",
+        nixl_root_path
+    );
 
     // Try to use pkg-config if available
     if let Some(libs) = get_nixl_libs() {
@@ -125,10 +144,7 @@ fn build_nixl(cc_builder: &mut cc::Build) {
         println!("cargo:warning=pkg-config not available, using manual library paths");
     }
 
-    cc_builder
-        .file("wrapper.cpp")
-        .includes(nixl_include_paths);
-
+    cc_builder.file("wrapper.cpp").includes(nixl_include_paths);
 
     println!("cargo:rustc-link-search={}", nixl_lib_path);
 

src/bindings/rust/src/agent.rs

@@ -14,18 +14,23 @@
 // limitations under the License.
 
 use super::*;
-use crate::descriptors::{QueryResponseList, RegDescList};
 use crate::bindings::{
-    nixl_capi_agent_config_s as nixl_capi_agent_config_t,
-    nixl_capi_thread_sync_t, nixl_capi_create_configured_agent};
+    nixl_capi_agent_config_s as nixl_capi_agent_config_t, nixl_capi_create_configured_agent,
+    nixl_capi_thread_sync_t,
+};
+use crate::descriptors::{QueryResponseList, RegDescList};
 
 impl From<ThreadSync> for nixl_capi_thread_sync_t {
     fn from(value: ThreadSync) -> Self {
         match value {
             ThreadSync::None => crate::bindings::nixl_capi_thread_sync_t_NIXL_CAPI_THREAD_SYNC_NONE,
-            ThreadSync::Strict => crate::bindings::nixl_capi_thread_sync_t_NIXL_CAPI_THREAD_SYNC_STRICT,
+            ThreadSync::Strict => {
+                crate::bindings::nixl_capi_thread_sync_t_NIXL_CAPI_THREAD_SYNC_STRICT
+            }
             ThreadSync::Rw => crate::bindings::nixl_capi_thread_sync_t_NIXL_CAPI_THREAD_SYNC_RW,
-            ThreadSync::Default => crate::bindings::nixl_capi_thread_sync_t_NIXL_CAPI_THREAD_SYNC_DEFAULT,
+            ThreadSync::Default => {
+                crate::bindings::nixl_capi_thread_sync_t_NIXL_CAPI_THREAD_SYNC_DEFAULT
+            }
         }
     }
 }
@@ -94,9 +99,8 @@ impl Agent {
         };
 
         let mut agent = ptr::null_mut();
-        let status = unsafe {
-            nixl_capi_create_configured_agent(c_name.as_ptr(), &mut c_cfg, &mut agent)
-        };
+        let status =
+            unsafe { nixl_capi_create_configured_agent(c_name.as_ptr(), &mut c_cfg, &mut agent) };
 
         match status {
             NIXL_CAPI_SUCCESS => {
@@ -402,7 +406,11 @@ impl Agent {
     /// # Returns
     /// A byte array containing the local partial metadata
     ///
-    pub fn get_local_partial_md(&self, descs: &RegDescList, opt_args: Option<&OptArgs>) -> Result<Vec<u8>, NixlError> {
+    pub fn get_local_partial_md(
+        &self,
+        descs: &RegDescList,
+        opt_args: Option<&OptArgs>,
+    ) -> Result<Vec<u8>, NixlError> {
         tracing::trace!("Getting local partial metadata");
         let mut data = std::ptr::null_mut();
         let mut len: usize = 0;
@@ -425,15 +433,24 @@ impl Agent {
                     libc::free(data as *mut libc::c_void);
                     vec
                 };
-                tracing::trace!(metadata.size = len, "Successfully retrieved local partial metadata");
+                tracing::trace!(
+                    metadata.size = len,
+                    "Successfully retrieved local partial metadata"
+                );
                 Ok(bytes)
             }
             NIXL_CAPI_ERROR_INVALID_PARAM => {
-                tracing::error!(error = "invalid_param", "Failed to get local partial metadata");
+                tracing::error!(
+                    error = "invalid_param",
+                    "Failed to get local partial metadata"
+                );
                 Err(NixlError::InvalidParam)
             }
             _ => {
-                tracing::error!(error = "backend_error", "Failed to get local partial metadata");
+                tracing::error!(
+                    error = "backend_error",
+                    "Failed to get local partial metadata"
+                );
                 Err(NixlError::BackendError)
             }
         }
@@ -476,7 +493,11 @@ impl Agent {
         }
     }
 
-    pub fn make_connection(&self, remote_agent: &str, opt_args: Option<&OptArgs>) -> Result<(), NixlError> {
+    pub fn make_connection(
+        &self,
+        remote_agent: &str,
+        opt_args: Option<&OptArgs>,
+    ) -> Result<(), NixlError> {
         let remote_agent = CString::new(remote_agent)?;
         let inner_guard = self.inner.write().unwrap();
 
@@ -521,10 +542,15 @@ impl Agent {
         }
     }
 
-    pub fn make_xfer_req(&self, operation: XferOp,
-                         local_descs: &XferDlistHandle, local_indices: &[i32],
-                         remote_descs: &XferDlistHandle, remote_indices: &[i32],
-                         opt_args: Option<&OptArgs>) -> Result<XferRequest, NixlError> {
+    pub fn make_xfer_req(
+        &self,
+        operation: XferOp,
+        local_descs: &XferDlistHandle,
+        local_indices: &[i32],
+        remote_descs: &XferDlistHandle,
+        remote_indices: &[i32],
+        opt_args: Option<&OptArgs>,
+    ) -> Result<XferRequest, NixlError> {
         let mut req = std::ptr::null_mut();
         let inner_guard = self.inner.read().unwrap();
 
@@ -539,13 +565,13 @@ impl Agent {
                 remote_indices.as_ptr(),
                 remote_indices.len() as usize,
                 &mut req,
-                opt_args.map_or(std::ptr::null_mut(), |args| args.inner.as_ptr())
+                opt_args.map_or(std::ptr::null_mut(), |args| args.inner.as_ptr()),
             )
         };
 
         match status {
-            NIXL_CAPI_SUCCESS => Ok(XferRequest::new(NonNull::new(req)
-                .ok_or(NixlError::FailedToCreateXferRequest)?,
+            NIXL_CAPI_SUCCESS => Ok(XferRequest::new(
+                NonNull::new(req).ok_or(NixlError::FailedToCreateXferRequest)?,
                 self.inner.clone(),
             )),
             NIXL_CAPI_ERROR_INVALID_PARAM => Err(NixlError::InvalidParam),
@@ -657,7 +683,11 @@ impl Agent {
     /// # Arguments
     /// * `descs` - Registration descriptor list to send
     /// * `opt_args` - Optional arguments for sending metadata
-    pub fn send_local_partial_md(&self, descs: &RegDescList, opt_args: Option<&OptArgs>) -> Result<(), NixlError> {
+    pub fn send_local_partial_md(
+        &self,
+        descs: &RegDescList,
+        opt_args: Option<&OptArgs>,
+    ) -> Result<(), NixlError> {
         tracing::trace!("Sending local partial metadata to etcd");
         let inner_guard = self.inner.write().unwrap();
         let status = unsafe {
@@ -673,14 +703,16 @@ impl Agent {
                 Ok(())
             }
             NIXL_CAPI_ERROR_INVALID_PARAM => {
-                tracing::error!(error = "invalid_param", "Failed to send local partial metadata to etcd");
+                tracing::error!(
+                    error = "invalid_param",
+                    "Failed to send local partial metadata to etcd"
+                );
                 Err(NixlError::InvalidParam)
             }
-            _ => Err(NixlError::BackendError)
+            _ => Err(NixlError::BackendError),
         }
     }
 
-
     /// Fetch a remote agent's metadata from etcd
     ///
     /// Once fetched, the metadata will be loaded and cached locally, enabling
@@ -975,7 +1007,7 @@ impl Agent {
 
         match status {
             NIXL_CAPI_SUCCESS => Ok(XferStatus::Success), // Transfer completed
-            NIXL_CAPI_IN_PROG => Ok(XferStatus::InProgress),  // Transfer in progress
+            NIXL_CAPI_IN_PROG => Ok(XferStatus::InProgress), // Transfer in progress
             NIXL_CAPI_ERROR_INVALID_PARAM => Err(NixlError::InvalidParam),
             _ => Err(NixlError::BackendError),
         }
@@ -995,22 +1027,17 @@ impl Agent {
         let mut backend = std::ptr::null_mut();
         let inner_guard = self.inner.write().unwrap();
         let status = unsafe {
-            nixl_capi_query_xfer_backend(
-                inner_guard.handle.as_ptr(),
-                req.handle(),
-                &mut backend
-            )
+            nixl_capi_query_xfer_backend(inner_guard.handle.as_ptr(), req.handle(), &mut backend)
         };
         match status {
-            NIXL_CAPI_SUCCESS => {
-                Ok(Backend{ inner: NonNull::new(backend).ok_or(NixlError::FailedToCreateBackend)? })
-            }
+            NIXL_CAPI_SUCCESS => Ok(Backend {
+                inner: NonNull::new(backend).ok_or(NixlError::FailedToCreateBackend)?,
+            }),
             NIXL_CAPI_ERROR_INVALID_PARAM => Err(NixlError::InvalidParam),
             _ => Err(NixlError::BackendError),
         }
     }
 
-
     /// Gets notifications from other agents
     ///
     /// # Arguments

src/bindings/rust/src/descriptors/reg.rs

@@ -13,8 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use super::*;
 use super::sync_manager::{BackendSyncable, SyncManager};
+use super::*;
 
 /// Public registration descriptor used for indexing and comparisons
 #[derive(Debug, Clone, PartialEq)]
@@ -78,9 +78,8 @@ impl<'a> RegDescList<'a> {
     /// Creates a new registration descriptor list for the given memory type
     pub fn new(mem_type: MemType) -> Result<Self, NixlError> {
         let mut dlist = ptr::null_mut();
-        let status = unsafe {
-            nixl_capi_create_reg_dlist(mem_type as nixl_capi_mem_type_t, &mut dlist)
-        };
+        let status =
+            unsafe { nixl_capi_create_reg_dlist(mem_type as nixl_capi_mem_type_t, &mut dlist) };
 
         match status {
             NIXL_CAPI_SUCCESS => {
@@ -105,7 +104,9 @@ impl<'a> RegDescList<'a> {
         }
     }
 
-    pub fn get_type(&self) -> Result<MemType, NixlError> { Ok(self.mem_type) }
+    pub fn get_type(&self) -> Result<MemType, NixlError> {
+        Ok(self.mem_type)
+    }
 
     /// Adds a descriptor to the list
     pub fn add_desc(&mut self, addr: usize, len: usize, dev_id: u64) -> Result<(), NixlError> {
@@ -137,10 +138,14 @@ impl<'a> RegDescList<'a> {
     }
 
     /// Returns the number of descriptors in the list
-    pub fn desc_count(&self) -> Result<usize, NixlError> { Ok(self.sync_mgr.data().descriptors.len()) }
+    pub fn desc_count(&self) -> Result<usize, NixlError> {
+        Ok(self.sync_mgr.data().descriptors.len())
+    }
 
     /// Returns the number of descriptors in the list
-    pub fn len(&self) -> Result<usize, NixlError> { Ok(self.sync_mgr.data().descriptors.len()) }
+    pub fn len(&self) -> Result<usize, NixlError> {
+        Ok(self.sync_mgr.data().descriptors.len())
+    }
 
     /// Trims the list to the given size
     pub fn trim(&mut self) -> Result<(), NixlError> {
@@ -152,11 +157,15 @@ impl<'a> RegDescList<'a> {
 
     /// Removes the descriptor at the given index
     pub fn rem_desc(&mut self, index: i32) -> Result<(), NixlError> {
-        if index < 0 { return Err(NixlError::InvalidParam); }
+        if index < 0 {
+            return Err(NixlError::InvalidParam);
+        }
         let idx = index as usize;
 
         self.sync_mgr.modify(|data| {
-            if idx >= data.descriptors.len() { return Err(NixlError::InvalidParam); }
+            if idx >= data.descriptors.len() {
+                return Err(NixlError::InvalidParam);
+            }
             data.descriptors.remove(idx);
             Ok(())
         })
@@ -185,12 +194,15 @@ impl<'a> RegDescList<'a> {
     /// Resizes the list to the given size
     pub fn resize(&mut self, new_size: usize) -> Result<(), NixlError> {
         self.sync_mgr.modify(|data| {
-            data.descriptors.resize(new_size, RegDescriptor {
-                addr: 0,
-                len: 0,
-                dev_id: 0,
-                metadata: Vec::new(),
-            });
+            data.descriptors.resize(
+                new_size,
+                RegDescriptor {
+                    addr: 0,
+                    len: 0,
+                    dev_id: 0,
+                    metadata: Vec::new(),
+                },
+            );
         });
         Ok(())
     }
@@ -224,7 +236,10 @@ impl<'a> RegDescList<'a> {
     }
 
     pub(crate) fn handle(&self) -> *mut bindings::nixl_capi_reg_dlist_s {
-        self.sync_mgr.backend().map(|b| b.as_ptr()).unwrap_or(ptr::null_mut())
+        self.sync_mgr
+            .backend()
+            .map(|b| b.as_ptr())
+            .unwrap_or(ptr::null_mut())
     }
 }
 

src/bindings/rust/src/descriptors/sync_manager.rs

@@ -66,4 +66,3 @@ impl<T: BackendSyncable> SyncManager<T> {
         Ok(())
     }
 }
-