passthrough: turn kernel passthrough off when init() doesn't enable it

init() set `passthrough` when it enabled kernel passthrough, but never
cleared it. A takeover that calls init() again on the same instance,
with options that no longer allow passthrough, kept registering backing
ids for new files. Clear it first. Inodes with handles from before keep
sharing their backing ids until their last handle closes.

Signed-off-by: Ilan Joselevich <personal@ilanjoselevich.com>

Author: Kranzes

crates/fuse-backend-passthrough/src/lib.rs

@@ -2071,6 +2071,36 @@ mod tests {
             .unwrap();
         assert_eq!(*files.closed.lock().unwrap(), vec![7]);
 
+        // An init() without passthrough turns it off again.
+        let tmpdir = TempDir::new().unwrap();
+        let files = Files::new(vec![Ok(3)]);
+        let fs = passthrough_fs(&tmpdir, files.clone());
+        let (entry, h1, opts1, _) = fs.create(&ctx, ROOT_ID, &name, createin).unwrap();
+        assert!(opts1.contains(OpenOptions::PASSTHROUGH));
+        assert!(!fs
+            .init(FsOptions::empty())
+            .unwrap()
+            .contains(FsOptions::PASSTHROUGH));
+        // A new file doesn't pass through.
+        let other = CString::new("other").unwrap();
+        let (_, _, opts_other, id_other) = fs.create(&ctx, ROOT_ID, &other, createin).unwrap();
+        assert!(!opts_other.contains(OpenOptions::PASSTHROUGH));
+        assert_eq!(id_other, None);
+        assert_eq!(files.calls.load(Ordering::Relaxed), 1);
+        // An inode with a handle from before still shares its id, because the kernel fails
+        // other opens of it.
+        let (h2, opts2, id2) = fs
+            .open(&ctx, entry.inode, libc::O_RDONLY as u32, 0)
+            .unwrap();
+        assert!(opts2.contains(OpenOptions::PASSTHROUGH));
+        assert_eq!(id2, Some(3));
+        fs.release(&ctx, entry.inode, 0, h1.unwrap(), false, false, None)
+            .unwrap();
+        assert!(files.closed.lock().unwrap().is_empty());
+        fs.release(&ctx, entry.inode, 0, h2.unwrap(), false, false, None)
+            .unwrap();
+        assert_eq!(*files.closed.lock().unwrap(), vec![3]);
+
         // EPERM turns passthrough off, so the next open doesn't try again.
         let tmpdir = TempDir::new().unwrap();
         let files = Files::new(vec![Err(io::Error::from_raw_os_error(libc::EPERM))]);

crates/fuse-backend-passthrough/src/sync_io.rs

@@ -749,6 +749,10 @@ impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
             self.perfile_dax.store(true, Ordering::Relaxed);
         }
 
+        // A takeover can call init() again with other options, so passthrough stays on only if
+        // this negotiation enables it again.
+        #[cfg(target_os = "linux")]
+        self.passthrough.store(false, Ordering::Relaxed);
         #[cfg(target_os = "linux")]
         if self.kernel_passthrough.is_some() && capable.contains(FsOptions::PASSTHROUGH) {
             // The kernel ignores FUSE_PASSTHROUGH along with FUSE_WRITEBACK_CACHE, and needs open