xref: /openbmc/linux/fs/ext4/fsync.c (revision 6aa7de05)
1 /*
2  *  linux/fs/ext4/fsync.c
3  *
4  *  Copyright (C) 1993  Stephen Tweedie (sct@redhat.com)
5  *  from
6  *  Copyright (C) 1992  Remy Card (card@masi.ibp.fr)
7  *                      Laboratoire MASI - Institut Blaise Pascal
8  *                      Universite Pierre et Marie Curie (Paris VI)
9  *  from
10  *  linux/fs/minix/truncate.c   Copyright (C) 1991, 1992  Linus Torvalds
11  *
12  *  ext4fs fsync primitive
13  *
14  *  Big-endian to little-endian byte-swapping/bitmaps by
15  *        David S. Miller (davem@caip.rutgers.edu), 1995
16  *
17  *  Removed unnecessary code duplication for little endian machines
18  *  and excessive __inline__s.
19  *        Andi Kleen, 1997
20  *
21  * Major simplications and cleanup - we only need to do the metadata, because
22  * we can depend on generic_block_fdatasync() to sync the data blocks.
23  */
24 
25 #include <linux/time.h>
26 #include <linux/fs.h>
27 #include <linux/sched.h>
28 #include <linux/writeback.h>
29 #include <linux/blkdev.h>
30 
31 #include "ext4.h"
32 #include "ext4_jbd2.h"
33 
34 #include <trace/events/ext4.h>
35 
36 /*
37  * If we're not journaling and this is a just-created file, we have to
38  * sync our parent directory (if it was freshly created) since
39  * otherwise it will only be written by writeback, leaving a huge
40  * window during which a crash may lose the file.  This may apply for
41  * the parent directory's parent as well, and so on recursively, if
42  * they are also freshly created.
43  */
44 static int ext4_sync_parent(struct inode *inode)
45 {
46 	struct dentry *dentry = NULL;
47 	struct inode *next;
48 	int ret = 0;
49 
50 	if (!ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY))
51 		return 0;
52 	inode = igrab(inode);
53 	while (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) {
54 		ext4_clear_inode_state(inode, EXT4_STATE_NEWENTRY);
55 		dentry = d_find_any_alias(inode);
56 		if (!dentry)
57 			break;
58 		next = igrab(d_inode(dentry->d_parent));
59 		dput(dentry);
60 		if (!next)
61 			break;
62 		iput(inode);
63 		inode = next;
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 so it didn't go through
68 		 * ext4_evict_inode()) and so we are safe to flush metadata
69 		 * 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 	iput(inode);
79 	return ret;
80 }
81 
82 /*
83  * akpm: A new design for ext4_sync_file().
84  *
85  * This is only called from sys_fsync(), sys_fdatasync() and sys_msync().
86  * There cannot be a transaction open by this task.
87  * Another task could have dirtied this inode.  Its data can be in any
88  * state in the journalling system.
89  *
90  * What we do is just kick off a commit and wait on it.  This will snapshot the
91  * inode to disk.
92  */
93 
94 int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
95 {
96 	struct inode *inode = file->f_mapping->host;
97 	struct ext4_inode_info *ei = EXT4_I(inode);
98 	journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
99 	int ret = 0, err;
100 	tid_t commit_tid;
101 	bool needs_barrier = false;
102 
103 	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
104 		return -EIO;
105 
106 	J_ASSERT(ext4_journal_current_handle() == NULL);
107 
108 	trace_ext4_sync_file_enter(file, datasync);
109 
110 	if (sb_rdonly(inode->i_sb)) {
111 		/* Make sure that we read updated s_mount_flags value */
112 		smp_rmb();
113 		if (EXT4_SB(inode->i_sb)->s_mount_flags & EXT4_MF_FS_ABORTED)
114 			ret = -EROFS;
115 		goto out;
116 	}
117 
118 	if (!journal) {
119 		ret = __generic_file_fsync(file, start, end, datasync);
120 		if (!ret)
121 			ret = ext4_sync_parent(inode);
122 		if (test_opt(inode->i_sb, BARRIER))
123 			goto issue_flush;
124 		goto out;
125 	}
126 
127 	ret = file_write_and_wait_range(file, start, end);
128 	if (ret)
129 		return ret;
130 	/*
131 	 * data=writeback,ordered:
132 	 *  The caller's filemap_fdatawrite()/wait will sync the data.
133 	 *  Metadata is in the journal, we wait for proper transaction to
134 	 *  commit here.
135 	 *
136 	 * data=journal:
137 	 *  filemap_fdatawrite won't do anything (the buffers are clean).
138 	 *  ext4_force_commit will write the file data into the journal and
139 	 *  will wait on that.
140 	 *  filemap_fdatawait() will encounter a ton of newly-dirtied pages
141 	 *  (they were dirtied by commit).  But that's OK - the blocks are
142 	 *  safe in-journal, which is all fsync() needs to ensure.
143 	 */
144 	if (ext4_should_journal_data(inode)) {
145 		ret = ext4_force_commit(inode->i_sb);
146 		goto out;
147 	}
148 
149 	commit_tid = datasync ? ei->i_datasync_tid : ei->i_sync_tid;
150 	if (journal->j_flags & JBD2_BARRIER &&
151 	    !jbd2_trans_will_send_data_barrier(journal, commit_tid))
152 		needs_barrier = true;
153 	ret = jbd2_complete_transaction(journal, commit_tid);
154 	if (needs_barrier) {
155 	issue_flush:
156 		err = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
157 		if (!ret)
158 			ret = err;
159 	}
160 out:
161 	trace_ext4_sync_file_exit(inode, ret);
162 	return ret;
163 }
164