Allow for raw marshalling of BackingIds

Adds methods to convert BackingIds from/to their raw `backing_id` values, which allows for marshalling of backing file references across process boundaries.

Author: Popax21

src/channel.rs

@@ -95,4 +95,8 @@ impl ChannelSender {
     pub(crate) fn open_backing(&self, fd: BorrowedFd<'_>) -> std::io::Result<BackingId> {
         BackingId::create(&self.0, fd)
     }
+
+    pub(crate) unsafe fn wrap_backing(&self, id: u32) -> BackingId {
+        unsafe { BackingId::wrap_raw(&self.0, id) }
+    }
 }

src/passthrough.rs

@@ -35,6 +35,13 @@ pub struct BackingId {
 }
 
 impl BackingId {
+    pub(crate) unsafe fn wrap_raw(channel: &Arc<DevFuse>, id: u32) -> Self {
+        Self {
+            channel: Arc::downgrade(channel),
+            backing_id: id,
+        }
+    }
+
     pub(crate) fn create(channel: &Arc<DevFuse>, fd: impl AsFd) -> std::io::Result<Self> {
         if !cfg!(target_os = "linux") {
             return Err(std::io::Error::new(
@@ -54,6 +61,19 @@ impl BackingId {
             backing_id: id as u32,
         })
     }
+
+    /// Converts this backing file reference into the raw `backing_id` value as returned by the kernel.
+    ///
+    /// This method transfers ownership of the backing file to the caller, who must invoke the
+    /// `FUSE_DEV_IOC_BACKING_CLOSE` themselves once they wish to close the backing file.
+    ///
+    /// The returned ID may subsequently be reopened using
+    /// [`ReplyOpen::wrap_backing()`](crate::ReplyOpen::wrap_backing).
+    pub fn into_raw(self) -> u32 {
+        let id = self.backing_id;
+        std::mem::forget(self);
+        id
+    }
 }
 
 impl Drop for BackingId {

src/reply.rs

@@ -69,6 +69,17 @@ impl ReplySender {
             ReplySender::Sync(_) => unreachable!(),
         }
     }
+
+    /// Wraps a raw backing file ID
+    pub(crate) unsafe fn wrap_backing(&self, id: u32) -> BackingId {
+        match self {
+            ReplySender::Channel(sender) => unsafe { sender.wrap_backing(id) },
+            #[cfg(test)]
+            ReplySender::Assert(_) => unreachable!(),
+            #[cfg(test)]
+            ReplySender::Sync(_) => unreachable!(),
+        }
+    }
 }
 
 #[cfg(test)]
@@ -335,6 +346,24 @@ impl ReplyOpen {
         self.reply.sender.as_ref().unwrap().open_backing(fd.as_fd())
     }
 
+    /// Wraps a raw FUSE `backing_id` value, returning a `BackingId`. Once you have the backing ID,
+    /// you can pass it as the 3rd parameter of [`ReplyOpen::opened_passthrough()`]. This is done in
+    /// two separate steps because it may make sense to reuse backing IDs (to avoid having to
+    /// repeatedly reopen the underlying file or potentially keep thousands of fds open).
+    ///
+    /// This function takes ownership of the given backing ID value, automatically closing it once
+    /// the returned `BackingId` is dropped. You may reobtain ownership of the backing ID by calling
+    /// [`BackingId::into_raw()`].
+    ///
+    /// # Safety
+    ///
+    /// The given ID must be open and belong to this FUSE session, and may not be closed while the
+    /// returned `BackingId` instance is still live.
+    pub unsafe fn wrap_backing(&self, id: u32) -> BackingId {
+        // TODO: assert passthrough capability is enabled.
+        unsafe { self.reply.sender.as_ref().unwrap().wrap_backing(id) }
+    }
+
     /// Reply to a request with an opened backing id. Call [`ReplyOpen::open_backing()`]
     /// to get one of these.
     pub fn opened_passthrough(self, fh: ll::FileHandle, flags: FopenFlags, backing_id: &BackingId) {
@@ -474,6 +503,24 @@ impl ReplyCreate {
         self.reply.sender.as_ref().unwrap().open_backing(fd.as_fd())
     }
 
+    /// Wraps a raw FUSE `backing_id` value, returning a `BackingId`. Once you have the backing ID,
+    /// you can pass it as the 3rd parameter of [`ReplyOpen::opened_passthrough()`]. This is done in
+    /// two separate steps because it may make sense to reuse backing IDs (to avoid having to
+    /// repeatedly reopen the underlying file or potentially keep thousands of fds open).
+    ///
+    /// This function takes ownership of the given backing ID value, automatically closing it once
+    /// the returned `BackingId` is dropped. You may reobtain ownership of the backing ID by calling
+    /// [`BackingId::into_raw()`].
+    ///
+    /// # Safety
+    ///
+    /// The given ID must be open and belong to this FUSE session, and may not be closed while the
+    /// returned `BackingId` instance is still live.
+    pub unsafe fn wrap_backing(&self, id: u32) -> BackingId {
+        // TODO: assert passthrough capability is enabled.
+        unsafe { self.reply.sender.as_ref().unwrap().wrap_backing(id) }
+    }
+
     /// Reply to a request with an opened backing id. Call `ReplyCreate::open_backing()` to get one of
     /// these.
     pub fn created_passthrough(