f2fs: stop all the operations by cp_error flag

This patch replaces to use cp_error flag instead of RDONLY for quota off.

Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/acl.c b/fs/f2fs/acl.c
index 436b3a1464d9bd29c8756750b3a38154b2e1c313..2bb7c9fc5144aba162b01ba72295994f9fd23f00 100644 (file)
--- a/fs/f2fs/acl.c
+++ b/fs/f2fs/acl.c
@@ -250,6 +250,9 @@ static int __f2fs_set_acl(struct inode *inode, int type,
 
 int f2fs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
 {
+       if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
+               return -EIO;
+
        return __f2fs_set_acl(inode, type, acl, NULL);
 }
 

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 201608281681e6f5f1099591e72d06af4a72a59c..6b52d4b66c7b256c00609fdf38d5f3a958c7709d 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -29,7 +29,6 @@ struct kmem_cache *inode_entry_slab;
 void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io)
 {
        set_ckpt_flags(sbi, CP_ERROR_FLAG);
-       sbi->sb->s_flags |= MS_RDONLY;
        if (!end_io)
                f2fs_flush_merged_writes(sbi);
 }

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 2a414561eb4a34d288584b735a53e3cc2e8ae89e..86d6dfe3faab1e2c774d7684476e085009e339f1 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -53,6 +53,11 @@ static int f2fs_vm_page_mkwrite(struct vm_fault *vmf)
        struct dnode_of_data dn;
        int err;
 
+       if (unlikely(f2fs_cp_error(sbi))) {
+               err = -EIO;
+               goto err;
+       }
+
        sb_start_pagefault(inode->i_sb);
 
        f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
@@ -114,6 +119,7 @@ out_sem:
 out:
        sb_end_pagefault(inode->i_sb);
        f2fs_update_time(sbi, REQ_TIME);
+err:
        return block_page_mkwrite_return(err);
 }
 
@@ -310,6 +316,8 @@ out:
 
 int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 {
+       if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file)))))
+               return -EIO;
        return f2fs_do_sync_file(file, start, end, datasync, false);
 }
 
@@ -446,6 +454,9 @@ static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
        struct inode *inode = file_inode(file);
        int err;
 
+       if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
+               return -EIO;
+
        /* we don't need to use inline_data strictly */
        err = f2fs_convert_inline_inode(inode);
        if (err)
@@ -632,6 +643,9 @@ int f2fs_truncate(struct inode *inode)
 {
        int err;
 
+       if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
+               return -EIO;
+
        if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
                                S_ISLNK(inode->i_mode)))
                return 0;
@@ -731,6 +745,9 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
        int err;
        bool size_changed = false;
 
+       if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
+               return -EIO;
+
        err = setattr_prepare(dentry, attr);
        if (err)
                return err;
@@ -1459,6 +1476,9 @@ static long f2fs_fallocate(struct file *file, int mode,
        struct inode *inode = file_inode(file);
        long ret = 0;
 
+       if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
+               return -EIO;
+
        /* f2fs only support ->fallocate for regular file */
        if (!S_ISREG(inode->i_mode))
                return -EINVAL;
@@ -2637,6 +2657,9 @@ static int f2fs_ioc_fssetxattr(struct file *filp, unsigned long arg)
 
 long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
+       if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
+               return -EIO;
+
        switch (cmd) {
        case F2FS_IOC_GETFLAGS:
                return f2fs_ioc_getflags(filp, arg);
@@ -2694,6 +2717,9 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        struct blk_plug plug;
        ssize_t ret;
 
+       if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
+               return -EIO;
+
        inode_lock(inode);
        ret = generic_write_checks(iocb, from);
        if (ret > 0) {

diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 6ab8ac9fe0437434b0ae1ee7d347ca13eab7a51f..2c5dd1d0140fdaacfb3f281d2494e9f0bbf52f76 100644 (file)
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -177,6 +177,9 @@ static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
        nid_t ino = 0;
        int err;
 
+       if (unlikely(f2fs_cp_error(sbi)))
+               return -EIO;
+
        err = dquot_initialize(dir);
        if (err)
                return err;
@@ -221,6 +224,9 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
        struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
        int err;
 
+       if (unlikely(f2fs_cp_error(sbi)))
+               return -EIO;
+
        if (f2fs_encrypted_inode(dir) &&
                        !fscrypt_has_permitted_context(dir, inode))
                return -EPERM;
@@ -420,6 +426,9 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
 
        trace_f2fs_unlink_enter(dir, dentry);
 
+       if (unlikely(f2fs_cp_error(sbi)))
+               return -EIO;
+
        err = dquot_initialize(dir);
        if (err)
                return err;
@@ -475,6 +484,9 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
        struct fscrypt_symlink_data *sd = NULL;
        int err;
 
+       if (unlikely(f2fs_cp_error(sbi)))
+               return -EIO;
+
        if (f2fs_encrypted_inode(dir)) {
                err = fscrypt_get_encryption_info(dir);
                if (err)
@@ -581,6 +593,9 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
        struct inode *inode;
        int err;
 
+       if (unlikely(f2fs_cp_error(sbi)))
+               return -EIO;
+
        err = dquot_initialize(dir);
        if (err)
                return err;
@@ -633,6 +648,9 @@ static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
        struct inode *inode;
        int err = 0;
 
+       if (unlikely(f2fs_cp_error(sbi)))
+               return -EIO;
+
        err = dquot_initialize(dir);
        if (err)
                return err;
@@ -727,6 +745,9 @@ out:
 
 static int f2fs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
+       if (unlikely(f2fs_cp_error(F2FS_I_SB(dir))))
+               return -EIO;
+
        if (f2fs_encrypted_inode(dir)) {
                int err = fscrypt_get_encryption_info(dir);
                if (err)
@@ -738,6 +759,9 @@ static int f2fs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
 
 static int f2fs_create_whiteout(struct inode *dir, struct inode **whiteout)
 {
+       if (unlikely(f2fs_cp_error(F2FS_I_SB(dir))))
+               return -EIO;
+
        return __f2fs_tmpfile(dir, NULL, S_IFCHR | WHITEOUT_MODE, whiteout);
 }
 
@@ -757,6 +781,9 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
        bool is_old_inline = f2fs_has_inline_dentry(old_dir);
        int err = -ENOENT;
 
+       if (unlikely(f2fs_cp_error(sbi)))
+               return -EIO;
+
        if ((f2fs_encrypted_inode(old_dir) &&
                        !fscrypt_has_encryption_key(old_dir)) ||
                        (f2fs_encrypted_inode(new_dir) &&
@@ -950,6 +977,9 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
        int old_nlink = 0, new_nlink = 0;
        int err = -ENOENT;
 
+       if (unlikely(f2fs_cp_error(sbi)))
+               return -EIO;
+
        if ((f2fs_encrypted_inode(old_dir) &&
                        !fscrypt_has_encryption_key(old_dir)) ||
                        (f2fs_encrypted_inode(new_dir) &&

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 491dce39d47a9eb38880cb9e348bb4e1cd3ea6a0..97fa81503e1feecc858254bb009d6154b2dc9fad 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -859,6 +859,9 @@ int f2fs_sync_fs(struct super_block *sb, int sync)
        struct f2fs_sb_info *sbi = F2FS_SB(sb);
        int err = 0;
 
+       if (unlikely(f2fs_cp_error(sbi)))
+               return 0;
+
        trace_f2fs_sync_fs(sb, sync);
 
        if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))