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