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