Re: [PATCH v3] fuse: virtio-fs: stop new requests before draining queues

From: Li Wang

Date: Wed Nov 11 2026 - 22:13:20 EST


Hi Hang,

On 09/11/2026 10:39, Qihang wrote:
> virtio_fs_conn_destroy() drains the virtqueues and then calls
> fuse_conn_destroy(), which aborts the connection. The abort ends every
> request the fuse device still owns, and each ended request is freed as
> soon as its waiter wakes up.
>
> The drain only covers the requests that were already counted in
> fsvq->in_flight when it started. A request submitted after it returns is
> not covered, but is still handed to the device before the abort runs:
>
> CPU 0 (umount) CPU 1
> --------------------------------- --------------------------------
> virtio_fs_drain_all_queues()
> /* in_flight drops to 0 and
> the drain returns */
> virtio_fs_enqueue_req()
> virtqueue_add_sgs()
> inc_in_flight_req() -> 1
> fuse_conn_destroy()
> fuse_send_destroy()
> fuse_chan_abort()
> /* ends and frees the
> request above */
> fuse_chan_wait_aborted()
> /* the device still owns the
> virtqueue descriptors and
> DMA-writes into the freed
> request and its argbuf */
>
> Stop admitting requests on each queue before draining begins. The flag
> is set per queue, but that is sufficient: request admission,
> virtqueue_add_sgs() and, on the submission path, the in_flight
> increment are serialized by the same fsvq->lock. A request is
> therefore either rejected before the device can see it, or already
> counted in fsvq->in_flight and covered by the drain. There is no
> window in between.
>
> Rejected requests use the existing -ENOTCONN error path and are ended by
> virtio_fs_request_dispatch_work() through end_reqs, so no new request
> completion or ownership state is introduced. Nothing has to be
> discarded in the completion path, and fsvq->in_flight remains the only
> per-queue accounting state.
>
> The -ENOSPC path needs the same admission check. virtio_fs_enqueue_req()
> drops fsvq->lock before returning -ENOSPC, and the caller queues the
> request in a second critical section; teardown can finish in between and
> leave the request stranded on queued_reqs, which nothing drains.
> Re-check connected/aborting before queueing, in both the submission path
> and the dispatch worker. After aborting is set, no request can newly
> enter queued_reqs or the virtqueue, except the explicitly permitted
> FUSE_DESTROY path.
>
> Rejected requests are ended by virtio_fs_request_dispatch_work(). If
> their end callback may block (a DAX release), ending them inline can
> deadlock: the callback may issue a synchronous request that needs the
> same worker. Offload those endings to a separate work item, like the
> device completion path already does.
>
> The new state is not folded into fsvq->connected because the request
> queues have to stay usable: fuse_conn_destroy() sends FUSE_DESTROY
> through them, with args.force set so that fuse_simple_request() waits
> for the reply. Clearing fsvq->connected would make that request fail
> with -ENOTCONN and the server would never see the destroy.
>
> FUSE_DESTROY is the sole exception while aborting is set. It is sent
> only after the first drain, and its completion is waited for before
> fuse_chan_abort() can end requests, so the destroy is the only request
> the device sees after the drain. virtio-fs exposes no userspace
> /dev/fuse fd (and no_control disables the fusectl interface), so
> userspace cannot inject another request.
>
> virtio_fs_start_all_queues() clears the flag, so a mount that follows an
> unmount starts with admission enabled again.
>
> Fixes: a62a8ef9d97d ("virtio-fs: add virtiofs filesystem")
> Cc: stable@xxxxxxxxxxxxxxx
> Signed-off-by: Qihang <q.h.hack.winter@xxxxxxxxx>
> ---
> V2 -> V3:
> - re-check admission before queueing on -ENOSPC, in virtio_fs_send_req()
> and in the dispatch worker, so teardown cannot strand a request on
> queued_reqs
> - offload may_block request endings in the dispatch worker to avoid a
> self-deadlock through fuse_simple_request()
> - add Fixes: and Cc: stable
> V1 -> V2:
> - prevent new requests from reaching the virtqueue at teardown time
> instead of skipping completions of aborted requests
> - keep FUSE_DESTROY working: it is the teardown request and is waited
> for before fuse_chan_abort()
> - drop the per-vq aborted flag and the completion-skip branch
> fs/fuse/virtio_fs.c | 104 +++++++++++++++++++++++++++++++++++++++-----
> 1 file changed, 94 insertions(+), 10 deletions(-)
>
> diff --git a/fs/fuse/virtio_fs.c b/fs/fuse/virtio_fs.c
> index ba8d79c4bcac6..a46536c9fdc8e 100644
> --- a/fs/fuse/virtio_fs.c
> +++ b/fs/fuse/virtio_fs.c
> @@ -55,6 +55,7 @@ struct virtio_fs_vq {
> struct work_struct dispatch_work;
> struct fuse_dev *fud;
> bool connected;
> + bool aborting; /* reject new requests except FUSE_DESTROY */
> long in_flight;
> struct completion in_flight_zero; /* No inflight requests */
> struct kobject *kobj;
> @@ -97,6 +98,11 @@ struct virtio_fs_req_work {
> struct work_struct done_work;
> };
>
> +struct virtio_fs_end_work {
> + struct work_struct work;
> + struct fuse_req *req;
> +};

We can avoid introducing it and reuse virtio_fs_req_work instead.

Thanks,
Li Wang