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_GPL(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 filemap_fdatawait(bdev->bd_inode->i_mapping); 90 } 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 SYSCALL_DEFINE0(sync) 103 { 104 int nowait = 0, wait = 1; 105 106 wakeup_flusher_threads(0, WB_REASON_SYNC); 107 iterate_supers(sync_inodes_one_sb, NULL); 108 iterate_supers(sync_fs_one_sb, &nowait); 109 iterate_supers(sync_fs_one_sb, &wait); 110 iterate_bdevs(fdatawrite_one_bdev, NULL); 111 iterate_bdevs(fdatawait_one_bdev, NULL); 112 if (unlikely(laptop_mode)) 113 laptop_sync_completion(); 114 return 0; 115 } 116 117 static void do_sync_work(struct work_struct *work) 118 { 119 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 iterate_supers(sync_inodes_one_sb, &nowait); 126 iterate_supers(sync_fs_one_sb, &nowait); 127 iterate_bdevs(fdatawrite_one_bdev, NULL); 128 iterate_supers(sync_inodes_one_sb, &nowait); 129 iterate_supers(sync_fs_one_sb, &nowait); 130 iterate_bdevs(fdatawrite_one_bdev, NULL); 131 printk("Emergency Sync complete\n"); 132 kfree(work); 133 } 134 135 void emergency_sync(void) 136 { 137 struct work_struct *work; 138 139 work = kmalloc(sizeof(*work), GFP_ATOMIC); 140 if (work) { 141 INIT_WORK(work, do_sync_work); 142 schedule_work(work); 143 } 144 } 145 146 /* 147 * sync a single super 148 */ 149 SYSCALL_DEFINE1(syncfs, int, fd) 150 { 151 struct file *file; 152 struct super_block *sb; 153 int ret; 154 int fput_needed; 155 156 file = fget_light(fd, &fput_needed); 157 if (!file) 158 return -EBADF; 159 sb = file->f_dentry->d_sb; 160 161 down_read(&sb->s_umount); 162 ret = sync_filesystem(sb); 163 up_read(&sb->s_umount); 164 165 fput_light(file, fput_needed); 166 return ret; 167 } 168 169 /** 170 * vfs_fsync_range - helper to sync a range of data & metadata to disk 171 * @file: file to sync 172 * @start: offset in bytes of the beginning of data range to sync 173 * @end: offset in bytes of the end of data range (inclusive) 174 * @datasync: perform only datasync 175 * 176 * Write back data in range @start..@end and metadata for @file to disk. If 177 * @datasync is set only metadata needed to access modified file data is 178 * written. 179 */ 180 int vfs_fsync_range(struct file *file, loff_t start, loff_t end, int datasync) 181 { 182 if (!file->f_op || !file->f_op->fsync) 183 return -EINVAL; 184 return file->f_op->fsync(file, start, end, datasync); 185 } 186 EXPORT_SYMBOL(vfs_fsync_range); 187 188 /** 189 * vfs_fsync - perform a fsync or fdatasync on a file 190 * @file: file to sync 191 * @datasync: only perform a fdatasync operation 192 * 193 * Write back data and metadata for @file to disk. If @datasync is 194 * set only metadata needed to access modified file data is written. 195 */ 196 int vfs_fsync(struct file *file, int datasync) 197 { 198 return vfs_fsync_range(file, 0, LLONG_MAX, datasync); 199 } 200 EXPORT_SYMBOL(vfs_fsync); 201 202 static int do_fsync(unsigned int fd, int datasync) 203 { 204 struct file *file; 205 int ret = -EBADF; 206 int fput_needed; 207 208 file = fget_light(fd, &fput_needed); 209 if (file) { 210 ret = vfs_fsync(file, datasync); 211 fput_light(file, fput_needed); 212 } 213 return ret; 214 } 215 216 SYSCALL_DEFINE1(fsync, unsigned int, fd) 217 { 218 return do_fsync(fd, 0); 219 } 220 221 SYSCALL_DEFINE1(fdatasync, unsigned int, fd) 222 { 223 return do_fsync(fd, 1); 224 } 225 226 /** 227 * generic_write_sync - perform syncing after a write if file / inode is sync 228 * @file: file to which the write happened 229 * @pos: offset where the write started 230 * @count: length of the write 231 * 232 * This is just a simple wrapper about our general syncing function. 233 */ 234 int generic_write_sync(struct file *file, loff_t pos, loff_t count) 235 { 236 if (!(file->f_flags & O_DSYNC) && !IS_SYNC(file->f_mapping->host)) 237 return 0; 238 return vfs_fsync_range(file, pos, pos + count - 1, 239 (file->f_flags & __O_SYNC) ? 0 : 1); 240 } 241 EXPORT_SYMBOL(generic_write_sync); 242 243 /* 244 * sys_sync_file_range() permits finely controlled syncing over a segment of 245 * a file in the range offset .. (offset+nbytes-1) inclusive. If nbytes is 246 * zero then sys_sync_file_range() will operate from offset out to EOF. 247 * 248 * The flag bits are: 249 * 250 * SYNC_FILE_RANGE_WAIT_BEFORE: wait upon writeout of all pages in the range 251 * before performing the write. 252 * 253 * SYNC_FILE_RANGE_WRITE: initiate writeout of all those dirty pages in the 254 * range which are not presently under writeback. Note that this may block for 255 * significant periods due to exhaustion of disk request structures. 256 * 257 * SYNC_FILE_RANGE_WAIT_AFTER: wait upon writeout of all pages in the range 258 * after performing the write. 259 * 260 * Useful combinations of the flag bits are: 261 * 262 * SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE: ensures that all pages 263 * in the range which were dirty on entry to sys_sync_file_range() are placed 264 * under writeout. This is a start-write-for-data-integrity operation. 265 * 266 * SYNC_FILE_RANGE_WRITE: start writeout of all dirty pages in the range which 267 * are not presently under writeout. This is an asynchronous flush-to-disk 268 * operation. Not suitable for data integrity operations. 269 * 270 * SYNC_FILE_RANGE_WAIT_BEFORE (or SYNC_FILE_RANGE_WAIT_AFTER): wait for 271 * completion of writeout of all pages in the range. This will be used after an 272 * earlier SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE operation to wait 273 * for that operation to complete and to return the result. 274 * 275 * SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE|SYNC_FILE_RANGE_WAIT_AFTER: 276 * a traditional sync() operation. This is a write-for-data-integrity operation 277 * which will ensure that all pages in the range which were dirty on entry to 278 * sys_sync_file_range() are committed to disk. 279 * 280 * 281 * SYNC_FILE_RANGE_WAIT_BEFORE and SYNC_FILE_RANGE_WAIT_AFTER will detect any 282 * I/O errors or ENOSPC conditions and will return those to the caller, after 283 * clearing the EIO and ENOSPC flags in the address_space. 284 * 285 * It should be noted that none of these operations write out the file's 286 * metadata. So unless the application is strictly performing overwrites of 287 * already-instantiated disk blocks, there are no guarantees here that the data 288 * will be available after a crash. 289 */ 290 SYSCALL_DEFINE(sync_file_range)(int fd, loff_t offset, loff_t nbytes, 291 unsigned int flags) 292 { 293 int ret; 294 struct file *file; 295 struct address_space *mapping; 296 loff_t endbyte; /* inclusive */ 297 int fput_needed; 298 umode_t i_mode; 299 300 ret = -EINVAL; 301 if (flags & ~VALID_FLAGS) 302 goto out; 303 304 endbyte = offset + nbytes; 305 306 if ((s64)offset < 0) 307 goto out; 308 if ((s64)endbyte < 0) 309 goto out; 310 if (endbyte < offset) 311 goto out; 312 313 if (sizeof(pgoff_t) == 4) { 314 if (offset >= (0x100000000ULL << PAGE_CACHE_SHIFT)) { 315 /* 316 * The range starts outside a 32 bit machine's 317 * pagecache addressing capabilities. Let it "succeed" 318 */ 319 ret = 0; 320 goto out; 321 } 322 if (endbyte >= (0x100000000ULL << PAGE_CACHE_SHIFT)) { 323 /* 324 * Out to EOF 325 */ 326 nbytes = 0; 327 } 328 } 329 330 if (nbytes == 0) 331 endbyte = LLONG_MAX; 332 else 333 endbyte--; /* inclusive */ 334 335 ret = -EBADF; 336 file = fget_light(fd, &fput_needed); 337 if (!file) 338 goto out; 339 340 i_mode = file->f_path.dentry->d_inode->i_mode; 341 ret = -ESPIPE; 342 if (!S_ISREG(i_mode) && !S_ISBLK(i_mode) && !S_ISDIR(i_mode) && 343 !S_ISLNK(i_mode)) 344 goto out_put; 345 346 mapping = file->f_mapping; 347 if (!mapping) { 348 ret = -EINVAL; 349 goto out_put; 350 } 351 352 ret = 0; 353 if (flags & SYNC_FILE_RANGE_WAIT_BEFORE) { 354 ret = filemap_fdatawait_range(mapping, offset, endbyte); 355 if (ret < 0) 356 goto out_put; 357 } 358 359 if (flags & SYNC_FILE_RANGE_WRITE) { 360 ret = filemap_fdatawrite_range(mapping, offset, endbyte); 361 if (ret < 0) 362 goto out_put; 363 } 364 365 if (flags & SYNC_FILE_RANGE_WAIT_AFTER) 366 ret = filemap_fdatawait_range(mapping, offset, endbyte); 367 368 out_put: 369 fput_light(file, fput_needed); 370 out: 371 return ret; 372 } 373 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS 374 asmlinkage long SyS_sync_file_range(long fd, loff_t offset, loff_t nbytes, 375 long flags) 376 { 377 return SYSC_sync_file_range((int) fd, offset, nbytes, 378 (unsigned int) flags); 379 } 380 SYSCALL_ALIAS(sys_sync_file_range, SyS_sync_file_range); 381 #endif 382 383 /* It would be nice if people remember that not all the world's an i386 384 when they introduce new system calls */ 385 SYSCALL_DEFINE(sync_file_range2)(int fd, unsigned int flags, 386 loff_t offset, loff_t nbytes) 387 { 388 return sys_sync_file_range(fd, offset, nbytes, flags); 389 } 390 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS 391 asmlinkage long SyS_sync_file_range2(long fd, long flags, 392 loff_t offset, loff_t nbytes) 393 { 394 return SYSC_sync_file_range2((int) fd, (unsigned int) flags, 395 offset, nbytes); 396 } 397 SYSCALL_ALIAS(sys_sync_file_range2, SyS_sync_file_range2); 398 #endif 399