Enforce the kernel's 4096-byte minimum in set_max_write()

KernelConfig::set_max_write() documents that an out-of-range argument is
rejected with the nearest value which will succeed, but it only checked
the upper bound. Values below 4096 were accepted even though the kernel
clamps max_write to at least 4096 (process_init_reply() in
fs/fuse/inode.c), so the setting was silently ineffective: the
filesystem could still receive write requests of up to 4096 bytes,
larger than the limit it had configured.

Reject values below a new MIN_WRITE_SIZE constant with that nearest
valid value, replacing the previous zero-only check.

Fixes #327

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TfPeUUeQKYjo26Y9mQG9sA

Author: claude

CHANGELOG.md

@@ -1,6 +1,9 @@
 # FUSE for Rust - Changelog
 
 ## Unreleased
+* `KernelConfig::set_max_write()` now rejects values below 4096 with the nearest valid value,
+  per its documented contract (#327). The kernel clamps `max_write` to at least 4096, so a
+  smaller value was accepted but ineffective: write requests of up to 4096 bytes still arrived
 * Fix inverted mounted-check during session teardown: after the filesystem had already been
   unmounted externally, fuser would attempt to unmount the mountpoint again, which could
   unmount an unrelated filesystem mounted at the same path in the meantime

src/lib.rs

@@ -76,6 +76,7 @@ pub use crate::reply::ReplyXattr;
 pub use crate::request_param::Request;
 pub use crate::session::BackgroundSession;
 use crate::session::MAX_WRITE_SIZE;
+use crate::session::MIN_WRITE_SIZE;
 pub use crate::session::Session;
 pub use crate::session::SessionACL;
 pub use crate::session::SessionUnmounter;
@@ -295,10 +296,13 @@ impl KernelConfig {
     ///
     /// On success returns the previous value.
     /// # Errors
-    /// If the argument is too large, returns the nearest value which will succeed.
+    /// If the argument is too small or too large, returns the nearest value which will succeed.
     pub fn set_max_write(&mut self, value: u32) -> Result<u32, u32> {
-        if value == 0 {
-            return Err(1);
+        // The kernel clamps max_write below 4096 up to 4096 (process_init_reply()
+        // in fs/fuse/inode.c), so a smaller advertised value would not take
+        // effect: write requests of up to 4096 bytes would still arrive
+        if value < MIN_WRITE_SIZE as u32 {
+            return Err(MIN_WRITE_SIZE as u32);
         }
         if value > MAX_WRITE_SIZE as u32 {
             return Err(MAX_WRITE_SIZE as u32);
@@ -1072,3 +1076,36 @@ pub fn spawn_mount<'a, FS: Filesystem + Send + 'static + 'a, P: AsRef<Path>>(
 ) -> io::Result<BackgroundSession> {
     Session::new(filesystem, mountpoint.as_ref(), options).and_then(session::Session::spawn)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn kernel_config_set_max_write_bounds() {
+        let mut config = KernelConfig::new(InitFlags::empty(), 65536, Version(7, 31));
+        // Values the kernel would not honor (it clamps max_write below 4096 up
+        // to 4096) are rejected with the nearest value that will take effect
+        assert_eq!(config.set_max_write(0), Err(MIN_WRITE_SIZE as u32));
+        assert_eq!(
+            config.set_max_write(MIN_WRITE_SIZE as u32 - 1),
+            Err(MIN_WRITE_SIZE as u32)
+        );
+        // Values beyond the session's read buffer are rejected likewise
+        assert_eq!(
+            config.set_max_write(MAX_WRITE_SIZE as u32 + 1),
+            Err(MAX_WRITE_SIZE as u32)
+        );
+        // Rejected calls must leave the configured value unchanged
+        assert_eq!(config.max_write, MAX_WRITE_SIZE as u32);
+        // Both bounds themselves are accepted, returning the previous value
+        assert_eq!(
+            config.set_max_write(MIN_WRITE_SIZE as u32),
+            Ok(MAX_WRITE_SIZE as u32)
+        );
+        assert_eq!(
+            config.set_max_write(MAX_WRITE_SIZE as u32),
+            Ok(MIN_WRITE_SIZE as u32)
+        );
+    }
+}

src/session.rs

@@ -54,6 +54,11 @@ use crate::request::RequestWithSender;
 /// and 128k on other systems.
 pub(crate) const MAX_WRITE_SIZE: usize = 16 * 1024 * 1024;
 
+/// The minimum write size the kernel will honor: process_init_reply() in the
+/// kernel's fs/fuse/inode.c clamps a smaller negotiated max_write up to 4096,
+/// so advertising less would not stop larger write requests from arriving.
+pub(crate) const MIN_WRITE_SIZE: usize = 4096;
+
 #[derive(Default, Debug, Eq, PartialEq, Clone, Copy)]
 /// How requests should be filtered based on the calling UID.
 pub enum SessionACL {