Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/fs/sync.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us