]> git.ipfire.org Git - thirdparty/kernel/stable.git/commitdiff
fs: make the i_state flags an enum
authorJosef Bacik <josef@toxicpanda.com>
Tue, 26 Aug 2025 15:39:01 +0000 (11:39 -0400)
committerChristian Brauner <brauner@kernel.org>
Fri, 29 Aug 2025 13:00:30 +0000 (15:00 +0200)
Adjusting i_state flags always means updating the values manually. Bring
these forward into the 2020's and make a nice clean macro for defining
the i_state values as an enum, providing __ variants for the cases where
we need the bit position instead of the actual value, and leaving the
actual NAME as the 1U << bit value.

Reviewed-by: Christian Brauner <brauner@kernel.org>
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Link: https://lore.kernel.org/0da9348da6ece0dce12fccec07b1dd2b8e4cfdab.1756222464.git.josef@toxicpanda.com
Signed-off-by: Christian Brauner <brauner@kernel.org>
include/linux/fs.h

index 12ecc6b0e6f96be1aab855cab51ebd9a657f1be9..c34554d8c4feb98e93ebee1319c9da8fac76f371 100644 (file)
@@ -664,6 +664,124 @@ is_uncached_acl(struct posix_acl *acl)
 #define IOP_MGTIME     0x0020
 #define IOP_CACHED_LINK        0x0040
 
+/*
+ * Inode state bits.  Protected by inode->i_lock
+ *
+ * Four bits determine the dirty state of the inode: I_DIRTY_SYNC,
+ * 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.
+ *
+ * Two bits are used for locking and completion notification, I_NEW and I_SYNC.
+ *
+ * I_DIRTY_SYNC                Inode is dirty, but doesn't have to be written on
+ *                     fdatasync() (unless I_DIRTY_DATASYNC is also set).
+ *                     Timestamp updates are the usual cause.
+ * I_DIRTY_DATASYNC    Data-related inode changes pending.  We keep track of
+ *                     these changes separately from I_DIRTY_SYNC so that we
+ *                     don't have to write inode on fdatasync() when only
+ *                     e.g. the timestamps have changed.
+ * I_DIRTY_PAGES       Inode has dirty pages.  Inode itself may be clean.
+ * I_DIRTY_TIME                The inode itself has dirty timestamps, and the
+ *                     lazytime mount option is enabled.  We keep track of this
+ *                     separately from I_DIRTY_SYNC in order to implement
+ *                     lazytime.  This gets cleared if I_DIRTY_INODE
+ *                     (I_DIRTY_SYNC and/or I_DIRTY_DATASYNC) gets set. But
+ *                     I_DIRTY_TIME can still be set if I_DIRTY_SYNC is already
+ *                     in place because writeback might already be in progress
+ *                     and we don't want to lose the time update
+ * I_NEW               Serves as both a mutex and completion notification.
+ *                     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.
+ * 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.
+ *
+ * I_SYNC              Writeback of inode is running. The bit is set during
+ *                     data writeback, and cleared with a wakeup on the bit
+ *                     address once it is done. The bit is also used to pin
+ *                     the inode in memory for flusher thread.
+ *
+ * I_REFERENCED                Marks the inode as recently references on the LRU list.
+ *
+ * I_WB_SWITCH         Cgroup bdi_writeback switching in progress.  Used to
+ *                     synchronize competing switching instances and to tell
+ *                     wb stat updates to grab the i_pages lock.  See
+ *                     inode_switch_wbs_work_fn() for details.
+ *
+ * I_OVL_INUSE         Used by overlayfs to get exclusive ownership on upper
+ *                     and work dirs among overlayfs mounts.
+ *
+ * I_CREATING          New object's inode in the middle of setting up.
+ *
+ * I_DONTCACHE         Evict inode as soon as it is not used anymore.
+ *
+ * I_SYNC_QUEUED       Inode is queued in b_io or b_more_io writeback lists.
+ *                     Used to detect that mark_inode_dirty() should not move
+ *                     inode between dirty lists.
+ *
+ * I_PINNING_FSCACHE_WB        Inode is pinning an fscache object for writeback.
+ *
+ * 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.
+ */
+
+enum inode_state_bits {
+       __I_NEW                 = 0U,
+       __I_SYNC                = 1U,
+       __I_LRU_ISOLATING       = 2U
+       /* reserved wait address bit 3 */
+};
+
+enum inode_state_flags_t {
+       I_NEW                   = (1U << __I_NEW),
+       I_SYNC                  = (1U << __I_SYNC),
+       I_LRU_ISOLATING         = (1U << __I_LRU_ISOLATING),
+       /* reserved flag bit 3 */
+       I_DIRTY_SYNC            = (1U << 4),
+       I_DIRTY_DATASYNC        = (1U << 5),
+       I_DIRTY_PAGES           = (1U << 6),
+       I_WILL_FREE             = (1U << 7),
+       I_FREEING               = (1U << 8),
+       I_CLEAR                 = (1U << 9),
+       I_REFERENCED            = (1U << 10),
+       I_LINKABLE              = (1U << 11),
+       I_DIRTY_TIME            = (1U << 12),
+       I_WB_SWITCH             = (1U << 13),
+       I_OVL_INUSE             = (1U << 14),
+       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)
+#define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES)
+#define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME)
+
 /*
  * Keep mostly read-only and often accessed (especially for
  * the RCU path lookup and 'stat' data) fields at the beginning
@@ -722,7 +840,7 @@ struct inode {
 #endif
 
        /* Misc */
