fs/f2fs/namei.c

   1 /*
   2  * fs/f2fs/namei.c
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   5  *             http://www.samsung.com/
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11 #include <linux/fs.h>
  12 #include <linux/f2fs_fs.h>
  13 #include <linux/pagemap.h>
  14 #include <linux/sched.h>
  15 #include <linux/ctype.h>
  16 #include <linux/dcache.h>
  17 #include <linux/namei.h>
  18
  19 #include "f2fs.h"
  20 #include "node.h"
  21 #include "xattr.h"
  22 #include "acl.h"
  23 #include <trace/events/f2fs.h>
  24
  25 static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
  26 {
  27         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  28         nid_t ino;
  29         struct inode *inode;
  30         bool nid_free = false;
  31         int err;
  32
  33         inode = new_inode(dir->i_sb);
  34         if (!inode)
  35                 return ERR_PTR(-ENOMEM);
  36
  37         f2fs_lock_op(sbi);
  38         if (!alloc_nid(sbi, &ino)) {
  39                 f2fs_unlock_op(sbi);
  40                 err = -ENOSPC;
  41                 goto fail;
  42         }
  43         f2fs_unlock_op(sbi);
  44
  45         inode_init_owner(inode, dir, mode);
  46
  47         inode->i_ino = ino;
  48         inode->i_blocks = 0;
  49         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  50         inode->i_generation = sbi->s_next_generation++;
  51
  52         err = insert_inode_locked(inode);
  53         if (err) {
  54                 err = -EINVAL;
  55                 nid_free = true;
  56                 goto fail;
  57         }
  58
  59         /* If the directory encrypted, then we should encrypt the inode. */
  60         if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode))
  61                 f2fs_set_encrypted_inode(inode);
  62
  63         set_inode_flag(inode, FI_NEW_INODE);
  64
  65         if (test_opt(sbi, INLINE_XATTR))
  66                 set_inode_flag(inode, FI_INLINE_XATTR);
  67         if (test_opt(sbi, INLINE_DATA) && f2fs_may_inline_data(inode))
  68                 set_inode_flag(inode, FI_INLINE_DATA);
  69         if (f2fs_may_inline_dentry(inode))
  70                 set_inode_flag(inode, FI_INLINE_DENTRY);
  71
  72         f2fs_init_extent_tree(inode, NULL);
  73
  74         stat_inc_inline_xattr(inode);
  75         stat_inc_inline_inode(inode);
  76         stat_inc_inline_dir(inode);
  77
  78         trace_f2fs_new_inode(inode, 0);
  79         return inode;
  80
  81 fail:
  82         trace_f2fs_new_inode(inode, err);
  83         make_bad_inode(inode);
  84         if (nid_free)
  85                 set_inode_flag(inode, FI_FREE_NID);
  86         iput(inode);
  87         return ERR_PTR(err);
  88 }
  89
  90 static int is_multimedia_file(const unsigned char *s, const char *sub)
  91 {
  92         size_t slen = strlen(s);
  93         size_t sublen = strlen(sub);
  94
  95         /*
  96          * filename format of multimedia file should be defined as:
  97          * "filename + '.' + extension".
  98          */
  99         if (slen < sublen + 2)
 100                 return 0;
 101
 102         if (s[slen - sublen - 1] != '.')
 103                 return 0;
 104
 105         return !strncasecmp(s + slen - sublen, sub, sublen);
 106 }
 107
 108 /*
 109  * Set multimedia files as cold files for hot/cold data separation
 110  */
 111 static inline void set_cold_files(struct f2fs_sb_info *sbi, struct inode *inode,
 112                 const unsigned char *name)
 113 {
 114         int i;
 115         __u8 (*extlist)[8] = sbi->raw_super->extension_list;
 116
 117         int count = le32_to_cpu(sbi->raw_super->extension_count);
 118         for (i = 0; i < count; i++) {
 119                 if (is_multimedia_file(name, extlist[i])) {
 120                         file_set_cold(inode);
 121                         break;
 122                 }
 123         }
 124 }
 125
 126 static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 127                                                 bool excl)
 128 {
 129         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 130         struct inode *inode;
 131         nid_t ino = 0;
 132         int err;
 133
 134         inode = f2fs_new_inode(dir, mode);
 135         if (IS_ERR(inode))
 136                 return PTR_ERR(inode);
 137
 138         if (!test_opt(sbi, DISABLE_EXT_IDENTIFY))
 139                 set_cold_files(sbi, inode, dentry->d_name.name);
 140
 141         inode->i_op = &f2fs_file_inode_operations;
 142         inode->i_fop = &f2fs_file_operations;
 143         inode->i_mapping->a_ops = &f2fs_dblock_aops;
 144         ino = inode->i_ino;
 145
 146         f2fs_balance_fs(sbi, true);
 147
 148         f2fs_lock_op(sbi);
 149         err = f2fs_add_link(dentry, inode);
 150         if (err)
 151                 goto out;
 152         f2fs_unlock_op(sbi);
 153
 154         alloc_nid_done(sbi, ino);
 155
 156         d_instantiate(dentry, inode);
 157         unlock_new_inode(inode);
 158
 159         if (IS_DIRSYNC(dir))
 160                 f2fs_sync_fs(sbi->sb, 1);
 161         return 0;
 162 out:
 163         handle_failed_inode(inode);
 164         return err;
 165 }
 166
 167 static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
 168                 struct dentry *dentry)
 169 {
 170         struct inode *inode = d_inode(old_dentry);
 171         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 172         int err;
 173
 174         if (f2fs_encrypted_inode(dir) &&
 175                         !fscrypt_has_permitted_context(dir, inode))
 176                 return -EPERM;
 177
 178         f2fs_balance_fs(sbi, true);
 179
 180         inode->i_ctime = CURRENT_TIME;
 181         ihold(inode);
 182
 183         set_inode_flag(inode, FI_INC_LINK);
 184         f2fs_lock_op(sbi);
 185         err = f2fs_add_link(dentry, inode);
 186         if (err)
 187                 goto out;
 188         f2fs_unlock_op(sbi);
 189
 190         d_instantiate(dentry, inode);
 191
 192         if (IS_DIRSYNC(dir))
 193                 f2fs_sync_fs(sbi->sb, 1);
 194         return 0;
 195 out:
 196         clear_inode_flag(inode, FI_INC_LINK);
 197         iput(inode);
 198         f2fs_unlock_op(sbi);
 199         return err;
 200 }
 201
 202 struct dentry *f2fs_get_parent(struct dentry *child)
 203 {
 204         struct qstr dotdot = QSTR_INIT("..", 2);
 205         struct page *page;
 206         unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot, &page);
 207         if (!ino) {
 208                 if (IS_ERR(page))
 209                         return ERR_CAST(page);
 210                 return ERR_PTR(-ENOENT);
 211         }
 212         return d_obtain_alias(f2fs_iget(child->d_sb, ino));
 213 }
 214
 215 static int __recover_dot_dentries(struct inode *dir, nid_t pino)
 216 {
 217         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 218         struct qstr dot = QSTR_INIT(".", 1);
 219         struct qstr dotdot = QSTR_INIT("..", 2);
 220         struct f2fs_dir_entry *de;
 221         struct page *page;
 222         int err = 0;
 223
 224         if (f2fs_readonly(sbi->sb)) {
 225                 f2fs_msg(sbi->sb, KERN_INFO,
 226                         "skip recovering inline_dots inode (ino:%lu, pino:%u) "
 227                         "in readonly mountpoint", dir->i_ino, pino);
 228                 return 0;
 229         }
 230
 231         f2fs_balance_fs(sbi, true);
 232
 233         f2fs_lock_op(sbi);
 234
 235         de = f2fs_find_entry(dir, &dot, &page);
 236         if (de) {
 237                 f2fs_dentry_kunmap(dir, page);
 238                 f2fs_put_page(page, 0);
 239         } else if (IS_ERR(page)) {
 240                 err = PTR_ERR(page);
 241                 goto out;
 242         } else {
 243                 err = __f2fs_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR);
 244                 if (err)
 245                         goto out;
 246         }
 247
 248         de = f2fs_find_entry(dir, &dotdot, &page);
 249         if (de) {
 250                 f2fs_dentry_kunmap(dir, page);
 251                 f2fs_put_page(page, 0);
 252         } else if (IS_ERR(page)) {
 253                 err = PTR_ERR(page);
 254         } else {
 255                 err = __f2fs_add_link(dir, &dotdot, NULL, pino, S_IFDIR);
 256         }
 257 out:
 258         if (!err)
 259                 clear_inode_flag(dir, FI_INLINE_DOTS);
 260
 261         f2fs_unlock_op(sbi);
 262         return err;
 263 }
 264
 265 static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
 266                 unsigned int flags)
 267 {
 268         struct inode *inode = NULL;
 269         struct f2fs_dir_entry *de;
 270         struct page *page;
 271         nid_t ino;
 272         int err = 0;
 273         unsigned int root_ino = F2FS_ROOT_INO(F2FS_I_SB(dir));
 274
 275         if (f2fs_encrypted_inode(dir)) {
 276                 int res = fscrypt_get_encryption_info(dir);
 277
 278                 /*
 279                  * DCACHE_ENCRYPTED_WITH_KEY is set if the dentry is
 280                  * created while the directory was encrypted and we
 281                  * don't have access to the key.
 282                  */
 283                 if (fscrypt_has_encryption_key(dir))
 284                         fscrypt_set_encrypted_dentry(dentry);
 285                 fscrypt_set_d_op(dentry);
 286                 if (res && res != -ENOKEY)
 287                         return ERR_PTR(res);
 288         }
 289
 290         if (dentry->d_name.len > F2FS_NAME_LEN)
 291                 return ERR_PTR(-ENAMETOOLONG);
 292
 293         de = f2fs_find_entry(dir, &dentry->d_name, &page);
 294         if (!de) {
 295                 if (IS_ERR(page))
 296                         return (struct dentry *)page;
 297                 return d_splice_alias(inode, dentry);
 298         }
 299
 300         ino = le32_to_cpu(de->ino);
 301         f2fs_dentry_kunmap(dir, page);
 302         f2fs_put_page(page, 0);
 303
 304         inode = f2fs_iget(dir->i_sb, ino);
 305         if (IS_ERR(inode))
 306                 return ERR_CAST(inode);
 307
 308         if ((dir->i_ino == root_ino) && f2fs_has_inline_dots(dir)) {
 309                 err = __recover_dot_dentries(dir, root_ino);
 310                 if (err)
 311                         goto err_out;
 312         }
 313
 314         if (f2fs_has_inline_dots(inode)) {
 315                 err = __recover_dot_dentries(inode, dir->i_ino);
 316                 if (err)
 317                         goto err_out;
 318         }
 319         if (!IS_ERR(inode) && f2fs_encrypted_inode(dir) &&
 320                         (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
 321                         !fscrypt_has_permitted_context(dir, inode)) {
 322                 bool nokey = f2fs_encrypted_inode(inode) &&
 323                         !fscrypt_has_encryption_key(inode);
 324                 err = nokey ? -ENOKEY : -EPERM;
 325                 goto err_out;
 326         }
 327         return d_splice_alias(inode, dentry);
 328
 329 err_out:
 330         iput(inode);
 331         return ERR_PTR(err);
 332 }
 333
 334 static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
 335 {
 336         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 337         struct inode *inode = d_inode(dentry);
 338         struct f2fs_dir_entry *de;
 339         struct page *page;
 340         int err = -ENOENT;
 341
 342         trace_f2fs_unlink_enter(dir, dentry);
 343
 344         de = f2fs_find_entry(dir, &dentry->d_name, &page);
 345         if (!de) {
 346                 if (IS_ERR(page))
 347                         err = PTR_ERR(page);
 348                 goto fail;
 349         }
 350
 351         f2fs_balance_fs(sbi, true);
 352
 353         f2fs_lock_op(sbi);
 354         err = acquire_orphan_inode(sbi);
 355         if (err) {
 356                 f2fs_unlock_op(sbi);
 357                 f2fs_dentry_kunmap(dir, page);
 358                 f2fs_put_page(page, 0);
 359                 goto fail;
 360         }
 361         f2fs_delete_entry(de, page, dir, inode);
 362         f2fs_unlock_op(sbi);
 363
 364         if (IS_DIRSYNC(dir))
 365                 f2fs_sync_fs(sbi->sb, 1);
 366 fail:
 367         trace_f2fs_unlink_exit(inode, err);
 368         return err;
 369 }
 370
 371 static const char *f2fs_get_link(struct dentry *dentry,
 372                                  struct inode *inode,
 373                                  struct delayed_call *done)
 374 {
 375         const char *link = page_get_link(dentry, inode, done);
 376         if (!IS_ERR(link) && !*link) {
 377                 /* this is broken symlink case */
 378                 do_delayed_call(done);
 379                 clear_delayed_call(done);
 380                 link = ERR_PTR(-ENOENT);
 381         }
 382         return link;
 383 }
 384
 385 static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
 386                                         const char *symname)
 387 {
 388         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 389         struct inode *inode;
 390         size_t len = strlen(symname);
 391         struct fscrypt_str disk_link = FSTR_INIT((char *)symname, len + 1);
 392         struct fscrypt_symlink_data *sd = NULL;
 393         int err;
 394
 395         if (f2fs_encrypted_inode(dir)) {
 396                 err = fscrypt_get_encryption_info(dir);
 397                 if (err)
 398                         return err;
 399
 400                 if (!fscrypt_has_encryption_key(dir))
 401                         return -EPERM;
 402
 403                 disk_link.len = (fscrypt_fname_encrypted_size(dir, len) +
 404                                 sizeof(struct fscrypt_symlink_data));
 405         }
 406
 407         if (disk_link.len > dir->i_sb->s_blocksize)
 408                 return -ENAMETOOLONG;
 409
 410         inode = f2fs_new_inode(dir, S_IFLNK | S_IRWXUGO);
 411         if (IS_ERR(inode))
 412                 return PTR_ERR(inode);
 413
 414         if (f2fs_encrypted_inode(inode))
 415                 inode->i_op = &f2fs_encrypted_symlink_inode_operations;
 416         else
 417                 inode->i_op = &f2fs_symlink_inode_operations;
 418         inode_nohighmem(inode);
 419         inode->i_mapping->a_ops = &f2fs_dblock_aops;
 420
 421         f2fs_balance_fs(sbi, true);
 422
 423         f2fs_lock_op(sbi);
 424         err = f2fs_add_link(dentry, inode);
 425         if (err)
 426                 goto out;
 427         f2fs_unlock_op(sbi);
 428         alloc_nid_done(sbi, inode->i_ino);
 429
 430         if (f2fs_encrypted_inode(inode)) {
 431                 struct qstr istr = QSTR_INIT(symname, len);
 432                 struct fscrypt_str ostr;
 433
 434                 sd = kzalloc(disk_link.len, GFP_NOFS);
 435                 if (!sd) {
 436                         err = -ENOMEM;
 437                         goto err_out;
 438                 }
 439
 440                 err = fscrypt_get_encryption_info(inode);
 441                 if (err)
 442                         goto err_out;
 443
 444                 if (!fscrypt_has_encryption_key(inode)) {
 445                         err = -EPERM;
 446                         goto err_out;
 447                 }
 448
 449                 ostr.name = sd->encrypted_path;
 450                 ostr.len = disk_link.len;
 451                 err = fscrypt_fname_usr_to_disk(inode, &istr, &ostr);
 452                 if (err < 0)
 453                         goto err_out;
 454
 455                 sd->len = cpu_to_le16(ostr.len);
 456                 disk_link.name = (char *)sd;
 457         }
 458
 459         err = page_symlink(inode, disk_link.name, disk_link.len);
 460
 461 err_out:
 462         d_instantiate(dentry, inode);
 463         unlock_new_inode(inode);
 464
 465         /*
 466          * Let's flush symlink data in order to avoid broken symlink as much as
 467          * possible. Nevertheless, fsyncing is the best way, but there is no
 468          * way to get a file descriptor in order to flush that.
 469          *
 470          * Note that, it needs to do dir->fsync to make this recoverable.
 471          * If the symlink path is stored into inline_data, there is no
 472          * performance regression.
 473          */
 474         if (!err) {
 475                 filemap_write_and_wait_range(inode->i_mapping, 0,
 476                                                         disk_link.len - 1);
 477
 478                 if (IS_DIRSYNC(dir))
 479                         f2fs_sync_fs(sbi->sb, 1);
 480         } else {
 481                 f2fs_unlink(dir, dentry);
 482         }
 483
 484         kfree(sd);
 485         return err;
 486 out:
 487         handle_failed_inode(inode);
 488         return err;
 489 }
 490
 491 static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 492 {
 493         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 494         struct inode *inode;
 495         int err;
 496
 497         inode = f2fs_new_inode(dir, S_IFDIR | mode);
 498         if (IS_ERR(inode))
 499                 return PTR_ERR(inode);
 500
 501         inode->i_op = &f2fs_dir_inode_operations;
 502         inode->i_fop = &f2fs_dir_operations;
 503         inode->i_mapping->a_ops = &f2fs_dblock_aops;
 504         mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_HIGH_ZERO);
 505
 506         f2fs_balance_fs(sbi, true);
 507
 508         set_inode_flag(inode, FI_INC_LINK);
 509         f2fs_lock_op(sbi);
 510         err = f2fs_add_link(dentry, inode);
 511         if (err)
 512                 goto out_fail;
 513         f2fs_unlock_op(sbi);
 514
 515         alloc_nid_done(sbi, inode->i_ino);
 516
 517         d_instantiate(dentry, inode);
 518         unlock_new_inode(inode);
 519
 520         if (IS_DIRSYNC(dir))
 521                 f2fs_sync_fs(sbi->sb, 1);
 522         return 0;
 523
 524 out_fail:
 525         clear_inode_flag(inode, FI_INC_LINK);
 526         handle_failed_inode(inode);
 527         return err;
 528 }
 529
 530 static int f2fs_rmdir(struct inode *dir, struct dentry *dentry)
 531 {
 532         struct inode *inode = d_inode(dentry);
 533         if (f2fs_empty_dir(inode))
 534                 return f2fs_unlink(dir, dentry);
 535         return -ENOTEMPTY;
 536 }
 537
 538 static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
 539                                 umode_t mode, dev_t rdev)
 540 {
 541         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 542         struct inode *inode;
 543         int err = 0;
 544
 545         inode = f2fs_new_inode(dir, mode);
 546         if (IS_ERR(inode))
 547                 return PTR_ERR(inode);
 548
 549         init_special_inode(inode, inode->i_mode, rdev);
 550         inode->i_op = &f2fs_special_inode_operations;
 551
 552         f2fs_balance_fs(sbi, true);
 553
 554         f2fs_lock_op(sbi);
 555         err = f2fs_add_link(dentry, inode);
 556         if (err)
 557                 goto out;
 558         f2fs_unlock_op(sbi);
 559
 560         alloc_nid_done(sbi, inode->i_ino);
 561
 562         d_instantiate(dentry, inode);
 563         unlock_new_inode(inode);
 564
 565         if (IS_DIRSYNC(dir))
 566                 f2fs_sync_fs(sbi->sb, 1);
 567         return 0;
 568 out:
 569         handle_failed_inode(inode);
 570         return err;
 571 }
 572
 573 static int __f2fs_tmpfile(struct inode *dir, struct dentry *dentry,
 574                                         umode_t mode, struct inode **whiteout)
 575 {
 576         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 577         struct inode *inode;
 578         int err;
 579
 580         inode = f2fs_new_inode(dir, mode);
 581         if (IS_ERR(inode))
 582                 return PTR_ERR(inode);
 583
 584         if (whiteout) {
 585                 init_special_inode(inode, inode->i_mode, WHITEOUT_DEV);
 586                 inode->i_op = &f2fs_special_inode_operations;
 587         } else {
 588                 inode->i_op = &f2fs_file_inode_operations;
 589                 inode->i_fop = &f2fs_file_operations;
 590                 inode->i_mapping->a_ops = &f2fs_dblock_aops;
 591         }
 592
 593         f2fs_balance_fs(sbi, true);
 594
 595         f2fs_lock_op(sbi);
 596         err = acquire_orphan_inode(sbi);
 597         if (err)
 598                 goto out;
 599
 600         err = f2fs_do_tmpfile(inode, dir);
 601         if (err)
 602                 goto release_out;
 603
 604         /*
 605          * add this non-linked tmpfile to orphan list, in this way we could
 606          * remove all unused data of tmpfile after abnormal power-off.
 607          */
 608         add_orphan_inode(inode);
 609         alloc_nid_done(sbi, inode->i_ino);
 610
 611         if (whiteout) {
 612                 f2fs_i_links_write(inode, false);
 613                 *whiteout = inode;
 614         } else {
 615                 d_tmpfile(dentry, inode);
 616         }
 617         /* link_count was changed by d_tmpfile as well. */
 618         f2fs_unlock_op(sbi);
 619         unlock_new_inode(inode);
 620         return 0;
 621
 622 release_out:
 623         release_orphan_inode(sbi);
 624 out:
 625         handle_failed_inode(inode);
 626         return err;
 627 }
 628
 629 static int f2fs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
 630 {
 631         if (f2fs_encrypted_inode(dir)) {
 632                 int err = fscrypt_get_encryption_info(dir);
 633                 if (err)
 634                         return err;
 635         }
 636
 637         return __f2fs_tmpfile(dir, dentry, mode, NULL);
 638 }
 639
 640 static int f2fs_create_whiteout(struct inode *dir, struct inode **whiteout)
 641 {
 642         return __f2fs_tmpfile(dir, NULL, S_IFCHR | WHITEOUT_MODE, whiteout);
 643 }
 644
 645 static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
 646                         struct inode *new_dir, struct dentry *new_dentry,
 647                         unsigned int flags)
 648 {
 649         struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
 650         struct inode *old_inode = d_inode(old_dentry);
 651         struct inode *new_inode = d_inode(new_dentry);
 652         struct inode *whiteout = NULL;
 653         struct page *old_dir_page;
 654         struct page *old_page, *new_page = NULL;
 655         struct f2fs_dir_entry *old_dir_entry = NULL;
 656         struct f2fs_dir_entry *old_entry;
 657         struct f2fs_dir_entry *new_entry;
 658         bool is_old_inline = f2fs_has_inline_dentry(old_dir);
 659         int err = -ENOENT;
 660
 661         if ((old_dir != new_dir) && f2fs_encrypted_inode(new_dir) &&
 662                         !fscrypt_has_permitted_context(new_dir, old_inode)) {
 663                 err = -EPERM;
 664                 goto out;
 665         }
 666
 667         old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
 668         if (!old_entry) {
 669                 if (IS_ERR(old_page))
 670                         err = PTR_ERR(old_page);
 671                 goto out;
 672         }
 673
 674         if (S_ISDIR(old_inode->i_mode)) {
 675                 old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page);
 676                 if (!old_dir_entry) {
 677                         if (IS_ERR(old_dir_page))
 678                                 err = PTR_ERR(old_dir_page);
 679                         goto out_old;
 680                 }
 681         }
 682
 683         if (flags & RENAME_WHITEOUT) {
 684                 err = f2fs_create_whiteout(old_dir, &whiteout);
 685                 if (err)
 686                         goto out_dir;
 687         }
 688
 689         if (new_inode) {
 690
 691                 err = -ENOTEMPTY;
 692                 if (old_dir_entry && !f2fs_empty_dir(new_inode))
 693                         goto out_whiteout;
 694
 695                 err = -ENOENT;
 696                 new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name,
 697                                                 &new_page);
 698                 if (!new_entry) {
 699                         if (IS_ERR(new_page))
 700                                 err = PTR_ERR(new_page);
 701                         goto out_whiteout;
 702                 }
 703
 704                 f2fs_balance_fs(sbi, true);
 705
 706                 f2fs_lock_op(sbi);
 707
 708                 err = acquire_orphan_inode(sbi);
 709                 if (err)
 710                         goto put_out_dir;
 711
 712                 err = update_dent_inode(old_inode, new_inode,
 713                                                 &new_dentry->d_name);
 714                 if (err) {
 715                         release_orphan_inode(sbi);
 716                         goto put_out_dir;
 717                 }
 718
 719                 f2fs_set_link(new_dir, new_entry, new_page, old_inode);
 720
 721                 new_inode->i_ctime = CURRENT_TIME;
 722                 down_write(&F2FS_I(new_inode)->i_sem);
 723                 if (old_dir_entry)
 724                         f2fs_i_links_write(new_inode, false);
 725                 f2fs_i_links_write(new_inode, false);
 726                 up_write(&F2FS_I(new_inode)->i_sem);
 727
 728                 if (!new_inode->i_nlink)
 729                         add_orphan_inode(new_inode);
 730                 else
 731                         release_orphan_inode(sbi);
 732         } else {
 733                 f2fs_balance_fs(sbi, true);
 734
 735                 f2fs_lock_op(sbi);
 736
 737                 err = f2fs_add_link(new_dentry, old_inode);
 738                 if (err) {
 739                         f2fs_unlock_op(sbi);
 740                         goto out_whiteout;
 741                 }
 742
 743                 if (old_dir_entry)
 744                         f2fs_i_links_write(new_dir, true);
 745
 746                 /*
 747                  * old entry and new entry can locate in the same inline
 748                  * dentry in inode, when attaching new entry in inline dentry,
 749                  * it could force inline dentry conversion, after that,
 750                  * old_entry and old_page will point to wrong address, in
 751                  * order to avoid this, let's do the check and update here.
 752                  */
 753                 if (is_old_inline && !f2fs_has_inline_dentry(old_dir)) {
 754                         f2fs_put_page(old_page, 0);
 755                         old_page = NULL;
 756
 757                         old_entry = f2fs_find_entry(old_dir,
 758                                                 &old_dentry->d_name, &old_page);
 759                         if (!old_entry) {
 760                                 err = -ENOENT;
 761                                 if (IS_ERR(old_page))
 762                                         err = PTR_ERR(old_page);
 763                                 f2fs_unlock_op(sbi);
 764                                 goto out_whiteout;
 765                         }
 766                 }
 767         }
 768
 769         down_write(&F2FS_I(old_inode)->i_sem);
 770         file_lost_pino(old_inode);
 771         if (new_inode && file_enc_name(new_inode))
 772                 file_set_enc_name(old_inode);
 773         up_write(&F2FS_I(old_inode)->i_sem);
 774
 775         old_inode->i_ctime = CURRENT_TIME;
 776         f2fs_mark_inode_dirty_sync(old_inode);
 777
 778         f2fs_delete_entry(old_entry, old_page, old_dir, NULL);
 779
 780         if (whiteout) {
 781                 whiteout->i_state |= I_LINKABLE;
 782                 set_inode_flag(whiteout, FI_INC_LINK);
 783                 err = f2fs_add_link(old_dentry, whiteout);
 784                 if (err)
 785                         goto put_out_dir;
 786                 whiteout->i_state &= ~I_LINKABLE;
 787                 iput(whiteout);
 788         }
 789
 790         if (old_dir_entry) {
 791                 if (old_dir != new_dir && !whiteout) {
 792                         f2fs_set_link(old_inode, old_dir_entry,
 793                                                 old_dir_page, new_dir);
 794                 } else {
 795                         f2fs_dentry_kunmap(old_inode, old_dir_page);
 796                         f2fs_put_page(old_dir_page, 0);
 797                 }
 798                 f2fs_i_links_write(old_dir, false);
 799         }
 800
 801         f2fs_unlock_op(sbi);
 802
 803         if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
 804                 f2fs_sync_fs(sbi->sb, 1);
 805         return 0;
 806
 807 put_out_dir:
 808         f2fs_unlock_op(sbi);
 809         if (new_page) {
 810                 f2fs_dentry_kunmap(new_dir, new_page);
 811                 f2fs_put_page(new_page, 0);
 812         }
 813 out_whiteout:
 814         if (whiteout)
 815                 iput(whiteout);
 816 out_dir:
 817         if (old_dir_entry) {
 818                 f2fs_dentry_kunmap(old_inode, old_dir_page);
 819                 f2fs_put_page(old_dir_page, 0);
 820         }
 821 out_old:
 822         f2fs_dentry_kunmap(old_dir, old_page);
 823         f2fs_put_page(old_page, 0);
 824 out:
 825         return err;
 826 }
 827
 828 static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
 829                              struct inode *new_dir, struct dentry *new_dentry)
 830 {
 831         struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
 832         struct inode *old_inode = d_inode(old_dentry);
 833         struct inode *new_inode = d_inode(new_dentry);
 834         struct page *old_dir_page, *new_dir_page;
 835         struct page *old_page, *new_page;
 836         struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL;
 837         struct f2fs_dir_entry *old_entry, *new_entry;
 838         int old_nlink = 0, new_nlink = 0;
 839         int err = -ENOENT;
 840
 841         if ((f2fs_encrypted_inode(old_dir) || f2fs_encrypted_inode(new_dir)) &&
 842                         (old_dir != new_dir) &&
 843                         (!fscrypt_has_permitted_context(new_dir, old_inode) ||
 844                          !fscrypt_has_permitted_context(old_dir, new_inode)))
 845                 return -EPERM;
 846
 847         old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
 848         if (!old_entry) {
 849                 if (IS_ERR(old_page))
 850                         err = PTR_ERR(old_page);
 851                 goto out;
 852         }
 853
 854         new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, &new_page);
 855         if (!new_entry) {
 856                 if (IS_ERR(new_page))
 857                         err = PTR_ERR(new_page);
 858                 goto out_old;
 859         }
 860
 861         /* prepare for updating ".." directory entry info later */
 862         if (old_dir != new_dir) {
 863                 if (S_ISDIR(old_inode->i_mode)) {
 864                         old_dir_entry = f2fs_parent_dir(old_inode,
 865                                                         &old_dir_page);
 866                         if (!old_dir_entry) {
 867                                 if (IS_ERR(old_dir_page))
 868                                         err = PTR_ERR(old_dir_page);
 869                                 goto out_new;
 870                         }
 871                 }
 872
 873                 if (S_ISDIR(new_inode->i_mode)) {
 874                         new_dir_entry = f2fs_parent_dir(new_inode,
 875                                                         &new_dir_page);
 876                         if (!new_dir_entry) {
 877                                 if (IS_ERR(new_dir_page))
 878                                         err = PTR_ERR(new_dir_page);
 879                                 goto out_old_dir;
 880                         }
 881                 }
 882         }
 883
 884         /*
 885          * If cross rename between file and directory those are not
 886          * in the same directory, we will inc nlink of file's parent
 887          * later, so we should check upper boundary of its nlink.
 888          */
 889         if ((!old_dir_entry || !new_dir_entry) &&
 890                                 old_dir_entry != new_dir_entry) {
 891                 old_nlink = old_dir_entry ? -1 : 1;
 892                 new_nlink = -old_nlink;
 893                 err = -EMLINK;
 894                 if ((old_nlink > 0 && old_inode->i_nlink >= F2FS_LINK_MAX) ||
 895                         (new_nlink > 0 && new_inode->i_nlink >= F2FS_LINK_MAX))
 896                         goto out_new_dir;
 897         }
 898
 899         f2fs_balance_fs(sbi, true);
 900
 901         f2fs_lock_op(sbi);
 902
 903         err = update_dent_inode(old_inode, new_inode, &new_dentry->d_name);
 904         if (err)
 905                 goto out_unlock;
 906         if (file_enc_name(new_inode))
 907                 file_set_enc_name(old_inode);
 908
 909         err = update_dent_inode(new_inode, old_inode, &old_dentry->d_name);
 910         if (err)
 911                 goto out_undo;
 912         if (file_enc_name(old_inode))
 913                 file_set_enc_name(new_inode);
 914
 915         /* update ".." directory entry info of old dentry */
 916         if (old_dir_entry)
 917                 f2fs_set_link(old_inode, old_dir_entry, old_dir_page, new_dir);
 918
 919         /* update ".." directory entry info of new dentry */
 920         if (new_dir_entry)
 921                 f2fs_set_link(new_inode, new_dir_entry, new_dir_page, old_dir);
 922
 923         /* update directory entry info of old dir inode */
 924         f2fs_set_link(old_dir, old_entry, old_page, new_inode);
 925
 926         down_write(&F2FS_I(old_inode)->i_sem);
 927         file_lost_pino(old_inode);
 928         up_write(&F2FS_I(old_inode)->i_sem);
 929
 930         old_dir->i_ctime = CURRENT_TIME;
 931         if (old_nlink) {
 932                 down_write(&F2FS_I(old_dir)->i_sem);
 933                 f2fs_i_links_write(old_dir, old_nlink > 0);
 934                 up_write(&F2FS_I(old_dir)->i_sem);
 935         }
 936         f2fs_mark_inode_dirty_sync(old_dir);
 937
 938         /* update directory entry info of new dir inode */
 939         f2fs_set_link(new_dir, new_entry, new_page, old_inode);
 940
 941         down_write(&F2FS_I(new_inode)->i_sem);
 942         file_lost_pino(new_inode);
 943         up_write(&F2FS_I(new_inode)->i_sem);
 944
 945         new_dir->i_ctime = CURRENT_TIME;
 946         if (new_nlink) {
 947                 down_write(&F2FS_I(new_dir)->i_sem);
 948                 f2fs_i_links_write(new_dir, new_nlink > 0);
 949                 up_write(&F2FS_I(new_dir)->i_sem);
 950         }
 951         f2fs_mark_inode_dirty_sync(new_dir);
 952
 953         f2fs_unlock_op(sbi);
 954
 955         if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
 956                 f2fs_sync_fs(sbi->sb, 1);
 957         return 0;
 958 out_undo:
 959         /*
 960          * Still we may fail to recover name info of f2fs_inode here
 961          * Drop it, once its name is set as encrypted
 962          */
 963         update_dent_inode(old_inode, old_inode, &old_dentry->d_name);
 964 out_unlock:
 965         f2fs_unlock_op(sbi);
 966 out_new_dir:
 967         if (new_dir_entry) {
 968                 f2fs_dentry_kunmap(new_inode, new_dir_page);
 969                 f2fs_put_page(new_dir_page, 0);
 970         }
 971 out_old_dir:
 972         if (old_dir_entry) {
 973                 f2fs_dentry_kunmap(old_inode, old_dir_page);
 974                 f2fs_put_page(old_dir_page, 0);
 975         }
 976 out_new:
 977         f2fs_dentry_kunmap(new_dir, new_page);
 978         f2fs_put_page(new_page, 0);
 979 out_old:
 980         f2fs_dentry_kunmap(old_dir, old_page);
 981         f2fs_put_page(old_page, 0);
 982 out:
 983         return err;
 984 }
 985
 986 static int f2fs_rename2(struct inode *old_dir, struct dentry *old_dentry,
 987                         struct inode *new_dir, struct dentry *new_dentry,
 988                         unsigned int flags)
 989 {
 990         if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
 991                 return -EINVAL;
 992
 993         if (flags & RENAME_EXCHANGE) {
 994                 return f2fs_cross_rename(old_dir, old_dentry,
 995                                          new_dir, new_dentry);
 996         }
 997         /*
 998          * VFS has already handled the new dentry existence case,
 999          * here, we just deal with "RENAME_NOREPLACE" as regular rename.
1000          */
1001         return f2fs_rename(old_dir, old_dentry, new_dir, new_dentry, flags);
1002 }
1003
1004 static const char *f2fs_encrypted_get_link(struct dentry *dentry,
1005                                            struct inode *inode,
1006                                            struct delayed_call *done)
1007 {
1008         struct page *cpage = NULL;
1009         char *caddr, *paddr = NULL;
1010         struct fscrypt_str cstr = FSTR_INIT(NULL, 0);
1011         struct fscrypt_str pstr = FSTR_INIT(NULL, 0);
1012         struct fscrypt_symlink_data *sd;
1013         loff_t size = min_t(loff_t, i_size_read(inode), PAGE_SIZE - 1);
1014         u32 max_size = inode->i_sb->s_blocksize;
1015         int res;
1016
1017         if (!dentry)
1018                 return ERR_PTR(-ECHILD);
1019
1020         res = fscrypt_get_encryption_info(inode);
1021         if (res)
1022                 return ERR_PTR(res);
1023
1024         cpage = read_mapping_page(inode->i_mapping, 0, NULL);
1025         if (IS_ERR(cpage))
1026                 return ERR_CAST(cpage);
1027         caddr = page_address(cpage);
1028         caddr[size] = 0;
1029
1030         /* Symlink is encrypted */
1031         sd = (struct fscrypt_symlink_data *)caddr;
1032         cstr.name = sd->encrypted_path;
1033         cstr.len = le16_to_cpu(sd->len);
1034
1035         /* this is broken symlink case */
1036         if (unlikely(cstr.len == 0)) {
1037                 res = -ENOENT;
1038                 goto errout;
1039         }
1040
1041         if ((cstr.len + sizeof(struct fscrypt_symlink_data) - 1) > max_size) {
1042                 /* Symlink data on the disk is corrupted */
1043                 res = -EIO;
1044                 goto errout;
1045         }
1046         res = fscrypt_fname_alloc_buffer(inode, cstr.len, &pstr);
1047         if (res)
1048                 goto errout;
1049
1050         res = fscrypt_fname_disk_to_usr(inode, 0, 0, &cstr, &pstr);
1051         if (res < 0)
1052                 goto errout;
1053
1054         /* this is broken symlink case */
1055         if (unlikely(pstr.name[0] == 0)) {
1056                 res = -ENOENT;
1057                 goto errout;
1058         }
1059
1060         paddr = pstr.name;
1061
1062         /* Null-terminate the name */
1063         paddr[res] = '\0';
1064
1065         put_page(cpage);
1066         set_delayed_call(done, kfree_link, paddr);
1067         return paddr;
1068 errout:
1069         fscrypt_fname_free_buffer(&pstr);
1070         put_page(cpage);
1071         return ERR_PTR(res);
1072 }
1073
1074 const struct inode_operations f2fs_encrypted_symlink_inode_operations = {
1075         .readlink       = generic_readlink,
1076         .get_link       = f2fs_encrypted_get_link,
1077         .getattr        = f2fs_getattr,
1078         .setattr        = f2fs_setattr,
1079 #ifdef CONFIG_F2FS_FS_XATTR
1080         .setxattr       = generic_setxattr,
1081         .getxattr       = generic_getxattr,
1082         .listxattr      = f2fs_listxattr,
1083         .removexattr    = generic_removexattr,
1084 #endif
1085 };
1086
1087 const struct inode_operations f2fs_dir_inode_operations = {
1088         .create         = f2fs_create,
1089         .lookup         = f2fs_lookup,
1090         .link           = f2fs_link,
1091         .unlink         = f2fs_unlink,
1092         .symlink        = f2fs_symlink,
1093         .mkdir          = f2fs_mkdir,
1094         .rmdir          = f2fs_rmdir,
1095         .mknod          = f2fs_mknod,
1096         .rename2        = f2fs_rename2,
1097         .tmpfile        = f2fs_tmpfile,
1098         .getattr        = f2fs_getattr,
1099         .setattr        = f2fs_setattr,
1100         .get_acl        = f2fs_get_acl,
1101         .set_acl        = f2fs_set_acl,
1102 #ifdef CONFIG_F2FS_FS_XATTR
1103         .setxattr       = generic_setxattr,
1104         .getxattr       = generic_getxattr,
1105         .listxattr      = f2fs_listxattr,
1106         .removexattr    = generic_removexattr,
1107 #endif
1108 };
1109
1110 const struct inode_operations f2fs_symlink_inode_operations = {
1111         .readlink       = generic_readlink,
1112         .get_link       = f2fs_get_link,
1113         .getattr        = f2fs_getattr,
1114         .setattr        = f2fs_setattr,
1115 #ifdef CONFIG_F2FS_FS_XATTR
1116         .setxattr       = generic_setxattr,
1117         .getxattr       = generic_getxattr,
1118         .listxattr      = f2fs_listxattr,
1119         .removexattr    = generic_removexattr,
1120 #endif
1121 };
1122
1123 const struct inode_operations f2fs_special_inode_operations = {
1124         .getattr        = f2fs_getattr,
1125         .setattr        = f2fs_setattr,
1126         .get_acl        = f2fs_get_acl,
1127         .set_acl        = f2fs_set_acl,
1128 #ifdef CONFIG_F2FS_FS_XATTR
1129         .setxattr       = generic_setxattr,
1130         .getxattr       = generic_getxattr,
1131         .listxattr      = f2fs_listxattr,
1132         .removexattr    = generic_removexattr,
1133 #endif
1134 };