Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
ac27a0ec | 2 | /* |
617ba13b | 3 | * linux/fs/ext4/fsync.c |
ac27a0ec DK |
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 | * | |
617ba13b | 13 | * ext4fs fsync primitive |
ac27a0ec DK |
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> | |
d755fb38 | 30 | #include <linux/blkdev.h> |
9bffad1e | 31 | |
3dcf5451 CH |
32 | #include "ext4.h" |
33 | #include "ext4_jbd2.h" | |
ac27a0ec | 34 | |
9bffad1e TT |
35 | #include <trace/events/ext4.h> |
36 | ||
14ece102 FM |
37 | /* |
38 | * If we're not journaling and this is a just-created file, we have to | |
39 | * sync our parent directory (if it was freshly created) since | |
40 | * otherwise it will only be written by writeback, leaving a huge | |
41 | * window during which a crash may lose the file. This may apply for | |
42 | * the parent directory's parent as well, and so on recursively, if | |
43 | * they are also freshly created. | |
44 | */ | |
0893ed45 | 45 | static int ext4_sync_parent(struct inode *inode) |
14ece102 | 46 | { |
08adf452 | 47 | struct dentry *dentry, *next; |
0893ed45 | 48 | int ret = 0; |
14ece102 | 49 | |
d59729f4 TT |
50 | if (!ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) |
51 | return 0; | |
08adf452 EB |
52 | dentry = d_find_any_alias(inode); |
53 | if (!dentry) | |
54 | return 0; | |
d59729f4 | 55 | while (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) { |
14ece102 | 56 | ext4_clear_inode_state(inode, EXT4_STATE_NEWENTRY); |
08adf452 EB |
57 | |
58 | next = dget_parent(dentry); | |
d59729f4 | 59 | dput(dentry); |
08adf452 EB |
60 | dentry = next; |
61 | inode = dentry->d_inode; | |
62 | ||
6ae4c5a6 JK |
63 | /* |
64 | * The directory inode may have gone through rmdir by now. But | |
65 | * the inode itself and its blocks are still allocated (we hold | |
08adf452 EB |
66 | * a reference to the inode via its dentry), so it didn't go |
67 | * through ext4_evict_inode()) and so we are safe to flush | |
68 | * metadata blocks and the inode. | |
6ae4c5a6 | 69 | */ |
0893ed45 CW |
70 | ret = sync_mapping_buffers(inode->i_mapping); |
71 | if (ret) | |
72 | break; | |
64744e03 | 73 | ret = sync_inode_metadata(inode, 1); |
0893ed45 CW |
74 | if (ret) |
75 | break; | |
14ece102 | 76 | } |
08adf452 | 77 | dput(dentry); |
0893ed45 | 78 | return ret; |
14ece102 FM |
79 | } |
80 | ||
3eaf9cc6 MB |
81 | static int ext4_fsync_nojournal(struct inode *inode, bool datasync, |
82 | bool *needs_barrier) | |
83 | { | |
84 | int ret, err; | |
85 | ||
86 | ret = sync_mapping_buffers(inode->i_mapping); | |
87 | if (!(inode->i_state & I_DIRTY_ALL)) | |
88 | return ret; | |
89 | if (datasync && !(inode->i_state & I_DIRTY_DATASYNC)) | |
90 | return ret; | |
91 | ||
92 | err = sync_inode_metadata(inode, 1); | |
93 | if (!ret) | |
94 | ret = err; | |
95 | ||
96 | if (!ret) | |
97 | ret = ext4_sync_parent(inode); | |
98 | if (test_opt(inode->i_sb, BARRIER)) | |
99 | *needs_barrier = true; | |
100 | ||
101 | return ret; | |
102 | } | |
103 | ||
104 | static int ext4_fsync_journal(struct inode *inode, bool datasync, | |
105 | bool *needs_barrier) | |
106 | { | |
107 | struct ext4_inode_info *ei = EXT4_I(inode); | |
108 | journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; | |
109 | tid_t commit_tid = datasync ? ei->i_datasync_tid : ei->i_sync_tid; | |
110 | ||
111 | if (journal->j_flags & JBD2_BARRIER && | |
112 | !jbd2_trans_will_send_data_barrier(journal, commit_tid)) | |
113 | *needs_barrier = true; | |
114 | ||
aa75f4d3 | 115 | return ext4_fc_commit(journal, commit_tid); |
3eaf9cc6 MB |
116 | } |
117 | ||
ac27a0ec | 118 | /* |
617ba13b | 119 | * akpm: A new design for ext4_sync_file(). |
ac27a0ec DK |
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 | */ | |
02c24a82 | 129 | int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync) |
ac27a0ec | 130 | { |
37b10dd0 | 131 | int ret = 0, err; |
93628ffb | 132 | bool needs_barrier = false; |
3eaf9cc6 MB |
133 | struct inode *inode = file->f_mapping->host; |
134 | struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); | |
ac27a0ec | 135 | |
3eaf9cc6 | 136 | if (unlikely(ext4_forced_shutdown(sbi))) |
0db1ff22 TT |
137 | return -EIO; |
138 | ||
837c23fb | 139 | ASSERT(ext4_journal_current_handle() == NULL); |
ac27a0ec | 140 | |
0562e0ba | 141 | trace_ext4_sync_file_enter(file, datasync); |
ede86cc4 | 142 | |
bc98a42c | 143 | if (sb_rdonly(inode->i_sb)) { |
4418e141 DM |
144 | /* Make sure that we read updated s_mount_flags value */ |
145 | smp_rmb(); | |
9b5f6c9b | 146 | if (ext4_test_mount_flag(inode->i_sb, EXT4_MF_FS_ABORTED)) |
4418e141 | 147 | ret = -EROFS; |
92e6222d | 148 | goto out; |
4418e141 | 149 | } |
b436b9be | 150 | |
8fdd60f2 TT |
151 | ret = file_write_and_wait_range(file, start, end); |
152 | if (ret) | |
2be7d717 | 153 | goto out; |
3eaf9cc6 | 154 | |
ac27a0ec | 155 | /* |
ac27a0ec | 156 | * The caller's filemap_fdatawrite()/wait will sync the data. |
b436b9be JK |
157 | * Metadata is in the journal, we wait for proper transaction to |
158 | * commit here. | |
ac27a0ec | 159 | */ |
3eaf9cc6 MB |
160 | if (!sbi->s_journal) |
161 | ret = ext4_fsync_nojournal(inode, datasync, &needs_barrier); | |
3eaf9cc6 MB |
162 | else |
163 | ret = ext4_fsync_journal(inode, datasync, &needs_barrier); | |
ac27a0ec | 164 | |
a4a39040 | 165 | if (needs_barrier) { |
c6bf3f0e | 166 | err = blkdev_issue_flush(inode->i_sb->s_bdev); |
a4a39040 TT |
167 | if (!ret) |
168 | ret = err; | |
169 | } | |
37b10dd0 | 170 | out: |
95cb6713 TT |
171 | err = file_check_and_advance_wb_err(file); |
172 | if (ret == 0) | |
173 | ret = err; | |
0562e0ba | 174 | trace_ext4_sync_file_exit(inode, ret); |
ac27a0ec DK |
175 | return ret; |
176 | } |