fuse: add PAGE_MKWRITE opcode

cding-ddn · cding-ddn · commit e77b0a544510 · 2025-07-07T17:10:43.000Z
Add PAGE_MKWRITE fuse request to allow FUSE daemon to acquire
DLM lock for protecting dirty page creation.

Allow read_folio to return EAGAIN error and translate it to
AOP_TRUNCATE_PAGE to retry page fault and read operations.
This is used to prevent deadlock of folio lock/DLM lock order reversal:
 - Fault or read operations acquire folio lock first, then DLM lock.
 - FUSE daemon blocks new DLM lock acquisition while it invalidating
   page cache. invalidate_inode_pages2_range() acquires folio lock
To prevent deadlock, the FUSE daemon will fail its DLM lock acquisition
with EAGAIN if it detects an in-flight page cache invalidating
operation.

This enables memory mapping across cluster nodes with proper
distributed locking coordination.
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
@@ -882,8 +882,11 @@ static int fuse_do_readpage(struct file *file, struct page *page)
 
 	fuse_read_args_fill(&ia, file, pos, desc.length, FUSE_READ);
 	res = fuse_simple_request(fm, &ia.ap.args);
-	if (res < 0)
+	if (res < 0) {
+		if (res == -EAGAIN)
+			res = AOP_TRUNCATED_PAGE;
 		return res;
+	}
 	/*
 	 * Short read means EOF.  If file size is larger, truncate it
 	 */
@@ -2506,6 +2509,35 @@ static void fuse_vma_close(struct vm_area_struct *vma)
 	mapping_set_error(vma->vm_file->f_mapping, err);
 }
 
+static int fuse_send_page_mkwrite(struct file *file, loff_t pos, size_t len)
+{
+	struct inode *inode = file_inode(file);
+	struct fuse_mount *fm = get_fuse_mount(inode);
+	struct fuse_file *ff = file->private_data;
+	struct fuse_page_mkwrite_in inarg = {
+		.fh = ff->fh,
+		.off = pos,
+		.len = len
+	};
+	FUSE_ARGS(args);
+	int err = 0;
+
+	if (fm->fc->no_mkwrite)
+		return err;
+
+	args.opcode = FUSE_PAGE_MKWRITE;
+	args.nodeid = ff->nodeid;
+	args.in_numargs = 1;
+	args.in_args[0].size = sizeof(inarg);
+	args.in_args[0].value = &inarg;
+
+	err = fuse_simple_request(fm, &args);
+	if (err == -ENOSYS) {
+		fm->fc->no_mkwrite = 1;
+		err = 0;
+	}
+	return err;
+}
 /*
  * Wait for writeback against this page to complete before allowing it
  * to be marked dirty again, and hence written back again, possibly
@@ -2525,6 +2557,12 @@ static vm_fault_t fuse_page_mkwrite(struct vm_fault *vmf)
 {
 	struct page *page = vmf->page;
 	struct inode *inode = file_inode(vmf->vma->vm_file);
+	int err;
+
+	err = fuse_send_page_mkwrite(vmf->vma->vm_file, vmf->pgoff << PAGE_SHIFT, PAGE_SIZE);
+	if (err < 0) {
+		return vmf_error(err);
+	}
 
 	file_update_time(vmf->vma->vm_file);
 	lock_page(page);
diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
@@ -860,6 +860,9 @@ struct fuse_conn {
 	/* do we have support for dlm in the fs? */
 	unsigned int dlm:1;
 
+	/* Is mkwrite not implemented by fs? */
+	unsigned int no_mkwrite:1;
+
 	/* Use io_uring for communication */
 	unsigned int io_uring;
 
diff --git a/fs/fuse/fuse_trace.h b/fs/fuse/fuse_trace.h
@@ -59,6 +59,7 @@
 	EM( FUSE_TMPFILE,		"FUSE_TMPFILE")		\
 	EM( FUSE_STATX,			"FUSE_STATX")		\
 	EM( FUSE_DLM_WB_LOCK,		"FUSE_DLM_WB_LOCK")   \
+	EM( FUSE_PAGE_MKWRITE,		"FUSE_PAGE_MKWRITE")	\
 	EMe(CUSE_INIT,			"CUSE_INIT")
 
 /*
diff --git a/include/uapi/linux/fuse.h b/include/uapi/linux/fuse.h
@@ -639,6 +639,7 @@ enum fuse_opcode {
 	FUSE_TMPFILE		= 51,
 	FUSE_STATX		= 52,
 	FUSE_DLM_WB_LOCK 	= 53,
+	FUSE_PAGE_MKWRITE	= 54,
 
 	/* CUSE specific operations */
 	CUSE_INIT		= 4096,
@@ -902,6 +903,12 @@ struct fuse_init_out {
 
 #define CUSE_INIT_INFO_MAX 4096
 
+struct fuse_page_mkwrite_in {
+	uint64_t	fh;
+	uint64_t	off;
+	uint64_t	len;
+};
+
 struct cuse_init_in {
 	uint32_t	major;
 	uint32_t	minor;
