Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
+1
-1
Documentation/filesystems/porting.rst
+1
-1
fs/afs/inode.c
+1
-1
fs/afs/inode.c
+5
-5
fs/ext4/inode.c
+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
+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
+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
+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
+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
+1
-1
include/linux/writeback.h
+4
-4
include/trace/events/writeback.h
+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
),