fuse: Add DLM retry workaround for iomap write failures

When FUSE server returns -EAGAIN during iomap write operations due to
DLM lock contention, 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.

This uses a single per connection xa_array under the assumption that
there won't be too many parallel writers.

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

Author: bsbernd

fs/fuse/file.c

@@ -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 (DLM lock contention),
+	 * 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,
@@ -1604,6 +1641,7 @@ static ssize_t fuse_cache_write_iter(struct kiocb *iocb, struct iov_iter *from)
 
 	inode_lock(inode);
 
+retry:
 	err = count = generic_write_checks(iocb, from);
 	if (err <= 0)
 		goto out;
@@ -1621,6 +1659,30 @@ 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) {
+		/*
+		 * 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) {
+			err = xa_ret;
+			goto out;
+		}
+
 		/*
 		 * Use iomap so that we can do granular uptodate reads
 		 * and granular dirty tracking for large folios.
@@ -1629,6 +1691,26 @@ static ssize_t fuse_cache_write_iter(struct kiocb *iocb, struct iov_iter *from)
 						    &fuse_iomap_ops,
 						    &fuse_iomap_write_ops,
 						    file);
+
+		/*
+		 * 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);
 	} 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);
 	}
 }