Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Manual conversion to use ->i_state accessors of all places not covered by coccinelle

Nothing to look at apart from iput_final().

Signed-off-by: Mateusz Guzik <mjguzik@gmail.com>
Signed-off-by: Christian Brauner <brauner@kernel.org>

authored by

Mateusz Guzik and committed by
Christian Brauner
f5aa78e2 b4dbfd86

+26 -28
+1 -1
Documentation/filesystems/porting.rst
··· 211 211 e.g.:: 212 212 213 213 inode = iget_locked(sb, ino); 214 - if (inode->i_state & I_NEW) { 214 + if (inode_state_read_once(inode) & I_NEW) { 215 215 err = read_inode_from_disk(inode); 216 216 if (err < 0) { 217 217 iget_failed(inode);
+1 -1
fs/afs/inode.c
··· 427 427 struct afs_vnode *vnode = vp->vnode; 428 428 int ret; 429 429 430 - if (vnode->netfs.inode.i_state & I_NEW) { 430 + if (inode_state_read_once(&vnode->netfs.inode) & I_NEW) { 431 431 ret = afs_inode_init_from_status(op, vp, vnode); 432 432 afs_op_set_error(op, ret); 433 433 if (ret == 0)
+5 -5
fs/ext4/inode.c
··· 425 425 if (!S_ISREG(inode->i_mode) || 426 426 IS_NOQUOTA(inode) || IS_VERITY(inode) || 427 427 is_special_ino(inode->i_sb, inode->i_ino) || 428 - (inode->i_state & (I_FREEING | I_WILL_FREE | I_NEW)) || 428 + (inode_state_read_once(inode) & (I_FREEING | I_WILL_FREE | I_NEW)) || 429 429 ext4_test_inode_flag(inode, EXT4_INODE_EA_INODE) || 430 430 ext4_verity_in_progress(inode)) 431 431 return; ··· 3473 3473 /* Any metadata buffers to write? */ 3474 3474 if (!list_empty(&inode->i_mapping->i_private_list)) 3475 3475 return true; 3476 - return inode->i_state & I_DIRTY_DATASYNC; 3476 + return inode_state_read_once(inode) & I_DIRTY_DATASYNC; 3477 3477 } 3478 3478 3479 3479 static void ext4_set_iomap(struct inode *inode, struct iomap *iomap, ··· 4552 4552 * or it's a completely new inode. In those cases we might not 4553 4553 * have i_rwsem locked because it's not necessary. 4554 4554 */ 4555 - if (!(inode->i_state & (I_NEW|I_FREEING))) 4555 + if (!(inode_state_read_once(inode) & (I_NEW | I_FREEING))) 4556 4556 WARN_ON(!inode_is_locked(inode)); 4557 4557 trace_ext4_truncate_enter(inode); 4558 4558 ··· 5210 5210 inode = iget_locked(sb, ino); 5211 5211 if (!inode) 5212 5212 return ERR_PTR(-ENOMEM); 5213 - if (!(inode->i_state & I_NEW)) { 5213 + if (!(inode_state_read_once(inode) & I_NEW)) { 5214 5214 ret = check_igot_inode(inode, flags, function, line); 5215 5215 if (ret) { 5216 5216 iput(inode); ··· 5541 5541 if (inode_is_dirtytime_only(inode)) { 5542 5542 struct ext4_inode_info *ei = EXT4_I(inode); 5543 5543 5544 - inode->i_state &= ~I_DIRTY_TIME; 5544 + inode_state_clear(inode, I_DIRTY_TIME); 5545 5545 spin_unlock(&inode->i_lock); 5546 5546 5547 5547 spin_lock(&ei->i_raw_lock);
+2 -2
fs/ext4/orphan.c
··· 107 107 if (!sbi->s_journal || is_bad_inode(inode)) 108 108 return 0; 109 109 110 - WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) && 110 + WARN_ON_ONCE(!(inode_state_read_once(inode) & (I_NEW | I_FREEING)) && 111 111 !inode_is_locked(inode)); 112 112 if (ext4_inode_orphan_tracked(inode)) 113 113 return 0; ··· 232 232 if (!sbi->s_journal && !(sbi->s_mount_state & EXT4_ORPHAN_FS)) 233 233 return 0; 234 234 235 - WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) && 235 + WARN_ON_ONCE(!(inode_state_read_once(inode) & (I_NEW | I_FREEING)) && 236 236 !inode_is_locked(inode)); 237 237 if (ext4_test_inode_state(inode, EXT4_STATE_ORPHAN_FILE)) 238 238 return ext4_orphan_file_del(handle, inode);
+8 -10
fs/inode.c
··· 829 829 * This also means we don't need any fences for the call below. 830 830 */ 831 831 inode_wake_up_bit(inode, __I_NEW); 832 - BUG_ON(inode->i_state != (I_FREEING | I_CLEAR)); 832 + BUG_ON(inode_state_read_once(inode) != (I_FREEING | I_CLEAR)); 833 833 834 834 destroy_inode(inode); 835 835 } ··· 1883 1883 { 1884 1884 struct super_block *sb = inode->i_sb; 1885 1885 const struct super_operations *op = inode->i_sb->s_op; 1886 - unsigned long state; 1887 1886 int drop; 1888 1887 1889 1888 WARN_ON(inode_state_read(inode) & I_NEW); ··· 1907 1908 */ 1908 1909 VFS_BUG_ON_INODE(atomic_read(&inode->i_count) != 0, inode); 1909 1910 1910 - state = inode_state_read(inode); 1911 - if (!drop) { 1912 - WRITE_ONCE(inode->i_state, state | I_WILL_FREE); 1911 + if (drop) { 1912 + inode_state_set(inode, I_FREEING); 1913 + } else { 1914 + inode_state_set(inode, I_WILL_FREE); 1913 1915 spin_unlock(&inode->i_lock); 1914 1916 1915 1917 write_inode_now(inode, 1); 1916 1918 1917 1919 spin_lock(&inode->i_lock); 1918 - state = inode_state_read(inode); 1919 - WARN_ON(state & I_NEW); 1920 - state &= ~I_WILL_FREE; 1920 + WARN_ON(inode_state_read(inode) & I_NEW); 1921 + inode_state_replace(inode, I_WILL_FREE, I_FREEING); 1921 1922 } 1922 1923 1923 - WRITE_ONCE(inode->i_state, state | I_FREEING); 1924 1924 if (!list_empty(&inode->i_lru)) 1925 1925 inode_lru_list_del(inode); 1926 1926 spin_unlock(&inode->i_lock); ··· 2983 2985 pr_warn("%s encountered for inode %px\n" 2984 2986 "fs %s mode %ho opflags 0x%hx flags 0x%x state 0x%x count %d\n", 2985 2987 reason, inode, sb->s_type->name, inode->i_mode, inode->i_opflags, 2986 - inode->i_flags, inode->i_state, atomic_read(&inode->i_count)); 2988 + inode->i_flags, inode_state_read_once(inode), atomic_read(&inode->i_count)); 2987 2989 } 2988 2990 2989 2991 EXPORT_SYMBOL(dump_inode);
+1 -1
include/linux/backing-dev.h
··· 280 280 * Paired with a release fence in inode_do_switch_wbs() and 281 281 * ensures that we see the new wb if we see cleared I_WB_SWITCH. 282 282 */ 283 - cookie->locked = inode->i_state & I_WB_SWITCH; 283 + cookie->locked = inode_state_read_once(inode) & I_WB_SWITCH; 284 284 smp_rmb(); 285 285 286 286 if (unlikely(cookie->locked))
+3 -3
include/linux/fs.h
··· 1026 1026 static inline void wait_on_inode(struct inode *inode) 1027 1027 { 1028 1028 wait_var_event(inode_state_wait_address(inode, __I_NEW), 1029 - !(READ_ONCE(inode->i_state) & I_NEW)); 1029 + !(inode_state_read_once(inode) & I_NEW)); 1030 1030 /* 1031 1031 * Pairs with routines clearing I_NEW. 1032 1032 */ ··· 2719 2719 */ 2720 2720 static inline bool inode_is_dirtytime_only(struct inode *inode) 2721 2721 { 2722 - return (inode->i_state & (I_DIRTY_TIME | I_NEW | 2723 - I_FREEING | I_WILL_FREE)) == I_DIRTY_TIME; 2722 + return (inode_state_read_once(inode) & 2723 + (I_DIRTY_TIME | I_NEW | I_FREEING | I_WILL_FREE)) == I_DIRTY_TIME; 2724 2724 } 2725 2725 2726 2726 extern void inc_nlink(struct inode *inode);
+1 -1
include/linux/writeback.h
··· 227 227 static inline void inode_detach_wb(struct inode *inode) 228 228 { 229 229 if (inode->i_wb) { 230 - WARN_ON_ONCE(!(inode->i_state & I_CLEAR)); 230 + WARN_ON_ONCE(!(inode_state_read_once(inode) & I_CLEAR)); 231 231 wb_put(inode->i_wb); 232 232 inode->i_wb = NULL; 233 233 }
+4 -4
include/trace/events/writeback.h
··· 120 120 /* may be called for files on pseudo FSes w/ unregistered bdi */ 121 121 strscpy_pad(__entry->name, bdi_dev_name(bdi), 32); 122 122 __entry->ino = inode->i_ino; 123 - __entry->state = inode->i_state; 123 + __entry->state = inode_state_read_once(inode); 124 124 __entry->flags = flags; 125 125 ), 126 126 ··· 748 748 strscpy_pad(__entry->name, 749 749 bdi_dev_name(inode_to_bdi(inode)), 32); 750 750 __entry->ino = inode->i_ino; 751 - __entry->state = inode->i_state; 751 + __entry->state = inode_state_read_once(inode); 752 752 __entry->dirtied_when = inode->dirtied_when; 753 753 __entry->cgroup_ino = __trace_wb_assign_cgroup(inode_to_wb(inode)); 754 754 ), ··· 787 787 strscpy_pad(__entry->name, 788 788 bdi_dev_name(inode_to_bdi(inode)), 32); 789 789 __entry->ino = inode->i_ino; 790 - __entry->state = inode->i_state; 790 + __entry->state = inode_state_read_once(inode); 791 791 __entry->dirtied_when = inode->dirtied_when; 792 792 __entry->writeback_index = inode->i_mapping->writeback_index; 793 793 __entry->nr_to_write = nr_to_write; ··· 839 839 TP_fast_assign( 840 840 __entry->dev = inode->i_sb->s_dev; 841 841 __entry->ino = inode->i_ino; 842 - __entry->state = inode->i_state; 842 + __entry->state = inode_state_read_once(inode); 843 843 __entry->mode = inode->i_mode; 844 844 __entry->dirtied_when = inode->dirtied_when; 845 845 ),