Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
minix: 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-81-jack@suse.cz
Signed-off-by: Christian Brauner <brauner@kernel.org>
authored by
Jan Kara
and committed by
Christian Brauner
caaa184b
d0874a58
+24
-8
+1
-1
fs/minix/dir.c
+1
-1
fs/minix/dir.c
+9
-1
fs/minix/file.c
+9
-1
fs/minix/file.c
···
7
7
* minix regular file handling primitives
8
8
*/
9
9
10
+
#include <linux/buffer_head.h>
10
11
#include "minix.h"
12
+
13
+
int minix_fsync(struct file *file, loff_t start, loff_t end, int datasync)
14
+
{
15
+
return mmb_fsync(file,
16
+
&minix_i(file->f_mapping->host)->i_metadata_bhs,
17
+
start, end, datasync);
18
+
}
11
19
12
20
/*
13
21
* We have mostly NULLs here: the current defaults are OK for
···
26
18
.read_iter = generic_file_read_iter,
27
19
.write_iter = generic_file_write_iter,
28
20
.mmap_prepare = generic_file_mmap_prepare,
29
-
.fsync = generic_buffers_fsync,
21
+
.fsync = minix_fsync,
30
22
.splice_read = filemap_splice_read,
31
23
};
32
24
+4
-2
fs/minix/inode.c
+4
-2
fs/minix/inode.c
···
49
49
inode->i_size = 0;
50
50
minix_truncate(inode);
51
51
} else {
52
-
sync_mapping_buffers(&inode->i_data);
52
+
mmb_sync(&minix_i(inode)->i_metadata_bhs);
53
53
}
54
-
invalidate_inode_buffers(inode);
54
+
mmb_invalidate(&minix_i(inode)->i_metadata_bhs);
55
55
clear_inode(inode);
56
56
if (!inode->i_nlink)
57
57
minix_free_inode(inode);
···
85
85
ei = alloc_inode_sb(sb, minix_inode_cachep, GFP_KERNEL);
86
86
if (!ei)
87
87
return NULL;
88
+
mmb_init(&ei->i_metadata_bhs, &ei->vfs_inode.i_data);
89
+
88
90
return &ei->vfs_inode;
89
91
}
90
92
+7
-4
fs/minix/itree_common.c
+7
-4
fs/minix/itree_common.c
···
98
98
*branch[n].p = branch[n].key;
99
99
set_buffer_uptodate(bh);
100
100
unlock_buffer(bh);
101
-
mark_buffer_dirty_inode(bh, inode);
101
+
mmb_mark_buffer_dirty(bh, &minix_i(inode)->i_metadata_bhs);
102
102
parent = nr;
103
103
}
104
104
if (n == num)
···
135
135
136
136
/* had we spliced it onto indirect block? */
137
137
if (where->bh)
138
-
mark_buffer_dirty_inode(where->bh, inode);
138
+
mmb_mark_buffer_dirty(where->bh,
139
+
&minix_i(inode)->i_metadata_bhs);
139
140
140
141
mark_inode_dirty(inode);
141
142
return 0;
···
329
328
if (partial == chain)
330
329
mark_inode_dirty(inode);
331
330
else
332
-
mark_buffer_dirty_inode(partial->bh, inode);
331
+
mmb_mark_buffer_dirty(partial->bh,
332
+
&minix_i(inode)->i_metadata_bhs);
333
333
free_branches(inode, &nr, &nr+1, (chain+n-1) - partial);
334
334
}
335
335
/* Clear the ends of indirect blocks on the shared branch */
336
336
while (partial > chain) {
337
337
free_branches(inode, partial->p + 1, block_end(partial->bh),
338
338
(chain+n-1) - partial);
339
-
mark_buffer_dirty_inode(partial->bh, inode);
339
+
mmb_mark_buffer_dirty(partial->bh,
340
+
&minix_i(inode)->i_metadata_bhs);
340
341
brelse (partial->bh);
341
342
partial--;
342
343
}
+3
fs/minix/minix.h
+3
fs/minix/minix.h
···
19
19
__u16 i1_data[16];
20
20
__u32 i2_data[16];
21
21
} u;
22
+
struct mapping_metadata_bhs i_metadata_bhs;
22
23
struct inode vfs_inode;
23
24
};
24
25
···
58
57
int minix_getattr(struct mnt_idmap *, const struct path *,
59
58
struct kstat *, u32, unsigned int);
60
59
int minix_prepare_chunk(struct folio *folio, loff_t pos, unsigned len);
60
+
struct mapping_metadata_bhs *minix_get_metadata_bhs(struct inode *inode);
61
+
int minix_fsync(struct file *file, loff_t start, loff_t end, int datasync);
61
62
62
63
extern void V1_minix_truncate(struct inode *);
63
64
extern void V2_minix_truncate(struct inode *);