update Redfs rhel10 to all features from ubuntu hwe

fs/fuse/dir.c

@@ -723,6 +723,10 @@ static int fuse_create_open(struct mnt_idmap *idmap, struct inode *dir,
 	memset(&inarg, 0, sizeof(inarg));
 	memset(&outentry, 0, sizeof(outentry));
 	inarg.flags = flags;
+
+	/* The kernel owns append positioning; see fuse_send_open() */
+	if (fm->fc->writeback_cache)
+		inarg.flags &= ~O_APPEND;
 	inarg.mode = mode;
 	inarg.umask = current_umask();
 
@@ -785,10 +789,27 @@ static int fuse_create_open(struct mnt_idmap *idmap, struct inode *dir,
 		fi = get_fuse_inode(inode);
 		fuse_sync_release(fi, ff, flags);
 	} else {
-		if (fm->fc->atomic_o_trunc && trunc)
+		if (fm->fc->atomic_o_trunc && trunc) {
+			/*
+			 * Every grant goes with the cache, as on the
+			 * fuse_open() O_TRUNC path: a record left behind
+			 * would keep naming bytes the folios no longer hold.
+			 */
+			if (fm->fc->dlm && fm->fc->writeback_cache)
+				fuse_dlm_cache_release_locks(
+						get_fuse_inode(inode));
 			truncate_pagecache(inode, 0);
-		else if (!(ff->open_flags & FOPEN_KEEP_CACHE))
-			invalidate_inode_pages2(inode->i_mapping);
+		} else if (!(ff->open_flags & FOPEN_KEEP_CACHE)) {
+			/*
+			 * Only when the drop really emptied the mapping, as
+			 * in fuse_open(): a folio that survived still needs
+			 * its record.
+			 */
+			if (fuse_open_drop_cache(inode) &&
+			    fm->fc->dlm && fm->fc->writeback_cache)
+				fuse_dlm_ranges_dropped(get_fuse_inode(inode),
+							0, U64_MAX);
+		}
 	}
 	return err;
 
@@ -2082,34 +2103,24 @@ int fuse_do_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
 		WARN_ON(!(attr->ia_valid & ATTR_SIZE));
 		WARN_ON(attr->ia_size != 0);
 		if (fc->atomic_o_trunc) {
-			struct percpu_rw_semaphore *wb_sem = fi->wb_inval_rwsem;
-
 			/*
 			 * No need to send request to userspace, since actual
 			 * truncation has already been done by OPEN.  But still
 			 * need to truncate page cache.
 			 *
-			 * Revoke and drop under the coherency gate write side,
-			 * like the NOTIFY invalidate path: a gate reader that
-			 * already re-validated its grant must not have the
-			 * lock tree and the cache yanked mid-hold, or it
-			 * would repopulate the truncated range trusting a
-			 * grant that no longer exists.  Waiting for gate
-			 * readers here is safe: we hold i_rwsem exclusive, so
-			 * no gate holder can be waiting on it (the write path
-			 * takes i_rwsem before the gate, the read path never
-			 * takes it).
+			 * Dropping every grant here does not need a reader or
+			 * writer fenced out: truncate_pagecache() discards the
+			 * folios rather than writing them, and a write racing
+			 * this is a write racing an O_TRUNC open, which has no
+			 * order to preserve.  i_rwsem is held exclusive
+			 * anyway, so no cached write is in progress.
 			 */
-			if (wb_sem)
-				percpu_down_write(wb_sem);
 			if (fc->dlm && fc->writeback_cache)
 				fuse_dlm_cache_release_locks(fi);
 			spin_lock(&fi->lock);
 			i_size_write(inode, 0);
 			spin_unlock(&fi->lock);
 			truncate_pagecache(inode, 0);
-			if (wb_sem)
-				percpu_up_write(wb_sem);
 			goto out;
 		}
 		file = NULL;
@@ -2213,23 +2224,43 @@ int fuse_do_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
 	 */
 	if ((is_truncate || !is_wb) &&
 	    S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
-		struct percpu_rw_semaphore *wb_sem = fi->wb_inval_rwsem;
-
 		/*
-		 * Revoke and drop under the coherency gate write side; see
-		 * the atomic-O_TRUNC branch above.  i_rwsem is held
-		 * exclusive here as well (setattr), so waiting out gate
-		 * readers cannot deadlock.
+		 * Revoke past the new size and drop what is beyond it; see
+		 * the atomic-O_TRUNC branch above for why this needs nothing
+		 * fenced out.  i_rwsem is held exclusive here as well.
 		 */
-		if (wb_sem)
-			percpu_down_write(wb_sem);
 		if (fc->dlm && fc->writeback_cache)
-			fuse_dlm_unlock_range(fi, outarg.attr.size & PAGE_MASK, -1);
+			fuse_dlm_unlock_range(fi, outarg.attr.size & PAGE_MASK,
+					      U64_MAX);
 
 		truncate_pagecache(inode, outarg.attr.size);
 		invalidate_inode_pages2(mapping);
-		if (wb_sem)
-			percpu_up_write(wb_sem);
+
+		/*
+		 * The cache above the new size is gone, so the ranges
+		 * describing it have nothing left to say.  From the first
+		 * whole page above it: the page holding the new end of the
+		 * file survives the truncate, and so does its record.
+		 */
+		if (fc->dlm && fc->writeback_cache)
+			fuse_dlm_ranges_dropped(fi, PAGE_ALIGN(outarg.attr.size),
+						U64_MAX);
+
+		/*
+		 * invalidate_inode_pages2() emptied the mapping below the new
+		 * size too (laundering anything dirty first, so those bytes
+		 * are on the server).  A revoked range is kept only to make
+		 * writeback take the grant again before sending the folios
+		 * under it, so with those folios gone it describes nothing
+		 * and would sit in the tree unfreed, keeping its neighbours
+		 * from merging.  Only when the drop really emptied it: a busy
+		 * folio that survived still needs its record, and a fault
+		 * populating after the check keeps its page visible to it.
+		 */
+		if (fc->dlm && fc->writeback_cache && outarg.attr.size &&
+		    !filemap_range_has_page(mapping, 0, outarg.attr.size - 1))
+			fuse_dlm_ranges_dropped(fi, 0,
+						PAGE_ALIGN(outarg.attr.size) - 1);
 	}
 
 	clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);