1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * linux/fs/ext4/fsync.c |
4 | * |
5 | * Copyright (C) 1993 Stephen Tweedie (sct@redhat.com) |
6 | * from |
7 | * Copyright (C) 1992 Remy Card (card@masi.ibp.fr) |
8 | * Laboratoire MASI - Institut Blaise Pascal |
9 | * Universite Pierre et Marie Curie (Paris VI) |
10 | * from |
11 | * linux/fs/minix/truncate.c Copyright (C) 1991, 1992 Linus Torvalds |
12 | * |
13 | * ext4fs fsync primitive |
14 | * |
15 | * Big-endian to little-endian byte-swapping/bitmaps by |
16 | * David S. Miller (davem@caip.rutgers.edu), 1995 |
17 | * |
18 | * Removed unnecessary code duplication for little endian machines |
19 | * and excessive __inline__s. |
20 | * Andi Kleen, 1997 |
21 | * |
22 | * Major simplications and cleanup - we only need to do the metadata, because |
23 | * we can depend on generic_block_fdatasync() to sync the data blocks. |
24 | */ |
25 | |
26 | #include <linux/time.h> |
27 | #include <linux/fs.h> |
28 | #include <linux/sched.h> |
29 | #include <linux/writeback.h> |
30 | #include <linux/blkdev.h> |
31 | #include <linux/buffer_head.h> |
32 | |
33 | #include "ext4.h" |
34 | #include "ext4_jbd2.h" |
35 | |
36 | #include <trace/events/ext4.h> |
37 | |
38 | /* |
39 | * If we're not journaling and this is a just-created file, we have to |
40 | * sync our parent directory (if it was freshly created) since |
41 | * otherwise it will only be written by writeback, leaving a huge |
42 | * window during which a crash may lose the file. This may apply for |
43 | * the parent directory's parent as well, and so on recursively, if |
44 | * they are also freshly created. |
45 | */ |
46 | static int ext4_sync_parent(struct inode *inode) |
47 | { |
48 | struct dentry *dentry, *next; |
49 | int ret = 0; |
50 | |
51 | if (!ext4_test_inode_state(inode, bit: EXT4_STATE_NEWENTRY)) |
52 | return 0; |
53 | dentry = d_find_any_alias(inode); |
54 | if (!dentry) |
55 | return 0; |
56 | while (ext4_test_inode_state(inode, bit: EXT4_STATE_NEWENTRY)) { |
57 | ext4_clear_inode_state(inode, bit: EXT4_STATE_NEWENTRY); |
58 | |
59 | next = dget_parent(dentry); |
60 | dput(dentry); |
61 | dentry = next; |
62 | inode = dentry->d_inode; |
63 | |
64 | /* |
65 | * The directory inode may have gone through rmdir by now. But |
66 | * the inode itself and its blocks are still allocated (we hold |
67 | * a reference to the inode via its dentry), so it didn't go |
68 | * through ext4_evict_inode()) and so we are safe to flush |
69 | * metadata blocks and the inode. |
70 | */ |
71 | ret = sync_mapping_buffers(mapping: inode->i_mapping); |
72 | if (ret) |
73 | break; |
74 | ret = sync_inode_metadata(inode, wait: 1); |
75 | if (ret) |
76 | break; |
77 | } |
78 | dput(dentry); |
79 | return ret; |
80 | } |
81 | |
82 | static int ext4_fsync_nojournal(struct file *file, loff_t start, loff_t end, |
83 | int datasync, bool *needs_barrier) |
84 | { |
85 | struct inode *inode = file->f_inode; |
86 | int ret; |
87 | |
88 | ret = generic_buffers_fsync_noflush(file, start, end, datasync); |
89 | if (!ret) |
90 | ret = ext4_sync_parent(inode); |
91 | if (test_opt(inode->i_sb, BARRIER)) |
92 | *needs_barrier = true; |
93 | |
94 | return ret; |
95 | } |
96 | |
97 | static int ext4_fsync_journal(struct inode *inode, bool datasync, |
98 | bool *needs_barrier) |
99 | { |
100 | struct ext4_inode_info *ei = EXT4_I(inode); |
101 | journal_t *journal = EXT4_SB(sb: inode->i_sb)->s_journal; |
102 | tid_t commit_tid = datasync ? ei->i_datasync_tid : ei->i_sync_tid; |
103 | |
104 | /* |
105 | * Fastcommit does not really support fsync on directories or other |
106 | * special files. Force a full commit. |
107 | */ |
108 | if (!S_ISREG(inode->i_mode)) |
109 | return ext4_force_commit(sb: inode->i_sb); |
110 | |
111 | if (journal->j_flags & JBD2_BARRIER && |
112 | !jbd2_trans_will_send_data_barrier(journal, tid: commit_tid)) |
113 | *needs_barrier = true; |
114 | |
115 | return ext4_fc_commit(journal, commit_tid); |
116 | } |
117 | |
118 | /* |
119 | * akpm: A new design for ext4_sync_file(). |
120 | * |
121 | * This is only called from sys_fsync(), sys_fdatasync() and sys_msync(). |
122 | * There cannot be a transaction open by this task. |
123 | * Another task could have dirtied this inode. Its data can be in any |
124 | * state in the journalling system. |
125 | * |
126 | * What we do is just kick off a commit and wait on it. This will snapshot the |
127 | * inode to disk. |
128 | */ |
129 | int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync) |
130 | { |
131 | int ret = 0, err; |
132 | bool needs_barrier = false; |
133 | struct inode *inode = file->f_mapping->host; |
134 | |
135 | if (unlikely(ext4_forced_shutdown(inode->i_sb))) |
136 | return -EIO; |
137 | |
138 | ASSERT(ext4_journal_current_handle() == NULL); |
139 | |
140 | trace_ext4_sync_file_enter(file, datasync); |
141 | |
142 | if (sb_rdonly(sb: inode->i_sb)) { |
143 | /* Make sure that we read updated s_ext4_flags value */ |
144 | smp_rmb(); |
145 | if (ext4_forced_shutdown(sb: inode->i_sb)) |
146 | ret = -EROFS; |
147 | goto out; |
148 | } |
149 | |
150 | if (!EXT4_SB(sb: inode->i_sb)->s_journal) { |
151 | ret = ext4_fsync_nojournal(file, start, end, datasync, |
152 | needs_barrier: &needs_barrier); |
153 | if (needs_barrier) |
154 | goto issue_flush; |
155 | goto out; |
156 | } |
157 | |
158 | ret = file_write_and_wait_range(file, start, end); |
159 | if (ret) |
160 | goto out; |
161 | |
162 | /* |
163 | * The caller's filemap_fdatawrite()/wait will sync the data. |
164 | * Metadata is in the journal, we wait for proper transaction to |
165 | * commit here. |
166 | */ |
167 | ret = ext4_fsync_journal(inode, datasync, needs_barrier: &needs_barrier); |
168 | |
169 | issue_flush: |
170 | if (needs_barrier) { |
171 | err = blkdev_issue_flush(bdev: inode->i_sb->s_bdev); |
172 | if (!ret) |
173 | ret = err; |
174 | } |
175 | out: |
176 | err = file_check_and_advance_wb_err(file); |
177 | if (ret == 0) |
178 | ret = err; |
179 | trace_ext4_sync_file_exit(inode, ret); |
180 | return ret; |
181 | } |
182 | |