f2fs: report error for f2fs_parent_dir

[deliverable/linux.git] / fs / f2fs / namei.c

diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 324ed3812f30e906cdb5d9c2a6135135b5035dc4..618829e8049c09de846972a5438e92fca19dbcc9 100644 (file)
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -60,10 +60,14 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
        if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode))
                f2fs_set_encrypted_inode(inode);
 
+       set_inode_flag(inode, FI_NEW_INODE);
+
+       if (test_opt(sbi, INLINE_XATTR))
+               set_inode_flag(inode, FI_INLINE_XATTR);
        if (test_opt(sbi, INLINE_DATA) && f2fs_may_inline_data(inode))
-               set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
+               set_inode_flag(inode, FI_INLINE_DATA);
        if (f2fs_may_inline_dentry(inode))
-               set_inode_flag(F2FS_I(inode), FI_INLINE_DENTRY);
+               set_inode_flag(inode, FI_INLINE_DENTRY);
 
        f2fs_init_extent_tree(inode, NULL);
 
@@ -72,14 +76,13 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
        stat_inc_inline_dir(inode);
 
        trace_f2fs_new_inode(inode, 0);
-       mark_inode_dirty(inode);
        return inode;
 
 fail:
        trace_f2fs_new_inode(inode, err);
        make_bad_inode(inode);
        if (nid_free)
-               set_inode_flag(F2FS_I(inode), FI_FREE_NID);
+               set_inode_flag(inode, FI_FREE_NID);
        iput(inode);
        return ERR_PTR(err);
 }
@@ -177,7 +180,7 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
        inode->i_ctime = CURRENT_TIME;
        ihold(inode);
 
-       set_inode_flag(F2FS_I(inode), FI_INC_LINK);
+       set_inode_flag(inode, FI_INC_LINK);
        f2fs_lock_op(sbi);
        err = f2fs_add_link(dentry, inode);
        if (err)
@@ -190,7 +193,7 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
                f2fs_sync_fs(sbi->sb, 1);
        return 0;
 out:
-       clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
+       clear_inode_flag(inode, FI_INC_LINK);
        iput(inode);
        f2fs_unlock_op(sbi);
        return err;
@@ -229,6 +232,9 @@ static int __recover_dot_dentries(struct inode *dir, nid_t pino)
        if (de) {
                f2fs_dentry_kunmap(dir, page);
                f2fs_put_page(page, 0);
+       } else if (IS_ERR(page)) {
+               err = PTR_ERR(page);
+               goto out;
        } else {
                err = __f2fs_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR);
                if (err)
@@ -239,14 +245,14 @@ static int __recover_dot_dentries(struct inode *dir, nid_t pino)
        if (de) {
                f2fs_dentry_kunmap(dir, page);
                f2fs_put_page(page, 0);
+       } else if (IS_ERR(page)) {
+               err = PTR_ERR(page);
        } else {
                err = __f2fs_add_link(dir, &dotdot, NULL, pino, S_IFDIR);
        }
 out:
-       if (!err) {
-               clear_inode_flag(F2FS_I(dir), FI_INLINE_DOTS);
-               mark_inode_dirty(dir);
-       }
+       if (!err)
+               clear_inode_flag(dir, FI_INLINE_DOTS);
 
        f2fs_unlock_op(sbi);
        return err;
@@ -281,8 +287,11 @@ static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
                return ERR_PTR(-ENAMETOOLONG);
 
        de = f2fs_find_entry(dir, &dentry->d_name, &page);
-       if (!de)
+       if (!de) {
+               if (IS_ERR(page))
+                       return (struct dentry *)page;
                return d_splice_alias(inode, dentry);
+       }
 
        ino = le32_to_cpu(de->ino);
        f2fs_dentry_kunmap(dir, page);
@@ -345,9 +354,6 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
        f2fs_delete_entry(de, page, dir, inode);
        f2fs_unlock_op(sbi);
 
-       /* In order to evict this inode, we set it dirty */
-       mark_inode_dirty(inode);
-
        if (IS_DIRSYNC(dir))
                f2fs_sync_fs(sbi->sb, 1);
 fail:
@@ -492,7 +498,7 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 
        f2fs_balance_fs(sbi, true);
 
-       set_inode_flag(F2FS_I(inode), FI_INC_LINK);
+       set_inode_flag(inode, FI_INC_LINK);
        f2fs_lock_op(sbi);
        err = f2fs_add_link(dentry, inode);
        if (err)
@@ -509,7 +515,7 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
        return 0;
 
 out_fail:
-       clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
+       clear_inode_flag(inode, FI_INC_LINK);
        handle_failed_inode(inode);
        return err;
 }
