fuse: Add DLM retry workaround for iomap write failures

When the FUSE server returns -EAGAIN during write-back operations
(signaled by DLM), the write fails with an IO error. This happens
because:

1. Page invalidation holds DLM lock and needs folio lock
2. iomap write path holds folio lock and calls fuse_iomap_read_folio_range()
3. FUSE gets -EAGAIN from server (cannot acquire DLM lock - would deadlock)
4. fuse_do_readfolio() converts -EAGAIN to AOP_TRUNCATED_PAGE and unlocks folio
   (This prevents the deadlock by releasing the folio lock)
5. However, iomap doesn't understand AOP_TRUNCATED_PAGE and treats it as error
6. Result: Write fails with IO error, even though it's just temporary contention

This is a FUSE-only workaround until mainline iomap gains
AOP_TRUNCATED_PAGE retry support. The solution:

1. Stack-allocate retry state in fuse_cache_write_iter()
2. Register it in fuse_conn xarray before calling iomap (indexed by task pointer)
3. When fuse_iomap_read_folio_range() sees AOP_TRUNCATED_PAGE:
   - Mark the retry flag in the registered state
   - Convert to -EAGAIN for iomap
4. After iomap returns, check the retry flag
5. If set, retry the entire write operation
6. Remove from xarray when done (or keep for next retry iteration)

This allows writes to succeed by retrying after the DLM lock contention
clears, rather than failing with IO error.

Technical flow showing why iov_iter is not advanced on -EAGAIN:

fuse_cache_write_iter()
  total_written = 0
retry:
  iomap_file_buffered_write()
    iomap_write_iter() [write loop]
      iomap_write_begin()
        __iomap_write_begin()
          Need read? → Yes
            read_folio_range()
              FUSE server -EAGAIN?
                Yes → Set retry flag, return -EAGAIN
                No → Success
            Error → Break loop [iov_iter NOT advanced]
            Success → Continue
      copy_folio_from_iter_atomic() [Advances iov_iter]
      iomap_write_end()
      Advance iter.pos
      Loop while more data
    Update iocb->ki_pos = iter.pos
    Return bytes written

  if (written > 0)
    total_written += written

  if (retry_needed)
    goto retry

  return total_written

Signed-off-by: Bernd Schubert <bernd@bsbernd.com>

Author: bsbernd

fs/fuse/file.c

