| 1 |
// SPDX-License-Identifier: GPL-2.0 |
| 2 |
/* |
| 3 |
* linux/fs/ext4/fsync.c |
| 4 |
* |
| 5 |
* Copyright (C) 1993 Stephen Tweedie ([email protected]) |
| 6 |
* from |
| 7 |
* Copyright (C) 1992 Remy Card ([email protected]) |
| 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 ([email protected]), 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, 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, EXT4_STATE_NEWENTRY)) { |
| 57 |
ext4_clear_inode_state(inode, 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(inode->i_mapping); |
| 72 |
if (ret) |
| 73 |
break; |
| 74 |
ret = sync_inode_metadata(inode, 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 |
struct writeback_control wbc = { |
| 87 |
.sync_mode = WB_SYNC_ALL, |
| 88 |
.nr_to_write = 0, |
| 89 |
}; |
| 90 |
int ret; |
| 91 |
|
| 92 |
ret = generic_buffers_fsync_noflush(file, start, end, datasync); |
| 93 |
if (ret) |
| 94 |
return ret; |
| 95 |
|
| 96 |
/* Force writeout of inode table buffer to disk */ |
| 97 |
ret = ext4_write_inode(inode, &wbc); |
| 98 |
if (ret) |
| 99 |
return ret; |
| 100 |
|
| 101 |
ret = ext4_sync_parent(inode); |
| 102 |
|
| 103 |
if (test_opt(inode->i_sb, BARRIER)) |
| 104 |
*needs_barrier = true; |
| 105 |
|
| 106 |
return ret; |
| 107 |
} |
| 108 |
|
| 109 |
static int ext4_fsync_journal(struct inode *inode, bool datasync, |
| 110 |
bool *needs_barrier) |
| 111 |
{ |
| 112 |
struct ext4_inode_info *ei = EXT4_I(inode); |
| 113 |
journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; |
| 114 |
tid_t commit_tid = datasync ? ei->i_datasync_tid : ei->i_sync_tid; |
| 115 |
|
| 116 |
/* |
| 117 |
* Fastcommit does not really support fsync on directories or other |
| 118 |
* special files. Force a full commit. |
| 119 |
*/ |
| 120 |
if (!S_ISREG(inode->i_mode)) |
| 121 |
return ext4_force_commit(inode->i_sb); |
| 122 |
|
| 123 |
if (journal->j_flags & JBD2_BARRIER && |
| 124 |
!jbd2_trans_will_send_data_barrier(journal, commit_tid)) |
| 125 |
*needs_barrier = true; |
| 126 |
|
| 127 |
return ext4_fc_commit(journal, commit_tid); |
| 128 |
} |
| 129 |
|
| 130 |
/* |
| 131 |
* akpm: A new design for ext4_sync_file(). |
| 132 |
* |
| 133 |
* This is only called from sys_fsync(), sys_fdatasync() and sys_msync(). |
| 134 |
* There cannot be a transaction open by this task. |
| 135 |
* Another task could have dirtied this inode. Its data can be in any |
| 136 |
* state in the journalling system. |
| 137 |
* |
| 138 |
* What we do is just kick off a commit and wait on it. This will snapshot the |
| 139 |
* inode to disk. |
| 140 |
*/ |
| 141 |
int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync) |
| 142 |
{ |
| 143 |
int ret = 0, err; |
| 144 |
bool needs_barrier = false; |
| 145 |
struct inode *inode = file->f_mapping->host; |
| 146 |
|
| 147 |
ret = ext4_emergency_state(inode->i_sb); |
| 148 |
if (unlikely(ret)) |
| 149 |
return ret; |
| 150 |
|
| 151 |
ASSERT(ext4_journal_current_handle() == NULL); |
| 152 |
|
| 153 |
trace_ext4_sync_file_enter(file, datasync); |
| 154 |
|
| 155 |
if (sb_rdonly(inode->i_sb)) |
| 156 |
goto out; |
| 157 |
|
| 158 |
if (!EXT4_SB(inode->i_sb)->s_journal) { |
| 159 |
ret = ext4_fsync_nojournal(file, start, end, datasync, |
| 160 |
&needs_barrier); |
| 161 |
if (needs_barrier) |
| 162 |
goto issue_flush; |
| 163 |
goto out; |
| 164 |
} |
| 165 |
|
| 166 |
ret = file_write_and_wait_range(file, start, end); |
| 167 |
if (ret) |
| 168 |
goto out; |
| 169 |
|
| 170 |
/* |
| 171 |
* The caller's filemap_fdatawrite()/wait will sync the data. |
| 172 |
* Metadata is in the journal, we wait for proper transaction to |
| 173 |
* commit here. |
| 174 |
*/ |
| 175 |
ret = ext4_fsync_journal(inode, datasync, &needs_barrier); |
| 176 |
|
| 177 |
issue_flush: |
| 178 |
if (needs_barrier) { |
| 179 |
err = blkdev_issue_flush(inode->i_sb->s_bdev); |
| 180 |
if (!ret) |
| 181 |
ret = err; |
| 182 |
} |
| 183 |
out: |
| 184 |
err = file_check_and_advance_wb_err(file); |
| 185 |
if (ret == 0) |
| 186 |
ret = err; |
| 187 |
trace_ext4_sync_file_exit(inode, ret); |
| 188 |
return ret; |
| 189 |
} |