OSDN Git Service

(root) / sagit-ice-cold / kernel_xiaomi_msm8998.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Merge remote-tracking branch 'origin/upstream-f2fs-stable-linux-4.4.y' into android-4.4
[sagit-ice-cold/kernel_xiaomi_msm8998.git] / fs / f2fs / namei.c
diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 794dac1..05193a1 100644 (file)
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -37,7 +37,7 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
                return ERR_PTR(-ENOMEM);
 
        f2fs_lock_op(sbi);
-       if (!alloc_nid(sbi, &ino)) {
+       if (!f2fs_alloc_nid(sbi, &ino)) {
                f2fs_unlock_op(sbi);
                err = -ENOSPC;
                goto fail;
@@ -54,6 +54,9 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
                        F2FS_I(inode)->i_crtime = current_time(inode);
        inode->i_generation = sbi->s_next_generation++;
 
+       if (S_ISDIR(inode->i_mode))
+               F2FS_I(inode)->i_current_depth = 1;
+
        err = insert_inode_locked(inode);
        if (err) {
                err = -EINVAL;
@@ -61,7 +64,7 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
        }
 
        if (f2fs_sb_has_project_quota(sbi->sb) &&
-               (F2FS_I(dir)->i_flags & FS_PROJINHERIT_FL))
+               (F2FS_I(dir)->i_flags & F2FS_PROJINHERIT_FL))
                F2FS_I(inode)->i_projid = F2FS_I(dir)->i_projid;
        else
                F2FS_I(inode)->i_projid = make_kprojid(&init_user_ns,
@@ -78,7 +81,8 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
        set_inode_flag(inode, FI_NEW_INODE);
 
        /* If the directory encrypted, then we should encrypt the inode. */
-       if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode))
+       if ((f2fs_encrypted_inode(dir) || DUMMY_ENCRYPTION_ENABLED(sbi)) &&
+                               f2fs_may_encrypt(inode))
                f2fs_set_encrypted_inode(inode);
 
        if (f2fs_sb_has_extra_attr(sbi->sb)) {
@@ -97,7 +101,7 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
        if (f2fs_sb_has_flexible_inline_xattr(sbi->sb)) {
                f2fs_bug_on(sbi, !f2fs_has_extra_attr(inode));
                if (f2fs_has_inline_xattr(inode))
-                       xattr_size = sbi->inline_xattr_size;
+                       xattr_size = F2FS_OPTION(sbi).inline_xattr_size;
                /* Otherwise, will be 0 */
        } else if (f2fs_has_inline_xattr(inode) ||
                                f2fs_has_inline_dentry(inode)) {
@@ -115,9 +119,9 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
                f2fs_mask_flags(mode, F2FS_I(dir)->i_flags & F2FS_FL_INHERITED);
 
        if (S_ISDIR(inode->i_mode))
-               F2FS_I(inode)->i_flags |= FS_INDEX_FL;
+               F2FS_I(inode)->i_flags |= F2FS_INDEX_FL;
 
-       if (F2FS_I(inode)->i_flags & FS_PROJINHERIT_FL)
+       if (F2FS_I(inode)->i_flags & F2FS_PROJINHERIT_FL)
                set_inode_flag(inode, FI_PROJ_INHERIT);
 
        trace_f2fs_new_inode(inode, 0);
@@ -192,7 +196,7 @@ static inline void set_file_temperature(struct f2fs_sb_info *sbi, struct inode *
        up_read(&sbi->sb_lock);
 }
 
-int update_extension_list(struct f2fs_sb_info *sbi, const char *name,
+int f2fs_update_extension_list(struct f2fs_sb_info *sbi, const char *name,
                                                        bool hot, bool set)
 {
        __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
@@ -242,7 +246,7 @@ int update_extension_list(struct f2fs_sb_info *sbi, const char *name,
                return -EINVAL;
 
        if (hot) {
-               strncpy(extlist[count], name, strlen(name));
+               memcpy(extlist[count], name, strlen(name));
                sbi->raw_super->hot_ext_count = hot_count + 1;
        } else {
                char buf[F2FS_MAX_EXTENSION][F2FS_EXTENSION_LEN];
@@ -250,7 +254,7 @@ int update_extension_list(struct f2fs_sb_info *sbi, const char *name,
                memcpy(buf, &extlist[cold_count],
                                F2FS_EXTENSION_LEN * hot_count);
                memset(extlist[cold_count], 0, F2FS_EXTENSION_LEN);
-               strncpy(extlist[cold_count], name, strlen(name));
+               memcpy(extlist[cold_count], name, strlen(name));
                memcpy(&extlist[cold_count + 1], buf,
                                F2FS_EXTENSION_LEN * hot_count);
                sbi->raw_super->extension_count = cpu_to_le32(cold_count + 1);
@@ -291,10 +295,9 @@ static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                goto out;
        f2fs_unlock_op(sbi);
 
-       alloc_nid_done(sbi, ino);
+       f2fs_alloc_nid_done(sbi, ino);
 
-       d_instantiate(dentry, inode);
-       unlock_new_inode(inode);
+       d_instantiate_new(dentry, inode);
 
        if (IS_DIRSYNC(dir))
                f2fs_sync_fs(sbi->sb, 1);
@@ -302,7 +305,7 @@ static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
        f2fs_balance_fs(sbi, true);
        return 0;
 out:
-       handle_failed_inode(inode);
+       f2fs_handle_failed_inode(inode);
        return err;
 }
 
@@ -397,7 +400,7 @@ static int __recover_dot_dentries(struct inode *dir, nid_t pino)
                err = PTR_ERR(page);
                goto out;
        } else {
-               err = __f2fs_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR);
+               err = f2fs_do_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR);
                if (err)
                        goto out;
        }
@@ -408,7 +411,7 @@ static int __recover_dot_dentries(struct inode *dir, nid_t pino)
        else if (IS_ERR(page))
                err = PTR_ERR(page);
        else
-               err = __f2fs_add_link(dir, &dotdot, NULL, pino, S_IFDIR);
+               err = f2fs_do_add_link(dir, &dotdot, NULL, pino, S_IFDIR);
 out:
        if (!err)
                clear_inode_flag(dir, FI_INLINE_DOTS);
@@ -520,7 +523,7 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
        f2fs_balance_fs(sbi, true);
 
        f2fs_lock_op(sbi);
-       err = acquire_orphan_inode(sbi);
+       err = f2fs_acquire_orphan_inode(sbi);
        if (err) {
                f2fs_unlock_op(sbi);
                f2fs_put_page(page, 0);
@@ -582,9 +585,9 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
        f2fs_lock_op(sbi);
        err = f2fs_add_link(dentry, inode);
        if (err)
-               goto out_handle_failed_inode;
+               goto out_f2fs_handle_failed_inode;
        f2fs_unlock_op(sbi);
-       alloc_nid_done(sbi, inode->i_ino);
+       f2fs_alloc_nid_done(sbi, inode->i_ino);
 
        err = fscrypt_encrypt_symlink(inode, symname, len, &disk_link);
        if (err)
@@ -593,8 +596,7 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
        err = page_symlink(inode, disk_link.name, disk_link.len);
 
 err_out:
-       d_instantiate(dentry, inode);
-       unlock_new_inode(inode);
+       d_instantiate_new(dentry, inode);
 
        /*
         * Let's flush symlink data in order to avoid broken symlink as much as
@@ -618,8 +620,8 @@ err_out:
        f2fs_balance_fs(sbi, true);
        goto out_free_encrypted_link;
 
-out_handle_failed_inode:
-       handle_failed_inode(inode);
+out_f2fs_handle_failed_inode:
+       f2fs_handle_failed_inode(inode);
 out_free_encrypted_link:
        if (disk_link.name != (unsigned char *)symname)
                kfree(disk_link.name);
@@ -655,10 +657,9 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
                goto out_fail;
        f2fs_unlock_op(sbi);
 
-       alloc_nid_done(sbi, inode->i_ino);
+       f2fs_alloc_nid_done(sbi, inode->i_ino);
 
-       d_instantiate(dentry, inode);
-       unlock_new_inode(inode);
+       d_instantiate_new(dentry, inode);
 
        if (IS_DIRSYNC(dir))
                f2fs_sync_fs(sbi->sb, 1);
@@ -668,7 +669,7 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 
 out_fail:
        clear_inode_flag(inode, FI_INC_LINK);
-       handle_failed_inode(inode);
+       f2fs_handle_failed_inode(inode);
        return err;
 }
 
@@ -707,10 +708,9 @@ static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
                goto out;
        f2fs_unlock_op(sbi);
 
-       alloc_nid_done(sbi, inode->i_ino);
+       f2fs_alloc_nid_done(sbi, inode->i_ino);
 
-       d_instantiate(dentry, inode);
-       unlock_new_inode(inode);
+       d_instantiate_new(dentry, inode);
 
        if (IS_DIRSYNC(dir))
                f2fs_sync_fs(sbi->sb, 1);
@@ -718,7 +718,7 @@ static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
        f2fs_balance_fs(sbi, true);
        return 0;
 out:
-       handle_failed_inode(inode);
+       f2fs_handle_failed_inode(inode);
        return err;
 }
 
@@ -747,7 +747,7 @@ static int __f2fs_tmpfile(struct inode *dir, struct dentry *dentry,
        }
 
        f2fs_lock_op(sbi);
-       err = acquire_orphan_inode(sbi);
+       err = f2fs_acquire_orphan_inode(sbi);
        if (err)
                goto out;
 
@@ -759,8 +759,8 @@ static int __f2fs_tmpfile(struct inode *dir, struct dentry *dentry,
         * add this non-linked tmpfile to orphan list, in this way we could
         * remove all unused data of tmpfile after abnormal power-off.
         */
-       add_orphan_inode(inode);
-       alloc_nid_done(sbi, inode->i_ino);
+       f2fs_add_orphan_inode(inode);
+       f2fs_alloc_nid_done(sbi, inode->i_ino);
 
        if (whiteout) {
                f2fs_i_links_write(inode, false);
@@ -776,18 +776,20 @@ static int __f2fs_tmpfile(struct inode *dir, struct dentry *dentry,
        return 0;
 
 release_out:
-       release_orphan_inode(sbi);
+       f2fs_release_orphan_inode(sbi);
 out:
-       handle_failed_inode(inode);
+       f2fs_handle_failed_inode(inode);
        return err;
 }
 
 static int f2fs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
-       if (unlikely(f2fs_cp_error(F2FS_I_SB(dir))))
+       struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
+
+       if (unlikely(f2fs_cp_error(sbi)))
                return -EIO;
 
-       if (f2fs_encrypted_inode(dir)) {
+       if (f2fs_encrypted_inode(dir) || DUMMY_ENCRYPTION_ENABLED(sbi)) {
                int err = fscrypt_get_encryption_info(dir);
                if (err)
                        return err;
@@ -883,7 +885,7 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
                f2fs_lock_op(sbi);
 
-               err = acquire_orphan_inode(sbi);
+               err = f2fs_acquire_orphan_inode(sbi);
                if (err)
                        goto put_out_dir;
 
@@ -897,9 +899,9 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                up_write(&F2FS_I(new_inode)->i_sem);
 
                if (!new_inode->i_nlink)
-                       add_orphan_inode(new_inode);
+                       f2fs_add_orphan_inode(new_inode);
                else
-                       release_orphan_inode(sbi);
+                       f2fs_release_orphan_inode(sbi);
        } else {
                f2fs_balance_fs(sbi, true);
 
@@ -967,7 +969,12 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        f2fs_put_page(old_dir_page, 0);
                f2fs_i_links_write(old_dir, false);
        }
-       add_ino_entry(sbi, new_dir->i_ino, TRANS_DIR_INO);
+       if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT) {
+               f2fs_add_ino_entry(sbi, new_dir->i_ino, TRANS_DIR_INO);
+               if (S_ISDIR(old_inode->i_mode))
+                       f2fs_add_ino_entry(sbi, old_inode->i_ino,
+                                                       TRANS_DIR_INO);
+       }
 
        f2fs_unlock_op(sbi);
 
@@ -1117,8 +1124,10 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
        }
        f2fs_mark_inode_dirty_sync(new_dir, false);
 
-       add_ino_entry(sbi, old_dir->i_ino, TRANS_DIR_INO);
-       add_ino_entry(sbi, new_dir->i_ino, TRANS_DIR_INO);
+       if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT) {
+               f2fs_add_ino_entry(sbi, old_dir->i_ino, TRANS_DIR_INO);
+               f2fs_add_ino_entry(sbi, new_dir->i_ino, TRANS_DIR_INO);
+       }
 
        f2fs_unlock_op(sbi);
 
Mirror: https://github.com/0ranko0P/kernel_xiaomi_msm8998/
About OSDN
Find Software
Develop Software
Help