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