Skip to contentSkip to conversation

fs: Various I_DIRTY_* state handling fixes

PATCH In review Jan Kara 4 participants 24 messages Nov 18 – Nov 20

Subsystems (11)
lore
Share & tools
lore

Jan Kara

author reviewer
#0 lore raw

v2 cover fs: Various I_DIRTY_* state handling fixes

Hello,

this series is a result of my audit of I_DIRTY_* state handling fixes. Over the years some pointless code or code with smaller or larger bugs has accumulated in filesystems around handling of inode dirty state. In particular testing for I_DIRTY_PAGES is very subtle (and racy without holding i_lock), some places forget that I_DIRTY_TIME also means inode has dirty metadata etc. So this patch set removes direct checks of dirtiness state from filesystems and either change them to directly testing PAGECACHE_TAG_DIRTY or to a helper function which performs appropriate dirtiness check reliably.

Changes since v1:
* Fixed orangefs checking of inode dirtiness
* Added Reviewed-by & Acked-by tags
* Added Fixes tags
* Made gfs2_fsync() conversion more bug-to-bug compatible

Honza
Previous versions:

author reviewer
#1 lore raw

PATCH v2 1/13 bdev: Drop pointless loop from blkdev_flush_mapping()

bdev_write_inode() is really odd loop calling write_inode_now(). The bdev doesn't have any pages by now and if there are any dirty bits in the inode state, they are stale. Just call write_inode_now() once to clear them.

---
 block/bdev.c | 25 ++++++-------------------
 1 file changed, 6 insertions(+), 19 deletions(-)
block/bdev.c +6 -19
index f20f91b3176e..9fa72df4f47a 100644
@@ -60,24 +60,6 @@ struct block_device *file_bdev(struct file *bdev_file)
 }
 EXPORT_SYMBOL(file_bdev);
 
-static void bdev_write_inode(struct block_device *bdev)
-{
-	struct inode *inode = BD_INODE(bdev);
-	int ret;
-
-	spin_lock(&inode->i_lock);
-	while (inode_state_read(inode) & I_DIRTY) {
-		spin_unlock(&inode->i_lock);
-		ret = write_inode_now(inode, true);
-		if (ret)
-			pr_warn_ratelimited(
-	"VFS: Dirty inode writeback failed for block device %pg (err=%d).\n",
-				bdev, ret);
-		spin_lock(&inode->i_lock);
-	}
-	spin_unlock(&inode->i_lock);
-}
-
 /* Kill _all_ buffers and pagecache , dirty or not.. */
 static void kill_bdev(struct block_device *bdev)
 {
@@ -755,7 +737,12 @@ static void blkdev_flush_mapping(struct block_device *bdev)
 	WARN_ON_ONCE(bdev->bd_holders);
 	sync_blockdev(bdev);
 	kill_bdev(bdev);
-	bdev_write_inode(bdev);
+	/*
+	 * All data is written out and evicted but inode can have some stale
+	 * I_DIRTY bits set. Call write_inode_now() to get rid of them so that
+	 * the inode can be evicted.
+	 */
+	write_inode_now(BD_INODE(bdev), 1);
 }
 
 static void blkdev_put_whole(struct block_device *bdev)
Signature · 1 line
2.53.0
Reviewed-by on v2 1/13
#2 lore raw

Re: [PATCH 01/13] bdev: Drop pointless loop from blkdev_flush_mapping()

Quoted 6 lines · Jan Kara

bdev_write_inode() is really odd loop calling write_inode_now(). The bdev doesn't have any pages by now and if there are any dirty bits in the inode state, they are stale. Just call write_inode_now() once to clear them.

When I looked at the commit that introduced bdev_write_inode()[1], it says to call write_inode_now() on the final put of the block device. At the moment, tt looks like we call bdev_write_inode() only when bd_openers is 0.

Looks good,

--
Pankaj

[1] 564f00f6c03a ("block_dev: only write bdev inode on close")

Quoted 50 lines
---
 block/bdev.c | 25 ++++++-------------------
 1 file changed, 6 insertions(+), 19 deletions(-)
block/bdev.c +6 -19
index f20f91b3176e..9fa72df4f47a 100644
@@ -60,24 +60,6 @@ struct block_device *file_bdev(struct file *bdev_file)
 }
 EXPORT_SYMBOL(file_bdev);
 
