fs/f2fs/namei.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * fs/f2fs/namei.c
   4  *
   5  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   6  *             http://www.samsung.com/
   7  */
   8 #include <linux/fs.h>
   9 #include <linux/f2fs_fs.h>
  10 #include <linux/pagemap.h>
  11 #include <linux/sched.h>
  12 #include <linux/ctype.h>
  13 #include <linux/random.h>
  14 #include <linux/dcache.h>
  15 #include <linux/namei.h>
  16 #include <linux/quotaops.h>
  17
  18 #include "f2fs.h"
  19 #include "node.h"
  20 #include "segment.h"
  21 #include "xattr.h"
  22 #include "acl.h"
  23 #include <trace/events/f2fs.h>
  24
  25 static struct inode *f2fs_new_inode(struct user_namespace *mnt_userns,
  26                                                 struct inode *dir, umode_t mode)
  27 {
  28         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  29         nid_t ino;
  30         struct inode *inode;
  31         bool nid_free = false;
  32         bool encrypt = false;
  33         int xattr_size = 0;
  34         int err;
  35
  36         inode = new_inode(dir->i_sb);
  37         if (!inode)
  38                 return ERR_PTR(-ENOMEM);
  39
  40         if (!f2fs_alloc_nid(sbi, &ino)) {
  41                 err = -ENOSPC;
  42                 goto fail;
  43         }
  44
  45         nid_free = true;
  46
  47         inode_init_owner(mnt_userns, inode, dir, mode);
  48
  49         inode->i_ino = ino;
  50         inode->i_blocks = 0;
  51         inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
  52         F2FS_I(inode)->i_crtime = inode->i_mtime;
  53         inode->i_generation = prandom_u32();
  54
  55         if (S_ISDIR(inode->i_mode))
  56                 F2FS_I(inode)->i_current_depth = 1;
  57
  58         err = insert_inode_locked(inode);
  59         if (err) {
  60                 err = -EINVAL;
  61                 goto fail;
  62         }
  63
  64         if (f2fs_sb_has_project_quota(sbi) &&
  65                 (F2FS_I(dir)->i_flags & F2FS_PROJINHERIT_FL))
  66                 F2FS_I(inode)->i_projid = F2FS_I(dir)->i_projid;
  67         else
  68                 F2FS_I(inode)->i_projid = make_kprojid(mnt_userns,
  69                                                         F2FS_DEF_PROJID);
  70
  71         err = fscrypt_prepare_new_inode(dir, inode, &encrypt);
  72         if (err)
  73                 goto fail_drop;
  74
  75         err = f2fs_dquot_initialize(inode);
  76         if (err)
  77                 goto fail_drop;
  78
  79         set_inode_flag(inode, FI_NEW_INODE);
  80
  81         if (encrypt)
  82                 f2fs_set_encrypted_inode(inode);
  83
  84         if (f2fs_sb_has_extra_attr(sbi)) {
  85                 set_inode_flag(inode, FI_EXTRA_ATTR);
  86                 F2FS_I(inode)->i_extra_isize = F2FS_TOTAL_EXTRA_ATTR_SIZE;
  87         }
  88
  89         if (test_opt(sbi, INLINE_XATTR))
  90                 set_inode_flag(inode, FI_INLINE_XATTR);
  91
  92         if (f2fs_may_inline_dentry(inode))
  93                 set_inode_flag(inode, FI_INLINE_DENTRY);
  94
  95         if (f2fs_sb_has_flexible_inline_xattr(sbi)) {
  96                 f2fs_bug_on(sbi, !f2fs_has_extra_attr(inode));
  97                 if (f2fs_has_inline_xattr(inode))
  98                         xattr_size = F2FS_OPTION(sbi).inline_xattr_size;
  99                 /* Otherwise, will be 0 */
 100         } else if (f2fs_has_inline_xattr(inode) ||
 101                                 f2fs_has_inline_dentry(inode)) {
 102                 xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
 103         }
 104         F2FS_I(inode)->i_inline_xattr_size = xattr_size;
 105
 106         f2fs_init_extent_tree(inode, NULL);
 107
 108         F2FS_I(inode)->i_flags =
 109                 f2fs_mask_flags(mode, F2FS_I(dir)->i_flags & F2FS_FL_INHERITED);
 110
 111         if (S_ISDIR(inode->i_mode))
 112                 F2FS_I(inode)->i_flags |= F2FS_INDEX_FL;
 113
 114         if (F2FS_I(inode)->i_flags & F2FS_PROJINHERIT_FL)
 115                 set_inode_flag(inode, FI_PROJ_INHERIT);
 116
 117         if (f2fs_sb_has_compression(sbi)) {
 118                 /* Inherit the compression flag in directory */
 119                 if ((F2FS_I(dir)->i_flags & F2FS_COMPR_FL) &&
 120                                         f2fs_may_compress(inode))
 121                         set_compress_context(inode);
 122         }
 123
 124         /* Should enable inline_data after compression set */
 125         if (test_opt(sbi, INLINE_DATA) && f2fs_may_inline_data(inode))
 126                 set_inode_flag(inode, FI_INLINE_DATA);
 127
 128         stat_inc_inline_xattr(inode);
 129         stat_inc_inline_inode(inode);
 130         stat_inc_inline_dir(inode);
 131
 132         f2fs_set_inode_flags(inode);
 133
 134         trace_f2fs_new_inode(inode, 0);
 135         return inode;
 136
 137 fail:
 138         trace_f2fs_new_inode(inode, err);
 139         make_bad_inode(inode);
 140         if (nid_free)
 141                 set_inode_flag(inode, FI_FREE_NID);
 142         iput(inode);
 143         return ERR_PTR(err);
 144 fail_drop:
 145         trace_f2fs_new_inode(inode, err);
 146         dquot_drop(inode);
 147         inode->i_flags |= S_NOQUOTA;
 148         if (nid_free)
 149                 set_inode_flag(inode, FI_FREE_NID);
 150         clear_nlink(inode);
 151         unlock_new_inode(inode);
 152         iput(inode);
 153         return ERR_PTR(err);
 154 }
 155
 156 static inline int is_extension_exist(const unsigned char *s, const char *sub,
 157                                                 bool tmp_ext)
 158 {
 159         size_t slen = strlen(s);
 160         size_t sublen = strlen(sub);
 161         int i;
 162
 163         if (sublen == 1 && *sub == '*')
 164                 return 1;
 165
 166         /*
 167          * filename format of multimedia file should be defined as:
 168          * "filename + '.' + extension + (optional: '.' + temp extension)".
 169          */
 170         if (slen < sublen + 2)
 171                 return 0;
 172
 173         if (!tmp_ext) {
 174                 /* file has no temp extension */
 175                 if (s[slen - sublen - 1] != '.')
 176                         return 0;
 177                 return !strncasecmp(s + slen - sublen, sub, sublen);
 178         }
 179
 180         for (i = 1; i < slen - sublen; i++) {
 181                 if (s[i] != '.')
 182                         continue;
 183                 if (!strncasecmp(s + i + 1, sub, sublen))
 184                         return 1;
 185         }
 186
 187         return 0;
 188 }
 189
 190 /*
 191  * Set file's temperature for hot/cold data separation
 192  */
 193 static inline void set_file_temperature(struct f2fs_sb_info *sbi, struct inode *inode,
 194                 const unsigned char *name)
 195 {
 196         __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
 197         int i, cold_count, hot_count;
 198
 199         f2fs_down_read(&sbi->sb_lock);
 200
 201         cold_count = le32_to_cpu(sbi->raw_super->extension_count);
 202         hot_count = sbi->raw_super->hot_ext_count;
 203
 204         for (i = 0; i < cold_count + hot_count; i++) {
 205                 if (is_extension_exist(name, extlist[i], true))
 206                         break;
 207         }
 208
 209         f2fs_up_read(&sbi->sb_lock);
 210
 211         if (i == cold_count + hot_count)
 212                 return;
 213
 214         if (i < cold_count)
 215                 file_set_cold(inode);
 216         else
 217                 file_set_hot(inode);
 218 }
 219
 220 int f2fs_update_extension_list(struct f2fs_sb_info *sbi, const char *name,
 221                                                         bool hot, bool set)
 222 {
 223         __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
 224         int cold_count = le32_to_cpu(sbi->raw_super->extension_count);
 225         int hot_count = sbi->raw_super->hot_ext_count;
 226         int total_count = cold_count + hot_count;
 227         int start, count;
 228         int i;
 229
 230         if (set) {
 231                 if (total_count == F2FS_MAX_EXTENSION)
 232                         return -EINVAL;
 233         } else {
 234                 if (!hot && !cold_count)
 235                         return -EINVAL;
 236                 if (hot && !hot_count)
 237                         return -EINVAL;
 238         }
 239
 240         if (hot) {
 241                 start = cold_count;
 242                 count = total_count;
 243         } else {
 244                 start = 0;
 245                 count = cold_count;
 246         }
 247
 248         for (i = start; i < count; i++) {
 249                 if (strcmp(name, extlist[i]))
 250                         continue;
 251
 252                 if (set)
 253                         return -EINVAL;
 254
 255                 memcpy(extlist[i], extlist[i + 1],
 256                                 F2FS_EXTENSION_LEN * (total_count - i - 1));
 257                 memset(extlist[total_count - 1], 0, F2FS_EXTENSION_LEN);
 258                 if (hot)
 259                         sbi->raw_super->hot_ext_count = hot_count - 1;
 260                 else
 261                         sbi->raw_super->extension_count =
 262                                                 cpu_to_le32(cold_count - 1);
 263                 return 0;
 264         }
 265
 266         if (!set)
 267                 return -EINVAL;
 268
 269         if (hot) {
 270                 memcpy(extlist[count], name, strlen(name));
 271                 sbi->raw_super->hot_ext_count = hot_count + 1;
 272         } else {
 273                 char buf[F2FS_MAX_EXTENSION][F2FS_EXTENSION_LEN];
 274
 275                 memcpy(buf, &extlist[cold_count],
 276                                 F2FS_EXTENSION_LEN * hot_count);
 277                 memset(extlist[cold_count], 0, F2FS_EXTENSION_LEN);
 278                 memcpy(extlist[cold_count], name, strlen(name));
 279                 memcpy(&extlist[cold_count + 1], buf,
 280                                 F2FS_EXTENSION_LEN * hot_count);
 281                 sbi->raw_super->extension_count = cpu_to_le32(cold_count + 1);
 282         }
 283         return 0;
 284 }
 285
 286 static void set_compress_inode(struct f2fs_sb_info *sbi, struct inode *inode,
 287                                                 const unsigned char *name)
 288 {
 289         __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
 290         unsigned char (*noext)[F2FS_EXTENSION_LEN] = F2FS_OPTION(sbi).noextensions;
 291         unsigned char (*ext)[F2FS_EXTENSION_LEN] = F2FS_OPTION(sbi).extensions;
 292         unsigned char ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
 293         unsigned char noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
 294         int i, cold_count, hot_count;
 295
 296         if (!f2fs_sb_has_compression(sbi) ||
 297                         F2FS_I(inode)->i_flags & F2FS_NOCOMP_FL ||
 298                         !f2fs_may_compress(inode) ||
 299                         (!ext_cnt && !noext_cnt))
 300                 return;
 301
 302         f2fs_down_read(&sbi->sb_lock);
 303
 304         cold_count = le32_to_cpu(sbi->raw_super->extension_count);
 305         hot_count = sbi->raw_super->hot_ext_count;
 306
 307         for (i = cold_count; i < cold_count + hot_count; i++) {
 308                 if (is_extension_exist(name, extlist[i], false)) {
 309                         f2fs_up_read(&sbi->sb_lock);
 310                         return;
 311                 }
 312         }
 313
 314         f2fs_up_read(&sbi->sb_lock);
 315
 316         for (i = 0; i < noext_cnt; i++) {
 317                 if (is_extension_exist(name, noext[i], false)) {
 318                         f2fs_disable_compressed_file(inode);
 319                         return;
 320                 }
 321         }
 322
 323         if (is_inode_flag_set(inode, FI_COMPRESSED_FILE))
 324                 return;
 325
 326         for (i = 0; i < ext_cnt; i++) {
 327                 if (!is_extension_exist(name, ext[i], false))
 328                         continue;
 329
 330                 /* Do not use inline_data with compression */
 331                 stat_dec_inline_inode(inode);
 332                 clear_inode_flag(inode, FI_INLINE_DATA);
 333                 set_compress_context(inode);
 334                 return;
 335         }
 336 }
 337
 338 static int f2fs_create(struct user_namespace *mnt_userns, struct inode *dir,
 339                        struct dentry *dentry, umode_t mode, bool excl)
 340 {
 341         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 342         struct inode *inode;
 343         nid_t ino = 0;
 344         int err;
 345
 346         if (unlikely(f2fs_cp_error(sbi)))
 347                 return -EIO;
 348         if (!f2fs_is_checkpoint_ready(sbi))
 349                 return -ENOSPC;
 350
 351         err = f2fs_dquot_initialize(dir);
 352         if (err)
 353                 return err;
 354
 355         inode = f2fs_new_inode(mnt_userns, dir, mode);
 356         if (IS_ERR(inode))
 357                 return PTR_ERR(inode);
 358
 359         if (!test_opt(sbi, DISABLE_EXT_IDENTIFY))
 360                 set_file_temperature(sbi, inode, dentry->d_name.name);
 361
 362         set_compress_inode(sbi, inode, dentry->d_name.name);
 363
 364         inode->i_op = &f2fs_file_inode_operations;
 365         inode->i_fop = &f2fs_file_operations;
 366         inode->i_mapping->a_ops = &f2fs_dblock_aops;
 367         ino = inode->i_ino;
 368
 369         f2fs_lock_op(sbi);
 370         err = f2fs_add_link(dentry, inode);
 371         if (err)
 372                 goto out;
 373         f2fs_unlock_op(sbi);
 374
 375         f2fs_alloc_nid_done(sbi, ino);
 376
 377         d_instantiate_new(dentry, inode);
 378
 379         if (IS_DIRSYNC(dir))
 380                 f2fs_sync_fs(sbi->sb, 1);
 381
 382         f2fs_balance_fs(sbi, true);
 383         return 0;
 384 out:
 385         f2fs_handle_failed_inode(inode);
 386         return err;
 387 }
 388
 389 static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
 390                 struct dentry *dentry)
 391 {
 392         struct inode *inode = d_inode(old_dentry);
 393         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 394         int err;
 395
 396         if (unlikely(f2fs_cp_error(sbi)))
 397                 return -EIO;
 398         if (!f2fs_is_checkpoint_ready(sbi))
 399                 return -ENOSPC;
 400
 401         err = fscrypt_prepare_link(old_dentry, dir, dentry);
 402         if (err)
 403                 return err;
 404
 405         if (is_inode_flag_set(dir, FI_PROJ_INHERIT) &&
 406                         (!projid_eq(F2FS_I(dir)->i_projid,
 407                         F2FS_I(old_dentry->d_inode)->i_projid)))
 408                 return -EXDEV;
 409
 410         err = f2fs_dquot_initialize(dir);
 411         if (err)
 412                 return err;
 413
 414         f2fs_balance_fs(sbi, true);
 415
 416         inode->i_ctime = current_time(inode);
 417         ihold(inode);
 418
 419         set_inode_flag(inode, FI_INC_LINK);
 420         f2fs_lock_op(sbi);
 421         err = f2fs_add_link(dentry, inode);
 422         if (err)
 423                 goto out;
 424         f2fs_unlock_op(sbi);
 425
 426         d_instantiate(dentry, inode);
 427
 428         if (IS_DIRSYNC(dir))
 429                 f2fs_sync_fs(sbi->sb, 1);
 430         return 0;
 431 out:
 432         clear_inode_flag(inode, FI_INC_LINK);
 433         iput(inode);
 434         f2fs_unlock_op(sbi);
 435         return err;
 436 }
 437
 438 struct dentry *f2fs_get_parent(struct dentry *child)
 439 {
 440         struct page *page;
 441         unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot_name, &page);
 442
 443         if (!ino) {
 444                 if (IS_ERR(page))
 445                         return ERR_CAST(page);
 446                 return ERR_PTR(-ENOENT);
 447         }
 448         return d_obtain_alias(f2fs_iget(child->d_sb, ino));
 449 }
 450
 451 static int __recover_dot_dentries(struct inode *dir, nid_t pino)
 452 {
 453         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 454         struct qstr dot = QSTR_INIT(".", 1);
 455         struct qstr dotdot = QSTR_INIT("..", 2);
 456         struct f2fs_dir_entry *de;
 457         struct page *page;
 458         int err = 0;
 459
 460         if (f2fs_readonly(sbi->sb)) {
 461                 f2fs_info(sbi, "skip recovering inline_dots inode (ino:%lu, pino:%u) in readonly mountpoint",
 462                           dir->i_ino, pino);
 463                 return 0;
 464         }
 465
 466         if (!S_ISDIR(dir->i_mode)) {
 467                 f2fs_err(sbi, "inconsistent inode status, skip recovering inline_dots inode (ino:%lu, i_mode:%u, pino:%u)",
 468                           dir->i_ino, dir->i_mode, pino);
 469                 set_sbi_flag(sbi, SBI_NEED_FSCK);
 470                 return -ENOTDIR;
 471         }
 472
 473         err = f2fs_dquot_initialize(dir);
 474         if (err)
 475                 return err;
 476
 477         f2fs_balance_fs(sbi, true);
 478
 479         f2fs_lock_op(sbi);
 480
 481         de = f2fs_find_entry(dir, &dot, &page);
 482         if (de) {
 483                 f2fs_put_page(page, 0);
 484         } else if (IS_ERR(page)) {
 485                 err = PTR_ERR(page);
 486                 goto out;
 487         } else {
 488                 err = f2fs_do_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR);
 489                 if (err)
 490                         goto out;
 491         }
 492
 493         de = f2fs_find_entry(dir, &dotdot, &page);
 494         if (de)
 495                 f2fs_put_page(page, 0);
 496         else if (IS_ERR(page))
 497                 err = PTR_ERR(page);
 498         else
 499                 err = f2fs_do_add_link(dir, &dotdot, NULL, pino, S_IFDIR);
 500 out:
 501         if (!err)
 502                 clear_inode_flag(dir, FI_INLINE_DOTS);
 503
 504         f2fs_unlock_op(sbi);
 505         return err;
 506 }
 507
 508 static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
 509                 unsigned int flags)
 510 {
 511         struct inode *inode = NULL;
 512         struct f2fs_dir_entry *de;
 513         struct page *page;
 514         struct dentry *new;
 515         nid_t ino = -1;
 516         int err = 0;
 517         unsigned int root_ino = F2FS_ROOT_INO(F2FS_I_SB(dir));
 518         struct f2fs_filename fname;
 519
 520         trace_f2fs_lookup_start(dir, dentry, flags);
 521
 522         if (dentry->d_name.len > F2FS_NAME_LEN) {
 523                 err = -ENAMETOOLONG;
 524                 goto out;
 525         }
 526
 527         err = f2fs_prepare_lookup(dir, dentry, &fname);
 528         generic_set_encrypted_ci_d_ops(dentry);
 529         if (err == -ENOENT)
 530                 goto out_splice;
 531         if (err)
 532                 goto out;
 533         de = __f2fs_find_entry(dir, &fname, &page);
 534         f2fs_free_filename(&fname);
 535
 536         if (!de) {
 537                 if (IS_ERR(page)) {
 538                         err = PTR_ERR(page);
 539                         goto out;
 540                 }
 541                 err = -ENOENT;
 542                 goto out_splice;
 543         }
 544
 545         ino = le32_to_cpu(de->ino);
 546         f2fs_put_page(page, 0);
 547
 548         inode = f2fs_iget(dir->i_sb, ino);
 549         if (IS_ERR(inode)) {
 550                 err = PTR_ERR(inode);
 551                 goto out;
 552         }
 553
 554         if ((dir->i_ino == root_ino) && f2fs_has_inline_dots(dir)) {
 555                 err = __recover_dot_dentries(dir, root_ino);
 556                 if (err)
 557                         goto out_iput;
 558         }
 559
 560         if (f2fs_has_inline_dots(inode)) {
 561                 err = __recover_dot_dentries(inode, dir->i_ino);
 562                 if (err)
 563                         goto out_iput;
 564         }
 565         if (IS_ENCRYPTED(dir) &&
 566             (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
 567             !fscrypt_has_permitted_context(dir, inode)) {
 568                 f2fs_warn(F2FS_I_SB(inode), "Inconsistent encryption contexts: %lu/%lu",
 569                           dir->i_ino, inode->i_ino);
 570                 err = -EPERM;
 571                 goto out_iput;
 572         }
 573 out_splice:
 574 #if IS_ENABLED(CONFIG_UNICODE)
 575         if (!inode && IS_CASEFOLDED(dir)) {
 576                 /* Eventually we want to call d_add_ci(dentry, NULL)
 577                  * for negative dentries in the encoding case as
 578                  * well.  For now, prevent the negative dentry
 579                  * from being cached.
 580                  */
 581                 trace_f2fs_lookup_end(dir, dentry, ino, err);
 582                 return NULL;
 583         }
 584 #endif
 585         new = d_splice_alias(inode, dentry);
 586         err = PTR_ERR_OR_ZERO(new);
 587         trace_f2fs_lookup_end(dir, dentry, ino, !new ? -ENOENT : err);
 588         return new;
 589 out_iput:
 590         iput(inode);
 591 out:
 592         trace_f2fs_lookup_end(dir, dentry, ino, err);
 593         return ERR_PTR(err);
 594 }
 595
 596 static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
 597 {
 598         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 599         struct inode *inode = d_inode(dentry);
 600         struct f2fs_dir_entry *de;
 601         struct page *page;
 602         int err;
 603
 604         trace_f2fs_unlink_enter(dir, dentry);
 605
 606         if (unlikely(f2fs_cp_error(sbi))) {
 607                 err = -EIO;
 608                 goto fail;
 609         }
 610
 611         err = f2fs_dquot_initialize(dir);
 612         if (err)
 613                 goto fail;
 614         err = f2fs_dquot_initialize(inode);
 615         if (err)
 616                 goto fail;
 617
 618         de = f2fs_find_entry(dir, &dentry->d_name, &page);
 619         if (!de) {
 620                 if (IS_ERR(page))
 621                         err = PTR_ERR(page);
 622                 goto fail;
 623         }
 624
 625         f2fs_balance_fs(sbi, true);
 626
 627         f2fs_lock_op(sbi);
 628         err = f2fs_acquire_orphan_inode(sbi);
 629         if (err) {
 630                 f2fs_unlock_op(sbi);
 631                 f2fs_put_page(page, 0);
 632                 goto fail;
 633         }
 634         f2fs_delete_entry(de, page, dir, inode);
 635 #if IS_ENABLED(CONFIG_UNICODE)
 636         /* VFS negative dentries are incompatible with Encoding and
 637          * Case-insensitiveness. Eventually we'll want avoid
 638          * invalidating the dentries here, alongside with returning the
 639          * negative dentries at f2fs_lookup(), when it is better
 640          * supported by the VFS for the CI case.
 641          */
 642         if (IS_CASEFOLDED(dir))
 643                 d_invalidate(dentry);
 644 #endif
 645         f2fs_unlock_op(sbi);
 646
 647         if (IS_DIRSYNC(dir))
 648                 f2fs_sync_fs(sbi->sb, 1);
 649 fail:
 650         trace_f2fs_unlink_exit(inode, err);
 651         return err;
 652 }
 653
 654 static const char *f2fs_get_link(struct dentry *dentry,
 655                                  struct inode *inode,
 656                                  struct delayed_call *done)
 657 {
 658         const char *link = page_get_link(dentry, inode, done);
 659
 660         if (!IS_ERR(link) && !*link) {
 661                 /* this is broken symlink case */
 662                 do_delayed_call(done);
 663                 clear_delayed_call(done);
 664                 link = ERR_PTR(-ENOENT);
 665         }
 666         return link;
 667 }
 668
 669 static int f2fs_symlink(struct user_namespace *mnt_userns, struct inode *dir,
 670                         struct dentry *dentry, const char *symname)
 671 {
 672         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 673         struct inode *inode;
 674         size_t len = strlen(symname);
 675         struct fscrypt_str disk_link;
 676         int err;
 677
 678         if (unlikely(f2fs_cp_error(sbi)))
 679                 return -EIO;
 680         if (!f2fs_is_checkpoint_ready(sbi))
 681                 return -ENOSPC;
 682
 683         err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize,
 684                                       &disk_link);
 685         if (err)
 686                 return err;
 687
 688         err = f2fs_dquot_initialize(dir);
 689         if (err)
 690                 return err;
 691
 692         inode = f2fs_new_inode(mnt_userns, dir, S_IFLNK | S_IRWXUGO);
 693         if (IS_ERR(inode))
 694                 return PTR_ERR(inode);
 695
 696         if (IS_ENCRYPTED(inode))
 697                 inode->i_op = &f2fs_encrypted_symlink_inode_operations;
 698         else
 699                 inode->i_op = &f2fs_symlink_inode_operations;
 700         inode_nohighmem(inode);
 701         inode->i_mapping->a_ops = &f2fs_dblock_aops;
 702
 703         f2fs_lock_op(sbi);
 704         err = f2fs_add_link(dentry, inode);
 705         if (err)
 706                 goto out_f2fs_handle_failed_inode;
 707         f2fs_unlock_op(sbi);
 708         f2fs_alloc_nid_done(sbi, inode->i_ino);
 709
 710         err = fscrypt_encrypt_symlink(inode, symname, len, &disk_link);
 711         if (err)
 712                 goto err_out;
 713
 714         err = page_symlink(inode, disk_link.name, disk_link.len);
 715
 716 err_out:
 717         d_instantiate_new(dentry, inode);
 718
 719         /*
 720          * Let's flush symlink data in order to avoid broken symlink as much as
 721          * possible. Nevertheless, fsyncing is the best way, but there is no
 722          * way to get a file descriptor in order to flush that.
 723          *
 724          * Note that, it needs to do dir->fsync to make this recoverable.
 725          * If the symlink path is stored into inline_data, there is no
 726          * performance regression.
 727          */
 728         if (!err) {
 729                 filemap_write_and_wait_range(inode->i_mapping, 0,
 730                                                         disk_link.len - 1);
 731
 732                 if (IS_DIRSYNC(dir))
 733                         f2fs_sync_fs(sbi->sb, 1);
 734         } else {
 735                 f2fs_unlink(dir, dentry);
 736         }
 737
 738         f2fs_balance_fs(sbi, true);
 739         goto out_free_encrypted_link;
 740
 741 out_f2fs_handle_failed_inode:
 742         f2fs_handle_failed_inode(inode);
 743 out_free_encrypted_link:
 744         if (disk_link.name != (unsigned char *)symname)
 745                 kfree(disk_link.name);
 746         return err;
 747 }
 748
 749 static int f2fs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
 750                       struct dentry *dentry, umode_t mode)
 751 {
 752         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 753         struct inode *inode;
 754         int err;
 755
 756         if (unlikely(f2fs_cp_error(sbi)))
 757                 return -EIO;
 758
 759         err = f2fs_dquot_initialize(dir);
 760         if (err)
 761                 return err;
 762
 763         inode = f2fs_new_inode(mnt_userns, dir, S_IFDIR | mode);
 764         if (IS_ERR(inode))
 765                 return PTR_ERR(inode);
 766
 767         inode->i_op = &f2fs_dir_inode_operations;
 768         inode->i_fop = &f2fs_dir_operations;
 769         inode->i_mapping->a_ops = &f2fs_dblock_aops;
 770         mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
 771
 772         set_inode_flag(inode, FI_INC_LINK);
 773         f2fs_lock_op(sbi);
 774         err = f2fs_add_link(dentry, inode);
 775         if (err)
 776                 goto out_fail;
 777         f2fs_unlock_op(sbi);
 778
 779         f2fs_alloc_nid_done(sbi, inode->i_ino);
 780
 781         d_instantiate_new(dentry, inode);
 782
 783         if (IS_DIRSYNC(dir))
 784                 f2fs_sync_fs(sbi->sb, 1);
 785
 786         f2fs_balance_fs(sbi, true);
 787         return 0;
 788
 789 out_fail:
 790         clear_inode_flag(inode, FI_INC_LINK);
 791         f2fs_handle_failed_inode(inode);
 792         return err;
 793 }
 794
 795 static int f2fs_rmdir(struct inode *dir, struct dentry *dentry)
 796 {
 797         struct inode *inode = d_inode(dentry);
 798
 799         if (f2fs_empty_dir(inode))
 800                 return f2fs_unlink(dir, dentry);
 801         return -ENOTEMPTY;
 802 }
 803
 804 static int f2fs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
 805                       struct dentry *dentry, umode_t mode, dev_t rdev)
 806 {
 807         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 808         struct inode *inode;
 809         int err = 0;
 810
 811         if (unlikely(f2fs_cp_error(sbi)))
 812                 return -EIO;
 813         if (!f2fs_is_checkpoint_ready(sbi))
 814                 return -ENOSPC;
 815
 816         err = f2fs_dquot_initialize(dir);
 817         if (err)
 818                 return err;
 819
 820         inode = f2fs_new_inode(mnt_userns, dir, mode);
 821         if (IS_ERR(inode))
 822                 return PTR_ERR(inode);
 823
 824         init_special_inode(inode, inode->i_mode, rdev);
 825         inode->i_op = &f2fs_special_inode_operations;
 826
 827         f2fs_lock_op(sbi);
 828         err = f2fs_add_link(dentry, inode);
 829         if (err)
 830                 goto out;
 831         f2fs_unlock_op(sbi);
 832
 833         f2fs_alloc_nid_done(sbi, inode->i_ino);
 834
 835         d_instantiate_new(dentry, inode);
 836
 837         if (IS_DIRSYNC(dir))
 838                 f2fs_sync_fs(sbi->sb, 1);
 839
 840         f2fs_balance_fs(sbi, true);
 841         return 0;
 842 out:
 843         f2fs_handle_failed_inode(inode);
 844         return err;
 845 }
 846
 847 static int __f2fs_tmpfile(struct user_namespace *mnt_userns, struct inode *dir,
 848                           struct dentry *dentry, umode_t mode, bool is_whiteout,
 849                           struct inode **new_inode)
 850 {
 851         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 852         struct inode *inode;
 853         int err;
 854
 855         err = f2fs_dquot_initialize(dir);
 856         if (err)
 857                 return err;
 858
 859         inode = f2fs_new_inode(mnt_userns, dir, mode);
 860         if (IS_ERR(inode))
 861                 return PTR_ERR(inode);
 862
 863         if (is_whiteout) {
 864                 init_special_inode(inode, inode->i_mode, WHITEOUT_DEV);
 865                 inode->i_op = &f2fs_special_inode_operations;
 866         } else {
 867                 inode->i_op = &f2fs_file_inode_operations;
 868                 inode->i_fop = &f2fs_file_operations;
 869                 inode->i_mapping->a_ops = &f2fs_dblock_aops;
 870         }
 871
 872         f2fs_lock_op(sbi);
 873         err = f2fs_acquire_orphan_inode(sbi);
 874         if (err)
 875                 goto out;
 876
 877         err = f2fs_do_tmpfile(inode, dir);
 878         if (err)
 879                 goto release_out;
 880
 881         /*
 882          * add this non-linked tmpfile to orphan list, in this way we could
 883          * remove all unused data of tmpfile after abnormal power-off.
 884          */
 885         f2fs_add_orphan_inode(inode);
 886         f2fs_alloc_nid_done(sbi, inode->i_ino);
 887
 888         if (is_whiteout) {
 889                 f2fs_i_links_write(inode, false);
 890
 891                 spin_lock(&inode->i_lock);
 892                 inode->i_state |= I_LINKABLE;
 893                 spin_unlock(&inode->i_lock);
 894         } else {
 895                 if (dentry)
 896                         d_tmpfile(dentry, inode);
 897                 else
 898                         f2fs_i_links_write(inode, false);
 899         }
 900         /* link_count was changed by d_tmpfile as well. */
 901         f2fs_unlock_op(sbi);
 902         unlock_new_inode(inode);
 903
 904         if (new_inode)
 905                 *new_inode = inode;
 906
 907         f2fs_balance_fs(sbi, true);
 908         return 0;
 909
 910 release_out:
 911         f2fs_release_orphan_inode(sbi);
 912 out:
 913         f2fs_handle_failed_inode(inode);
 914         return err;
 915 }
 916
 917 static int f2fs_tmpfile(struct user_namespace *mnt_userns, struct inode *dir,
 918                         struct dentry *dentry, umode_t mode)
 919 {
 920         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 921
 922         if (unlikely(f2fs_cp_error(sbi)))
 923                 return -EIO;
 924         if (!f2fs_is_checkpoint_ready(sbi))
 925                 return -ENOSPC;
 926
 927         return __f2fs_tmpfile(mnt_userns, dir, dentry, mode, false, NULL);
 928 }
 929
 930 static int f2fs_create_whiteout(struct user_namespace *mnt_userns,
 931                                 struct inode *dir, struct inode **whiteout)
 932 {
 933         if (unlikely(f2fs_cp_error(F2FS_I_SB(dir))))
 934                 return -EIO;
 935
 936         return __f2fs_tmpfile(mnt_userns, dir, NULL,
 937                                 S_IFCHR | WHITEOUT_MODE, true, whiteout);
 938 }
 939
 940 int f2fs_get_tmpfile(struct user_namespace *mnt_userns, struct inode *dir,
 941                      struct inode **new_inode)
 942 {
 943         return __f2fs_tmpfile(mnt_userns, dir, NULL, S_IFREG, false, new_inode);
 944 }
 945
 946 static int f2fs_rename(struct user_namespace *mnt_userns, struct inode *old_dir,
 947                         struct dentry *old_dentry, struct inode *new_dir,
 948                         struct dentry *new_dentry, unsigned int flags)
 949 {
 950         struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
 951         struct inode *old_inode = d_inode(old_dentry);
 952         struct inode *new_inode = d_inode(new_dentry);
 953         struct inode *whiteout = NULL;
 954         struct page *old_dir_page = NULL;
 955         struct page *old_page, *new_page = NULL;
 956         struct f2fs_dir_entry *old_dir_entry = NULL;
 957         struct f2fs_dir_entry *old_entry;
 958         struct f2fs_dir_entry *new_entry;
 959         int err;
 960
 961         if (unlikely(f2fs_cp_error(sbi)))
 962                 return -EIO;
 963         if (!f2fs_is_checkpoint_ready(sbi))
 964                 return -ENOSPC;
 965
 966         if (is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
 967                         (!projid_eq(F2FS_I(new_dir)->i_projid,
 968                         F2FS_I(old_dentry->d_inode)->i_projid)))
 969                 return -EXDEV;
 970
 971         /*
 972          * If new_inode is null, the below renaming flow will
 973          * add a link in old_dir which can conver inline_dir.
 974          * After then, if we failed to get the entry due to other
 975          * reasons like ENOMEM, we had to remove the new entry.
 976          * Instead of adding such the error handling routine, let's
 977          * simply convert first here.
 978          */
 979         if (old_dir == new_dir && !new_inode) {
 980                 err = f2fs_try_convert_inline_dir(old_dir, new_dentry);
 981                 if (err)
 982                         return err;
 983         }
 984
 985         if (flags & RENAME_WHITEOUT) {
 986                 err = f2fs_create_whiteout(mnt_userns, old_dir, &whiteout);
 987                 if (err)
 988                         return err;
 989         }
 990
 991         err = f2fs_dquot_initialize(old_dir);
 992         if (err)
 993                 goto out;
 994
 995         err = f2fs_dquot_initialize(new_dir);
 996         if (err)
 997                 goto out;
 998
 999         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 };