@@ -960,8 +960,8 @@ static int fuse_do_readfolio(struct file *file, struct folio *folio,
 	if (res < 0) {
 		/*
 		 * please refer to Documentation/filesystems/fuse/fuse-AOP_TRUNCATED_PAGE-reason.txt
-		 * why this is necessarry.
-		 * READ can return -EAGAIN from DLM subsystem
+		 * why READ can return -EAGAIN from DLM subsystem.
+		 * XXX find a better DLM specific error code
 		 */
 		if (res == -EAGAIN && fm->fc->dlm)
 			res = AOP_TRUNCATED_PAGE;
@@ -1001,8 +1001,45 @@ static int fuse_iomap_read_folio_range(const struct iomap_iter *iter,
 				       size_t len)
 {
 	struct file *file = iter->private;
+	struct inode *inode = file_inode(file);
+	struct fuse_conn *fc = get_fuse_conn(inode);
 	size_t off = offset_in_folio(folio, pos);
-	return fuse_do_readfolio(file, folio, off, len);
+	int ret;
+	ret = fuse_do_readfolio(file, folio, off, len);
+
+	/*
+	 * TEMPORARY WORKAROUND for iomap write deadlock:
+	 *
+	 * When FUSE server returns -EAGAIN due to DLM,
+	 * fuse_do_readfolio() converts it to AOP_TRUNCATED_PAGE and
+	 * unlocks the folio (per AOP_TRUNCATED_PAGE contract).
+	 *
+	 * However, iomap doesn't understand AOP_TRUNCATED_PAGE.
+	 * We need to:
+	 * 1. Mark the retry flag (caller stored it in xarray)
+	 * 2. Convert to -EAGAIN so iomap sees an error
+	 * 3. Let fuse_cache_write_iter() detect and retry
+	 *
+	 * This breaks the ABBA deadlock:
+	 * - Folio is unlocked (page invalidation can proceed)
+	 * - Write will be retried at higher level
+	 *
+	 * Remove this when mainline iomap gains AOP_TRUNCATED_PAGE support.
+	 */
+	if (ret == AOP_TRUNCATED_PAGE) {
+		struct fuse_dlm_retry *retry;
+		unsigned long task_key = (unsigned long)current;
+
+		retry = xa_load(&fc->dlm_retry_tasks, task_key);
+		if (retry) {
+			retry->retry_needed = true;
+		}
+
+		/* Convert to -EAGAIN for iomap */
+		ret = -EAGAIN;
+	}
+
+	return ret;
 }
 
 static void fuse_readpages_end(struct fuse_mount *fm, struct fuse_args *args,
@@ -1555,6 +1592,69 @@ static const struct iomap_ops fuse_iomap_ops = {
 	.iomap_begin	= fuse_iomap_begin,
 };
 
+static ssize_t fuse_writeback_write_iter(struct kiocb *iocb,
+					 struct iov_iter *from,
+					 struct file *file)
+{
+	struct fuse_conn *fc = get_fuse_conn(file_inode(file));
+	ssize_t written, total_written = 0;
+
+	/*
+	 * TEMPORARY WORKAROUND for iomap write deadlock:
+	 *
+	 * Stack-allocate retry state and register it before calling
+	 * iomap. If fuse_iomap_read_folio_range() encounters
+	 * AOP_TRUNCATED_PAGE, it will mark retry_needed.
+	 *
+	 * Stack allocation ensures no memory leaks - the state is
+	 * valid for the duration of this function call and is
+	 * automatically cleaned up.
+	 */
+	struct fuse_dlm_retry retry_state = {
+		.retry_needed = false,
+	};
+	unsigned long task_key = (unsigned long)current;
+	int xa_ret;
+
+	xa_ret = xa_err(xa_store(&fc->dlm_retry_tasks, task_key,
+				 &retry_state, GFP_KERNEL));
+	if (xa_ret)
+		return xa_ret;
+
+retry:
+	/*
+	 * Use iomap so that we can do granular uptodate reads
+	 * and granular dirty tracking for large folios.
+	 */
+	written = iomap_file_buffered_write(iocb, from, &fuse_iomap_ops,
+					    &fuse_iomap_write_ops, file);
+
+	if (written > 0)
+		total_written += written;
+
+	/*
+	 * If DLM lock contention occurred (AOP_TRUNCATED_PAGE),
+	 * retry the entire write operation.
+	 *
+	 * The folio has been unlocked by fuse_do_readfolio(),
+	 * breaking the ABBA deadlock with page invalidation.
+	 *
+	 * Keep the entry in xarray and reuse it for the retry.
+	 *
+	 * Remove this when mainline iomap gains AOP_TRUNCATED_PAGE
+	 * retry support.
+	 */
+	if (retry_state.retry_needed) {
+		retry_state.retry_needed = false;
+		goto retry;
+	}
+
+	/* Remove from xarray now that we're done */
+	xa_erase(&fc->dlm_retry_tasks, task_key);
+
+	return written < 0 ? written : total_written;
+}
+
 static ssize_t fuse_cache_write_iter(struct kiocb *iocb, struct iov_iter *from)
 {
 	struct file *file = iocb->ki_filp;
@@ -1621,14 +1721,11 @@ static ssize_t fuse_cache_write_iter(struct kiocb *iocb, struct iov_iter *from)
 		written = direct_write_fallback(iocb, from, written,
 						fuse_perform_write(iocb, from));
 	} else if (writeback) {
-		/*
-		 * Use iomap so that we can do granular uptodate reads
-		 * and granular dirty tracking for large folios.
-		 */
-		written = iomap_file_buffered_write(iocb, from,
-						    &fuse_iomap_ops,
-						    &fuse_iomap_write_ops,
-						    file);
+		written = fuse_writeback_write_iter(iocb, from, file);
+		if (written < 0) {
+			err = written;
+			goto out;
+		}
 	} else {
 		written = fuse_perform_write(iocb, from);
 	}

fs/fuse/fuse_i.h

@@ -639,6 +639,17 @@ struct fuse_sync_bucket {
 	struct rcu_head rcu;
 };
 
+/**
+ * DLM retry tracking for iomap write deadlock workaround.
+ *
+ * Temporary workaround until mainline iomap gains AOP_TRUNCATED_PAGE
+ * retry support. Tracks tasks that need to retry write operations due
+ * to DLM lock contention (-EAGAIN from FUSE server).
+ */
+struct fuse_dlm_retry {
+	bool retry_needed;
+};
+
 /**
  * A Fuse connection.
  *
@@ -1022,6 +1033,12 @@ struct fuse_conn {
 	/* The foffset alignment in PAGE */
 	unsigned int alignment_pages;
 
+	/**
+	 * XArray tracking tasks that need DLM retry.
+	 * Maps task pointer -> struct fuse_dlm_retry.
+	 * Temporary workaround for iomap write deadlock.
+	 */
+	struct xarray dlm_retry_tasks;
 };
 
 /*

fs/fuse/inode.c

@@ -1056,6 +1056,7 @@ void fuse_conn_init(struct fuse_conn *fc, struct fuse_mount *fm,
 	fc->initialized = 0;
 	fc->connected = 1;
 	fc->dlm = 1;
+	xa_init(&fc->dlm_retry_tasks);
 
 	/* module option for now */
 	fc->compound_open_getattr = enable_compound;
@@ -1109,6 +1110,7 @@ void fuse_conn_put(struct fuse_conn *fc)
 		}
 		if (IS_ENABLED(CONFIG_FUSE_PASSTHROUGH))
 			fuse_backing_files_free(fc);
+		xa_destroy(&fc->dlm_retry_tasks);
 		call_rcu(&fc->rcu, delayed_release);
 	}
 }