-static void bdev_write_inode(struct block_device *bdev)
-{
-	struct inode *inode = BD_INODE(bdev);
-	int ret;
-
-	spin_lock(&inode->i_lock);
-	while (inode_state_read(inode) & I_DIRTY) {
-		spin_unlock(&inode->i_lock);
-		ret = write_inode_now(inode, true);
-		if (ret)
-			pr_warn_ratelimited(
-	"VFS: Dirty inode writeback failed for block device %pg (err=%d).\n",
-				bdev, ret);
-		spin_lock(&inode->i_lock);
-	}
-	spin_unlock(&inode->i_lock);
-}
-
 /* Kill _all_ buffers and pagecache , dirty or not.. */
 static void kill_bdev(struct block_device *bdev)
 {
@@ -755,7 +737,12 @@ static void blkdev_flush_mapping(struct block_device *bdev)
 	WARN_ON_ONCE(bdev->bd_holders);
 	sync_blockdev(bdev);
 	kill_bdev(bdev);
-	bdev_write_inode(bdev);
+	/*
+	 * All data is written out and evicted but inode can have some stale
+	 * I_DIRTY bits set. Call write_inode_now() to get rid of them so that
+	 * the inode can be evicted.
+	 */
+	write_inode_now(BD_INODE(bdev), 1);
 }
 
 static void blkdev_put_whole(struct block_device *bdev)
Signature · 1 line
2.53.0
author reviewer
#3 lore raw

PATCH v2 2/13 xfs: Drop pointless I_DIRTY_PAGES check in xfs_can_free_cowblocks()

In reply to Jan Kara

PAGECACHE_TAG_DIRTY is the authoritative source of information about any folio being dirty in the mapping. I_DIRTY_PAGES is just an approximation used by writeback code that can get stale under certain situations. So just rely on the authoritative check.

---
 fs/xfs/xfs_reflink.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
fs/xfs/xfs_reflink.h +1 -2
index 683c1841e640..1310cc9fe829 100644
@@ -17,8 +17,7 @@ xfs_can_free_cowblocks(struct xfs_inode *ip)
 {
 	struct inode *inode = VFS_I(ip);
 
-	if ((inode_state_read_once(inode) & I_DIRTY_PAGES) ||
-	    mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY) ||
+	if (mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY) ||
 	    mapping_tagged(inode->i_mapping, PAGECACHE_TAG_WRITEBACK) ||
 	    atomic_read(&inode->i_dio_count))
 		return false;
Signature · 1 line
2.53.0
Reviewed-by on v2 2/13
#4 lore raw

Re: [PATCH 02/13] xfs: Drop pointless I_DIRTY_PAGES check in xfs_can_free_cowblocks()

Quoted 7 lines · Jan Kara

PAGECACHE_TAG_DIRTY is the authoritative source of information about any folio being dirty in the mapping. I_DIRTY_PAGES is just an approximation used by writeback code that can get stale under certain situations. So just rely on the authoritative check.

Looks good,

Quoted 21 lines
---
 fs/xfs/xfs_reflink.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
fs/xfs/xfs_reflink.h +1 -2
index 683c1841e640..1310cc9fe829 100644
@@ -17,8 +17,7 @@ xfs_can_free_cowblocks(struct xfs_inode *ip)
 {
 	struct inode *inode = VFS_I(ip);
 
-	if ((inode_state_read_once(inode) & I_DIRTY_PAGES) ||
-	    mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY) ||
+	if (mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY) ||
 	    mapping_tagged(inode->i_mapping, PAGECACHE_TAG_WRITEBACK) ||
 	    atomic_read(&inode->i_dio_count))
 		return false;
Signature · 1 line
2.53.0
author reviewer
#5 lore raw

PATCH v2 3/13 orangefs: Check PAGECACHE_TAG_DIRTY instead of I_DIRTY_PAGES inode state

In reply to Jan Kara

PAGECACHE_TAG_DIRTY is the authoritative source of dirty folios present
in the mapping. Use that instead of looking at I_DIRTY_PAGES inode state which can get stale for example when folios are written directly with filemap_fdatawrite(), which is how orangefs_flush() and orangefs_fsync() write the mapping. So a getattr keeps serving the cached inode after the folios are clean.

The dirty tag alone is not enough. folio_start_writeback() clears it and sets PAGECACHE_TAG_WRITEBACK before wait_for_direct_io() sends the write. OrangeFS writepages does not return until that call finishes, so I_DIRTY_PAGES still covers the round trip today. A getattr that looks only at the dirty tag stores the server's old size while the write is in flight. orangefs_writepage_locked() then reads that size and shortens the write.

Hold the cached attributes while either tag is set.

---
 fs/orangefs/orangefs-utils.c | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)