@@ -593,16 +599,16 @@ static int __f2fs_tmpfile(struct inode *dir, struct dentry *dentry,
         * remove all unused data of tmpfile after abnormal power-off.
         */
        add_orphan_inode(sbi, inode->i_ino);
-       f2fs_unlock_op(sbi);
-
        alloc_nid_done(sbi, inode->i_ino);
 
        if (whiteout) {
-               inode_dec_link_count(inode);
+               f2fs_i_links_write(inode, false);
                *whiteout = inode;
        } else {
                d_tmpfile(dentry, inode);
        }
+       /* link_count was changed by d_tmpfile as well. */
+       f2fs_unlock_op(sbi);
        unlock_new_inode(inode);
        return 0;
 
@@ -656,10 +662,11 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                goto out;
 
        if (S_ISDIR(old_inode->i_mode)) {
-               err = -EIO;
                old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page);
-               if (!old_dir_entry)
+               if (!old_dir_entry) {
+                       err = PTR_ERR(old_dir_page);
                        goto out_old;
+               }
        }
 
        if (flags & RENAME_WHITEOUT) {
@@ -700,19 +707,14 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                new_inode->i_ctime = CURRENT_TIME;
                down_write(&F2FS_I(new_inode)->i_sem);
                if (old_dir_entry)
-                       drop_nlink(new_inode);
-               drop_nlink(new_inode);
+                       f2fs_i_links_write(new_inode, false);
+               f2fs_i_links_write(new_inode, false);
                up_write(&F2FS_I(new_inode)->i_sem);
 
-               mark_inode_dirty(new_inode);
-
                if (!new_inode->i_nlink)
                        add_orphan_inode(sbi, new_inode->i_ino);
                else
                        release_orphan_inode(sbi);
-
-               update_inode_page(old_inode);
-               update_inode_page(new_inode);
        } else {
                f2fs_balance_fs(sbi, true);
 
@@ -724,10 +726,8 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        goto out_whiteout;
                }
 
-               if (old_dir_entry) {
-                       inc_nlink(new_dir);
-                       update_inode_page(new_dir);
-               }
+               if (old_dir_entry)
+                       f2fs_i_links_write(new_dir, true);
 
                /*
                 * old entry and new entry can locate in the same inline
@@ -757,13 +757,13 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
        up_write(&F2FS_I(old_inode)->i_sem);
 
        old_inode->i_ctime = CURRENT_TIME;
-       mark_inode_dirty(old_inode);
+       mark_inode_dirty_sync(old_inode);
 
        f2fs_delete_entry(old_entry, old_page, old_dir, NULL);
 
        if (whiteout) {
                whiteout->i_state |= I_LINKABLE;
-               set_inode_flag(F2FS_I(whiteout), FI_INC_LINK);
+               set_inode_flag(whiteout, FI_INC_LINK);
                err = f2fs_add_link(old_dentry, whiteout);
                if (err)
                        goto put_out_dir;
@@ -775,14 +775,11 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                if (old_dir != new_dir && !whiteout) {
                        f2fs_set_link(old_inode, old_dir_entry,
                                                old_dir_page, new_dir);
-                       update_inode_page(old_inode);
                } else {
                        f2fs_dentry_kunmap(old_inode, old_dir_page);
                        f2fs_put_page(old_dir_page, 0);
                }
-               drop_nlink(old_dir);
-               mark_inode_dirty(old_dir);
-               update_inode_page(old_dir);
+               f2fs_i_links_write(old_dir, false);
        }
 
        f2fs_unlock_op(sbi);
@@ -842,19 +839,21 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
        /* prepare for updating ".." directory entry info later */
        if (old_dir != new_dir) {
                if (S_ISDIR(old_inode->i_mode)) {
-                       err = -EIO;
                        old_dir_entry = f2fs_parent_dir(old_inode,
                                                        &old_dir_page);
-                       if (!old_dir_entry)
+                       if (!old_dir_entry) {
+                               err = PTR_ERR(old_dir_page);
                                goto out_new;
+                       }
                }
 
                if (S_ISDIR(new_inode->i_mode)) {
-                       err = -EIO;
                        new_dir_entry = f2fs_parent_dir(new_inode,
                                                        &new_dir_page);
-                       if (!new_dir_entry)
+                       if (!new_dir_entry) {
+                               err = PTR_ERR(new_dir_page);
                                goto out_old_dir;
+                       }
                }
        }
 
@@ -904,19 +903,13 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
        file_lost_pino(old_inode);
        up_write(&F2FS_I(old_inode)->i_sem);
 
-       update_inode_page(old_inode);
-
        old_dir->i_ctime = CURRENT_TIME;
        if (old_nlink) {
                down_write(&F2FS_I(old_dir)->i_sem);
-               if (old_nlink < 0)
-                       drop_nlink(old_dir);
-               else
-                       inc_nlink(old_dir);
+               f2fs_i_links_write(old_dir, old_nlink > 0);
                up_write(&F2FS_I(old_dir)->i_sem);
        }
-       mark_inode_dirty(old_dir);
-       update_inode_page(old_dir);
+       mark_inode_dirty_sync(old_dir);
 
        /* update directory entry info of new dir inode */
        f2fs_set_link(new_dir, new_entry, new_page, old_inode);
@@ -925,19 +918,13 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
        file_lost_pino(new_inode);
        up_write(&F2FS_I(new_inode)->i_sem);
 
-       update_inode_page(new_inode);
-
        new_dir->i_ctime = CURRENT_TIME;
        if (new_nlink) {
                down_write(&F2FS_I(new_dir)->i_sem);
-               if (new_nlink < 0)
-                       drop_nlink(new_dir);
-               else
-                       inc_nlink(new_dir);
+               f2fs_i_links_write(new_dir, new_nlink > 0);
                up_write(&F2FS_I(new_dir)->i_sem);
        }
-       mark_inode_dirty(new_dir);
-       update_inode_page(new_dir);
+       mark_inode_dirty_sync(new_dir);
 
        f2fs_unlock_op(sbi);