tjh.dev / kernel
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.

fat: 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-79-jack@suse.cz
Signed-off-by: Christian Brauner <brauner@kernel.org>

authored by

Jan Kara and committed by
Christian Brauner 43995984 b0806ac0

+34 -20
+10 -7
fs/fat/dir.c
··· 1027 1027 de++; 1028 1028 nr_slots--; 1029 1029 } 1030 - mark_buffer_dirty_inode(bh, dir); 1030 + mmb_mark_buffer_dirty(bh, &MSDOS_I(dir)->i_metadata_bhs); 1031 1031 if (IS_DIRSYNC(dir)) 1032 1032 err = sync_dirty_buffer(bh); 1033 1033 brelse(bh); ··· 1062 1062 de--; 1063 1063 nr_slots--; 1064 1064 } 1065 - mark_buffer_dirty_inode(bh, dir); 1065 + mmb_mark_buffer_dirty(bh, &MSDOS_I(dir)->i_metadata_bhs); 1066 1066 if (IS_DIRSYNC(dir)) 1067 1067 err = sync_dirty_buffer(bh); 1068 1068 brelse(bh); ··· 1114 1114 memset(bhs[n]->b_data, 0, sb->s_blocksize); 1115 1115 set_buffer_uptodate(bhs[n]); 1116 1116 unlock_buffer(bhs[n]); 1117 - mark_buffer_dirty_inode(bhs[n], dir); 1117 + mmb_mark_buffer_dirty(bhs[n], &MSDOS_I(dir)->i_metadata_bhs); 1118 1118 1119 1119 n++; 1120 1120 blknr++; ··· 1195 1195 memset(de + 2, 0, sb->s_blocksize - 2 * sizeof(*de)); 1196 1196 set_buffer_uptodate(bhs[0]); 1197 1197 unlock_buffer(bhs[0]); 1198 - mark_buffer_dirty_inode(bhs[0], dir); 1198 + mmb_mark_buffer_dirty(bhs[0], &MSDOS_I(dir)->i_metadata_bhs); 1199 1199 1200 1200 err = fat_zeroed_cluster(dir, blknr, 1, bhs, MAX_BUF_PER_PAGE); 1201 1201 if (err) ··· 1257 1257 memcpy(bhs[n]->b_data, slots, copy); 1258 1258 set_buffer_uptodate(bhs[n]); 1259 1259 unlock_buffer(bhs[n]); 1260 - mark_buffer_dirty_inode(bhs[n], dir); 1260 + mmb_mark_buffer_dirty(bhs[n], 1261 + &MSDOS_I(dir)->i_metadata_bhs); 1261 1262 slots += copy; 1262 1263 size -= copy; 1263 1264 if (!size) ··· 1359 1358 for (i = 0; i < long_bhs; i++) { 1360 1359 int copy = umin(sb->s_blocksize - offset, size); 1361 1360 memcpy(bhs[i]->b_data + offset, slots, copy); 1362 - mark_buffer_dirty_inode(bhs[i], dir); 1361 + mmb_mark_buffer_dirty(bhs[i], 1362 + &MSDOS_I(dir)->i_metadata_bhs); 1363 1363 offset = 0; 1364 1364 slots += copy; 1365 1365 size -= copy; ··· 1371 1369 /* Fill the short name slot. */ 1372 1370 int copy = umin(sb->s_blocksize - offset, size); 1373 1371 memcpy(bhs[i]->b_data + offset, slots, copy); 1374 - mark_buffer_dirty_inode(bhs[i], dir); 1372 + mmb_mark_buffer_dirty(bhs[i], 1373 + &MSDOS_I(dir)->i_metadata_bhs); 1375 1374 if (IS_DIRSYNC(dir)) 1376 1375 err = sync_dirty_buffer(bhs[i]); 1377 1376 }
+1
fs/fat/fat.h
··· 130 130 struct hlist_node i_dir_hash; /* hash by i_logstart */ 131 131 struct rw_semaphore truncate_lock; /* protect bmap against truncate */ 132 132 struct timespec64 i_crtime; /* File creation (birth) time */ 133 + struct mapping_metadata_bhs i_metadata_bhs; 133 134 struct inode vfs_inode; 134 135 }; 135 136
+10 -5
fs/fat/fatent.c
··· 170 170 } 171 171 spin_unlock(&fat12_entry_lock); 172 172 173 - mark_buffer_dirty_inode(fatent->bhs[0], fatent->fat_inode); 173 + mmb_mark_buffer_dirty(fatent->bhs[0], 174 + &MSDOS_I(fatent->fat_inode)->i_metadata_bhs); 174 175 if (fatent->nr_bhs == 2) 175 - mark_buffer_dirty_inode(fatent->bhs[1], fatent->fat_inode); 176 + mmb_mark_buffer_dirty(fatent->bhs[1], 177 + &MSDOS_I(fatent->fat_inode)->i_metadata_bhs); 176 178 } 177 179 178 180 static void fat16_ent_put(struct fat_entry *fatent, int new) ··· 183 181 new = EOF_FAT16; 184 182 185 183 *fatent->u.ent16_p = cpu_to_le16(new); 186 - mark_buffer_dirty_inode(fatent->bhs[0], fatent->fat_inode); 184 + mmb_mark_buffer_dirty(fatent->bhs[0], 185 + &MSDOS_I(fatent->fat_inode)->i_metadata_bhs); 187 186 } 188 187 189 188 static void fat32_ent_put(struct fat_entry *fatent, int new) ··· 192 189 WARN_ON(new & 0xf0000000); 193 190 new |= le32_to_cpu(*fatent->u.ent32_p) & ~0x0fffffff; 194 191 *fatent->u.ent32_p = cpu_to_le32(new); 195 - mark_buffer_dirty_inode(fatent->bhs[0], fatent->fat_inode); 192 + mmb_mark_buffer_dirty(fatent->bhs[0], 193 + &MSDOS_I(fatent->fat_inode)->i_metadata_bhs); 196 194 } 197 195 198 196 static int fat12_ent_next(struct fat_entry *fatent) ··· 399 395 memcpy(c_bh->b_data, bhs[n]->b_data, sb->s_blocksize); 400 396 set_buffer_uptodate(c_bh); 401 397 unlock_buffer(c_bh); 402 - mark_buffer_dirty_inode(c_bh, sbi->fat_inode); 398 + mmb_mark_buffer_dirty(c_bh, 399 + &MSDOS_I(sbi->fat_inode)->i_metadata_bhs); 403 400 if (sb->s_flags & SB_SYNCHRONOUS) 404 401 err = sync_dirty_buffer(c_bh); 405 402 brelse(c_bh);
+5 -3
fs/fat/file.c
··· 186 186 int fat_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync) 187 187 { 188 188 struct inode *inode = filp->f_mapping->host; 189 + struct inode *fat_inode = MSDOS_SB(inode->i_sb)->fat_inode; 189 190 int err; 190 191 191 - err = generic_buffers_fsync_noflush(filp, start, end, datasync); 192 + err = mmb_fsync_noflush(filp, &MSDOS_I(inode)->i_metadata_bhs, 193 + start, end, datasync); 192 194 if (err) 193 195 return err; 194 196 195 - err = sync_mapping_buffers(MSDOS_SB(inode->i_sb)->fat_inode->i_mapping); 197 + err = mmb_sync(&MSDOS_I(fat_inode)->i_metadata_bhs); 196 198 if (err) 197 199 return err; 198 200 ··· 238 236 */ 239 237 err = filemap_fdatawrite_range(mapping, start, 240 238 start + count - 1); 241 - err2 = sync_mapping_buffers(mapping); 239 + err2 = mmb_sync(&MSDOS_I(inode)->i_metadata_bhs); 242 240 if (!err) 243 241 err = err2; 244 242 err2 = write_inode_now(inode, 1);
+3 -2
fs/fat/inode.c
··· 658 658 inode->i_size = 0; 659 659 fat_truncate_blocks(inode, 0); 660 660 } else { 661 - sync_mapping_buffers(inode->i_mapping); 661 + mmb_sync(&MSDOS_I(inode)->i_metadata_bhs); 662 662 fat_free_eofblocks(inode); 663 663 } 664 664 665 - invalidate_inode_buffers(inode); 665 + mmb_invalidate(&MSDOS_I(inode)->i_metadata_bhs); 666 666 clear_inode(inode); 667 667 fat_cache_inval_inode(inode); 668 668 fat_detach(inode); ··· 763 763 ei->i_pos = 0; 764 764 ei->i_crtime.tv_sec = 0; 765 765 ei->i_crtime.tv_nsec = 0; 766 + mmb_init(&ei->i_metadata_bhs, &ei->vfs_inode.i_data); 766 767 767 768 return &ei->vfs_inode; 768 769 }
+4 -2
fs/fat/namei_msdos.c
··· 527 527 528 528 if (update_dotdot) { 529 529 fat_set_start(dotdot_de, MSDOS_I(new_dir)->i_logstart); 530 - mark_buffer_dirty_inode(dotdot_bh, old_inode); 530 + mmb_mark_buffer_dirty(dotdot_bh, 531 + &MSDOS_I(old_inode)->i_metadata_bhs); 531 532 if (IS_DIRSYNC(new_dir)) { 532 533 err = sync_dirty_buffer(dotdot_bh); 533 534 if (err) ··· 567 566 568 567 if (update_dotdot) { 569 568 fat_set_start(dotdot_de, MSDOS_I(old_dir)->i_logstart); 570 - mark_buffer_dirty_inode(dotdot_bh, old_inode); 569 + mmb_mark_buffer_dirty(dotdot_bh, 570 + &MSDOS_I(old_inode)->i_metadata_bhs); 571 571 corrupt |= sync_dirty_buffer(dotdot_bh); 572 572 } 573 573 error_inode:
+1 -1
fs/fat/namei_vfat.c
··· 915 915 struct msdos_dir_entry *dotdot_de) 916 916 { 917 917 fat_set_start(dotdot_de, MSDOS_I(dir)->i_logstart); 918 - mark_buffer_dirty_inode(dotdot_bh, inode); 918 + mmb_mark_buffer_dirty(dotdot_bh, &MSDOS_I(inode)->i_metadata_bhs); 919 919 if (IS_DIRSYNC(dir)) 920 920 return sync_dirty_buffer(dotdot_bh); 921 921 return 0;