f2fs: support fs shutdown

This patch introduces a generic ioctl for fs shutdown, which was used by xfs.

If this shutdown is triggered, filesystem stops any further IOs according to the
following options.

1. FS_GOING_DOWN_FULLSYNC
 : this will flush all the data and dentry blocks, and do checkpoint before
   shutdown.

2. FS_GOING_DOWN_METASYNC
 : this will do checkpoint before shutdown.

3. FS_GOING_DOWN_NOSYNC
 : this will trigger shutdown as is.

Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 08fc7e0d5e4ab9496286e31a5d42e46385005047..51d97f7b77f04beea0e42c907eaa923b051f3fdc 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -217,6 +217,15 @@ static inline bool __has_cursum_space(struct f2fs_summary_block *sum, int size,
 #define F2FS_IOC_RELEASE_VOLATILE_WRITE        _IO(F2FS_IOCTL_MAGIC, 4)
 #define F2FS_IOC_ABORT_VOLATILE_WRITE  _IO(F2FS_IOCTL_MAGIC, 5)
 
+/*
+ * should be same as XFS_IOC_GOINGDOWN.
+ * Flags for going down operation used by FS_IOC_GOINGDOWN
+ */
+#define F2FS_IOC_SHUTDOWN      _IOR('X', 125, __u32)   /* Shutdown */
+#define F2FS_GOING_DOWN_FULLSYNC       0x0     /* going down with full sync */
+#define F2FS_GOING_DOWN_METASYNC       0x1     /* going down with metadata */
+#define F2FS_GOING_DOWN_NOSYNC         0x2     /* going down */
+
 #if defined(__KERNEL__) && defined(CONFIG_COMPAT)
 /*
  * ioctl commands in 32 bit emulation

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index baadaf2afc6c8895cd3111723469a00f3c9d8100..99cec04fa96eedfbd4675a627f5f5f614ff2e6c0 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1029,6 +1029,41 @@ static int f2fs_ioc_abort_volatile_write(struct file *filp)
        return ret;
 }
 
+static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
+{
+       struct inode *inode = file_inode(filp);
+       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+       struct super_block *sb = sbi->sb;
+       __u32 in;
+
+       if (!capable(CAP_SYS_ADMIN))
+               return -EPERM;
+
+       if (get_user(in, (__u32 __user *)arg))
+               return -EFAULT;
+
+       switch (in) {
+       case F2FS_GOING_DOWN_FULLSYNC:
+               sb = freeze_bdev(sb->s_bdev);
+               if (sb && !IS_ERR(sb)) {
+                       f2fs_stop_checkpoint(sbi);
+                       thaw_bdev(sb->s_bdev, sb);
+               }
+               break;
+       case F2FS_GOING_DOWN_METASYNC:
+               /* do checkpoint only */
+               f2fs_sync_fs(sb, 1);
+               f2fs_stop_checkpoint(sbi);
+               break;
+       case F2FS_GOING_DOWN_NOSYNC:
+               f2fs_stop_checkpoint(sbi);
+               break;
+       default:
+               return -EINVAL;
+       }
+       return 0;
+}
+
 static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
 {
        struct inode *inode = file_inode(filp);
@@ -1078,6 +1113,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                return f2fs_ioc_release_volatile_write(filp);
        case F2FS_IOC_ABORT_VOLATILE_WRITE:
                return f2fs_ioc_abort_volatile_write(filp);
+       case F2FS_IOC_SHUTDOWN:
+               return f2fs_ioc_shutdown(filp, arg);
        case FITRIM:
                return f2fs_ioc_fitrim(filp, arg);
        default: