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 unsigned long start) 32 { 33 if (wait) 34 sync_inodes_sb(sb, start); 35 else 36 writeback_inodes_sb(sb, WB_REASON_SYNC); 37 38 if (sb->s_op->sync_fs) 39 sb->s_op->sync_fs(sb, wait); 40 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 int sync_filesystem(struct super_block *sb) 49 { 50 int ret; 51 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 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 if (sb->s_flags & MS_RDONLY) 63 return 0; 64 65 ret = __sync_filesystem(sb, 0, start); 66 if (ret < 0) 67 return ret; 68 return __sync_filesystem(sb, 1, start); 69 } 70 EXPORT_SYMBOL_GPL(sync_filesystem); 71 72 static void sync_inodes_one_sb(struct super_block *sb, void *arg) 73 { 74 if (!(sb->s_flags & MS_RDONLY)) 75 sync_inodes_sb(sb, *((unsigned long *)arg)); 76 } 77 78 static void sync_fs_one_sb(struct super_block *sb, void *arg) 79 { 80 if (!(sb->s_flags & MS_RDONLY) && sb->s_op->sync_fs) 81 sb->s_op->sync_fs(sb, *(int *)arg); 82 } 83 84 static void fdatawrite_one_bdev(struct block_device *bdev, void *arg) 85 { 86 filemap_fdatawrite(bdev->bd_inode->i_mapping); 87 } 88 89 static void fdatawait_one_bdev(struct block_device *bdev, void *arg) 90 { 91 filemap_fdatawait(bdev->bd_inode->i_mapping); 92 } 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 SYSCALL_DEFINE0(sync) 105 { 106 int nowait = 0, wait = 1; 107 unsigned long start = jiffies; 108 109 wakeup_flusher_threads(0, WB_REASON_SYNC); 110 iterate_supers(sync_inodes_one_sb, &start); 111 iterate_supers(sync_fs_one_sb, &nowait); 112 iterate_supers(sync_fs_one_sb, &wait); 113 iterate_bdevs(fdatawrite_one_bdev, NULL); 114 iterate_bdevs(fdatawait_one_bdev, NULL); 115 if (unlikely(laptop_mode)) 116 laptop_sync_completion(); 117 return 0; 118 } 119 120 static void do_sync_work(struct work_struct *work) 121 { 122 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 iterate_supers(sync_inodes_one_sb, &nowait); 129 iterate_supers(sync_fs_one_sb, &nowait); 130 iterate_bdevs(fdatawrite_one_bdev, NULL); 131 iterate_supers(sync_inodes_one_sb, &nowait); 132 iterate_supers(sync_fs_one_sb, &nowait); 133 iterate_bdevs(fdatawrite_one_bdev, NULL); 134 printk("Emergency Sync complete\n"); 135 kfree(work); 136 } 137 138 void emergency_sync(void) 139 { 140 struct work_struct *work; 141 142 work = kmalloc(sizeof(*work), GFP_ATOMIC); 143 if (work) { 144 INIT_WORK(work, do_sync_work); 145 schedule_work(work); 146 } 147 } 148 149 /* 150 * sync a single super 151 */ 152 SYSCALL_DEFINE1(syncfs, int, fd) 153 { 154 struct fd f = fdget(fd); 155 struct super_block *sb; 156 int ret; 157 158 if (!f.file) 159 return -EBADF; 160 sb = f.file->f_dentry->d_sb; 161 162 down_read(&sb->s_umount); 163 ret = sync_filesystem(sb); 164 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 int vfs_fsync_range(struct file *file, loff_t start, loff_t end, int datasync) 182 { 183 if (!file->f_op->fsync) 184 return -EINVAL; 185 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 int vfs_fsync(struct file *file, int datasync) 198 { 199 return vfs_fsync_range(file, 0, LLONG_MAX, datasync); 200 } 201 EXPORT_SYMBOL(vfs_fsync); 202 203 static int do_fsync(unsigned int fd, int datasync) 204 { 205 struct fd f = fdget(fd); 206 int ret = -EBADF; 207 208 if (f.file) { 209 ret = vfs_fsync(f.file, datasync); 210 fdput(f); 211 } 212 return ret; 213 } 214 215 SYSCALL_DEFINE1(fsync, unsigned int, fd) 216 { 217 return do_fsync(fd, 0); 218 } 219 220 SYSCALL_DEFINE1(fdatasync, unsigned int, fd) 221 { 222 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 int generic_write_sync(struct file *file, loff_t pos, loff_t count) 234 { 235 if (!(file->f_flags & O_DSYNC) && !IS_SYNC(file->f_mapping->host)) 236 return 0; 237 return vfs_fsync_range(file, pos, pos + count - 1, 238 (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 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 if (flags & ~VALID_FLAGS) 300 goto out; 301 302 endbyte = offset + nbytes; 303 304 if ((s64)offset < 0) 305 goto out; 306 if ((s64)endbyte < 0) 307 goto out; 308 if (endbyte < offset) 309 goto out; 310 311 if (sizeof(pgoff_t) == 4) { 312 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 if (endbyte >= (0x100000000ULL << PAGE_CACHE_SHIFT)) { 321 /* 322 * Out to EOF 323 */ 324 nbytes = 0; 325 } 326 } 327 328 if (nbytes == 0) 329 endbyte = LLONG_MAX; 330 else 331 endbyte--; /* inclusive */ 332 333 ret = -EBADF; 334 f = fdget(fd); 335 if (!f.file) 336 goto out; 337 338 i_mode = file_inode(f.file)->i_mode; 339 ret = -ESPIPE; 340 if (!S_ISREG(i_mode) && !S_ISBLK(i_mode) && !S_ISDIR(i_mode) && 341 !S_ISLNK(i_mode)) 342 goto out_put; 343 344 mapping = f.file->f_mapping; 345 if (!mapping) { 346 ret = -EINVAL; 347 goto out_put; 348 } 349 350 ret = 0; 351 if (flags & SYNC_FILE_RANGE_WAIT_BEFORE) { 352 ret = filemap_fdatawait_range(mapping, offset, endbyte); 353 if (ret < 0) 354 goto out_put; 355 } 356 357 if (flags & SYNC_FILE_RANGE_WRITE) { 358 ret = filemap_fdatawrite_range(mapping, offset, endbyte); 359 if (ret < 0) 360 goto out_put; 361 } 362 363 if (flags & SYNC_FILE_RANGE_WAIT_AFTER) 364 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 SYSCALL_DEFINE4(sync_file_range2, int, fd, unsigned int, flags, 375 loff_t, offset, loff_t, nbytes) 376 { 377 return sys_sync_file_range(fd, offset, nbytes, flags); 378 } 379