fs/orangefs/orangefs-utils.c +17 -3
index 9ab1119ebd28..241b10858b31 100644
@@ -233,6 +233,20 @@ static int orangefs_inode_is_stale(struct inode *inode,
 	return 0;
 }
 
+/*
+ * Dirty and writeback tags, not I_DIRTY_PAGES. filemap_fdatawrite()
+ * leaves that flag set after the folios are clean. folio_start_writeback()
+ * clears the dirty tag before wait_for_direct_io() returns, so the
+ * writeback tag is what covers the server write.
+ */
+static bool orangefs_writeback_pending(struct inode *inode)
+{
+	struct address_space *mapping = inode->i_mapping;
+
+	return mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) ||
+		mapping_tagged(mapping, PAGECACHE_TAG_WRITEBACK);
+}
+
 int orangefs_inode_getattr(struct inode *inode, int flags)
 {
 	struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
@@ -247,7 +261,7 @@ int orangefs_inode_getattr(struct inode *inode, int flags)
 	spin_lock(&inode->i_lock);
 	/* Must have all the attributes in the mask and be within cache time. */
 	if ((!flags && time_before(jiffies, orangefs_inode->getattr_time)) ||
-	    orangefs_inode->attr_valid || inode_state_read(inode) & I_DIRTY_PAGES) {
+	    orangefs_inode->attr_valid || orangefs_writeback_pending(inode)) {
 		if (orangefs_inode->attr_valid) {
 			spin_unlock(&inode->i_lock);
 			write_inode_now(inode, 1);
@@ -281,13 +295,13 @@ int orangefs_inode_getattr(struct inode *inode, int flags)
 	spin_lock(&inode->i_lock);
 	/* Must have all the attributes in the mask and be within cache time. */
 	if ((!flags && time_before(jiffies, orangefs_inode->getattr_time)) ||
-	    orangefs_inode->attr_valid || inode_state_read(inode) & I_DIRTY_PAGES) {
+	    orangefs_inode->attr_valid || orangefs_writeback_pending(inode)) {
 		if (orangefs_inode->attr_valid) {
 			spin_unlock(&inode->i_lock);
 			write_inode_now(inode, 1);
 			goto again2;
 		}
-		if (inode_state_read(inode) & I_DIRTY_PAGES) {
+		if (orangefs_writeback_pending(inode)) {
 			ret = 0;
 			goto out_unlock;
 		}
Signature · 1 line
2.53.0
author reviewer
#6 lore raw

PATCH v2 4/13 fs: Provide inode_is_dirty() helper

In reply to Jan Kara

Provide inode_is_dirty() helper for use by filesystems (mostly fsync methods).

---
 include/linux/fs.h | 11 +++++++++++
 1 file changed, 11 insertions(+)
include/linux/fs.h +11 -0
index 99caef43ff3c..025f5d890689 100644
@@ -2217,6 +2217,17 @@ static inline void mark_inode_dirty_sync(struct inode *inode)
 	__mark_inode_dirty(inode, I_DIRTY_SYNC);
 }
 
+/*
+ * Check whether inode itself needs to be written out either at all or for
+ * the purposes of datasync if @datasync is set.
+ */
+static inline bool inode_is_dirty(struct inode *inode, bool datasync)
+{
+	int mask = datasync ? I_DIRTY_DATASYNC : (I_DIRTY_INODE | I_DIRTY_TIME);
+
+	return inode_state_read_once(inode) & mask;
+}
+
 static inline void set_inode_metadata_writeback(struct inode *inode)
 {
 	spin_lock(&inode->i_lock);
Signature · 1 line
2.53.0
author reviewer
#7 lore raw

PATCH v2 5/13 jfs: Use inode_is_dirty() in jfs_fsync()

In reply to Jan Kara

Use inode_is_dirty() helper in jfs_fsync() instead of explicit i_state check. This slightly changes behavior in that we no longer trigger inode commit if the inode is clean except it still has I_DIRTY_PAGES set after data writeout but that is actually a desirable behavior because commit is pointless if only folios are dirty.

---
 fs/jfs/file.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
fs/jfs/file.c +1 -2
index 2f5bb79c0591..90001d3d90fc 100644
@@ -27,8 +27,7 @@ int jfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 		return rc;
 
 	inode_lock(inode);
-	if (!(inode_state_read_once(inode) & I_DIRTY_ALL) ||
-	    (datasync && !(inode_state_read_once(inode) & I_DIRTY_DATASYNC))) {
+	if (!inode_is_dirty(inode, datasync)) {
 		/* Make sure committed changes hit the disk */
 		jfs_flush_journal(JFS_SBI(inode->i_sb)->log, 1);
 		inode_unlock(inode);
Signature · 1 line
2.53.0
author reviewer
#8 lore raw

PATCH v2 6/13 gfs2: Avoid racy dirtiness check in gfs2_fsync()

In reply to Jan Kara

Check for I_DIRTY_PAGES state in gfs2_fsync() is racy because __writeback_single_inode() unconditionally clears the flag and reinstates it only later based on PAGECACHE_TAG_DIRTY tag. If gfs2_fsync() unlocked read of i_state hits in between, it will not see I_DIRTY_PAGES although there may be dirty folios in the mapping. Check for PAGECACHE_TAG_DIRTY instead and use inode_is_dirty() helper for inode metadata dirtiness check.

---
 fs/gfs2/file.c | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)
fs/gfs2/file.c +3 -7
index 1efd0679badd..f5532f72ab99 100644
@@ -749,7 +749,7 @@ static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
 {
 	struct address_space *mapping = file->f_mapping;
 	struct inode *inode = mapping->host;
-	int sync_state = inode_state_read_once(inode) & I_DIRTY;
+	bool dirty_data = mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY);
 	struct gfs2_glock *gl = gfs2_inode_glock(inode);
 	struct gfs2_inode *ip = GFS2_I(inode);
 	int ret = 0, ret1 = 0;
@@ -760,12 +760,8 @@ static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
 			return ret1;
 	}
 
-	if (!gfs2_is_jdata(ip))
-		sync_state &= ~I_DIRTY_PAGES;
-	if (datasync)
-		sync_state &= ~I_DIRTY_SYNC;
-
-	if (sync_state) {
+	if (inode_is_dirty(inode, datasync) ||
+	    (gfs2_is_jdata(ip) && dirty_data)) {
 		ret = sync_inode_metadata(inode, 1);
 		if (ret)
 			return ret;
Signature · 1 line
2.53.0
#9 lore raw

Re: [PATCH 06/13] gfs2: Avoid racy dirtiness check in gfs2_fsync()

Hi Jan,

Quoted 28 lines · Jan Kara

Check for I_DIRTY_PAGES state in gfs2_fsync() is racy because __writeback_single_inode() unconditionally clears the flag and reinstates it only later based on PAGECACHE_TAG_DIRTY tag. If gfs2_fsync() unlocked read of i_state hits in between, it will not see I_DIRTY_PAGES although there may be dirty folios in the mapping. Check for PAGECACHE_TAG_DIRTY instead and use inode_is_dirty() helper for inode metadata dirtiness check.

---
 fs/gfs2/file.c | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)
fs/gfs2/file.c +1 -1
index 1efd0679badd..f5532f72ab99 100644
@@ -749,7 +749,7 @@ static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
 {
        struct address_space *mapping = file->f_mapping;
        struct inode *inode = mapping->host;
-       int sync_state = inode_state_read_once(inode) & I_DIRTY;
+       bool dirty_data = mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY);
        struct gfs2_glock *gl = gfs2_inode_glock(inode);
        struct gfs2_inode *ip = GFS2_I(inode);
        int ret = 0, ret1 = 0;
@@ -760,12 +760,8 @@ static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
                        return ret1;

fs/gfs2/file.c static int gfs2_fsync(struct file *file, loff_t start, loff_t end, · line 764

Quoted 10 lines
fs/gfs2/file.c +2 -6
        }
 
-       if (!gfs2_is_jdata(ip))
-               sync_state &= ~I_DIRTY_PAGES;
-       if (datasync)
-               sync_state &= ~I_DIRTY_SYNC;
-
-       if (sync_state) {
+       if (inode_is_dirty(inode, datasync) ||
+           (gfs2_is_jdata(ip) && dirty_data)) {

this adds back the I_DIRTY_TIME check explicitly removed in commit:

3aac630b5ce1 ("gfs2: don't worry about I_DIRTY_TIME in gfs2_fsync()")

Could you please clarify what's going on?

Quoted 6 lines
fs/gfs2/file.c +0 -1
                ret = sync_inode_metadata(inode, 1);
                if (ret)
                        return ret;
--

2.53.0

Thanks,
Andreas

author reviewer
#10 lore raw

Re: [PATCH 06/13] gfs2: Avoid racy dirtiness check in gfs2_fsync()

Quoted 10 lines · Andreas Gruenbacher
Quoted 9 lines · Jan Kara

Check for I_DIRTY_PAGES state in gfs2_fsync() is racy because __writeback_single_inode() unconditionally clears the flag and reinstates it only later based on PAGECACHE_TAG_DIRTY tag. If gfs2_fsync() unlocked read of i_state hits in between, it will not see I_DIRTY_PAGES although there may be dirty folios in the mapping. Check for PAGECACHE_TAG_DIRTY instead and use inode_is_dirty() helper for inode metadata dirtiness check.

...

Quoted 15 lines

fs/gfs2/file.c static int gfs2_fsync(struct file *file, loff_t start, loff_t end, · line 764

Quoted 12 lines
fs/gfs2/file.c +2 -6
@@ -760,12 +760,8 @@ static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
                        return ret1;
        }
 
-       if (!gfs2_is_jdata(ip))
-               sync_state &= ~I_DIRTY_PAGES;
-       if (datasync)
-               sync_state &= ~I_DIRTY_SYNC;
-
-       if (sync_state) {
+       if (inode_is_dirty(inode, datasync) ||
+           (gfs2_is_jdata(ip) && dirty_data)) {

this adds back the I_DIRTY_TIME check explicitly removed in commit:

Quoted 3 lines

3aac630b5ce1 ("gfs2: don't worry about I_DIRTY_TIME in gfs2_fsync()")

Could you please clarify what's going on?

I wonder how you remember this after five years :). Anyway, the truth is I forgot fsync path is calling sync_lazytime() as well before calling into ->fsync and even if I remembered that, then it would be fragile for the helper to rely on that (and there are already users of inode_is_dirty() and inode_or_mapping_dirty() which want it). So to summarize you are correct that the added I_DIRTY_TIME check is unnecessary for gfs2_fsync() as it should never trigger just for that but it is also harmless and the helper is more robust that way.

Honza

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
maintainer Reviewed-by
#11 lore raw

Re: [PATCH 06/13] gfs2: Avoid racy dirtiness check in gfs2_fsync()

Quoted 31 lines · Jan Kara
Quoted 10 lines · Andreas Gruenbacher
Quoted 9 lines · Jan Kara

Check for I_DIRTY_PAGES state in gfs2_fsync() is racy because __writeback_single_inode() unconditionally clears the flag and reinstates it only later based on PAGECACHE_TAG_DIRTY tag. If gfs2_fsync() unlocked read of i_state hits in between, it will not see I_DIRTY_PAGES although there may be dirty folios in the mapping. Check for PAGECACHE_TAG_DIRTY instead and use inode_is_dirty() helper for inode metadata dirtiness check.

...

Quoted 15 lines

fs/gfs2/file.c static int gfs2_fsync(struct file *file, loff_t start, loff_t end, · line 764

Quoted 12 lines
fs/gfs2/file.c +2 -6
@@ -760,12 +760,8 @@ static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
                        return ret1;
        }
 
-       if (!gfs2_is_jdata(ip))
-               sync_state &= ~I_DIRTY_PAGES;
-       if (datasync)
-               sync_state &= ~I_DIRTY_SYNC;
-
-       if (sync_state) {
+       if (inode_is_dirty(inode, datasync) ||
+           (gfs2_is_jdata(ip) && dirty_data)) {

this adds back the I_DIRTY_TIME check explicitly removed in commit:

Quoted 3 lines

3aac630b5ce1 ("gfs2: don't worry about I_DIRTY_TIME in gfs2_fsync()")

Could you please clarify what's going on?

Quoted 8 lines

I wonder how you remember this after five years :). Anyway, the truth is I forgot fsync path is calling sync_lazytime() as well before calling into ->fsync and even if I remembered that, then it would be fragile for the helper to rely on that (and there are already users of inode_is_dirty() and inode_or_mapping_dirty() which want it). So to summarize you are correct that the added I_DIRTY_TIME check is unnecessary for gfs2_fsync() as it should never trigger just for that but it is also harmless and the helper is more robust that way.

Alright. Could you please include that in the commit message?

Thanks,
Andreas

author reviewer
#12 lore raw

Re: [PATCH 06/13] gfs2: Avoid racy dirtiness check in gfs2_fsync()

Quoted 41 lines · Andreas Gruenbacher
Quoted 31 lines · Jan Kara
Quoted 10 lines · Andreas Gruenbacher
Quoted 9 lines · Jan Kara

Check for I_DIRTY_PAGES state in gfs2_fsync() is racy because __writeback_single_inode() unconditionally clears the flag and reinstates it only later based on PAGECACHE_TAG_DIRTY tag. If gfs2_fsync() unlocked read of i_state hits in between, it will not see I_DIRTY_PAGES although there may be dirty folios in the mapping. Check for PAGECACHE_TAG_DIRTY instead and use inode_is_dirty() helper for inode metadata dirtiness check.

...

Quoted 15 lines

fs/gfs2/file.c static int gfs2_fsync(struct file *file, loff_t start, loff_t end, · line 764

Quoted 12 lines
fs/gfs2/file.c +2 -6
@@ -760,12 +760,8 @@ static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
                        return ret1;
        }
 
-       if (!gfs2_is_jdata(ip))
-               sync_state &= ~I_DIRTY_PAGES;
-       if (datasync)
-               sync_state &= ~I_DIRTY_SYNC;
-
-       if (sync_state) {
+       if (inode_is_dirty(inode, datasync) ||
+           (gfs2_is_jdata(ip) && dirty_data)) {

this adds back the I_DIRTY_TIME check explicitly removed in commit:

Quoted 3 lines

3aac630b5ce1 ("gfs2: don't worry about I_DIRTY_TIME in gfs2_fsync()")

Could you please clarify what's going on?

Quoted 8 lines

I wonder how you remember this after five years :). Anyway, the truth is I forgot fsync path is calling sync_lazytime() as well before calling into ->fsync and even if I remembered that, then it would be fragile for the helper to rely on that (and there are already users of inode_is_dirty() and inode_or_mapping_dirty() which want it). So to summarize you are correct that the added I_DIRTY_TIME check is unnecessary for gfs2_fsync() as it should never trigger just for that but it is also harmless and the helper is more robust that way.

Quoted 3 lines

Alright. Could you please include that in the commit message?

Sure added this to the changelog. Thanks for review!

Honza

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
author reviewer
#13 lore raw

PATCH v2 7/13 fuse: Use inode_is_dirty() check in fuse_evict_inode()

In reply to Jan Kara

Use inode_is_dirty() helper instead of explicit i_state check. This will result in additionally warning if we have unwritten timestamp updates when lazytime is enabled but that is actually desirable.

---
 fs/fuse/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/fuse/inode.c +1 -1
index 1341b681d0ed..ef88ba7bf682 100644
@@ -143,7 +143,7 @@ static void fuse_evict_inode(struct inode *inode)
 	struct fuse_inode *fi = get_fuse_inode(inode);
 
 	/* Will write inode on close/munmap and in all other dirtiers */
-	WARN_ON(inode_state_read_once(inode) & I_DIRTY_INODE);
+	WARN_ON(inode_is_dirty(inode, false));
 
 	if (IS_DAX(inode))
 		dax_break_layout_final(inode);
Signature · 1 line
2.53.0
author reviewer
#14 lore raw

PATCH v2 8/13 fs: Provide inode_or_folios_dirty() helper

In reply to Jan Kara

Provide a helper function checking whether inode itself or some of its folios are dirty. We'll use it in filesystems instead of direct i_state checks. Note that this check returns true also if only timestamps are dirty when lazytime is enabled. This is what users really want.

---
 include/linux/fs.h | 7 +++++++
 1 file changed, 7 insertions(+)
include/linux/fs.h +7 -0
index 025f5d890689..f602deacf953 100644
@@ -2228,6 +2228,13 @@ static inline bool inode_is_dirty(struct inode *inode, bool datasync)
 	return inode_state_read_once(inode) & mask;
 }
 
+/* Check whether anything in the inode itself or its folios need writing */
+static inline bool inode_or_folios_dirty(struct inode *inode)
+{
+	return inode_state_read_once(inode) & I_DIRTY_ALL ||
+		mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY);
+}
+
 static inline void set_inode_metadata_writeback(struct inode *inode)
 {
 	spin_lock(&inode->i_lock);
Signature · 1 line
2.53.0
#15 lore raw

Re: [PATCH 08/13] fs: Provide inode_or_folios_dirty() helper

Quoted 4 lines · Jan Kara

Provide a helper function checking whether inode itself or some of its folios are dirty. We'll use it in filesystems instead of direct i_state checks. Note that this check returns true also if only timestamps are dirty when lazytime is enabled.

This is confusing. Can we just say this here?

"Also returns true when only the timestamps are dirty."

Quoted 26 lines

This is what users really want.

---
 include/linux/fs.h | 7 +++++++
 1 file changed, 7 insertions(+)
include/linux/fs.h +7 -1
index 025f5d890689..f602deacf953 100644
@@ -2228,6 +2228,13 @@ static inline bool inode_is_dirty(struct inode *inode, bool datasync)
        return inode_state_read_once(inode) & mask;
 }
 
+/* Check whether anything in the inode itself or its folios need writing */
+static inline bool inode_or_folios_dirty(struct inode *inode)
+{
+       return inode_state_read_once(inode) & I_DIRTY_ALL ||
+               mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY);
+}
+
 static inline void set_inode_metadata_writeback(struct inode *inode)
 {
        spin_lock(&inode->i_lock);
--
Quoted 2 lines

2.53.0

Thanks,
Andreas

author reviewer
#16 lore raw

Re: [PATCH 08/13] fs: Provide inode_or_folios_dirty() helper

Quoted 9 lines · Andreas Gruenbacher
Quoted 4 lines · Jan Kara

Provide a helper function checking whether inode itself or some of its folios are dirty. We'll use it in filesystems instead of direct i_state checks. Note that this check returns true also if only timestamps are dirty when lazytime is enabled.

This is confusing. Can we just say this here?

"Also returns true when only the timestamps are dirty."

OK, changelog updated.

Honza

Quoted 33 lines
Quoted 27 lines

This is what users really want.

---
 include/linux/fs.h | 7 +++++++
 1 file changed, 7 insertions(+)
include/linux/fs.h +7 -1
index 025f5d890689..f602deacf953 100644
@@ -2228,6 +2228,13 @@ static inline bool inode_is_dirty(struct inode *inode, bool datasync)
        return inode_state_read_once(inode) & mask;
 }
 
+/* Check whether anything in the inode itself or its folios need writing */
+static inline bool inode_or_folios_dirty(struct inode *inode)
+{
+       return inode_state_read_once(inode) & I_DIRTY_ALL ||
+               mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY);
+}
+
 static inline void set_inode_metadata_writeback(struct inode *inode)
 {
        spin_lock(&inode->i_lock);
--
Quoted 2 lines

2.53.0

Thanks,
Andreas

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
author reviewer
#17 lore raw

PATCH v2 9/13 gfs2: Fix dirtiness checks in gfs2_write_inode() and evict_linked_inode()

In reply to Jan Kara

The checks are bogus because they check against inode->i_flags instead of inode->i_state. Use the inode_or_folios_dirty() helper which actually checks what was intended.

Fixes 957a7acd46e6 ("gfs2: Remove inode from ordered write list in gfs2_write_inode()")
Fixes bd67f17718cc ("gfs2: Fix data loss during inode evict")
---
 fs/gfs2/super.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
fs/gfs2/super.c +3 -2
index 04bb4cf787d4..9b723dd591a5 100644
@@ -460,7 +460,7 @@ static int gfs2_write_inode(struct inode *inode, struct writeback_control *wbc)
 		mark_inode_dirty_sync(inode);
 	else {
 		spin_lock(&inode->i_lock);
-		if (!(inode->i_flags & I_DIRTY))
+		if (!inode_or_folios_dirty(inode))
 			gfs2_ordered_del_inode(ip);
 		spin_unlock(&inode->i_lock);
 	}
@@ -1418,7 +1418,8 @@ static int evict_linked_inode(struct inode *inode, struct gfs2_holder *gh)
 	struct address_space *metamapping = gfs2_glock2aspace(gl);
 	int ret;
 
-	if (!(test_bit(GLF_DIRTY, &gl->gl_flags) || inode->i_flags & I_DIRTY))
+	if (!(test_bit(GLF_DIRTY, &gl->gl_flags) ||
+	      inode_or_folios_dirty(inode)))
 		goto clean;
 
 	/* The inode glock must be held exclusively and be instantiated. */
Signature · 1 line
2.53.0
maintainer Reviewed-by on v2 9/13
#18 lore raw

Re: [PATCH 09/13] gfs2: Fix dirtiness checks in gfs2_write_inode() and evict_linked_inode()

Ja,

thanks for catching this.

Quoted 35 lines · Jan Kara

The checks are bogus because they check against inode->i_flags instead of inode->i_state. Use the inode_or_folios_dirty() helper which actually checks what was intended.

Fixes 957a7acd46e6 ("gfs2: Remove inode from ordered write list in gfs2_write_inode()")
Fixes bd67f17718cc ("gfs2: Fix data loss during inode evict")
---
 fs/gfs2/super.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
fs/gfs2/super.c +3 -3
index 04bb4cf787d4..9b723dd591a5 100644
@@ -460,7 +460,7 @@ static int gfs2_write_inode(struct inode *inode, struct writeback_control *wbc)
                mark_inode_dirty_sync(inode);
        else {
                spin_lock(&inode->i_lock);
-               if (!(inode->i_flags & I_DIRTY))
+               if (!inode_or_folios_dirty(inode))
                        gfs2_ordered_del_inode(ip);
                spin_unlock(&inode->i_lock);
        }
@@ -1418,7 +1418,8 @@ static int evict_linked_inode(struct inode *inode, struct gfs2_holder *gh)
        struct address_space *metamapping = gfs2_glock2aspace(gl);
        int ret;
 
-       if (!(test_bit(GLF_DIRTY, &gl->gl_flags) || inode->i_flags & I_DIRTY))
+       if (!(test_bit(GLF_DIRTY, &gl->gl_flags) ||
+             inode_or_folios_dirty(inode)))
                goto clean;
 
        /* The inode glock must be held exclusively and be instantiated. */
--
Quoted 2 lines

2.53.0

Andreas

author reviewer
#19 lore raw

PATCH v2 10/13 afs: Use inode_or_folios_dirty() in afs_evict_inode()

In reply to Jan Kara

Use the helper instead of direct inode I_DIRTY check to abstract details of inode dirtiness handling. This also properly triggers when only timestamps are dirty and lazytime is enabled (although I'm not sure if it really matters for this particular case in AFS).

---
 fs/afs/inode.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)
fs/afs/inode.c +2 -4
index 0733abff77a5..69982e7d7020 100644
@@ -667,10 +667,8 @@ void afs_evict_inode(struct inode *inode)
 
 	ASSERTCMP(inode->i_ino, ==, vnode->fid.vnode);
 
-	if ((S_ISDIR(inode->i_mode) ||
-	     S_ISLNK(inode->i_mode)) &&
-	    (inode_state_read_once(inode) & I_DIRTY) &&
-	    !sbi->dyn_root) {
+	if ((S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
+	    inode_or_folios_dirty(inode) && !sbi->dyn_root) {
 		struct writeback_control wbc = {
 			.sync_mode = WB_SYNC_ALL,
 			.for_sync = true,
Signature · 1 line
2.53.0
author reviewer
#20 lore raw

PATCH v2 11/13 nfsd: Use inode_or_folios_dirty() for dirtiness check in wait_for_concurrent_writes()

In reply to Jan Kara

The check for dirtiness in wait_for_concurrent_writes() is racy because I_DIRTY_PAGES flag can be temporarily cleared by __writeback_single_inode(). Use inode_or_folios_dirty() helper to avoid that. This also makes sure inode timestamps properly persisted when lazytime is enabled.

---
 fs/nfsd/vfs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/nfsd/vfs.c +1 -1
index 56c49b5bc5bb..a314ca39272f 100644
@@ -1249,7 +1249,7 @@ static int wait_for_concurrent_writes(struct file *file)
 		dprintk("nfsd: write resume %d\n", task_pid_nr(current));
 	}
 
-	if (inode_state_read_once(inode) & I_DIRTY) {
+	if (inode_or_folios_dirty(inode)) {
 		dprintk("nfsd: write sync %d\n", task_pid_nr(current));
 		err = vfs_fsync(file, 0);
 	}
Signature · 1 line
2.53.0
author reviewer
#21 lore raw

PATCH v2 12/13 fscrypt: Use inode_or_folios_dirty() instead of explicit state check

In reply to Jan Kara

Use inode_or_folios_dirty() helper instead of explicit inode state check. No functional change.

---
 fs/crypto/keysetup.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/crypto/keysetup.c +1 -1
index a77b889d7578..1cd40663b251 100644
@@ -839,7 +839,7 @@ int fscrypt_drop_inode(struct inode *inode)
 	 * userspace is still using the files, inodes can be dirtied between
 	 * then and now.  We mustn't lose any writes, so skip dirty inodes here.
 	 */
-	if (inode_state_read(inode) & I_DIRTY_ALL)
+	if (inode_or_folios_dirty(inode))
 		return 0;
 
 	/*
Signature · 1 line
2.53.0
author reviewer
#22 lore raw

PATCH v2 13/13 fs: Use inode_or_folios_dirty() in __inode_lru_list_add()

In reply to Jan Kara

Use inode_or_folios_dirty() helper instead of explicit i_state check in __inode_lru_list_add(). No functional change.

---
 fs/inode.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)
fs/inode.c +3 -1
index f63535ee3629..73afa57fe385 100644
@@ -552,7 +552,9 @@ static void __inode_lru_list_add(struct inode *inode, bool rotate)
 {
 	lockdep_assert_held(&inode->i_lock);
 
-	if (inode_state_read(inode) & (I_DIRTY_ALL | I_SYNC | I_FREEING | I_WILL_FREE))
+	if (inode_state_read(inode) & (I_SYNC | I_FREEING | I_WILL_FREE))
+		return;
+	if (inode_or_folios_dirty(inode))
 		return;
 	if (icount_read(inode))
 		return;
Signature · 1 line
2.53.0