Commit | Line | Data |
---|---|---|
ac27a0ec | 1 | /* |
617ba13b | 2 | * linux/fs/ext4/fsync.c |
ac27a0ec DK |
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 | * | |
617ba13b | 12 | * ext4fs fsync primitive |
ac27a0ec DK |
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> | |
dab291af | 29 | #include <linux/jbd2.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 | ||
4a873a47 TT |
37 | static void dump_completed_IO(struct inode * inode) |
38 | { | |
e8bbe8c4 | 39 | #ifdef EXT4FS_DEBUG |
4a873a47 TT |
40 | struct list_head *cur, *before, *after; |
41 | ext4_io_end_t *io, *io0, *io1; | |
42 | unsigned long flags; | |
43 | ||
44 | if (list_empty(&EXT4_I(inode)->i_completed_io_list)){ | |
45 | ext4_debug("inode %lu completed_io list is empty\n", inode->i_ino); | |
46 | return; | |
47 | } | |
48 | ||
49 | ext4_debug("Dump inode %lu completed_io list \n", inode->i_ino); | |
50 | spin_lock_irqsave(&EXT4_I(inode)->i_completed_io_lock, flags); | |
51 | list_for_each_entry(io, &EXT4_I(inode)->i_completed_io_list, list){ | |
52 | cur = &io->list; | |
53 | before = cur->prev; | |
54 | io0 = container_of(before, ext4_io_end_t, list); | |
55 | after = cur->next; | |
56 | io1 = container_of(after, ext4_io_end_t, list); | |
57 | ||
58 | ext4_debug("io 0x%p from inode %lu,prev 0x%p,next 0x%p\n", | |
59 | io, inode->i_ino, io0, io1); | |
60 | } | |
61 | spin_unlock_irqrestore(&EXT4_I(inode)->i_completed_io_lock, flags); | |
62 | #endif | |
63 | } | |
64 | ||
65 | /* | |
66 | * This function is called from ext4_sync_file(). | |
67 | * | |
68 | * When IO is completed, the work to convert unwritten extents to | |
69 | * written is queued on workqueue but may not get immediately | |
70 | * scheduled. When fsync is called, we need to ensure the | |
71 | * conversion is complete before fsync returns. | |
72 | * The inode keeps track of a list of pending/completed IO that | |
73 | * might needs to do the conversion. This function walks through | |
74 | * the list and convert the related unwritten extents for completed IO | |
75 | * to written. | |
76 | * The function return the number of pending IOs on success. | |
77 | */ | |
e0cbee3e | 78 | int ext4_flush_completed_IO(struct inode *inode) |
4a873a47 TT |
79 | { |
80 | ext4_io_end_t *io; | |
81 | struct ext4_inode_info *ei = EXT4_I(inode); | |
82 | unsigned long flags; | |
83 | int ret = 0; | |
84 | int ret2 = 0; | |
85 | ||
4a873a47 TT |
86 | dump_completed_IO(inode); |
87 | spin_lock_irqsave(&ei->i_completed_io_lock, flags); | |
88 | while (!list_empty(&ei->i_completed_io_list)){ | |
89 | io = list_entry(ei->i_completed_io_list.next, | |
90 | ext4_io_end_t, list); | |
b82e384c | 91 | list_del_init(&io->list); |
491caa43 | 92 | io->flag |= EXT4_IO_END_IN_FSYNC; |
4a873a47 TT |
93 | /* |
94 | * Calling ext4_end_io_nolock() to convert completed | |
95 | * IO to written. | |
96 | * | |
97 | * When ext4_sync_file() is called, run_queue() may already | |
98 | * about to flush the work corresponding to this io structure. | |
99 | * It will be upset if it founds the io structure related | |
100 | * to the work-to-be schedule is freed. | |
101 | * | |
102 | * Thus we need to keep the io structure still valid here after | |
25985edc | 103 | * conversion finished. The io structure has a flag to |
4a873a47 TT |
104 | * avoid double converting from both fsync and background work |
105 | * queue work. | |
106 | */ | |
107 | spin_unlock_irqrestore(&ei->i_completed_io_lock, flags); | |
108 | ret = ext4_end_io_nolock(io); | |
4a873a47 TT |
109 | if (ret < 0) |
110 | ret2 = ret; | |
b82e384c | 111 | spin_lock_irqsave(&ei->i_completed_io_lock, flags); |
491caa43 | 112 | io->flag &= ~EXT4_IO_END_IN_FSYNC; |
4a873a47 TT |
113 | } |
114 | spin_unlock_irqrestore(&ei->i_completed_io_lock, flags); | |
115 | return (ret2 < 0) ? ret2 : 0; | |
116 | } | |
117 | ||
14ece102 FM |
118 | /* |
119 | * If we're not journaling and this is a just-created file, we have to | |
120 | * sync our parent directory (if it was freshly created) since | |
121 | * otherwise it will only be written by writeback, leaving a huge | |
122 | * window during which a crash may lose the file. This may apply for | |
123 | * the parent directory's parent as well, and so on recursively, if | |
124 | * they are also freshly created. | |
125 | */ | |
0893ed45 | 126 | static int ext4_sync_parent(struct inode *inode) |
14ece102 | 127 | { |
0893ed45 | 128 | struct writeback_control wbc; |
14ece102 | 129 | struct dentry *dentry = NULL; |
d59729f4 | 130 | struct inode *next; |
0893ed45 | 131 | int ret = 0; |
14ece102 | 132 | |
d59729f4 TT |
133 | if (!ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) |
134 | return 0; | |
135 | inode = igrab(inode); | |
136 | while (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) { | |
14ece102 | 137 | ext4_clear_inode_state(inode, EXT4_STATE_NEWENTRY); |
9f713878 | 138 | dentry = d_find_any_alias(inode); |
d59729f4 | 139 | if (!dentry) |
14ece102 | 140 | break; |
d59729f4 TT |
141 | next = igrab(dentry->d_parent->d_inode); |
142 | dput(dentry); | |
143 | if (!next) | |
144 | break; | |
145 | iput(inode); | |
146 | inode = next; | |
0893ed45 CW |
147 | ret = sync_mapping_buffers(inode->i_mapping); |
148 | if (ret) | |
149 | break; | |
150 | memset(&wbc, 0, sizeof(wbc)); | |
151 | wbc.sync_mode = WB_SYNC_ALL; | |
152 | wbc.nr_to_write = 0; /* only write out the inode */ | |
153 | ret = sync_inode(inode, &wbc); | |
154 | if (ret) | |
155 | break; | |
14ece102 | 156 | } |
d59729f4 | 157 | iput(inode); |
0893ed45 | 158 | return ret; |
14ece102 FM |
159 | } |
160 | ||
02c24a82 JB |
161 | /** |
162 | * __sync_file - generic_file_fsync without the locking and filemap_write | |
163 | * @inode: inode to sync | |
164 | * @datasync: only sync essential metadata if true | |
165 | * | |
166 | * This is just generic_file_fsync without the locking. This is needed for | |
167 | * nojournal mode to make sure this inodes data/metadata makes it to disk | |
168 | * properly. The i_mutex should be held already. | |
169 | */ | |
170 | static int __sync_inode(struct inode *inode, int datasync) | |
171 | { | |
172 | int err; | |
173 | int ret; | |
174 | ||
175 | ret = sync_mapping_buffers(inode->i_mapping); | |
176 | if (!(inode->i_state & I_DIRTY)) | |
177 | return ret; | |
178 | if (datasync && !(inode->i_state & I_DIRTY_DATASYNC)) | |
179 | return ret; | |
180 | ||
181 | err = sync_inode_metadata(inode, 1); | |
182 | if (ret == 0) | |
183 | ret = err; | |
184 | return ret; | |
185 | } | |
186 | ||
ac27a0ec | 187 | /* |
617ba13b | 188 | * akpm: A new design for ext4_sync_file(). |
ac27a0ec DK |
189 | * |
190 | * This is only called from sys_fsync(), sys_fdatasync() and sys_msync(). | |
191 | * There cannot be a transaction open by this task. | |
192 | * Another task could have dirtied this inode. Its data can be in any | |
193 | * state in the journalling system. | |
194 | * | |
195 | * What we do is just kick off a commit and wait on it. This will snapshot the | |
196 | * inode to disk. | |
8d5d02e6 MC |
197 | * |
198 | * i_mutex lock is held when entering and exiting this function | |
ac27a0ec DK |
199 | */ |
200 | ||
02c24a82 | 201 | int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync) |
ac27a0ec | 202 | { |
7ea80859 | 203 | struct inode *inode = file->f_mapping->host; |
b436b9be | 204 | struct ext4_inode_info *ei = EXT4_I(inode); |
d755fb38 | 205 | journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; |
b436b9be JK |
206 | int ret; |
207 | tid_t commit_tid; | |
93628ffb | 208 | bool needs_barrier = false; |
ac27a0ec | 209 | |
ac39849d | 210 | J_ASSERT(ext4_journal_current_handle() == NULL); |
ac27a0ec | 211 | |
0562e0ba | 212 | trace_ext4_sync_file_enter(file, datasync); |
ede86cc4 | 213 | |
02c24a82 JB |
214 | ret = filemap_write_and_wait_range(inode->i_mapping, start, end); |
215 | if (ret) | |
216 | return ret; | |
217 | mutex_lock(&inode->i_mutex); | |
218 | ||
b436b9be | 219 | if (inode->i_sb->s_flags & MS_RDONLY) |
02c24a82 | 220 | goto out; |
b436b9be | 221 | |
3889fd57 | 222 | ret = ext4_flush_completed_IO(inode); |
8d5d02e6 | 223 | if (ret < 0) |
0562e0ba | 224 | goto out; |
60e6679e | 225 | |
14ece102 | 226 | if (!journal) { |
02c24a82 | 227 | ret = __sync_inode(inode, datasync); |
b3d9b7a3 | 228 | if (!ret && !hlist_empty(&inode->i_dentry)) |
0893ed45 | 229 | ret = ext4_sync_parent(inode); |
0562e0ba | 230 | goto out; |
14ece102 | 231 | } |
b436b9be | 232 | |
ac27a0ec | 233 | /* |
b436b9be | 234 | * data=writeback,ordered: |
ac27a0ec | 235 | * The caller's filemap_fdatawrite()/wait will sync the data. |
b436b9be JK |
236 | * Metadata is in the journal, we wait for proper transaction to |
237 | * commit here. | |
ac27a0ec DK |
238 | * |
239 | * data=journal: | |
240 | * filemap_fdatawrite won't do anything (the buffers are clean). | |
617ba13b | 241 | * ext4_force_commit will write the file data into the journal and |
ac27a0ec DK |
242 | * will wait on that. |
243 | * filemap_fdatawait() will encounter a ton of newly-dirtied pages | |
244 | * (they were dirtied by commit). But that's OK - the blocks are | |
245 | * safe in-journal, which is all fsync() needs to ensure. | |
246 | */ | |
0562e0ba JZ |
247 | if (ext4_should_journal_data(inode)) { |
248 | ret = ext4_force_commit(inode->i_sb); | |
249 | goto out; | |
250 | } | |
ac27a0ec | 251 | |
b436b9be | 252 | commit_tid = datasync ? ei->i_datasync_tid : ei->i_sync_tid; |
93628ffb JK |
253 | if (journal->j_flags & JBD2_BARRIER && |
254 | !jbd2_trans_will_send_data_barrier(journal, commit_tid)) | |
255 | needs_barrier = true; | |
256 | jbd2_log_start_commit(journal, commit_tid); | |
257 | ret = jbd2_log_wait_commit(journal, commit_tid); | |
258 | if (needs_barrier) | |
dd3932ed | 259 | blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL); |
0562e0ba | 260 | out: |
02c24a82 | 261 | mutex_unlock(&inode->i_mutex); |
0562e0ba | 262 | trace_ext4_sync_file_exit(inode, ret); |
ac27a0ec DK |
263 | return ret; |
264 | } |