Branch data     Line data    Source code

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