Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * fs/f2fs/namei.c
0004  *
0005  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
0006  *             http://www.samsung.com/
0007  */
0008 #include <linux/fs.h>
0009 #include <linux/f2fs_fs.h>
0010 #include <linux/pagemap.h>
0011 #include <linux/sched.h>
0012 #include <linux/ctype.h>
0013 #include <linux/random.h>
0014 #include <linux/dcache.h>
0015 #include <linux/namei.h>
0016 #include <linux/quotaops.h>
0017 
0018 #include "f2fs.h"
0019 #include "node.h"
0020 #include "segment.h"
0021 #include "xattr.h"
0022 #include "acl.h"
0023 #include <trace/events/f2fs.h>
0024 
0025 static struct inode *f2fs_new_inode(struct user_namespace *mnt_userns,
0026                         struct inode *dir, umode_t mode)
0027 {
0028     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0029     nid_t ino;
0030     struct inode *inode;
0031     bool nid_free = false;
0032     bool encrypt = false;
0033     int xattr_size = 0;
0034     int err;
0035 
0036     inode = new_inode(dir->i_sb);
0037     if (!inode)
0038         return ERR_PTR(-ENOMEM);
0039 
0040     if (!f2fs_alloc_nid(sbi, &ino)) {
0041         err = -ENOSPC;
0042         goto fail;
0043     }
0044 
0045     nid_free = true;
0046 
0047     inode_init_owner(mnt_userns, inode, dir, mode);
0048 
0049     inode->i_ino = ino;
0050     inode->i_blocks = 0;
0051     inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
0052     F2FS_I(inode)->i_crtime = inode->i_mtime;
0053     inode->i_generation = prandom_u32();
0054 
0055     if (S_ISDIR(inode->i_mode))
0056         F2FS_I(inode)->i_current_depth = 1;
0057 
0058     err = insert_inode_locked(inode);
0059     if (err) {
0060         err = -EINVAL;
0061         goto fail;
0062     }
0063 
0064     if (f2fs_sb_has_project_quota(sbi) &&
0065         (F2FS_I(dir)->i_flags & F2FS_PROJINHERIT_FL))
0066         F2FS_I(inode)->i_projid = F2FS_I(dir)->i_projid;
0067     else
0068         F2FS_I(inode)->i_projid = make_kprojid(mnt_userns,
0069                             F2FS_DEF_PROJID);
0070 
0071     err = fscrypt_prepare_new_inode(dir, inode, &encrypt);
0072     if (err)
0073         goto fail_drop;
0074 
0075     err = f2fs_dquot_initialize(inode);
0076     if (err)
0077         goto fail_drop;
0078 
0079     set_inode_flag(inode, FI_NEW_INODE);
0080 
0081     if (encrypt)
0082         f2fs_set_encrypted_inode(inode);
0083 
0084     if (f2fs_sb_has_extra_attr(sbi)) {
0085         set_inode_flag(inode, FI_EXTRA_ATTR);
0086         F2FS_I(inode)->i_extra_isize = F2FS_TOTAL_EXTRA_ATTR_SIZE;
0087     }
0088 
0089     if (test_opt(sbi, INLINE_XATTR))
0090         set_inode_flag(inode, FI_INLINE_XATTR);
0091 
0092     if (f2fs_may_inline_dentry(inode))
0093         set_inode_flag(inode, FI_INLINE_DENTRY);
0094 
0095     if (f2fs_sb_has_flexible_inline_xattr(sbi)) {
0096         f2fs_bug_on(sbi, !f2fs_has_extra_attr(inode));
0097         if (f2fs_has_inline_xattr(inode))
0098             xattr_size = F2FS_OPTION(sbi).inline_xattr_size;
0099         /* Otherwise, will be 0 */
0100     } else if (f2fs_has_inline_xattr(inode) ||
0101                 f2fs_has_inline_dentry(inode)) {
0102         xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
0103     }
0104     F2FS_I(inode)->i_inline_xattr_size = xattr_size;
0105 
0106     f2fs_init_extent_tree(inode, NULL);
0107 
0108     F2FS_I(inode)->i_flags =
0109         f2fs_mask_flags(mode, F2FS_I(dir)->i_flags & F2FS_FL_INHERITED);
0110 
0111     if (S_ISDIR(inode->i_mode))
0112         F2FS_I(inode)->i_flags |= F2FS_INDEX_FL;
0113 
0114     if (F2FS_I(inode)->i_flags & F2FS_PROJINHERIT_FL)
0115         set_inode_flag(inode, FI_PROJ_INHERIT);
0116 
0117     if (f2fs_sb_has_compression(sbi)) {
0118         /* Inherit the compression flag in directory */
0119         if ((F2FS_I(dir)->i_flags & F2FS_COMPR_FL) &&
0120                     f2fs_may_compress(inode))
0121             set_compress_context(inode);
0122     }
0123 
0124     /* Should enable inline_data after compression set */
0125     if (test_opt(sbi, INLINE_DATA) && f2fs_may_inline_data(inode))
0126         set_inode_flag(inode, FI_INLINE_DATA);
0127 
0128     stat_inc_inline_xattr(inode);
0129     stat_inc_inline_inode(inode);
0130     stat_inc_inline_dir(inode);
0131 
0132     f2fs_set_inode_flags(inode);
0133 
0134     trace_f2fs_new_inode(inode, 0);
0135     return inode;
0136 
0137 fail:
0138     trace_f2fs_new_inode(inode, err);
0139     make_bad_inode(inode);
0140     if (nid_free)
0141         set_inode_flag(inode, FI_FREE_NID);
0142     iput(inode);
0143     return ERR_PTR(err);
0144 fail_drop:
0145     trace_f2fs_new_inode(inode, err);
0146     dquot_drop(inode);
0147     inode->i_flags |= S_NOQUOTA;
0148     if (nid_free)
0149         set_inode_flag(inode, FI_FREE_NID);
0150     clear_nlink(inode);
0151     unlock_new_inode(inode);
0152     iput(inode);
0153     return ERR_PTR(err);
0154 }
0155 
0156 static inline int is_extension_exist(const unsigned char *s, const char *sub,
0157                         bool tmp_ext)
0158 {
0159     size_t slen = strlen(s);
0160     size_t sublen = strlen(sub);
0161     int i;
0162 
0163     if (sublen == 1 && *sub == '*')
0164         return 1;
0165 
0166     /*
0167      * filename format of multimedia file should be defined as:
0168      * "filename + '.' + extension + (optional: '.' + temp extension)".
0169      */
0170     if (slen < sublen + 2)
0171         return 0;
0172 
0173     if (!tmp_ext) {
0174         /* file has no temp extension */
0175         if (s[slen - sublen - 1] != '.')
0176             return 0;
0177         return !strncasecmp(s + slen - sublen, sub, sublen);
0178     }
0179 
0180     for (i = 1; i < slen - sublen; i++) {
0181         if (s[i] != '.')
0182             continue;
0183         if (!strncasecmp(s + i + 1, sub, sublen))
0184             return 1;
0185     }
0186 
0187     return 0;
0188 }
0189 
0190 /*
0191  * Set file's temperature for hot/cold data separation
0192  */
0193 static inline void set_file_temperature(struct f2fs_sb_info *sbi, struct inode *inode,
0194         const unsigned char *name)
0195 {
0196     __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
0197     int i, cold_count, hot_count;
0198 
0199     f2fs_down_read(&sbi->sb_lock);
0200 
0201     cold_count = le32_to_cpu(sbi->raw_super->extension_count);
0202     hot_count = sbi->raw_super->hot_ext_count;
0203 
0204     for (i = 0; i < cold_count + hot_count; i++) {
0205         if (is_extension_exist(name, extlist[i], true))
0206             break;
0207     }
0208 
0209     f2fs_up_read(&sbi->sb_lock);
0210 
0211     if (i == cold_count + hot_count)
0212         return;
0213 
0214     if (i < cold_count)
0215         file_set_cold(inode);
0216     else
0217         file_set_hot(inode);
0218 }
0219 
0220 int f2fs_update_extension_list(struct f2fs_sb_info *sbi, const char *name,
0221                             bool hot, bool set)
0222 {
0223     __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
0224     int cold_count = le32_to_cpu(sbi->raw_super->extension_count);
0225     int hot_count = sbi->raw_super->hot_ext_count;
0226     int total_count = cold_count + hot_count;
0227     int start, count;
0228     int i;
0229 
0230     if (set) {
0231         if (total_count == F2FS_MAX_EXTENSION)
0232             return -EINVAL;
0233     } else {
0234         if (!hot && !cold_count)
0235             return -EINVAL;
0236         if (hot && !hot_count)
0237             return -EINVAL;
0238     }
0239 
0240     if (hot) {
0241         start = cold_count;
0242         count = total_count;
0243     } else {
0244         start = 0;
0245         count = cold_count;
0246     }
0247 
0248     for (i = start; i < count; i++) {
0249         if (strcmp(name, extlist[i]))
0250             continue;
0251 
0252         if (set)
0253             return -EINVAL;
0254 
0255         memcpy(extlist[i], extlist[i + 1],
0256                 F2FS_EXTENSION_LEN * (total_count - i - 1));
0257         memset(extlist[total_count - 1], 0, F2FS_EXTENSION_LEN);
0258         if (hot)
0259             sbi->raw_super->hot_ext_count = hot_count - 1;
0260         else
0261             sbi->raw_super->extension_count =
0262                         cpu_to_le32(cold_count - 1);
0263         return 0;
0264     }
0265 
0266     if (!set)
0267         return -EINVAL;
0268 
0269     if (hot) {
0270         memcpy(extlist[count], name, strlen(name));
0271         sbi->raw_super->hot_ext_count = hot_count + 1;
0272     } else {
0273         char buf[F2FS_MAX_EXTENSION][F2FS_EXTENSION_LEN];
0274 
0275         memcpy(buf, &extlist[cold_count],
0276                 F2FS_EXTENSION_LEN * hot_count);
0277         memset(extlist[cold_count], 0, F2FS_EXTENSION_LEN);
0278         memcpy(extlist[cold_count], name, strlen(name));
0279         memcpy(&extlist[cold_count + 1], buf,
0280                 F2FS_EXTENSION_LEN * hot_count);
0281         sbi->raw_super->extension_count = cpu_to_le32(cold_count + 1);
0282     }
0283     return 0;
0284 }
0285 
0286 static void set_compress_inode(struct f2fs_sb_info *sbi, struct inode *inode,
0287                         const unsigned char *name)
0288 {
0289     __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
0290     unsigned char (*noext)[F2FS_EXTENSION_LEN] = F2FS_OPTION(sbi).noextensions;
0291     unsigned char (*ext)[F2FS_EXTENSION_LEN] = F2FS_OPTION(sbi).extensions;
0292     unsigned char ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
0293     unsigned char noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
0294     int i, cold_count, hot_count;
0295 
0296     if (!f2fs_sb_has_compression(sbi) ||
0297             F2FS_I(inode)->i_flags & F2FS_NOCOMP_FL ||
0298             !f2fs_may_compress(inode) ||
0299             (!ext_cnt && !noext_cnt))
0300         return;
0301 
0302     f2fs_down_read(&sbi->sb_lock);
0303 
0304     cold_count = le32_to_cpu(sbi->raw_super->extension_count);
0305     hot_count = sbi->raw_super->hot_ext_count;
0306 
0307     for (i = cold_count; i < cold_count + hot_count; i++) {
0308         if (is_extension_exist(name, extlist[i], false)) {
0309             f2fs_up_read(&sbi->sb_lock);
0310             return;
0311         }
0312     }
0313 
0314     f2fs_up_read(&sbi->sb_lock);
0315 
0316     for (i = 0; i < noext_cnt; i++) {
0317         if (is_extension_exist(name, noext[i], false)) {
0318             f2fs_disable_compressed_file(inode);
0319             return;
0320         }
0321     }
0322 
0323     if (is_inode_flag_set(inode, FI_COMPRESSED_FILE))
0324         return;
0325 
0326     for (i = 0; i < ext_cnt; i++) {
0327         if (!is_extension_exist(name, ext[i], false))
0328             continue;
0329 
0330         /* Do not use inline_data with compression */
0331         stat_dec_inline_inode(inode);
0332         clear_inode_flag(inode, FI_INLINE_DATA);
0333         set_compress_context(inode);
0334         return;
0335     }
0336 }
0337 
0338 static int f2fs_create(struct user_namespace *mnt_userns, struct inode *dir,
0339                struct dentry *dentry, umode_t mode, bool excl)
0340 {
0341     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0342     struct inode *inode;
0343     nid_t ino = 0;
0344     int err;
0345 
0346     if (unlikely(f2fs_cp_error(sbi)))
0347         return -EIO;
0348     if (!f2fs_is_checkpoint_ready(sbi))
0349         return -ENOSPC;
0350 
0351     err = f2fs_dquot_initialize(dir);
0352     if (err)
0353         return err;
0354 
0355     inode = f2fs_new_inode(mnt_userns, dir, mode);
0356     if (IS_ERR(inode))
0357         return PTR_ERR(inode);
0358 
0359     if (!test_opt(sbi, DISABLE_EXT_IDENTIFY))
0360         set_file_temperature(sbi, inode, dentry->d_name.name);
0361 
0362     set_compress_inode(sbi, inode, dentry->d_name.name);
0363 
0364     inode->i_op = &f2fs_file_inode_operations;
0365     inode->i_fop = &f2fs_file_operations;
0366     inode->i_mapping->a_ops = &f2fs_dblock_aops;
0367     ino = inode->i_ino;
0368 
0369     f2fs_lock_op(sbi);
0370     err = f2fs_add_link(dentry, inode);
0371     if (err)
0372         goto out;
0373     f2fs_unlock_op(sbi);
0374 
0375     f2fs_alloc_nid_done(sbi, ino);
0376 
0377     d_instantiate_new(dentry, inode);
0378 
0379     if (IS_DIRSYNC(dir))
0380         f2fs_sync_fs(sbi->sb, 1);
0381 
0382     f2fs_balance_fs(sbi, true);
0383     return 0;
0384 out:
0385     f2fs_handle_failed_inode(inode);
0386     return err;
0387 }
0388 
0389 static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
0390         struct dentry *dentry)
0391 {
0392     struct inode *inode = d_inode(old_dentry);
0393     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0394     int err;
0395 
0396     if (unlikely(f2fs_cp_error(sbi)))
0397         return -EIO;
0398     if (!f2fs_is_checkpoint_ready(sbi))
0399         return -ENOSPC;
0400 
0401     err = fscrypt_prepare_link(old_dentry, dir, dentry);
0402     if (err)
0403         return err;
0404 
0405     if (is_inode_flag_set(dir, FI_PROJ_INHERIT) &&
0406             (!projid_eq(F2FS_I(dir)->i_projid,
0407             F2FS_I(old_dentry->d_inode)->i_projid)))
0408         return -EXDEV;
0409 
0410     err = f2fs_dquot_initialize(dir);
0411     if (err)
0412         return err;
0413 
0414     f2fs_balance_fs(sbi, true);
0415 
0416     inode->i_ctime = current_time(inode);
0417     ihold(inode);
0418 
0419     set_inode_flag(inode, FI_INC_LINK);
0420     f2fs_lock_op(sbi);
0421     err = f2fs_add_link(dentry, inode);
0422     if (err)
0423         goto out;
0424     f2fs_unlock_op(sbi);
0425 
0426     d_instantiate(dentry, inode);
0427 
0428     if (IS_DIRSYNC(dir))
0429         f2fs_sync_fs(sbi->sb, 1);
0430     return 0;
0431 out:
0432     clear_inode_flag(inode, FI_INC_LINK);
0433     iput(inode);
0434     f2fs_unlock_op(sbi);
0435     return err;
0436 }
0437 
0438 struct dentry *f2fs_get_parent(struct dentry *child)
0439 {
0440     struct page *page;
0441     unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot_name, &page);
0442 
0443     if (!ino) {
0444         if (IS_ERR(page))
0445             return ERR_CAST(page);
0446         return ERR_PTR(-ENOENT);
0447     }
0448     return d_obtain_alias(f2fs_iget(child->d_sb, ino));
0449 }
0450 
0451 static int __recover_dot_dentries(struct inode *dir, nid_t pino)
0452 {
0453     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0454     struct qstr dot = QSTR_INIT(".", 1);
0455     struct qstr dotdot = QSTR_INIT("..", 2);
0456     struct f2fs_dir_entry *de;
0457     struct page *page;
0458     int err = 0;
0459 
0460     if (f2fs_readonly(sbi->sb)) {
0461         f2fs_info(sbi, "skip recovering inline_dots inode (ino:%lu, pino:%u) in readonly mountpoint",
0462               dir->i_ino, pino);
0463         return 0;
0464     }
0465 
0466     if (!S_ISDIR(dir->i_mode)) {
0467         f2fs_err(sbi, "inconsistent inode status, skip recovering inline_dots inode (ino:%lu, i_mode:%u, pino:%u)",
0468               dir->i_ino, dir->i_mode, pino);
0469         set_sbi_flag(sbi, SBI_NEED_FSCK);
0470         return -ENOTDIR;
0471     }
0472 
0473     err = f2fs_dquot_initialize(dir);
0474     if (err)
0475         return err;
0476 
0477     f2fs_balance_fs(sbi, true);
0478 
0479     f2fs_lock_op(sbi);
0480 
0481     de = f2fs_find_entry(dir, &dot, &page);
0482     if (de) {
0483         f2fs_put_page(page, 0);
0484     } else if (IS_ERR(page)) {
0485         err = PTR_ERR(page);
0486         goto out;
0487     } else {
0488         err = f2fs_do_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR);
0489         if (err)
0490             goto out;
0491     }
0492 
0493     de = f2fs_find_entry(dir, &dotdot, &page);
0494     if (de)
0495         f2fs_put_page(page, 0);
0496     else if (IS_ERR(page))
0497         err = PTR_ERR(page);
0498     else
0499         err = f2fs_do_add_link(dir, &dotdot, NULL, pino, S_IFDIR);
0500 out:
0501     if (!err)
0502         clear_inode_flag(dir, FI_INLINE_DOTS);
0503 
0504     f2fs_unlock_op(sbi);
0505     return err;
0506 }
0507 
0508 static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
0509         unsigned int flags)
0510 {
0511     struct inode *inode = NULL;
0512     struct f2fs_dir_entry *de;
0513     struct page *page;
0514     struct dentry *new;
0515     nid_t ino = -1;
0516     int err = 0;
0517     unsigned int root_ino = F2FS_ROOT_INO(F2FS_I_SB(dir));
0518     struct f2fs_filename fname;
0519 
0520     trace_f2fs_lookup_start(dir, dentry, flags);
0521 
0522     if (dentry->d_name.len > F2FS_NAME_LEN) {
0523         err = -ENAMETOOLONG;
0524         goto out;
0525     }
0526 
0527     err = f2fs_prepare_lookup(dir, dentry, &fname);
0528     generic_set_encrypted_ci_d_ops(dentry);
0529     if (err == -ENOENT)
0530         goto out_splice;
0531     if (err)
0532         goto out;
0533     de = __f2fs_find_entry(dir, &fname, &page);
0534     f2fs_free_filename(&fname);
0535 
0536     if (!de) {
0537         if (IS_ERR(page)) {
0538             err = PTR_ERR(page);
0539             goto out;
0540         }
0541         err = -ENOENT;
0542         goto out_splice;
0543     }
0544 
0545     ino = le32_to_cpu(de->ino);
0546     f2fs_put_page(page, 0);
0547 
0548     inode = f2fs_iget(dir->i_sb, ino);
0549     if (IS_ERR(inode)) {
0550         err = PTR_ERR(inode);
0551         goto out;
0552     }
0553 
0554     if ((dir->i_ino == root_ino) && f2fs_has_inline_dots(dir)) {
0555         err = __recover_dot_dentries(dir, root_ino);
0556         if (err)
0557             goto out_iput;
0558     }
0559 
0560     if (f2fs_has_inline_dots(inode)) {
0561         err = __recover_dot_dentries(inode, dir->i_ino);
0562         if (err)
0563             goto out_iput;
0564     }
0565     if (IS_ENCRYPTED(dir) &&
0566         (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
0567         !fscrypt_has_permitted_context(dir, inode)) {
0568         f2fs_warn(F2FS_I_SB(inode), "Inconsistent encryption contexts: %lu/%lu",
0569               dir->i_ino, inode->i_ino);
0570         err = -EPERM;
0571         goto out_iput;
0572     }
0573 out_splice:
0574 #if IS_ENABLED(CONFIG_UNICODE)
0575     if (!inode && IS_CASEFOLDED(dir)) {
0576         /* Eventually we want to call d_add_ci(dentry, NULL)
0577          * for negative dentries in the encoding case as
0578          * well.  For now, prevent the negative dentry
0579          * from being cached.
0580          */
0581         trace_f2fs_lookup_end(dir, dentry, ino, err);
0582         return NULL;
0583     }
0584 #endif
0585     new = d_splice_alias(inode, dentry);
0586     err = PTR_ERR_OR_ZERO(new);
0587     trace_f2fs_lookup_end(dir, dentry, ino, !new ? -ENOENT : err);
0588     return new;
0589 out_iput:
0590     iput(inode);
0591 out:
0592     trace_f2fs_lookup_end(dir, dentry, ino, err);
0593     return ERR_PTR(err);
0594 }
0595 
0596 static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
0597 {
0598     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0599     struct inode *inode = d_inode(dentry);
0600     struct f2fs_dir_entry *de;
0601     struct page *page;
0602     int err;
0603 
0604     trace_f2fs_unlink_enter(dir, dentry);
0605 
0606     if (unlikely(f2fs_cp_error(sbi))) {
0607         err = -EIO;
0608         goto fail;
0609     }
0610 
0611     err = f2fs_dquot_initialize(dir);
0612     if (err)
0613         goto fail;
0614     err = f2fs_dquot_initialize(inode);
0615     if (err)
0616         goto fail;
0617 
0618     de = f2fs_find_entry(dir, &dentry->d_name, &page);
0619     if (!de) {
0620         if (IS_ERR(page))
0621             err = PTR_ERR(page);
0622         goto fail;
0623     }
0624 
0625     f2fs_balance_fs(sbi, true);
0626 
0627     f2fs_lock_op(sbi);
0628     err = f2fs_acquire_orphan_inode(sbi);
0629     if (err) {
0630         f2fs_unlock_op(sbi);
0631         f2fs_put_page(page, 0);
0632         goto fail;
0633     }
0634     f2fs_delete_entry(de, page, dir, inode);
0635 #if IS_ENABLED(CONFIG_UNICODE)
0636     /* VFS negative dentries are incompatible with Encoding and
0637      * Case-insensitiveness. Eventually we'll want avoid
0638      * invalidating the dentries here, alongside with returning the
0639      * negative dentries at f2fs_lookup(), when it is better
0640      * supported by the VFS for the CI case.
0641      */
0642     if (IS_CASEFOLDED(dir))
0643         d_invalidate(dentry);
0644 #endif
0645     f2fs_unlock_op(sbi);
0646 
0647     if (IS_DIRSYNC(dir))
0648         f2fs_sync_fs(sbi->sb, 1);
0649 fail:
0650     trace_f2fs_unlink_exit(inode, err);
0651     return err;
0652 }
0653 
0654 static const char *f2fs_get_link(struct dentry *dentry,
0655                  struct inode *inode,
0656                  struct delayed_call *done)
0657 {
0658     const char *link = page_get_link(dentry, inode, done);
0659 
0660     if (!IS_ERR(link) && !*link) {
0661         /* this is broken symlink case */
0662         do_delayed_call(done);
0663         clear_delayed_call(done);
0664         link = ERR_PTR(-ENOENT);
0665     }
0666     return link;
0667 }
0668 
0669 static int f2fs_symlink(struct user_namespace *mnt_userns, struct inode *dir,
0670             struct dentry *dentry, const char *symname)
0671 {
0672     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0673     struct inode *inode;
0674     size_t len = strlen(symname);
0675     struct fscrypt_str disk_link;
0676     int err;
0677 
0678     if (unlikely(f2fs_cp_error(sbi)))
0679         return -EIO;
0680     if (!f2fs_is_checkpoint_ready(sbi))
0681         return -ENOSPC;
0682 
0683     err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize,
0684                       &disk_link);
0685     if (err)
0686         return err;
0687 
0688     err = f2fs_dquot_initialize(dir);
0689     if (err)
0690         return err;
0691 
0692     inode = f2fs_new_inode(mnt_userns, dir, S_IFLNK | S_IRWXUGO);
0693     if (IS_ERR(inode))
0694         return PTR_ERR(inode);
0695 
0696     if (IS_ENCRYPTED(inode))
0697         inode->i_op = &f2fs_encrypted_symlink_inode_operations;
0698     else
0699         inode->i_op = &f2fs_symlink_inode_operations;
0700     inode_nohighmem(inode);
0701     inode->i_mapping->a_ops = &f2fs_dblock_aops;
0702 
0703     f2fs_lock_op(sbi);
0704     err = f2fs_add_link(dentry, inode);
0705     if (err)
0706         goto out_f2fs_handle_failed_inode;
0707     f2fs_unlock_op(sbi);
0708     f2fs_alloc_nid_done(sbi, inode->i_ino);
0709 
0710     err = fscrypt_encrypt_symlink(inode, symname, len, &disk_link);
0711     if (err)
0712         goto err_out;
0713 
0714     err = page_symlink(inode, disk_link.name, disk_link.len);
0715 
0716 err_out:
0717     d_instantiate_new(dentry, inode);
0718 
0719     /*
0720      * Let's flush symlink data in order to avoid broken symlink as much as
0721      * possible. Nevertheless, fsyncing is the best way, but there is no
0722      * way to get a file descriptor in order to flush that.
0723      *
0724      * Note that, it needs to do dir->fsync to make this recoverable.
0725      * If the symlink path is stored into inline_data, there is no
0726      * performance regression.
0727      */
0728     if (!err) {
0729         filemap_write_and_wait_range(inode->i_mapping, 0,
0730                             disk_link.len - 1);
0731 
0732         if (IS_DIRSYNC(dir))
0733             f2fs_sync_fs(sbi->sb, 1);
0734     } else {
0735         f2fs_unlink(dir, dentry);
0736     }
0737 
0738     f2fs_balance_fs(sbi, true);
0739     goto out_free_encrypted_link;
0740 
0741 out_f2fs_handle_failed_inode:
0742     f2fs_handle_failed_inode(inode);
0743 out_free_encrypted_link:
0744     if (disk_link.name != (unsigned char *)symname)
0745         kfree(disk_link.name);
0746     return err;
0747 }
0748 
0749 static int f2fs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
0750               struct dentry *dentry, umode_t mode)
0751 {
0752     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0753     struct inode *inode;
0754     int err;
0755 
0756     if (unlikely(f2fs_cp_error(sbi)))
0757         return -EIO;
0758 
0759     err = f2fs_dquot_initialize(dir);
0760     if (err)
0761         return err;
0762 
0763     inode = f2fs_new_inode(mnt_userns, dir, S_IFDIR | mode);
0764     if (IS_ERR(inode))
0765         return PTR_ERR(inode);
0766 
0767     inode->i_op = &f2fs_dir_inode_operations;
0768     inode->i_fop = &f2fs_dir_operations;
0769     inode->i_mapping->a_ops = &f2fs_dblock_aops;
0770     mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
0771 
0772     set_inode_flag(inode, FI_INC_LINK);
0773     f2fs_lock_op(sbi);
0774     err = f2fs_add_link(dentry, inode);
0775     if (err)
0776         goto out_fail;
0777     f2fs_unlock_op(sbi);
0778 
0779     f2fs_alloc_nid_done(sbi, inode->i_ino);
0780 
0781     d_instantiate_new(dentry, inode);
0782 
0783     if (IS_DIRSYNC(dir))
0784         f2fs_sync_fs(sbi->sb, 1);
0785 
0786     f2fs_balance_fs(sbi, true);
0787     return 0;
0788 
0789 out_fail:
0790     clear_inode_flag(inode, FI_INC_LINK);
0791     f2fs_handle_failed_inode(inode);
0792     return err;
0793 }
0794 
0795 static int f2fs_rmdir(struct inode *dir, struct dentry *dentry)
0796 {
0797     struct inode *inode = d_inode(dentry);
0798 
0799     if (f2fs_empty_dir(inode))
0800         return f2fs_unlink(dir, dentry);
0801     return -ENOTEMPTY;
0802 }
0803 
0804 static int f2fs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
0805               struct dentry *dentry, umode_t mode, dev_t rdev)
0806 {
0807     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0808     struct inode *inode;
0809     int err = 0;
0810 
0811     if (unlikely(f2fs_cp_error(sbi)))
0812         return -EIO;
0813     if (!f2fs_is_checkpoint_ready(sbi))
0814         return -ENOSPC;
0815 
0816     err = f2fs_dquot_initialize(dir);
0817     if (err)
0818         return err;
0819 
0820     inode = f2fs_new_inode(mnt_userns, dir, mode);
0821     if (IS_ERR(inode))
0822         return PTR_ERR(inode);
0823 
0824     init_special_inode(inode, inode->i_mode, rdev);
0825     inode->i_op = &f2fs_special_inode_operations;
0826 
0827     f2fs_lock_op(sbi);
0828     err = f2fs_add_link(dentry, inode);
0829     if (err)
0830         goto out;
0831     f2fs_unlock_op(sbi);
0832 
0833     f2fs_alloc_nid_done(sbi, inode->i_ino);
0834 
0835     d_instantiate_new(dentry, inode);
0836 
0837     if (IS_DIRSYNC(dir))
0838         f2fs_sync_fs(sbi->sb, 1);
0839 
0840     f2fs_balance_fs(sbi, true);
0841     return 0;
0842 out:
0843     f2fs_handle_failed_inode(inode);
0844     return err;
0845 }
0846 
0847 static int __f2fs_tmpfile(struct user_namespace *mnt_userns, struct inode *dir,
0848               struct dentry *dentry, umode_t mode, bool is_whiteout,
0849               struct inode **new_inode)
0850 {
0851     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0852     struct inode *inode;
0853     int err;
0854 
0855     err = f2fs_dquot_initialize(dir);
0856     if (err)
0857         return err;
0858 
0859     inode = f2fs_new_inode(mnt_userns, dir, mode);
0860     if (IS_ERR(inode))
0861         return PTR_ERR(inode);
0862 
0863     if (is_whiteout) {
0864         init_special_inode(inode, inode->i_mode, WHITEOUT_DEV);
0865         inode->i_op = &f2fs_special_inode_operations;
0866     } else {
0867         inode->i_op = &f2fs_file_inode_operations;
0868         inode->i_fop = &f2fs_file_operations;
0869         inode->i_mapping->a_ops = &f2fs_dblock_aops;
0870     }
0871 
0872     f2fs_lock_op(sbi);
0873     err = f2fs_acquire_orphan_inode(sbi);
0874     if (err)
0875         goto out;
0876 
0877     err = f2fs_do_tmpfile(inode, dir);
0878     if (err)
0879         goto release_out;
0880 
0881     /*
0882      * add this non-linked tmpfile to orphan list, in this way we could
0883      * remove all unused data of tmpfile after abnormal power-off.
0884      */
0885     f2fs_add_orphan_inode(inode);
0886     f2fs_alloc_nid_done(sbi, inode->i_ino);
0887 
0888     if (is_whiteout) {
0889         f2fs_i_links_write(inode, false);
0890 
0891         spin_lock(&inode->i_lock);
0892         inode->i_state |= I_LINKABLE;
0893         spin_unlock(&inode->i_lock);
0894     } else {
0895         if (dentry)
0896             d_tmpfile(dentry, inode);
0897         else
0898             f2fs_i_links_write(inode, false);
0899     }
0900     /* link_count was changed by d_tmpfile as well. */
0901     f2fs_unlock_op(sbi);
0902     unlock_new_inode(inode);
0903 
0904     if (new_inode)
0905         *new_inode = inode;
0906 
0907     f2fs_balance_fs(sbi, true);
0908     return 0;
0909 
0910 release_out:
0911     f2fs_release_orphan_inode(sbi);
0912 out:
0913     f2fs_handle_failed_inode(inode);
0914     return err;
0915 }
0916 
0917 static int f2fs_tmpfile(struct user_namespace *mnt_userns, struct inode *dir,
0918             struct dentry *dentry, umode_t mode)
0919 {
0920     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0921 
0922     if (unlikely(f2fs_cp_error(sbi)))
0923         return -EIO;
0924     if (!f2fs_is_checkpoint_ready(sbi))
0925         return -ENOSPC;
0926 
0927     return __f2fs_tmpfile(mnt_userns, dir, dentry, mode, false, NULL);
0928 }
0929 
0930 static int f2fs_create_whiteout(struct user_namespace *mnt_userns,
0931                 struct inode *dir, struct inode **whiteout)
0932 {
0933     if (unlikely(f2fs_cp_error(F2FS_I_SB(dir))))
0934         return -EIO;
0935 
0936     return __f2fs_tmpfile(mnt_userns, dir, NULL,
0937                 S_IFCHR | WHITEOUT_MODE, true, whiteout);
0938 }
0939 
0940 int f2fs_get_tmpfile(struct user_namespace *mnt_userns, struct inode *dir,
0941              struct inode **new_inode)
0942 {
0943     return __f2fs_tmpfile(mnt_userns, dir, NULL, S_IFREG, false, new_inode);
0944 }
0945 
0946 static int f2fs_rename(struct user_namespace *mnt_userns, struct inode *old_dir,
0947             struct dentry *old_dentry, struct inode *new_dir,
0948             struct dentry *new_dentry, unsigned int flags)
0949 {
0950     struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
0951     struct inode *old_inode = d_inode(old_dentry);
0952     struct inode *new_inode = d_inode(new_dentry);
0953     struct inode *whiteout = NULL;
0954     struct page *old_dir_page = NULL;
0955     struct page *old_page, *new_page = NULL;
0956     struct f2fs_dir_entry *old_dir_entry = NULL;
0957     struct f2fs_dir_entry *old_entry;
0958     struct f2fs_dir_entry *new_entry;
0959     int err;
0960 
0961     if (unlikely(f2fs_cp_error(sbi)))
0962         return -EIO;
0963     if (!f2fs_is_checkpoint_ready(sbi))
0964         return -ENOSPC;
0965 
0966     if (is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
0967             (!projid_eq(F2FS_I(new_dir)->i_projid,
0968             F2FS_I(old_dentry->d_inode)->i_projid)))
0969         return -EXDEV;
0970 
0971     /*
0972      * If new_inode is null, the below renaming flow will
0973      * add a link in old_dir which can conver inline_dir.
0974      * After then, if we failed to get the entry due to other
0975      * reasons like ENOMEM, we had to remove the new entry.
0976      * Instead of adding such the error handling routine, let's
0977      * simply convert first here.
0978      */
0979     if (old_dir == new_dir && !new_inode) {
0980         err = f2fs_try_convert_inline_dir(old_dir, new_dentry);
0981         if (err)
0982             return err;
0983     }
0984 
0985     if (flags & RENAME_WHITEOUT) {
0986         err = f2fs_create_whiteout(mnt_userns, old_dir, &whiteout);
0987         if (err)
0988             return err;
0989     }
0990 
0991     err = f2fs_dquot_initialize(old_dir);
0992     if (err)
0993         goto out;
0994 
0995     err = f2fs_dquot_initialize(new_dir);
0996     if (err)
0997         goto out;
0998 
0999     if (new_inode) {
1000         err = f2fs_dquot_initialize(new_inode);
1001         if (err)
1002             goto out;
1003     }
1004 
1005     err = -ENOENT;
1006     old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
1007     if (!old_entry) {
1008         if (IS_ERR(old_page))
1009             err = PTR_ERR(old_page);
1010         goto out;
1011     }
1012 
1013     if (S_ISDIR(old_inode->i_mode)) {
1014         old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page);
1015         if (!old_dir_entry) {
1016             if (IS_ERR(old_dir_page))
1017                 err = PTR_ERR(old_dir_page);
1018             goto out_old;
1019         }
1020     }
1021 
1022     if (new_inode) {
1023 
1024         err = -ENOTEMPTY;
1025         if (old_dir_entry && !f2fs_empty_dir(new_inode))
1026             goto out_dir;
1027 
1028         err = -ENOENT;
1029         new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name,
1030                         &new_page);
1031         if (!new_entry) {
1032             if (IS_ERR(new_page))
1033                 err = PTR_ERR(new_page);
1034             goto out_dir;
1035         }
1036 
1037         f2fs_balance_fs(sbi, true);
1038 
1039         f2fs_lock_op(sbi);
1040 
1041         err = f2fs_acquire_orphan_inode(sbi);
1042         if (err)
1043             goto put_out_dir;
1044 
1045         f2fs_set_link(new_dir, new_entry, new_page, old_inode);
1046         new_page = NULL;
1047 
1048         new_inode->i_ctime = current_time(new_inode);
1049         f2fs_down_write(&F2FS_I(new_inode)->i_sem);
1050         if (old_dir_entry)
1051             f2fs_i_links_write(new_inode, false);
1052         f2fs_i_links_write(new_inode, false);
1053         f2fs_up_write(&F2FS_I(new_inode)->i_sem);
1054 
1055         if (!new_inode->i_nlink)
1056             f2fs_add_orphan_inode(new_inode);
1057         else
1058             f2fs_release_orphan_inode(sbi);
1059     } else {
1060         f2fs_balance_fs(sbi, true);
1061 
1062         f2fs_lock_op(sbi);
1063 
1064         err = f2fs_add_link(new_dentry, old_inode);
1065         if (err) {
1066             f2fs_unlock_op(sbi);
1067             goto out_dir;
1068         }
1069 
1070         if (old_dir_entry)
1071             f2fs_i_links_write(new_dir, true);
1072     }
1073 
1074     f2fs_down_write(&F2FS_I(old_inode)->i_sem);
1075     if (!old_dir_entry || whiteout)
1076         file_lost_pino(old_inode);
1077     else
1078         /* adjust dir's i_pino to pass fsck check */
1079         f2fs_i_pino_write(old_inode, new_dir->i_ino);
1080     f2fs_up_write(&F2FS_I(old_inode)->i_sem);
1081 
1082     old_inode->i_ctime = current_time(old_inode);
1083     f2fs_mark_inode_dirty_sync(old_inode, false);
1084 
1085     f2fs_delete_entry(old_entry, old_page, old_dir, NULL);
1086     old_page = NULL;
1087 
1088     if (whiteout) {
1089         set_inode_flag(whiteout, FI_INC_LINK);
1090         err = f2fs_add_link(old_dentry, whiteout);
1091         if (err)
1092             goto put_out_dir;
1093 
1094         spin_lock(&whiteout->i_lock);
1095         whiteout->i_state &= ~I_LINKABLE;
1096         spin_unlock(&whiteout->i_lock);
1097 
1098         iput(whiteout);
1099     }
1100 
1101     if (old_dir_entry) {
1102         if (old_dir != new_dir && !whiteout)
1103             f2fs_set_link(old_inode, old_dir_entry,
1104                         old_dir_page, new_dir);
1105         else
1106             f2fs_put_page(old_dir_page, 0);
1107         f2fs_i_links_write(old_dir, false);
1108     }
1109     if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT) {
1110         f2fs_add_ino_entry(sbi, new_dir->i_ino, TRANS_DIR_INO);
1111         if (S_ISDIR(old_inode->i_mode))
1112             f2fs_add_ino_entry(sbi, old_inode->i_ino,
1113                             TRANS_DIR_INO);
1114     }
1115 
1116     f2fs_unlock_op(sbi);
1117 
1118     if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
1119         f2fs_sync_fs(sbi->sb, 1);
1120 
1121     f2fs_update_time(sbi, REQ_TIME);
1122     return 0;
1123 
1124 put_out_dir:
1125     f2fs_unlock_op(sbi);
1126     f2fs_put_page(new_page, 0);
1127 out_dir:
1128     if (old_dir_entry)
1129         f2fs_put_page(old_dir_page, 0);
1130 out_old:
1131     f2fs_put_page(old_page, 0);
1132 out:
1133     iput(whiteout);
1134     return err;
1135 }
1136 
1137 static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
1138                  struct inode *new_dir, struct dentry *new_dentry)
1139 {
1140     struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
1141     struct inode *old_inode = d_inode(old_dentry);
1142     struct inode *new_inode = d_inode(new_dentry);
1143     struct page *old_dir_page, *new_dir_page;
1144     struct page *old_page, *new_page;
1145     struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL;
1146     struct f2fs_dir_entry *old_entry, *new_entry;
1147     int old_nlink = 0, new_nlink = 0;
1148     int err;
1149 
1150     if (unlikely(f2fs_cp_error(sbi)))
1151         return -EIO;
1152     if (!f2fs_is_checkpoint_ready(sbi))
1153         return -ENOSPC;
1154 
1155     if ((is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
1156             !projid_eq(F2FS_I(new_dir)->i_projid,
1157             F2FS_I(old_dentry->d_inode)->i_projid)) ||
1158         (is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
1159             !projid_eq(F2FS_I(old_dir)->i_projid,
1160             F2FS_I(new_dentry->d_inode)->i_projid)))
1161         return -EXDEV;
1162 
1163     err = f2fs_dquot_initialize(old_dir);
1164     if (err)
1165         goto out;
1166 
1167     err = f2fs_dquot_initialize(new_dir);
1168     if (err)
1169         goto out;
1170 
1171     err = -ENOENT;
1172     old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
1173     if (!old_entry) {
1174         if (IS_ERR(old_page))
1175             err = PTR_ERR(old_page);
1176         goto out;
1177     }
1178 
1179     new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, &new_page);
1180     if (!new_entry) {
1181         if (IS_ERR(new_page))
1182             err = PTR_ERR(new_page);
1183         goto out_old;
1184     }
1185 
1186     /* prepare for updating ".." directory entry info later */
1187     if (old_dir != new_dir) {
1188         if (S_ISDIR(old_inode->i_mode)) {
1189             old_dir_entry = f2fs_parent_dir(old_inode,
1190                             &old_dir_page);
1191             if (!old_dir_entry) {
1192                 if (IS_ERR(old_dir_page))
1193                     err = PTR_ERR(old_dir_page);
1194                 goto out_new;
1195             }
1196         }
1197 
1198         if (S_ISDIR(new_inode->i_mode)) {
1199             new_dir_entry = f2fs_parent_dir(new_inode,
1200                             &new_dir_page);
1201             if (!new_dir_entry) {
1202                 if (IS_ERR(new_dir_page))
1203                     err = PTR_ERR(new_dir_page);
1204                 goto out_old_dir;
1205             }
1206         }
1207     }
1208 
1209     /*
1210      * If cross rename between file and directory those are not
1211      * in the same directory, we will inc nlink of file's parent
1212      * later, so we should check upper boundary of its nlink.
1213      */
1214     if ((!old_dir_entry || !new_dir_entry) &&
1215                 old_dir_entry != new_dir_entry) {
1216         old_nlink = old_dir_entry ? -1 : 1;
1217         new_nlink = -old_nlink;
1218         err = -EMLINK;
1219         if ((old_nlink > 0 && old_dir->i_nlink >= F2FS_LINK_MAX) ||
1220             (new_nlink > 0 && new_dir->i_nlink >= F2FS_LINK_MAX))
1221             goto out_new_dir;
1222     }
1223 
1224     f2fs_balance_fs(sbi, true);
1225 
1226     f2fs_lock_op(sbi);
1227 
1228     /* update ".." directory entry info of old dentry */
1229     if (old_dir_entry)
1230         f2fs_set_link(old_inode, old_dir_entry, old_dir_page, new_dir);
1231 
1232     /* update ".." directory entry info of new dentry */
1233     if (new_dir_entry)
1234         f2fs_set_link(new_inode, new_dir_entry, new_dir_page, old_dir);
1235 
1236     /* update directory entry info of old dir inode */
1237     f2fs_set_link(old_dir, old_entry, old_page, new_inode);
1238 
1239     f2fs_down_write(&F2FS_I(old_inode)->i_sem);
1240     if (!old_dir_entry)
1241         file_lost_pino(old_inode);
1242     else
1243         /* adjust dir's i_pino to pass fsck check */
1244         f2fs_i_pino_write(old_inode, new_dir->i_ino);
1245     f2fs_up_write(&F2FS_I(old_inode)->i_sem);
1246 
1247     old_dir->i_ctime = current_time(old_dir);
1248     if (old_nlink) {
1249         f2fs_down_write(&F2FS_I(old_dir)->i_sem);
1250         f2fs_i_links_write(old_dir, old_nlink > 0);
1251         f2fs_up_write(&F2FS_I(old_dir)->i_sem);
1252     }
1253     f2fs_mark_inode_dirty_sync(old_dir, false);
1254 
1255     /* update directory entry info of new dir inode */
1256     f2fs_set_link(new_dir, new_entry, new_page, old_inode);
1257 
1258     f2fs_down_write(&F2FS_I(new_inode)->i_sem);
1259     if (!new_dir_entry)
1260         file_lost_pino(new_inode);
1261     else
1262         /* adjust dir's i_pino to pass fsck check */
1263         f2fs_i_pino_write(new_inode, old_dir->i_ino);
1264     f2fs_up_write(&F2FS_I(new_inode)->i_sem);
1265 
1266     new_dir->i_ctime = current_time(new_dir);
1267     if (new_nlink) {
1268         f2fs_down_write(&F2FS_I(new_dir)->i_sem);
1269         f2fs_i_links_write(new_dir, new_nlink > 0);
1270         f2fs_up_write(&F2FS_I(new_dir)->i_sem);
1271     }
1272     f2fs_mark_inode_dirty_sync(new_dir, false);
1273 
1274     if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT) {
1275         f2fs_add_ino_entry(sbi, old_dir->i_ino, TRANS_DIR_INO);
1276         f2fs_add_ino_entry(sbi, new_dir->i_ino, TRANS_DIR_INO);
1277     }
1278 
1279     f2fs_unlock_op(sbi);
1280 
1281     if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
1282         f2fs_sync_fs(sbi->sb, 1);
1283 
1284     f2fs_update_time(sbi, REQ_TIME);
1285     return 0;
1286 out_new_dir:
1287     if (new_dir_entry) {
1288         f2fs_put_page(new_dir_page, 0);
1289     }
1290 out_old_dir:
1291     if (old_dir_entry) {
1292         f2fs_put_page(old_dir_page, 0);
1293     }
1294 out_new:
1295     f2fs_put_page(new_page, 0);
1296 out_old:
1297     f2fs_put_page(old_page, 0);
1298 out:
1299     return err;
1300 }
1301 
1302 static int f2fs_rename2(struct user_namespace *mnt_userns,
1303             struct inode *old_dir, struct dentry *old_dentry,
1304             struct inode *new_dir, struct dentry *new_dentry,
1305             unsigned int flags)
1306 {
1307     int err;
1308 
1309     if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
1310         return -EINVAL;
1311 
1312     err = fscrypt_prepare_rename(old_dir, old_dentry, new_dir, new_dentry,
1313                      flags);
1314     if (err)
1315         return err;
1316 
1317     if (flags & RENAME_EXCHANGE) {
1318         return f2fs_cross_rename(old_dir, old_dentry,
1319                      new_dir, new_dentry);
1320     }
1321     /*
1322      * VFS has already handled the new dentry existence case,
1323      * here, we just deal with "RENAME_NOREPLACE" as regular rename.
1324      */
1325     return f2fs_rename(mnt_userns, old_dir, old_dentry,
1326                     new_dir, new_dentry, flags);
1327 }
1328 
1329 static const char *f2fs_encrypted_get_link(struct dentry *dentry,
1330                        struct inode *inode,
1331                        struct delayed_call *done)
1332 {
1333     struct page *page;
1334     const char *target;
1335 
1336     if (!dentry)
1337         return ERR_PTR(-ECHILD);
1338 
1339     page = read_mapping_page(inode->i_mapping, 0, NULL);
1340     if (IS_ERR(page))
1341         return ERR_CAST(page);
1342 
1343     target = fscrypt_get_symlink(inode, page_address(page),
1344                      inode->i_sb->s_blocksize, done);
1345     put_page(page);
1346     return target;
1347 }
1348 
1349 static int f2fs_encrypted_symlink_getattr(struct user_namespace *mnt_userns,
1350                       const struct path *path,
1351                       struct kstat *stat, u32 request_mask,
1352                       unsigned int query_flags)
1353 {
1354     f2fs_getattr(mnt_userns, path, stat, request_mask, query_flags);
1355 
1356     return fscrypt_symlink_getattr(path, stat);
1357 }
1358 
1359 const struct inode_operations f2fs_encrypted_symlink_inode_operations = {
1360     .get_link   = f2fs_encrypted_get_link,
1361     .getattr    = f2fs_encrypted_symlink_getattr,
1362     .setattr    = f2fs_setattr,
1363     .listxattr  = f2fs_listxattr,
1364 };
1365 
1366 const struct inode_operations f2fs_dir_inode_operations = {
1367     .create     = f2fs_create,
1368     .lookup     = f2fs_lookup,
1369     .link       = f2fs_link,
1370     .unlink     = f2fs_unlink,
1371     .symlink    = f2fs_symlink,
1372     .mkdir      = f2fs_mkdir,
1373     .rmdir      = f2fs_rmdir,
1374     .mknod      = f2fs_mknod,
1375     .rename     = f2fs_rename2,
1376     .tmpfile    = f2fs_tmpfile,
1377     .getattr    = f2fs_getattr,
1378     .setattr    = f2fs_setattr,
1379     .get_acl    = f2fs_get_acl,
1380     .set_acl    = f2fs_set_acl,
1381     .listxattr  = f2fs_listxattr,
1382     .fiemap     = f2fs_fiemap,
1383     .fileattr_get   = f2fs_fileattr_get,
1384     .fileattr_set   = f2fs_fileattr_set,
1385 };
1386 
1387 const struct inode_operations f2fs_symlink_inode_operations = {
1388     .get_link   = f2fs_get_link,
1389     .getattr    = f2fs_getattr,
1390     .setattr    = f2fs_setattr,
1391     .listxattr  = f2fs_listxattr,
1392 };
1393 
1394 const struct inode_operations f2fs_special_inode_operations = {
1395     .getattr    = f2fs_getattr,
1396     .setattr    = f2fs_setattr,
1397     .get_acl    = f2fs_get_acl,
1398     .set_acl    = f2fs_set_acl,
1399     .listxattr  = f2fs_listxattr,
1400 };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!