Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
affs: Track metadata bhs in fs-private inode part
Track metadata bhs for an inode in fs-private part of the inode.
Signed-off-by: Jan Kara <jack@suse.cz>
Link: https://patch.msgid.link/20260326095354.16340-77-jack@suse.cz
Signed-off-by: Christian Brauner <brauner@kernel.org>
authored by
Jan Kara
and committed by
Christian Brauner
6874973e
b0439bbc
+35
-28
+2
fs/affs/affs.h
+2
fs/affs/affs.h
···
44
44
struct mutex i_link_lock; /* Protects internal inode access. */
45
45
struct mutex i_ext_lock; /* Protects internal inode access. */
46
46
#define i_hash_lock i_ext_lock
47
+
struct mapping_metadata_bhs i_metadata_bhs;
47
48
u32 i_blkcnt; /* block count */
48
49
u32 i_extcnt; /* extended block count */
49
50
u32 *i_lc; /* linear cache of extended blocks */
···
152
151
extern int affs_check_name(const unsigned char *name, int len,
153
152
bool notruncate);
154
153
extern int affs_copy_name(unsigned char *bstr, struct dentry *dentry);
154
+
struct mapping_metadata_bhs *affs_get_metadata_bhs(struct inode *inode);
155
155
156
156
/* bitmap. c */
157
157
+6
-6
fs/affs/amigaffs.c
+6
-6
fs/affs/amigaffs.c
···
57
57
AFFS_TAIL(sb, dir_bh)->hash_chain = cpu_to_be32(ino);
58
58
59
59
affs_adjust_checksum(dir_bh, ino);
60
-
mark_buffer_dirty_inode(dir_bh, dir);
60
+
mmb_mark_buffer_dirty(dir_bh, &AFFS_I(dir)->i_metadata_bhs);
61
61
affs_brelse(dir_bh);
62
62
63
63
inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
···
100
100
else
101
101
AFFS_TAIL(sb, bh)->hash_chain = ino;
102
102
affs_adjust_checksum(bh, be32_to_cpu(ino) - hash_ino);
103
-
mark_buffer_dirty_inode(bh, dir);
103
+
mmb_mark_buffer_dirty(bh, &AFFS_I(dir)->i_metadata_bhs);
104
104
AFFS_TAIL(sb, rem_bh)->parent = 0;
105
105
retval = 0;
106
106
break;
···
180
180
affs_unlock_dir(dir);
181
181
goto done;
182
182
}
183
-
mark_buffer_dirty_inode(link_bh, inode);
183
+
mmb_mark_buffer_dirty(link_bh, &AFFS_I(inode)->i_metadata_bhs);
184
184
185
185
memcpy(AFFS_TAIL(sb, bh)->name, AFFS_TAIL(sb, link_bh)->name, 32);
186
186
retval = affs_insert_hash(dir, bh);
···
188
188
affs_unlock_dir(dir);
189
189
goto done;
190
190
}
191
-
mark_buffer_dirty_inode(bh, inode);
191
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
192
192
193
193
affs_unlock_dir(dir);
194
194
iput(dir);
···
203
203
__be32 ino2 = AFFS_TAIL(sb, link_bh)->link_chain;
204
204
AFFS_TAIL(sb, bh)->link_chain = ino2;
205
205
affs_adjust_checksum(bh, be32_to_cpu(ino2) - link_ino);
206
-
mark_buffer_dirty_inode(bh, inode);
206
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
207
207
retval = 0;
208
208
/* Fix the link count, if bh is a normal header block without links */
209
209
switch (be32_to_cpu(AFFS_TAIL(sb, bh)->stype)) {
···
306
306
retval = affs_remove_hash(dir, bh);
307
307
if (retval)
308
308
goto done_unlock;
309
-
mark_buffer_dirty_inode(bh, inode);
309
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
310
310
311
311
affs_unlock_dir(dir);
312
312
+14
-11
fs/affs/file.c
+14
-11
fs/affs/file.c
···
140
140
AFFS_TAIL(sb, new_bh)->parent = cpu_to_be32(inode->i_ino);
141
141
affs_fix_checksum(sb, new_bh);
142
142
143
-
mark_buffer_dirty_inode(new_bh, inode);
143
+
mmb_mark_buffer_dirty(new_bh, &AFFS_I(inode)->i_metadata_bhs);
144
144
145
145
tmp = be32_to_cpu(AFFS_TAIL(sb, bh)->extension);
146
146
if (tmp)
147
147
affs_warning(sb, "alloc_ext", "previous extension set (%x)", tmp);
148
148
AFFS_TAIL(sb, bh)->extension = cpu_to_be32(blocknr);
149
149
affs_adjust_checksum(bh, blocknr - tmp);
150
-
mark_buffer_dirty_inode(bh, inode);
150
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
151
151
152
152
AFFS_I(inode)->i_extcnt++;
153
153
mark_inode_dirty(inode);
···
581
581
memset(AFFS_DATA(bh) + boff, 0, tmp);
582
582
be32_add_cpu(&AFFS_DATA_HEAD(bh)->size, tmp);
583
583
affs_fix_checksum(sb, bh);
584
-
mark_buffer_dirty_inode(bh, inode);
584
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
585
585
size += tmp;
586
586
bidx++;
587
587
} else if (bidx) {
···
603
603
AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp);
604
604
affs_fix_checksum(sb, bh);
605
605
bh->b_state &= ~(1UL << BH_New);
606
-
mark_buffer_dirty_inode(bh, inode);
606
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
607
607
if (prev_bh) {
608
608
u32 tmp_next = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next);
609
609
···
613
613
bidx, tmp_next);
614
614
AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr);
615
615
affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp_next);
616
-
mark_buffer_dirty_inode(prev_bh, inode);
616
+
mmb_mark_buffer_dirty(prev_bh,
617
+
&AFFS_I(inode)->i_metadata_bhs);
617
618
affs_brelse(prev_bh);
618
619
}
619
620
size += bsize;
···
733
732
AFFS_DATA_HEAD(bh)->size = cpu_to_be32(
734
733
max(boff + tmp, be32_to_cpu(AFFS_DATA_HEAD(bh)->size)));
735
734
affs_fix_checksum(sb, bh);
736
-
mark_buffer_dirty_inode(bh, inode);
735
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
737
736
written += tmp;
738
737
from += tmp;
739
738
bidx++;
···
766
765
bidx, tmp_next);
767
766
AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr);
768
767
affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp_next);
769
-
mark_buffer_dirty_inode(prev_bh, inode);
768
+
mmb_mark_buffer_dirty(prev_bh,
769
+
&AFFS_I(inode)->i_metadata_bhs);
770
770
}
771
771
}
772
772
affs_brelse(prev_bh);
773
773
affs_fix_checksum(sb, bh);
774
-
mark_buffer_dirty_inode(bh, inode);
774
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
775
775
written += bsize;
776
776
from += bsize;
777
777
bidx++;
···
801
799
bidx, tmp_next);
802
800
AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr);
803
801
affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp_next);
804
-
mark_buffer_dirty_inode(prev_bh, inode);
802
+
mmb_mark_buffer_dirty(prev_bh,
803
+
&AFFS_I(inode)->i_metadata_bhs);
805
804
}
806
805
} else if (be32_to_cpu(AFFS_DATA_HEAD(bh)->size) < tmp)
807
806
AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp);
808
807
affs_brelse(prev_bh);
809
808
affs_fix_checksum(sb, bh);
810
-
mark_buffer_dirty_inode(bh, inode);
809
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
811
810
written += tmp;
812
811
from += tmp;
813
812
bidx++;
···
945
942
}
946
943
AFFS_TAIL(sb, ext_bh)->extension = 0;
947
944
affs_fix_checksum(sb, ext_bh);
948
-
mark_buffer_dirty_inode(ext_bh, inode);
945
+
mmb_mark_buffer_dirty(ext_bh, &AFFS_I(inode)->i_metadata_bhs);
949
946
affs_brelse(ext_bh);
950
947
951
948
if (inode->i_size) {
+7
-7
fs/affs/inode.c
+7
-7
fs/affs/inode.c
···
206
206
}
207
207
}
208
208
affs_fix_checksum(sb, bh);
209
-
mark_buffer_dirty_inode(bh, inode);
209
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
210
210
affs_brelse(bh);
211
211
affs_free_prealloc(inode);
212
212
return 0;
···
268
268
inode->i_size = 0;
269
269
affs_truncate(inode);
270
270
} else {
271
-
sync_mapping_buffers(&inode->i_data);
271
+
mmb_sync(&AFFS_I(inode)->i_metadata_bhs);
272
272
}
273
273
274
-
invalidate_inode_buffers(inode);
274
+
mmb_invalidate(&AFFS_I(inode)->i_metadata_bhs);
275
275
clear_inode(inode);
276
276
affs_free_prealloc(inode);
277
277
cache_page = (unsigned long)AFFS_I(inode)->i_lc;
···
306
306
bh = affs_getzeroblk(sb, block);
307
307
if (!bh)
308
308
goto err_bh;
309
-
mark_buffer_dirty_inode(bh, inode);
309
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
310
310
affs_brelse(bh);
311
311
312
312
inode->i_uid = current_fsuid();
···
394
394
AFFS_TAIL(sb, bh)->link_chain = chain;
395
395
AFFS_TAIL(sb, inode_bh)->link_chain = cpu_to_be32(block);
396
396
affs_adjust_checksum(inode_bh, block - be32_to_cpu(chain));
397
-
mark_buffer_dirty_inode(inode_bh, inode);
397
+
mmb_mark_buffer_dirty(inode_bh, &AFFS_I(inode)->i_metadata_bhs);
398
398
set_nlink(inode, 2);
399
399
ihold(inode);
400
400
}
401
401
affs_fix_checksum(sb, bh);
402
-
mark_buffer_dirty_inode(bh, inode);
402
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
403
403
dentry->d_fsdata = (void *)(long)bh->b_blocknr;
404
404
405
405
affs_lock_dir(dir);
406
406
retval = affs_insert_hash(dir, bh);
407
-
mark_buffer_dirty_inode(bh, inode);
407
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
408
408
affs_unlock_dir(dir);
409
409
affs_unlock_link(inode);
410
410
+5
-4
fs/affs/namei.c
+5
-4
fs/affs/namei.c
···
373
373
}
374
374
*p = 0;
375
375
inode->i_size = i + 1;
376
-
mark_buffer_dirty_inode(bh, inode);
376
+
mmb_mark_buffer_dirty(bh, &AFFS_I(inode)->i_metadata_bhs);
377
377
affs_brelse(bh);
378
378
mark_inode_dirty(inode);
379
379
···
443
443
/* TODO: move it back to old_dir, if error? */
444
444
445
445
done:
446
-
mark_buffer_dirty_inode(bh, retval ? old_dir : new_dir);
446
+
mmb_mark_buffer_dirty(bh,
447
+
&AFFS_I(retval ? old_dir : new_dir)->i_metadata_bhs);
447
448
affs_brelse(bh);
448
449
return retval;
449
450
}
···
497
496
retval = affs_insert_hash(old_dir, bh_new);
498
497
affs_unlock_dir(old_dir);
499
498
done:
500
-
mark_buffer_dirty_inode(bh_old, new_dir);
501
-
mark_buffer_dirty_inode(bh_new, old_dir);
499
+
mmb_mark_buffer_dirty(bh_old, &AFFS_I(new_dir)->i_metadata_bhs);
500
+
mmb_mark_buffer_dirty(bh_new, &AFFS_I(old_dir)->i_metadata_bhs);
502
501
affs_brelse(bh_old);
503
502
affs_brelse(bh_new);
504
503
return retval;