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