Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * High-level sync()-related operations
4 : : */
5 : :
6 : : #include <linux/kernel.h>
7 : : #include <linux/file.h>
8 : : #include <linux/fs.h>
9 : : #include <linux/slab.h>
10 : : #include <linux/export.h>
11 : : #include <linux/namei.h>
12 : : #include <linux/sched.h>
13 : : #include <linux/writeback.h>
14 : : #include <linux/syscalls.h>
15 : : #include <linux/linkage.h>
16 : : #include <linux/pagemap.h>
17 : : #include <linux/quotaops.h>
18 : : #include <linux/backing-dev.h>
19 : : #include "internal.h"
20 : :
21 : : #define VALID_FLAGS (SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE| \
22 : : SYNC_FILE_RANGE_WAIT_AFTER)
23 : :
24 : : /*
25 : : * Do the filesystem syncing work. For simple filesystems
26 : : * writeback_inodes_sb(sb) just dirties buffers with inodes so we have to
27 : : * submit IO for these buffers via __sync_blockdev(). This also speeds up the
28 : : * wait == 1 case since in that case write_inode() functions do
29 : : * sync_dirty_buffer() and thus effectively write one block at a time.
30 : : */
31 : 56 : static int __sync_filesystem(struct super_block *sb, int wait)
32 : : {
33 [ + + ]: 56 : if (wait)
34 : 28 : sync_inodes_sb(sb);
35 : : else
36 : 28 : writeback_inodes_sb(sb, WB_REASON_SYNC);
37 : :
38 [ - + ]: 56 : if (sb->s_op->sync_fs)
39 : 0 : sb->s_op->sync_fs(sb, wait);
40 : 56 : return __sync_blockdev(sb->s_bdev, wait);
41 : : }
42 : :
43 : : /*
44 : : * Write out and wait upon all dirty data associated with this
45 : : * superblock. Filesystem data as well as the underlying block
46 : : * device. Takes the superblock lock.
47 : : */
48 : 28 : int sync_filesystem(struct super_block *sb)
49 : : {
50 : 28 : int ret;
51 : :
52 : : /*
53 : : * We need to be protected against the filesystem going from
54 : : * r/o to r/w or vice versa.
55 : : */
56 [ - + ]: 28 : WARN_ON(!rwsem_is_locked(&sb->s_umount));
57 : :
58 : : /*
59 : : * No point in syncing out anything if the filesystem is read-only.
60 : : */
61 [ + - ]: 28 : if (sb_rdonly(sb))
62 : : return 0;
63 : :
64 : 28 : ret = __sync_filesystem(sb, 0);
65 [ + - ]: 28 : if (ret < 0)
66 : : return ret;
67 : 28 : return __sync_filesystem(sb, 1);
68 : : }
69 : : EXPORT_SYMBOL(sync_filesystem);
70 : :
71 : 0 : static void sync_inodes_one_sb(struct super_block *sb, void *arg)
72 : : {
73 [ # # ]: 0 : if (!sb_rdonly(sb))
74 : 0 : sync_inodes_sb(sb);
75 : 0 : }
76 : :
77 : 0 : static void sync_fs_one_sb(struct super_block *sb, void *arg)
78 : : {
79 [ # # # # ]: 0 : if (!sb_rdonly(sb) && sb->s_op->sync_fs)
80 : 0 : sb->s_op->sync_fs(sb, *(int *)arg);
81 : 0 : }
82 : :
83 : 0 : static void fdatawrite_one_bdev(struct block_device *bdev, void *arg)
84 : : {
85 : 0 : filemap_fdatawrite(bdev->bd_inode->i_mapping);
86 : 0 : }
87 : :
88 : 0 : static void fdatawait_one_bdev(struct block_device *bdev, void *arg)
89 : : {
90 : : /*
91 : : * We keep the error status of individual mapping so that
92 : : * applications can catch the writeback error using fsync(2).
93 : : * See filemap_fdatawait_keep_errors() for details.
94 : : */
95 : 0 : filemap_fdatawait_keep_errors(bdev->bd_inode->i_mapping);
96 : 0 : }
97 : :
98 : : /*
99 : : * Sync everything. We start by waking flusher threads so that most of
100 : : * writeback runs on all devices in parallel. Then we sync all inodes reliably
101 : : * which effectively also waits for all flusher threads to finish doing
102 : : * writeback. At this point all data is on disk so metadata should be stable
103 : : * and we tell filesystems to sync their metadata via ->sync_fs() calls.
104 : : * Finally, we writeout all block devices because some filesystems (e.g. ext2)
105 : : * just write metadata (such as inodes or bitmaps) to block device page cache
106 : : * and do not sync it on their own in ->sync_fs().
107 : : */
108 : 0 : void ksys_sync(void)
109 : : {
110 : 0 : int nowait = 0, wait = 1;
111 : :
112 : 0 : wakeup_flusher_threads(WB_REASON_SYNC);
113 : 0 : iterate_supers(sync_inodes_one_sb, NULL);
114 : 0 : iterate_supers(sync_fs_one_sb, &nowait);
115 : 0 : iterate_supers(sync_fs_one_sb, &wait);
116 : 0 : iterate_bdevs(fdatawrite_one_bdev, NULL);
117 : 0 : iterate_bdevs(fdatawait_one_bdev, NULL);
118 [ # # ]: 0 : if (unlikely(laptop_mode))
119 : 0 : laptop_sync_completion();
120 : 0 : }
121 : :
122 : 0 : SYSCALL_DEFINE0(sync)
123 : : {
124 : 0 : ksys_sync();
125 : 0 : return 0;
126 : : }
127 : :
128 : 0 : static void do_sync_work(struct work_struct *work)
129 : : {
130 : 0 : int nowait = 0;
131 : :
132 : : /*
133 : : * Sync twice to reduce the possibility we skipped some inodes / pages
134 : : * because they were temporarily locked
135 : : */
136 : 0 : iterate_supers(sync_inodes_one_sb, &nowait);
137 : 0 : iterate_supers(sync_fs_one_sb, &nowait);
138 : 0 : iterate_bdevs(fdatawrite_one_bdev, NULL);
139 : 0 : iterate_supers(sync_inodes_one_sb, &nowait);
140 : 0 : iterate_supers(sync_fs_one_sb, &nowait);
141 : 0 : iterate_bdevs(fdatawrite_one_bdev, NULL);
142 : 0 : printk("Emergency Sync complete\n");
143 : 0 : kfree(work);
144 : 0 : }
145 : :
146 : 0 : void emergency_sync(void)
147 : : {
148 : 0 : struct work_struct *work;
149 : :
150 : 0 : work = kmalloc(sizeof(*work), GFP_ATOMIC);
151 [ # # ]: 0 : if (work) {
152 : 0 : INIT_WORK(work, do_sync_work);
153 : 0 : schedule_work(work);
154 : : }
155 : 0 : }
156 : :
157 : : /*
158 : : * sync a single super
159 : : */
160 : 0 : SYSCALL_DEFINE1(syncfs, int, fd)
161 : : {
162 : 0 : struct fd f = fdget(fd);
163 : 0 : struct super_block *sb;
164 : 0 : int ret;
165 : :
166 [ # # ]: 0 : if (!f.file)
167 : : return -EBADF;
168 : 0 : sb = f.file->f_path.dentry->d_sb;
169 : :
170 : 0 : down_read(&sb->s_umount);
171 : 0 : ret = sync_filesystem(sb);
172 : 0 : up_read(&sb->s_umount);
173 : :
174 [ # # ]: 0 : fdput(f);
175 : 0 : return ret;
176 : : }
177 : :
178 : : /**
179 : : * vfs_fsync_range - helper to sync a range of data & metadata to disk
180 : : * @file: file to sync
181 : : * @start: offset in bytes of the beginning of data range to sync
182 : : * @end: offset in bytes of the end of data range (inclusive)
183 : : * @datasync: perform only datasync
184 : : *
185 : : * Write back data in range @start..@end and metadata for @file to disk. If
186 : : * @datasync is set only metadata needed to access modified file data is
187 : : * written.
188 : : */
189 : 476 : int vfs_fsync_range(struct file *file, loff_t start, loff_t end, int datasync)
190 : : {
191 : 476 : struct inode *inode = file->f_mapping->host;
192 : :
193 [ + - ]: 476 : if (!file->f_op->fsync)
194 : : return -EINVAL;
195 [ + - - + ]: 476 : if (!datasync && (inode->i_state & I_DIRTY_TIME))
196 : 0 : mark_inode_dirty_sync(inode);
197 : 476 : return file->f_op->fsync(file, start, end, datasync);
198 : : }
199 : : EXPORT_SYMBOL(vfs_fsync_range);
200 : :
201 : : /**
202 : : * vfs_fsync - perform a fsync or fdatasync on a file
203 : : * @file: file to sync
204 : : * @datasync: only perform a fdatasync operation
205 : : *
206 : : * Write back data and metadata for @file to disk. If @datasync is
207 : : * set only metadata needed to access modified file data is written.
208 : : */
209 : 476 : int vfs_fsync(struct file *file, int datasync)
210 : : {
211 : 0 : return vfs_fsync_range(file, 0, LLONG_MAX, datasync);
212 : : }
213 : : EXPORT_SYMBOL(vfs_fsync);
214 : :
215 : 476 : static int do_fsync(unsigned int fd, int datasync)
216 : : {
217 : 476 : struct fd f = fdget(fd);
218 : 476 : int ret = -EBADF;
219 : :
220 [ + - ]: 476 : if (f.file) {
221 : 476 : ret = vfs_fsync(f.file, datasync);
222 [ - + ]: 476 : fdput(f);
223 : : }
224 : 476 : return ret;
225 : : }
226 : :
227 : 952 : SYSCALL_DEFINE1(fsync, unsigned int, fd)
228 : : {
229 : 476 : return do_fsync(fd, 0);
230 : : }
231 : :
232 : 0 : SYSCALL_DEFINE1(fdatasync, unsigned int, fd)
233 : : {
234 : 0 : return do_fsync(fd, 1);
235 : : }
236 : :
237 : 0 : int sync_file_range(struct file *file, loff_t offset, loff_t nbytes,
238 : : unsigned int flags)
239 : : {
240 : 0 : int ret;
241 : 0 : struct address_space *mapping;
242 : 0 : loff_t endbyte; /* inclusive */
243 : 0 : umode_t i_mode;
244 : :
245 : 0 : ret = -EINVAL;
246 [ # # ]: 0 : if (flags & ~VALID_FLAGS)
247 : 0 : goto out;
248 : :
249 : 0 : endbyte = offset + nbytes;
250 : :
251 [ # # ]: 0 : if ((s64)offset < 0)
252 : 0 : goto out;
253 [ # # ]: 0 : if ((s64)endbyte < 0)
254 : 0 : goto out;
255 [ # # ]: 0 : if (endbyte < offset)
256 : 0 : goto out;
257 : :
258 : 0 : if (sizeof(pgoff_t) == 4) {
259 : : if (offset >= (0x100000000ULL << PAGE_SHIFT)) {
260 : : /*
261 : : * The range starts outside a 32 bit machine's
262 : : * pagecache addressing capabilities. Let it "succeed"
263 : : */
264 : : ret = 0;
265 : : goto out;
266 : : }
267 : : if (endbyte >= (0x100000000ULL << PAGE_SHIFT)) {
268 : : /*
269 : : * Out to EOF
270 : : */
271 : : nbytes = 0;
272 : : }
273 : : }
274 : :
275 [ # # ]: 0 : if (nbytes == 0)
276 : : endbyte = LLONG_MAX;
277 : : else
278 : 0 : endbyte--; /* inclusive */
279 : :
280 [ # # ]: 0 : i_mode = file_inode(file)->i_mode;
281 : 0 : ret = -ESPIPE;
282 [ # # # # : 0 : if (!S_ISREG(i_mode) && !S_ISBLK(i_mode) && !S_ISDIR(i_mode) &&
# # ]
283 : : !S_ISLNK(i_mode))
284 : 0 : goto out;
285 : :
286 : 0 : mapping = file->f_mapping;
287 : 0 : ret = 0;
288 [ # # ]: 0 : if (flags & SYNC_FILE_RANGE_WAIT_BEFORE) {
289 : 0 : ret = file_fdatawait_range(file, offset, endbyte);
290 [ # # ]: 0 : if (ret < 0)
291 : 0 : goto out;
292 : : }
293 : :
294 [ # # ]: 0 : if (flags & SYNC_FILE_RANGE_WRITE) {
295 : 0 : int sync_mode = WB_SYNC_NONE;
296 : :
297 [ # # ]: 0 : if ((flags & SYNC_FILE_RANGE_WRITE_AND_WAIT) ==
298 : : SYNC_FILE_RANGE_WRITE_AND_WAIT)
299 : 0 : sync_mode = WB_SYNC_ALL;
300 : :
301 : 0 : ret = __filemap_fdatawrite_range(mapping, offset, endbyte,
302 : : sync_mode);
303 [ # # ]: 0 : if (ret < 0)
304 : 0 : goto out;
305 : : }
306 : :
307 [ # # ]: 0 : if (flags & SYNC_FILE_RANGE_WAIT_AFTER)
308 : 0 : ret = file_fdatawait_range(file, offset, endbyte);
309 : :
310 : 0 : out:
311 : 0 : return ret;
312 : : }
313 : :
314 : : /*
315 : : * ksys_sync_file_range() permits finely controlled syncing over a segment of
316 : : * a file in the range offset .. (offset+nbytes-1) inclusive. If nbytes is
317 : : * zero then ksys_sync_file_range() will operate from offset out to EOF.
318 : : *
319 : : * The flag bits are:
320 : : *
321 : : * SYNC_FILE_RANGE_WAIT_BEFORE: wait upon writeout of all pages in the range
322 : : * before performing the write.
323 : : *
324 : : * SYNC_FILE_RANGE_WRITE: initiate writeout of all those dirty pages in the
325 : : * range which are not presently under writeback. Note that this may block for
326 : : * significant periods due to exhaustion of disk request structures.
327 : : *
328 : : * SYNC_FILE_RANGE_WAIT_AFTER: wait upon writeout of all pages in the range
329 : : * after performing the write.
330 : : *
331 : : * Useful combinations of the flag bits are:
332 : : *
333 : : * SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE: ensures that all pages
334 : : * in the range which were dirty on entry to ksys_sync_file_range() are placed
335 : : * under writeout. This is a start-write-for-data-integrity operation.
336 : : *
337 : : * SYNC_FILE_RANGE_WRITE: start writeout of all dirty pages in the range which
338 : : * are not presently under writeout. This is an asynchronous flush-to-disk
339 : : * operation. Not suitable for data integrity operations.
340 : : *
341 : : * SYNC_FILE_RANGE_WAIT_BEFORE (or SYNC_FILE_RANGE_WAIT_AFTER): wait for
342 : : * completion of writeout of all pages in the range. This will be used after an
343 : : * earlier SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE operation to wait
344 : : * for that operation to complete and to return the result.
345 : : *
346 : : * SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE|SYNC_FILE_RANGE_WAIT_AFTER
347 : : * (a.k.a. SYNC_FILE_RANGE_WRITE_AND_WAIT):
348 : : * a traditional sync() operation. This is a write-for-data-integrity operation
349 : : * which will ensure that all pages in the range which were dirty on entry to
350 : : * ksys_sync_file_range() are written to disk. It should be noted that disk
351 : : * caches are not flushed by this call, so there are no guarantees here that the
352 : : * data will be available on disk after a crash.
353 : : *
354 : : *
355 : : * SYNC_FILE_RANGE_WAIT_BEFORE and SYNC_FILE_RANGE_WAIT_AFTER will detect any
356 : : * I/O errors or ENOSPC conditions and will return those to the caller, after
357 : : * clearing the EIO and ENOSPC flags in the address_space.
358 : : *
359 : : * It should be noted that none of these operations write out the file's
360 : : * metadata. So unless the application is strictly performing overwrites of
361 : : * already-instantiated disk blocks, there are no guarantees here that the data
362 : : * will be available after a crash.
363 : : */
364 : 0 : int ksys_sync_file_range(int fd, loff_t offset, loff_t nbytes,
365 : : unsigned int flags)
366 : : {
367 : 0 : int ret;
368 : 0 : struct fd f;
369 : :
370 : 0 : ret = -EBADF;
371 : 0 : f = fdget(fd);
372 [ # # ]: 0 : if (f.file)
373 : 0 : ret = sync_file_range(f.file, offset, nbytes, flags);
374 : :
375 [ # # ]: 0 : fdput(f);
376 : 0 : return ret;
377 : : }
378 : :
379 : 0 : SYSCALL_DEFINE4(sync_file_range, int, fd, loff_t, offset, loff_t, nbytes,
380 : : unsigned int, flags)
381 : : {
382 : 0 : return ksys_sync_file_range(fd, offset, nbytes, flags);
383 : : }
384 : :
385 : : /* It would be nice if people remember that not all the world's an i386
386 : : when they introduce new system calls */
387 : 0 : SYSCALL_DEFINE4(sync_file_range2, int, fd, unsigned int, flags,
388 : : loff_t, offset, loff_t, nbytes)
389 : : {
390 : 0 : return ksys_sync_file_range(fd, offset, nbytes, flags);
391 : : }
|
