* [WIP RFC PATCH] fs: retire I_WILL_FREE
@ 2025-09-02 14:54 Mateusz Guzik
2025-09-03 3:44 ` Matthew Wilcox
2025-09-05 14:07 ` Christian Brauner
0 siblings, 2 replies; 3+ messages in thread
From: Mateusz Guzik @ 2025-09-02 14:54 UTC (permalink / raw)
To: brauner
Cc: viro, jack, linux-kernel, linux-fsdevel, josef, kernel-team,
amir73il, linux-btrfs, linux-ext4, linux-xfs, Mateusz Guzik
Following up on my response to the refcount patchset, here is a churn
patch to retire I_WILL_FREE.
The only consumer is the drop inode routine in ocfs2.
For the life of me I could not figure out if write_inode_now() is legal
to call in ->evict_inode later and have no means to test, so I devised a
hack: let the fs set I_FREEING ahead of time. Also note iput_final()
issues write_inode_now() anyway but only for the !drop case, which is the
opposite of what is being returned.
One could further hack around it by having ocfs2 return *DON'T* drop but
also set I_DONTCACHE, which would result in both issuing the write in
iput_final() and dropping. I think the hack I did implement is cleaner.
Preferred option is ->evict_inode from ocfs handling the i/o, but per
the above I don't know how to do it.
So.. the following is my proposed first step towards sanitisation of
i_state and the lifecycle flags.
I verified fs/inode.c and fs/fs-writeback.c compile, otherwise untested.
Generated against vfs-6.18.inode.refcount.preliminaries
Comments?
---
block/bdev.c | 2 +-
fs/bcachefs/fs.c | 2 +-
fs/btrfs/inode.c | 2 +-
fs/crypto/keyring.c | 2 +-
fs/drop_caches.c | 2 +-
fs/ext4/inode.c | 2 +-
fs/fs-writeback.c | 18 +++++++----------
fs/gfs2/ops_fstype.c | 2 +-
fs/inode.c | 34 +++++++++++++++++---------------
fs/notify/fsnotify.c | 6 +++---
fs/ocfs2/inode.c | 3 +--
fs/quota/dquot.c | 2 +-
fs/xfs/scrub/common.c | 3 +--
include/linux/fs.h | 32 ++++++++++++------------------
include/trace/events/writeback.h | 3 +--
security/landlock/fs.c | 12 +++++------
16 files changed, 58 insertions(+), 69 deletions(-)
diff --git a/block/bdev.c b/block/bdev.c
index b77ddd12dc06..1801d89e448b 100644
--- a/block/bdev.c
+++ b/block/bdev.c
@@ -1265,7 +1265,7 @@ void sync_bdevs(bool wait)
struct block_device *bdev;
spin_lock(&inode->i_lock);
- if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW) ||
+ if (inode->i_state & (I_FREEING | I_NEW) ||
mapping->nrpages == 0) {
spin_unlock(&inode->i_lock);
continue;
diff --git a/fs/bcachefs/fs.c b/fs/bcachefs/fs.c
index 687af0eea0c2..a62d597630d1 100644
--- a/fs/bcachefs/fs.c
+++ b/fs/bcachefs/fs.c
@@ -347,7 +347,7 @@ static struct bch_inode_info *bch2_inode_hash_find(struct bch_fs *c, struct btre
spin_unlock(&inode->v.i_lock);
return NULL;
}
- if ((inode->v.i_state & (I_FREEING|I_WILL_FREE))) {
+ if ((inode->v.i_state & I_FREEING)) {
if (!trans) {
__wait_on_freeing_inode(c, inode, inum);
} else {
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 5bcd8e25fa78..f1d9336b903f 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -3856,7 +3856,7 @@ static int btrfs_add_inode_to_root(struct btrfs_inode *inode, bool prealloc)
ASSERT(ret != -ENOMEM);
return ret;
} else if (existing) {
- WARN_ON(!(existing->vfs_inode.i_state & (I_WILL_FREE | I_FREEING)));
+ WARN_ON(!(existing->vfs_inode.i_state & I_FREEING));
}
return 0;
diff --git a/fs/crypto/keyring.c b/fs/crypto/keyring.c
index 7557f6a88b8f..97f4c7049222 100644
--- a/fs/crypto/keyring.c
+++ b/fs/crypto/keyring.c
@@ -957,7 +957,7 @@ static void evict_dentries_for_decrypted_inodes(struct fscrypt_master_key *mk)
list_for_each_entry(ci, &mk->mk_decrypted_inodes, ci_master_key_link) {
inode = ci->ci_inode;
spin_lock(&inode->i_lock);
- if (inode->i_state & (I_FREEING | I_WILL_FREE | I_NEW)) {
+ if (inode->i_state & (I_FREEING | I_NEW)) {
spin_unlock(&inode->i_lock);
continue;
}
diff --git a/fs/drop_caches.c b/fs/drop_caches.c
index 019a8b4eaaf9..40fa9b17375b 100644
--- a/fs/drop_caches.c
+++ b/fs/drop_caches.c
@@ -28,7 +28,7 @@ static void drop_pagecache_sb(struct super_block *sb, void *unused)
* inodes without pages but we deliberately won't in case
* we need to reschedule to avoid softlockups.
*/
- if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
+ if ((inode->i_state & (I_FREEING|I_NEW)) ||
(mapping_empty(inode->i_mapping) && !need_resched())) {
spin_unlock(&inode->i_lock);
continue;
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index ed54c4d0f2f9..14209758e5be 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -425,7 +425,7 @@ void ext4_check_map_extents_env(struct inode *inode)
if (!S_ISREG(inode->i_mode) ||
IS_NOQUOTA(inode) || IS_VERITY(inode) ||
is_special_ino(inode->i_sb, inode->i_ino) ||
- (inode->i_state & (I_FREEING | I_WILL_FREE | I_NEW)) ||
+ (inode->i_state & (I_FREEING | I_NEW)) ||
ext4_test_inode_flag(inode, EXT4_INODE_EA_INODE) ||
ext4_verity_in_progress(inode))
return;
diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index 6088a67b2aae..5fa388820daf 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -405,10 +405,10 @@ static bool inode_do_switch_wbs(struct inode *inode,
xa_lock_irq(&mapping->i_pages);
/*
- * Once I_FREEING or I_WILL_FREE are visible under i_lock, the eviction
+ * Once I_FREEING is visible under i_lock, the eviction
* path owns the inode and we shouldn't modify ->i_io_list.
*/
- if (unlikely(inode->i_state & (I_FREEING | I_WILL_FREE)))
+ if (unlikely(inode->i_state & I_FREEING))
goto skip_switch;
trace_inode_switch_wbs(inode, old_wb, new_wb);
@@ -560,7 +560,7 @@ static bool inode_prepare_wbs_switch(struct inode *inode,
/* while holding I_WB_SWITCH, no one else can update the association */
spin_lock(&inode->i_lock);
if (!(inode->i_sb->s_flags & SB_ACTIVE) ||
- inode->i_state & (I_WB_SWITCH | I_FREEING | I_WILL_FREE) ||
+ inode->i_state & (I_WB_SWITCH | I_FREEING) ||
inode_to_wb(inode) == new_wb) {
spin_unlock(&inode->i_lock);
return false;
@@ -1758,7 +1758,7 @@ __writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
* whether it is a data-integrity sync (%WB_SYNC_ALL) or not (%WB_SYNC_NONE).
*
* To prevent the inode from going away, either the caller must have a reference
- * to the inode, or the inode must have I_WILL_FREE or I_FREEING set.
+ * to the inode, or the inode must have I_FREEING set.
*/
static int writeback_single_inode(struct inode *inode,
struct writeback_control *wbc)
@@ -1768,9 +1768,7 @@ static int writeback_single_inode(struct inode *inode,
spin_lock(&inode->i_lock);
if (!icount_read(inode))
- WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING)));
- else
- WARN_ON(inode->i_state & I_WILL_FREE);
+ WARN_ON(!(inode->i_state & I_FREEING));
if (inode->i_state & I_SYNC) {
/*
@@ -1928,7 +1926,7 @@ static long writeback_sb_inodes(struct super_block *sb,
* kind writeout is handled by the freer.
*/
spin_lock(&inode->i_lock);
- if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
+ if (inode->i_state & (I_NEW | I_FREEING)) {
redirty_tail_locked(inode, wb);
spin_unlock(&inode->i_lock);
continue;
@@ -2696,7 +2694,7 @@ static void wait_sb_inodes(struct super_block *sb)
spin_unlock_irq(&sb->s_inode_wblist_lock);
spin_lock(&inode->i_lock);
- if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) {
+ if (inode->i_state & (I_FREEING | I_NEW)) {
spin_unlock(&inode->i_lock);
spin_lock_irq(&sb->s_inode_wblist_lock);
@@ -2844,8 +2842,6 @@ EXPORT_SYMBOL(sync_inodes_sb);
*
* This function commits an inode to disk immediately if it is dirty. This is
* primarily needed by knfsd.
- *
- * The caller must either have a ref on the inode or must have set I_WILL_FREE.
*/
int write_inode_now(struct inode *inode, int sync)
{
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index c770006f8889..1393181a64dc 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -1749,7 +1749,7 @@ static void gfs2_evict_inodes(struct super_block *sb)
spin_lock(&sb->s_inode_list_lock);
list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
spin_lock(&inode->i_lock);
- if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) &&
+ if ((inode->i_state & (I_FREEING | I_NEW)) &&
!need_resched()) {
spin_unlock(&inode->i_lock);
continue;
diff --git a/fs/inode.c b/fs/inode.c
index 2db680a37235..8188b0b5dfa1 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -532,7 +532,7 @@ EXPORT_SYMBOL(ihold);
static void __inode_add_lru(struct inode *inode, bool rotate)
{
- if (inode->i_state & (I_DIRTY_ALL | I_SYNC | I_FREEING | I_WILL_FREE))
+ if (inode->i_state & (I_DIRTY_ALL | I_SYNC | I_FREEING))
return;
if (icount_read(inode))
return;
@@ -577,7 +577,7 @@ static void inode_lru_list_del(struct inode *inode)
static void inode_pin_lru_isolating(struct inode *inode)
{
lockdep_assert_held(&inode->i_lock);
- WARN_ON(inode->i_state & (I_LRU_ISOLATING | I_FREEING | I_WILL_FREE));
+ WARN_ON(inode->i_state & (I_LRU_ISOLATING | I_FREEING));
inode->i_state |= I_LRU_ISOLATING;
}
@@ -879,7 +879,7 @@ void evict_inodes(struct super_block *sb)
spin_unlock(&inode->i_lock);
continue;
}
- if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
+ if (inode->i_state & (I_NEW | I_FREEING)) {
spin_unlock(&inode->i_lock);
continue;
}
@@ -1025,7 +1025,7 @@ static struct inode *find_inode(struct super_block *sb,
if (!test(inode, data))
continue;
spin_lock(&inode->i_lock);
- if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
+ if (inode->i_state & I_FREEING) {
__wait_on_freeing_inode(inode, is_inode_hash_locked);
goto repeat;
}
@@ -1066,7 +1066,7 @@ static struct inode *find_inode_fast(struct super_block *sb,
if (inode->i_sb != sb)
continue;
spin_lock(&inode->i_lock);
- if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
+ if (inode->i_state & I_FREEING) {
__wait_on_freeing_inode(inode, is_inode_hash_locked);
goto repeat;
}
@@ -1538,7 +1538,7 @@ EXPORT_SYMBOL(iunique);
struct inode *igrab(struct inode *inode)
{
spin_lock(&inode->i_lock);
- if (!(inode->i_state & (I_FREEING|I_WILL_FREE))) {
+ if (!(inode->i_state & I_FREEING)) {
__iget(inode);
spin_unlock(&inode->i_lock);
} else {
@@ -1728,7 +1728,7 @@ struct inode *find_inode_rcu(struct super_block *sb, unsigned long hashval,
hlist_for_each_entry_rcu(inode, head, i_hash) {
if (inode->i_sb == sb &&
- !(READ_ONCE(inode->i_state) & (I_FREEING | I_WILL_FREE)) &&
+ !(READ_ONCE(inode->i_state) & I_FREEING) &&
test(inode, data))
return inode;
}
@@ -1767,7 +1767,7 @@ struct inode *find_inode_by_ino_rcu(struct super_block *sb,
hlist_for_each_entry_rcu(inode, head, i_hash) {
if (inode->i_ino == ino &&
inode->i_sb == sb &&
- !(READ_ONCE(inode->i_state) & (I_FREEING | I_WILL_FREE)))
+ !(READ_ONCE(inode->i_state) & I_FREEING))
return inode;
}
return NULL;
@@ -1789,7 +1789,7 @@ int insert_inode_locked(struct inode *inode)
if (old->i_sb != sb)
continue;
spin_lock(&old->i_lock);
- if (old->i_state & (I_FREEING|I_WILL_FREE)) {
+ if (old->i_state & I_FREEING) {
spin_unlock(&old->i_lock);
continue;
}
@@ -1862,12 +1862,19 @@ static void iput_final(struct inode *inode)
int drop;
WARN_ON(inode->i_state & I_NEW);
+ VFS_BUG_ON_INODE(inode->i_state & I_FREEING, inode);
if (op->drop_inode)
drop = op->drop_inode(inode);
else
drop = generic_drop_inode(inode);
+ /*
+ * Note: the ->drop_inode routine is allowed to set I_FREEING for us,
+ * but this is only legal if they want to drop.
+ */
+ VFS_BUG_ON_INODE(!drop && (inode->i_state & I_FREEING), inode);
+
if (!drop &&
!(inode->i_state & I_DONTCACHE) &&
(sb->s_flags & SB_ACTIVE)) {
@@ -1877,19 +1884,14 @@ static void iput_final(struct inode *inode)
}
state = inode->i_state;
+ WRITE_ONCE(inode->i_state, state | I_FREEING);
if (!drop) {
- WRITE_ONCE(inode->i_state, state | I_WILL_FREE);
spin_unlock(&inode->i_lock);
-
write_inode_now(inode, 1);
-
spin_lock(&inode->i_lock);
- state = inode->i_state;
- WARN_ON(state & I_NEW);
- state &= ~I_WILL_FREE;
}
+ WARN_ON(inode->i_state & I_NEW);
- WRITE_ONCE(inode->i_state, state | I_FREEING);
if (!list_empty(&inode->i_lru))
inode_lru_list_del(inode);
spin_unlock(&inode->i_lock);
diff --git a/fs/notify/fsnotify.c b/fs/notify/fsnotify.c
index 46bfc543f946..cff8417fa6db 100644
--- a/fs/notify/fsnotify.c
+++ b/fs/notify/fsnotify.c
@@ -47,12 +47,12 @@ static void fsnotify_unmount_inodes(struct super_block *sb)
spin_lock(&sb->s_inode_list_lock);
list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
/*
- * We cannot __iget() an inode in state I_FREEING,
- * I_WILL_FREE, or I_NEW which is fine because by that point
+ * We cannot __iget() an inode in state I_FREEING
+ * or I_NEW which is fine because by that point
* the inode cannot have any associated watches.
*/
spin_lock(&inode->i_lock);
- if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) {
+ if (inode->i_state & (I_FREEING | I_NEW)) {
spin_unlock(&inode->i_lock);
continue;
}
diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
index 14bf440ea4df..29549fc899e9 100644
--- a/fs/ocfs2/inode.c
+++ b/fs/ocfs2/inode.c
@@ -1307,12 +1307,11 @@ int ocfs2_drop_inode(struct inode *inode)
inode->i_nlink, oi->ip_flags);
assert_spin_locked(&inode->i_lock);
- inode->i_state |= I_WILL_FREE;
+ inode->i_state |= I_FREEING;
spin_unlock(&inode->i_lock);
write_inode_now(inode, 1);
spin_lock(&inode->i_lock);
WARN_ON(inode->i_state & I_NEW);
- inode->i_state &= ~I_WILL_FREE;
return 1;
}
diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
index df4a9b348769..3aa916040602 100644
--- a/fs/quota/dquot.c
+++ b/fs/quota/dquot.c
@@ -1030,7 +1030,7 @@ static int add_dquot_ref(struct super_block *sb, int type)
spin_lock(&sb->s_inode_list_lock);
list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
spin_lock(&inode->i_lock);
- if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
+ if ((inode->i_state & (I_FREEING | I_NEW)) ||
!atomic_read(&inode->i_writecount) ||
!dqinit_needed(inode, type)) {
spin_unlock(&inode->i_lock);
diff --git a/fs/xfs/scrub/common.c b/fs/xfs/scrub/common.c
index 2ef7742be7d3..e678f944206f 100644
--- a/fs/xfs/scrub/common.c
+++ b/fs/xfs/scrub/common.c
@@ -1086,8 +1086,7 @@ xchk_install_handle_inode(
/*
* Install an already-referenced inode for scrubbing. Get our own reference to
- * the inode to make disposal simpler. The inode must not be in I_FREEING or
- * I_WILL_FREE state!
+ * the inode to make disposal simpler. The inode must not have I_FREEING set.
*/
int
xchk_install_live_inode(
diff --git a/include/linux/fs.h b/include/linux/fs.h
index c4fd010cf5bf..e8ad8f0a03c7 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -671,8 +671,8 @@ is_uncached_acl(struct posix_acl *acl)
* I_DIRTY_DATASYNC, I_DIRTY_PAGES, and I_DIRTY_TIME.
*
* Four bits define the lifetime of an inode. Initially, inodes are I_NEW,
- * until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at
- * various stages of removing an inode.
+ * until that flag is cleared. I_FREEING and I_CLEAR are set at various stages
+ * of removing an inode.
*
* Two bits are used for locking and completion notification, I_NEW and I_SYNC.
*
@@ -696,24 +696,21 @@ is_uncached_acl(struct posix_acl *acl)
* New inodes set I_NEW. If two processes both create
* the same inode, one of them will release its inode and
* wait for I_NEW to be released before returning.
- * Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
- * also cause waiting on I_NEW, without I_NEW actually
- * being set. find_inode() uses this to prevent returning
- * nearly-dead inodes.
- * I_WILL_FREE Must be set when calling write_inode_now() if i_count
- * is zero. I_FREEING must be set when I_WILL_FREE is
- * cleared.
+ * Inodes in I_FREEING or I_CLEAR state can also cause
+ * waiting on I_NEW, without I_NEW actually being set.
+ * find_inode() uses this to prevent returning nearly-dead
+ * inodes.
* I_FREEING Set when inode is about to be freed but still has dirty
* pages or buffers attached or the inode itself is still
* dirty.
* I_CLEAR Added by clear_inode(). In this state the inode is
* clean and can be destroyed. Inode keeps I_FREEING.
*
- * Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
- * prohibited for many purposes. iget() must wait for
- * the inode to be completely released, then create it
- * anew. Other functions will just ignore such inodes,
- * if appropriate. I_NEW is used for waiting.
+ * Inodes that are I_FREEING or I_CLEAR are prohibited for
+ * many purposes. iget() must wait for the inode to be
+ * completely released, then create it anew. Other
+ * functions will just ignore such inodes, if appropriate.
+ * I_NEW is used for waiting.
*
* I_SYNC Writeback of inode is running. The bit is set during
* data writeback, and cleared with a wakeup on the bit
@@ -743,8 +740,6 @@ is_uncached_acl(struct posix_acl *acl)
* I_LRU_ISOLATING Inode is pinned being isolated from LRU without holding
* i_count.
*
- * Q: What is the difference between I_WILL_FREE and I_FREEING?
- *
* __I_{SYNC,NEW,LRU_ISOLATING} are used to derive unique addresses to wait
* upon. There's one free address left.
*/
@@ -764,7 +759,7 @@ enum inode_state_flags_t {
I_DIRTY_SYNC = (1U << 4),
I_DIRTY_DATASYNC = (1U << 5),
I_DIRTY_PAGES = (1U << 6),
- I_WILL_FREE = (1U << 7),
+ I_PINNING_NETFS_WB = (1U << 7),
I_FREEING = (1U << 8),
I_CLEAR = (1U << 9),
I_REFERENCED = (1U << 10),
@@ -775,7 +770,6 @@ enum inode_state_flags_t {
I_CREATING = (1U << 15),
I_DONTCACHE = (1U << 16),
I_SYNC_QUEUED = (1U << 17),
- I_PINNING_NETFS_WB = (1U << 18)
};
#define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)
@@ -2628,7 +2622,7 @@ static inline int icount_read(const struct inode *inode)
static inline bool inode_is_dirtytime_only(struct inode *inode)
{
return (inode->i_state & (I_DIRTY_TIME | I_NEW |
- I_FREEING | I_WILL_FREE)) == I_DIRTY_TIME;
+ I_FREEING)) == I_DIRTY_TIME;
}
extern void inc_nlink(struct inode *inode);
diff --git a/include/trace/events/writeback.h b/include/trace/events/writeback.h
index 1e23919c0da9..6e3ebecc95e9 100644
--- a/include/trace/events/writeback.h
+++ b/include/trace/events/writeback.h
@@ -15,7 +15,7 @@
{I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \
{I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \
{I_NEW, "I_NEW"}, \
- {I_WILL_FREE, "I_WILL_FREE"}, \
+ {I_PINNING_NETFS_WB, "I_PINNING_NETFS_WB"}, \
{I_FREEING, "I_FREEING"}, \
{I_CLEAR, "I_CLEAR"}, \
{I_SYNC, "I_SYNC"}, \
@@ -27,7 +27,6 @@
{I_CREATING, "I_CREATING"}, \
{I_DONTCACHE, "I_DONTCACHE"}, \
{I_SYNC_QUEUED, "I_SYNC_QUEUED"}, \
- {I_PINNING_NETFS_WB, "I_PINNING_NETFS_WB"}, \
{I_LRU_ISOLATING, "I_LRU_ISOLATING"} \
)
diff --git a/security/landlock/fs.c b/security/landlock/fs.c
index 0bade2c5aa1d..7ffcd62324fa 100644
--- a/security/landlock/fs.c
+++ b/security/landlock/fs.c
@@ -1290,13 +1290,13 @@ static void hook_sb_delete(struct super_block *const sb)
*/
spin_lock(&inode->i_lock);
/*
- * Checks I_FREEING and I_WILL_FREE to protect against a race
- * condition when release_inode() just called iput(), which
- * could lead to a NULL dereference of inode->security or a
- * second call to iput() for the same Landlock object. Also
- * checks I_NEW because such inode cannot be tied to an object.
+ * Checks I_FREEING to protect against a race condition when
+ * release_inode() just called iput(), which could lead to a
+ * NULL dereference of inode->security or a second call to
+ * iput() for the same Landlock object. Also checks I_NEW
+ * because such inode cannot be tied to an object.
*/
- if (inode->i_state & (I_FREEING | I_WILL_FREE | I_NEW)) {
+ if (inode->i_state & (I_FREEING | I_NEW)) {
spin_unlock(&inode->i_lock);
continue;
}
--
2.43.0
^ permalink raw reply related [flat|nested] 3+ messages in thread
* Re: [WIP RFC PATCH] fs: retire I_WILL_FREE
2025-09-02 14:54 [WIP RFC PATCH] fs: retire I_WILL_FREE Mateusz Guzik
@ 2025-09-03 3:44 ` Matthew Wilcox
2025-09-05 14:07 ` Christian Brauner
1 sibling, 0 replies; 3+ messages in thread
From: Matthew Wilcox @ 2025-09-03 3:44 UTC (permalink / raw)
To: Mateusz Guzik
Cc: brauner, viro, jack, linux-kernel, linux-fsdevel, josef,
kernel-team, amir73il, linux-btrfs, linux-ext4, linux-xfs,
ocfs2-devel, Mark Fasheh, Joel Becker, Joseph Qi
On Tue, Sep 02, 2025 at 04:54:28PM +0200, Mateusz Guzik wrote:
> Following up on my response to the refcount patchset, here is a churn
> patch to retire I_WILL_FREE.
>
> The only consumer is the drop inode routine in ocfs2.
If the only consumer is ocfs2 ... then you should cc the ocfs2 people,
right?
> For the life of me I could not figure out if write_inode_now() is legal
> to call in ->evict_inode later and have no means to test, so I devised a
> hack: let the fs set I_FREEING ahead of time. Also note iput_final()
> issues write_inode_now() anyway but only for the !drop case, which is the
> opposite of what is being returned.
>
> One could further hack around it by having ocfs2 return *DON'T* drop but
> also set I_DONTCACHE, which would result in both issuing the write in
> iput_final() and dropping. I think the hack I did implement is cleaner.
> Preferred option is ->evict_inode from ocfs handling the i/o, but per
> the above I don't know how to do it.
>
> So.. the following is my proposed first step towards sanitisation of
> i_state and the lifecycle flags.
>
> I verified fs/inode.c and fs/fs-writeback.c compile, otherwise untested.
>
> Generated against vfs-6.18.inode.refcount.preliminaries
>
> Comments?
>
> ---
> block/bdev.c | 2 +-
> fs/bcachefs/fs.c | 2 +-
> fs/btrfs/inode.c | 2 +-
> fs/crypto/keyring.c | 2 +-
> fs/drop_caches.c | 2 +-
> fs/ext4/inode.c | 2 +-
> fs/fs-writeback.c | 18 +++++++----------
> fs/gfs2/ops_fstype.c | 2 +-
> fs/inode.c | 34 +++++++++++++++++---------------
> fs/notify/fsnotify.c | 6 +++---
> fs/ocfs2/inode.c | 3 +--
> fs/quota/dquot.c | 2 +-
> fs/xfs/scrub/common.c | 3 +--
> include/linux/fs.h | 32 ++++++++++++------------------
> include/trace/events/writeback.h | 3 +--
> security/landlock/fs.c | 12 +++++------
> 16 files changed, 58 insertions(+), 69 deletions(-)
>
> diff --git a/block/bdev.c b/block/bdev.c
> index b77ddd12dc06..1801d89e448b 100644
> --- a/block/bdev.c
> +++ b/block/bdev.c
> @@ -1265,7 +1265,7 @@ void sync_bdevs(bool wait)
> struct block_device *bdev;
>
> spin_lock(&inode->i_lock);
> - if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW) ||
> + if (inode->i_state & (I_FREEING | I_NEW) ||
> mapping->nrpages == 0) {
> spin_unlock(&inode->i_lock);
> continue;
> diff --git a/fs/bcachefs/fs.c b/fs/bcachefs/fs.c
> index 687af0eea0c2..a62d597630d1 100644
> --- a/fs/bcachefs/fs.c
> +++ b/fs/bcachefs/fs.c
> @@ -347,7 +347,7 @@ static struct bch_inode_info *bch2_inode_hash_find(struct bch_fs *c, struct btre
> spin_unlock(&inode->v.i_lock);
> return NULL;
> }
> - if ((inode->v.i_state & (I_FREEING|I_WILL_FREE))) {
> + if ((inode->v.i_state & I_FREEING)) {
> if (!trans) {
> __wait_on_freeing_inode(c, inode, inum);
> } else {
> diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
> index 5bcd8e25fa78..f1d9336b903f 100644
> --- a/fs/btrfs/inode.c
> +++ b/fs/btrfs/inode.c
> @@ -3856,7 +3856,7 @@ static int btrfs_add_inode_to_root(struct btrfs_inode *inode, bool prealloc)
> ASSERT(ret != -ENOMEM);
> return ret;
> } else if (existing) {
> - WARN_ON(!(existing->vfs_inode.i_state & (I_WILL_FREE | I_FREEING)));
> + WARN_ON(!(existing->vfs_inode.i_state & I_FREEING));
> }
>
> return 0;
> diff --git a/fs/crypto/keyring.c b/fs/crypto/keyring.c
> index 7557f6a88b8f..97f4c7049222 100644
> --- a/fs/crypto/keyring.c
> +++ b/fs/crypto/keyring.c
> @@ -957,7 +957,7 @@ static void evict_dentries_for_decrypted_inodes(struct fscrypt_master_key *mk)
> list_for_each_entry(ci, &mk->mk_decrypted_inodes, ci_master_key_link) {
> inode = ci->ci_inode;
> spin_lock(&inode->i_lock);
> - if (inode->i_state & (I_FREEING | I_WILL_FREE | I_NEW)) {
> + if (inode->i_state & (I_FREEING | I_NEW)) {
> spin_unlock(&inode->i_lock);
> continue;
> }
> diff --git a/fs/drop_caches.c b/fs/drop_caches.c
> index 019a8b4eaaf9..40fa9b17375b 100644
> --- a/fs/drop_caches.c
> +++ b/fs/drop_caches.c
> @@ -28,7 +28,7 @@ static void drop_pagecache_sb(struct super_block *sb, void *unused)
> * inodes without pages but we deliberately won't in case
> * we need to reschedule to avoid softlockups.
> */
> - if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
> + if ((inode->i_state & (I_FREEING|I_NEW)) ||
> (mapping_empty(inode->i_mapping) && !need_resched())) {
> spin_unlock(&inode->i_lock);
> continue;
> diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
> index ed54c4d0f2f9..14209758e5be 100644
> --- a/fs/ext4/inode.c
> +++ b/fs/ext4/inode.c
> @@ -425,7 +425,7 @@ void ext4_check_map_extents_env(struct inode *inode)
> if (!S_ISREG(inode->i_mode) ||
> IS_NOQUOTA(inode) || IS_VERITY(inode) ||
> is_special_ino(inode->i_sb, inode->i_ino) ||
> - (inode->i_state & (I_FREEING | I_WILL_FREE | I_NEW)) ||
> + (inode->i_state & (I_FREEING | I_NEW)) ||
> ext4_test_inode_flag(inode, EXT4_INODE_EA_INODE) ||
> ext4_verity_in_progress(inode))
> return;
> diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
> index 6088a67b2aae..5fa388820daf 100644
> --- a/fs/fs-writeback.c
> +++ b/fs/fs-writeback.c
> @@ -405,10 +405,10 @@ static bool inode_do_switch_wbs(struct inode *inode,
> xa_lock_irq(&mapping->i_pages);
>
> /*
> - * Once I_FREEING or I_WILL_FREE are visible under i_lock, the eviction
> + * Once I_FREEING is visible under i_lock, the eviction
> * path owns the inode and we shouldn't modify ->i_io_list.
> */
> - if (unlikely(inode->i_state & (I_FREEING | I_WILL_FREE)))
> + if (unlikely(inode->i_state & I_FREEING))
> goto skip_switch;
>
> trace_inode_switch_wbs(inode, old_wb, new_wb);
> @@ -560,7 +560,7 @@ static bool inode_prepare_wbs_switch(struct inode *inode,
> /* while holding I_WB_SWITCH, no one else can update the association */
> spin_lock(&inode->i_lock);
> if (!(inode->i_sb->s_flags & SB_ACTIVE) ||
> - inode->i_state & (I_WB_SWITCH | I_FREEING | I_WILL_FREE) ||
> + inode->i_state & (I_WB_SWITCH | I_FREEING) ||
> inode_to_wb(inode) == new_wb) {
> spin_unlock(&inode->i_lock);
> return false;
> @@ -1758,7 +1758,7 @@ __writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
> * whether it is a data-integrity sync (%WB_SYNC_ALL) or not (%WB_SYNC_NONE).
> *
> * To prevent the inode from going away, either the caller must have a reference
> - * to the inode, or the inode must have I_WILL_FREE or I_FREEING set.
> + * to the inode, or the inode must have I_FREEING set.
> */
> static int writeback_single_inode(struct inode *inode,
> struct writeback_control *wbc)
> @@ -1768,9 +1768,7 @@ static int writeback_single_inode(struct inode *inode,
>
> spin_lock(&inode->i_lock);
> if (!icount_read(inode))
> - WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING)));
> - else
> - WARN_ON(inode->i_state & I_WILL_FREE);
> + WARN_ON(!(inode->i_state & I_FREEING));
>
> if (inode->i_state & I_SYNC) {
> /*
> @@ -1928,7 +1926,7 @@ static long writeback_sb_inodes(struct super_block *sb,
> * kind writeout is handled by the freer.
> */
> spin_lock(&inode->i_lock);
> - if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
> + if (inode->i_state & (I_NEW | I_FREEING)) {
> redirty_tail_locked(inode, wb);
> spin_unlock(&inode->i_lock);
> continue;
> @@ -2696,7 +2694,7 @@ static void wait_sb_inodes(struct super_block *sb)
> spin_unlock_irq(&sb->s_inode_wblist_lock);
>
> spin_lock(&inode->i_lock);
> - if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) {
> + if (inode->i_state & (I_FREEING | I_NEW)) {
> spin_unlock(&inode->i_lock);
>
> spin_lock_irq(&sb->s_inode_wblist_lock);
> @@ -2844,8 +2842,6 @@ EXPORT_SYMBOL(sync_inodes_sb);
> *
> * This function commits an inode to disk immediately if it is dirty. This is
> * primarily needed by knfsd.
> - *
> - * The caller must either have a ref on the inode or must have set I_WILL_FREE.
> */
> int write_inode_now(struct inode *inode, int sync)
> {
> diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
> index c770006f8889..1393181a64dc 100644
> --- a/fs/gfs2/ops_fstype.c
> +++ b/fs/gfs2/ops_fstype.c
> @@ -1749,7 +1749,7 @@ static void gfs2_evict_inodes(struct super_block *sb)
> spin_lock(&sb->s_inode_list_lock);
> list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
> spin_lock(&inode->i_lock);
> - if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) &&
> + if ((inode->i_state & (I_FREEING | I_NEW)) &&
> !need_resched()) {
> spin_unlock(&inode->i_lock);
> continue;
> diff --git a/fs/inode.c b/fs/inode.c
> index 2db680a37235..8188b0b5dfa1 100644
> --- a/fs/inode.c
> +++ b/fs/inode.c
> @@ -532,7 +532,7 @@ EXPORT_SYMBOL(ihold);
>
> static void __inode_add_lru(struct inode *inode, bool rotate)
> {
> - if (inode->i_state & (I_DIRTY_ALL | I_SYNC | I_FREEING | I_WILL_FREE))
> + if (inode->i_state & (I_DIRTY_ALL | I_SYNC | I_FREEING))
> return;
> if (icount_read(inode))
> return;
> @@ -577,7 +577,7 @@ static void inode_lru_list_del(struct inode *inode)
> static void inode_pin_lru_isolating(struct inode *inode)
> {
> lockdep_assert_held(&inode->i_lock);
> - WARN_ON(inode->i_state & (I_LRU_ISOLATING | I_FREEING | I_WILL_FREE));
> + WARN_ON(inode->i_state & (I_LRU_ISOLATING | I_FREEING));
> inode->i_state |= I_LRU_ISOLATING;
> }
>
> @@ -879,7 +879,7 @@ void evict_inodes(struct super_block *sb)
> spin_unlock(&inode->i_lock);
> continue;
> }
> - if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
> + if (inode->i_state & (I_NEW | I_FREEING)) {
> spin_unlock(&inode->i_lock);
> continue;
> }
> @@ -1025,7 +1025,7 @@ static struct inode *find_inode(struct super_block *sb,
> if (!test(inode, data))
> continue;
> spin_lock(&inode->i_lock);
> - if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
> + if (inode->i_state & I_FREEING) {
> __wait_on_freeing_inode(inode, is_inode_hash_locked);
> goto repeat;
> }
> @@ -1066,7 +1066,7 @@ static struct inode *find_inode_fast(struct super_block *sb,
> if (inode->i_sb != sb)
> continue;
> spin_lock(&inode->i_lock);
> - if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
> + if (inode->i_state & I_FREEING) {
> __wait_on_freeing_inode(inode, is_inode_hash_locked);
> goto repeat;
> }
> @@ -1538,7 +1538,7 @@ EXPORT_SYMBOL(iunique);
> struct inode *igrab(struct inode *inode)
> {
> spin_lock(&inode->i_lock);
> - if (!(inode->i_state & (I_FREEING|I_WILL_FREE))) {
> + if (!(inode->i_state & I_FREEING)) {
> __iget(inode);
> spin_unlock(&inode->i_lock);
> } else {
> @@ -1728,7 +1728,7 @@ struct inode *find_inode_rcu(struct super_block *sb, unsigned long hashval,
>
> hlist_for_each_entry_rcu(inode, head, i_hash) {
> if (inode->i_sb == sb &&
> - !(READ_ONCE(inode->i_state) & (I_FREEING | I_WILL_FREE)) &&
> + !(READ_ONCE(inode->i_state) & I_FREEING) &&
> test(inode, data))
> return inode;
> }
> @@ -1767,7 +1767,7 @@ struct inode *find_inode_by_ino_rcu(struct super_block *sb,
> hlist_for_each_entry_rcu(inode, head, i_hash) {
> if (inode->i_ino == ino &&
> inode->i_sb == sb &&
> - !(READ_ONCE(inode->i_state) & (I_FREEING | I_WILL_FREE)))
> + !(READ_ONCE(inode->i_state) & I_FREEING))
> return inode;
> }
> return NULL;
> @@ -1789,7 +1789,7 @@ int insert_inode_locked(struct inode *inode)
> if (old->i_sb != sb)
> continue;
> spin_lock(&old->i_lock);
> - if (old->i_state & (I_FREEING|I_WILL_FREE)) {
> + if (old->i_state & I_FREEING) {
> spin_unlock(&old->i_lock);
> continue;
> }
> @@ -1862,12 +1862,19 @@ static void iput_final(struct inode *inode)
> int drop;
>
> WARN_ON(inode->i_state & I_NEW);
> + VFS_BUG_ON_INODE(inode->i_state & I_FREEING, inode);
>
> if (op->drop_inode)
> drop = op->drop_inode(inode);
> else
> drop = generic_drop_inode(inode);
>
> + /*
> + * Note: the ->drop_inode routine is allowed to set I_FREEING for us,
> + * but this is only legal if they want to drop.
> + */
> + VFS_BUG_ON_INODE(!drop && (inode->i_state & I_FREEING), inode);
> +
> if (!drop &&
> !(inode->i_state & I_DONTCACHE) &&
> (sb->s_flags & SB_ACTIVE)) {
> @@ -1877,19 +1884,14 @@ static void iput_final(struct inode *inode)
> }
>
> state = inode->i_state;
> + WRITE_ONCE(inode->i_state, state | I_FREEING);
> if (!drop) {
> - WRITE_ONCE(inode->i_state, state | I_WILL_FREE);
> spin_unlock(&inode->i_lock);
> -
> write_inode_now(inode, 1);
> -
> spin_lock(&inode->i_lock);
> - state = inode->i_state;
> - WARN_ON(state & I_NEW);
> - state &= ~I_WILL_FREE;
> }
> + WARN_ON(inode->i_state & I_NEW);
>
> - WRITE_ONCE(inode->i_state, state | I_FREEING);
> if (!list_empty(&inode->i_lru))
> inode_lru_list_del(inode);
> spin_unlock(&inode->i_lock);
> diff --git a/fs/notify/fsnotify.c b/fs/notify/fsnotify.c
> index 46bfc543f946..cff8417fa6db 100644
> --- a/fs/notify/fsnotify.c
> +++ b/fs/notify/fsnotify.c
> @@ -47,12 +47,12 @@ static void fsnotify_unmount_inodes(struct super_block *sb)
> spin_lock(&sb->s_inode_list_lock);
> list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
> /*
> - * We cannot __iget() an inode in state I_FREEING,
> - * I_WILL_FREE, or I_NEW which is fine because by that point
> + * We cannot __iget() an inode in state I_FREEING
> + * or I_NEW which is fine because by that point
> * the inode cannot have any associated watches.
> */
> spin_lock(&inode->i_lock);
> - if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) {
> + if (inode->i_state & (I_FREEING | I_NEW)) {
> spin_unlock(&inode->i_lock);
> continue;
> }
> diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
> index 14bf440ea4df..29549fc899e9 100644
> --- a/fs/ocfs2/inode.c
> +++ b/fs/ocfs2/inode.c
> @@ -1307,12 +1307,11 @@ int ocfs2_drop_inode(struct inode *inode)
> inode->i_nlink, oi->ip_flags);
>
> assert_spin_locked(&inode->i_lock);
> - inode->i_state |= I_WILL_FREE;
> + inode->i_state |= I_FREEING;
> spin_unlock(&inode->i_lock);
> write_inode_now(inode, 1);
> spin_lock(&inode->i_lock);
> WARN_ON(inode->i_state & I_NEW);
> - inode->i_state &= ~I_WILL_FREE;
>
> return 1;
> }
> diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
> index df4a9b348769..3aa916040602 100644
> --- a/fs/quota/dquot.c
> +++ b/fs/quota/dquot.c
> @@ -1030,7 +1030,7 @@ static int add_dquot_ref(struct super_block *sb, int type)
> spin_lock(&sb->s_inode_list_lock);
> list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
> spin_lock(&inode->i_lock);
> - if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
> + if ((inode->i_state & (I_FREEING | I_NEW)) ||
> !atomic_read(&inode->i_writecount) ||
> !dqinit_needed(inode, type)) {
> spin_unlock(&inode->i_lock);
> diff --git a/fs/xfs/scrub/common.c b/fs/xfs/scrub/common.c
> index 2ef7742be7d3..e678f944206f 100644
> --- a/fs/xfs/scrub/common.c
> +++ b/fs/xfs/scrub/common.c
> @@ -1086,8 +1086,7 @@ xchk_install_handle_inode(
>
> /*
> * Install an already-referenced inode for scrubbing. Get our own reference to
> - * the inode to make disposal simpler. The inode must not be in I_FREEING or
> - * I_WILL_FREE state!
> + * the inode to make disposal simpler. The inode must not have I_FREEING set.
> */
> int
> xchk_install_live_inode(
> diff --git a/include/linux/fs.h b/include/linux/fs.h
> index c4fd010cf5bf..e8ad8f0a03c7 100644
> --- a/include/linux/fs.h
> +++ b/include/linux/fs.h
> @@ -671,8 +671,8 @@ is_uncached_acl(struct posix_acl *acl)
> * I_DIRTY_DATASYNC, I_DIRTY_PAGES, and I_DIRTY_TIME.
> *
> * Four bits define the lifetime of an inode. Initially, inodes are I_NEW,
> - * until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at
> - * various stages of removing an inode.
> + * until that flag is cleared. I_FREEING and I_CLEAR are set at various stages
> + * of removing an inode.
> *
> * Two bits are used for locking and completion notification, I_NEW and I_SYNC.
> *
> @@ -696,24 +696,21 @@ is_uncached_acl(struct posix_acl *acl)
> * New inodes set I_NEW. If two processes both create
> * the same inode, one of them will release its inode and
> * wait for I_NEW to be released before returning.
> - * Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
> - * also cause waiting on I_NEW, without I_NEW actually
> - * being set. find_inode() uses this to prevent returning
> - * nearly-dead inodes.
> - * I_WILL_FREE Must be set when calling write_inode_now() if i_count
> - * is zero. I_FREEING must be set when I_WILL_FREE is
> - * cleared.
> + * Inodes in I_FREEING or I_CLEAR state can also cause
> + * waiting on I_NEW, without I_NEW actually being set.
> + * find_inode() uses this to prevent returning nearly-dead
> + * inodes.
> * I_FREEING Set when inode is about to be freed but still has dirty
> * pages or buffers attached or the inode itself is still
> * dirty.
> * I_CLEAR Added by clear_inode(). In this state the inode is
> * clean and can be destroyed. Inode keeps I_FREEING.
> *
> - * Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
> - * prohibited for many purposes. iget() must wait for
> - * the inode to be completely released, then create it
> - * anew. Other functions will just ignore such inodes,
> - * if appropriate. I_NEW is used for waiting.
> + * Inodes that are I_FREEING or I_CLEAR are prohibited for
> + * many purposes. iget() must wait for the inode to be
> + * completely released, then create it anew. Other
> + * functions will just ignore such inodes, if appropriate.
> + * I_NEW is used for waiting.
> *
> * I_SYNC Writeback of inode is running. The bit is set during
> * data writeback, and cleared with a wakeup on the bit
> @@ -743,8 +740,6 @@ is_uncached_acl(struct posix_acl *acl)
> * I_LRU_ISOLATING Inode is pinned being isolated from LRU without holding
> * i_count.
> *
> - * Q: What is the difference between I_WILL_FREE and I_FREEING?
> - *
> * __I_{SYNC,NEW,LRU_ISOLATING} are used to derive unique addresses to wait
> * upon. There's one free address left.
> */
> @@ -764,7 +759,7 @@ enum inode_state_flags_t {
> I_DIRTY_SYNC = (1U << 4),
> I_DIRTY_DATASYNC = (1U << 5),
> I_DIRTY_PAGES = (1U << 6),
> - I_WILL_FREE = (1U << 7),
> + I_PINNING_NETFS_WB = (1U << 7),
> I_FREEING = (1U << 8),
> I_CLEAR = (1U << 9),
> I_REFERENCED = (1U << 10),
> @@ -775,7 +770,6 @@ enum inode_state_flags_t {
> I_CREATING = (1U << 15),
> I_DONTCACHE = (1U << 16),
> I_SYNC_QUEUED = (1U << 17),
> - I_PINNING_NETFS_WB = (1U << 18)
> };
>
> #define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)
> @@ -2628,7 +2622,7 @@ static inline int icount_read(const struct inode *inode)
> static inline bool inode_is_dirtytime_only(struct inode *inode)
> {
> return (inode->i_state & (I_DIRTY_TIME | I_NEW |
> - I_FREEING | I_WILL_FREE)) == I_DIRTY_TIME;
> + I_FREEING)) == I_DIRTY_TIME;
> }
>
> extern void inc_nlink(struct inode *inode);
> diff --git a/include/trace/events/writeback.h b/include/trace/events/writeback.h
> index 1e23919c0da9..6e3ebecc95e9 100644
> --- a/include/trace/events/writeback.h
> +++ b/include/trace/events/writeback.h
> @@ -15,7 +15,7 @@
> {I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \
> {I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \
> {I_NEW, "I_NEW"}, \
> - {I_WILL_FREE, "I_WILL_FREE"}, \
> + {I_PINNING_NETFS_WB, "I_PINNING_NETFS_WB"}, \
> {I_FREEING, "I_FREEING"}, \
> {I_CLEAR, "I_CLEAR"}, \
> {I_SYNC, "I_SYNC"}, \
> @@ -27,7 +27,6 @@
> {I_CREATING, "I_CREATING"}, \
> {I_DONTCACHE, "I_DONTCACHE"}, \
> {I_SYNC_QUEUED, "I_SYNC_QUEUED"}, \
> - {I_PINNING_NETFS_WB, "I_PINNING_NETFS_WB"}, \
> {I_LRU_ISOLATING, "I_LRU_ISOLATING"} \
> )
>
> diff --git a/security/landlock/fs.c b/security/landlock/fs.c
> index 0bade2c5aa1d..7ffcd62324fa 100644
> --- a/security/landlock/fs.c
> +++ b/security/landlock/fs.c
> @@ -1290,13 +1290,13 @@ static void hook_sb_delete(struct super_block *const sb)
> */
> spin_lock(&inode->i_lock);
> /*
> - * Checks I_FREEING and I_WILL_FREE to protect against a race
> - * condition when release_inode() just called iput(), which
> - * could lead to a NULL dereference of inode->security or a
> - * second call to iput() for the same Landlock object. Also
> - * checks I_NEW because such inode cannot be tied to an object.
> + * Checks I_FREEING to protect against a race condition when
> + * release_inode() just called iput(), which could lead to a
> + * NULL dereference of inode->security or a second call to
> + * iput() for the same Landlock object. Also checks I_NEW
> + * because such inode cannot be tied to an object.
> */
> - if (inode->i_state & (I_FREEING | I_WILL_FREE | I_NEW)) {
> + if (inode->i_state & (I_FREEING | I_NEW)) {
> spin_unlock(&inode->i_lock);
> continue;
> }
> --
> 2.43.0
>
>
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: [WIP RFC PATCH] fs: retire I_WILL_FREE
2025-09-02 14:54 [WIP RFC PATCH] fs: retire I_WILL_FREE Mateusz Guzik
2025-09-03 3:44 ` Matthew Wilcox
@ 2025-09-05 14:07 ` Christian Brauner
1 sibling, 0 replies; 3+ messages in thread
From: Christian Brauner @ 2025-09-05 14:07 UTC (permalink / raw)
To: Mateusz Guzik
Cc: viro, jack, linux-kernel, linux-fsdevel, josef, kernel-team,
amir73il, linux-btrfs, linux-ext4, linux-xfs
> For the life of me I could not figure out if write_inode_now() is legal
> to call in ->evict_inode later and have no means to test, so I devised a
Welcome to our meticulously documented and simultaneously
self-explanatory codebase.
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2025-09-05 14:07 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2025-09-02 14:54 [WIP RFC PATCH] fs: retire I_WILL_FREE Mateusz Guzik
2025-09-03 3:44 ` Matthew Wilcox
2025-09-05 14:07 ` Christian Brauner
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).