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