-       u32                     i_state;
+       enum inode_state_flags_t        i_state;
        /* 32-bit hole */
        struct rw_semaphore     i_rwsem;
 
@@ -2482,117 +2600,6 @@ static inline void kiocb_clone(struct kiocb *kiocb, struct kiocb *kiocb_src,
        };
 }
 
-/*
- * Inode state bits.  Protected by inode->i_lock
- *
- * Four bits determine the dirty state of the inode: I_DIRTY_SYNC,
- * 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.
- *
- * Two bits are used for locking and completion notification, I_NEW and I_SYNC.
- *
- * I_DIRTY_SYNC                Inode is dirty, but doesn't have to be written on
- *                     fdatasync() (unless I_DIRTY_DATASYNC is also set).
- *                     Timestamp updates are the usual cause.
- * I_DIRTY_DATASYNC    Data-related inode changes pending.  We keep track of
- *                     these changes separately from I_DIRTY_SYNC so that we
- *                     don't have to write inode on fdatasync() when only
- *                     e.g. the timestamps have changed.
- * I_DIRTY_PAGES       Inode has dirty pages.  Inode itself may be clean.
- * I_DIRTY_TIME                The inode itself has dirty timestamps, and the
- *                     lazytime mount option is enabled.  We keep track of this
- *                     separately from I_DIRTY_SYNC in order to implement
- *                     lazytime.  This gets cleared if I_DIRTY_INODE
- *                     (I_DIRTY_SYNC and/or I_DIRTY_DATASYNC) gets set. But
- *                     I_DIRTY_TIME can still be set if I_DIRTY_SYNC is already
- *                     in place because writeback might already be in progress
- *                     and we don't want to lose the time update
- * I_NEW               Serves as both a mutex and completion notification.
- *                     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.
- * 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.
- *
- * I_SYNC              Writeback of inode is running. The bit is set during
- *                     data writeback, and cleared with a wakeup on the bit
- *                     address once it is done. The bit is also used to pin
- *                     the inode in memory for flusher thread.
- *
- * I_REFERENCED                Marks the inode as recently references on the LRU list.
- *
- * I_WB_SWITCH         Cgroup bdi_writeback switching in progress.  Used to
- *                     synchronize competing switching instances and to tell
- *                     wb stat updates to grab the i_pages lock.  See
- *                     inode_switch_wbs_work_fn() for details.
- *
- * I_OVL_INUSE         Used by overlayfs to get exclusive ownership on upper
- *                     and work dirs among overlayfs mounts.
- *
- * I_CREATING          New object's inode in the middle of setting up.
- *
- * I_DONTCACHE         Evict inode as soon as it is not used anymore.
- *
- * I_SYNC_QUEUED       Inode is queued in b_io or b_more_io writeback lists.
- *                     Used to detect that mark_inode_dirty() should not move
- *                     inode between dirty lists.
- *
- * I_PINNING_FSCACHE_WB        Inode is pinning an fscache object for writeback.
- *
- * 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.
- */
-#define __I_NEW                        0
-#define I_NEW                  (1 << __I_NEW)
-#define __I_SYNC               1
-#define I_SYNC                 (1 << __I_SYNC)
-#define __I_LRU_ISOLATING      2
-#define I_LRU_ISOLATING                (1 << __I_LRU_ISOLATING)
-
-#define I_DIRTY_SYNC           (1 << 3)
-#define I_DIRTY_DATASYNC       (1 << 4)
-#define I_DIRTY_PAGES          (1 << 5)
-#define I_WILL_FREE            (1 << 6)
-#define I_FREEING              (1 << 7)
-#define I_CLEAR                        (1 << 8)
-#define I_REFERENCED           (1 << 9)
-#define I_LINKABLE             (1 << 10)
-#define I_DIRTY_TIME           (1 << 11)
-#define I_WB_SWITCH            (1 << 12)
-#define I_OVL_INUSE            (1 << 13)
-#define I_CREATING             (1 << 14)
-#define I_DONTCACHE            (1 << 15)
-#define I_SYNC_QUEUED          (1 << 16)
-#define I_PINNING_NETFS_WB     (1 << 17)
-
-#define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)
-#define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES)
-#define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME)
-
 extern void __mark_inode_dirty(struct inode *, int);
 static inline void mark_inode_dirty(struct inode *inode)
 {