fusedev: stop an async worker on a read error it can't retry

The async server logged a read error it didn't know and read again.
Now that a tokio task waits for the device to become readable, a device
that stays readable but fails every read made the task spin at full CPU
and log on every pass. EINVAL for a buffer smaller than the kernel's
requests does that.

Retry ENOENT, which the kernel returns when a request was interrupted
before the read, and stop the task on any other error. The synchronous
server does the same.

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

Author: Kranzes

CHANGELOG.md

@@ -44,6 +44,8 @@
   through the IO driver of the tokio runtime that polls it, and checks its state flag every 100ms
   while idle. Polling it on a tokio runtime without IO enabled panics. `fuse-backend-fusedev`
   needs tokio 1.53.3.
+- The async fusedev server retries a read that fails with `ENOENT` and stops the task on read
+  errors it doesn't know, like the synchronous server. It used to log them and read again.
 - [254](https://github.com/cloud-hypervisor/fuse-backend-rs/pull/254): `fuse-backend-rs` is now a thin facade re-exporting the sub-crates. Every
   historical `fuse_backend_rs::{abi, api, buffer, common, transport, passthrough,
   overlayfs}` import path and cargo feature name (`fusedev`, `virtiofs`,

crates/fuse-backend-fusedev/src/linux_session.rs

@@ -1257,8 +1257,10 @@ mod asyncio {
                                 // The fuse device was unmounted or the connection was aborted.
                                 break 'serve;
                             }
-                            Some(libc::EINTR) => {
-                                // Interrupted by a signal, retry the read.
+                            Some(libc::EINTR) | Some(libc::ENOENT) => {
+                                // Interrupted by a signal, or the kernel dropped
+                                // the request because it was interrupted. Retry
+                                // the read.
                                 continue 'serve;
                             }
                             Some(libc::EAGAIN) => {
@@ -1276,17 +1278,15 @@ mod asyncio {
                                 tokio::task::yield_now().await;
                                 continue 'serve;
                             }
-                            None => {
+                            _ => {
                                 // The error isn't an OS error, for example because the
-                                // runtime is shutting down. Waiting again would fail the
-                                // same way.
+                                // runtime is shutting down, or one that retrying won't
+                                // fix, such as EINVAL for a buffer smaller than the
+                                // kernel's requests. Retrying would spin on it, so stop
+                                // like the synchronous server does.
                                 error!("failed to read request from fuse device fd, {}", e);
                                 break 'serve;
                             }
-                            _ => {
-                                // TODO: error handling
-                                error!("failed to read request from fuse device fd, {}", e);
-                            }
                         }
                     }
                 }