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 }; 1285