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 (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 f2fs_balance_fs(sbi); 132 133 inode = f2fs_new_inode(dir, mode); 134 if (IS_ERR(inode)) 135 return PTR_ERR(inode); 136 137 if (!test_opt(sbi, DISABLE_EXT_IDENTIFY)) 138 set_cold_files(sbi, inode, dentry->d_name.name); 139 140 inode->i_op = &f2fs_file_inode_operations; 141 inode->i_fop = &f2fs_file_operations; 142 inode->i_mapping->a_ops = &f2fs_dblock_aops; 143 ino = inode->i_ino; 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 !f2fs_is_child_context_consistent_with_parent(dir, inode)) 173 return -EPERM; 174 175 f2fs_balance_fs(sbi); 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(d_inode(child)->i_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 f2fs_lock_op(sbi); 218 219 de = f2fs_find_entry(dir, &dot, &page); 220 if (de) { 221 f2fs_dentry_kunmap(dir, page); 222 f2fs_put_page(page, 0); 223 } else { 224 err = __f2fs_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR); 225 if (err) 226 goto out; 227 } 228 229 de = f2fs_find_entry(dir, &dotdot, &page); 230 if (de) { 231 f2fs_dentry_kunmap(dir, page); 232 f2fs_put_page(page, 0); 233 } else { 234 err = __f2fs_add_link(dir, &dotdot, NULL, pino, S_IFDIR); 235 } 236 out: 237 if (!err) { 238 clear_inode_flag(F2FS_I(dir), FI_INLINE_DOTS); 239 mark_inode_dirty(dir); 240 } 241 242 f2fs_unlock_op(sbi); 243 return err; 244 } 245 246 static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry, 247 unsigned int flags) 248 { 249 struct inode *inode = NULL; 250 struct f2fs_dir_entry *de; 251 struct page *page; 252 nid_t ino; 253 int err = 0; 254 255 if (dentry->d_name.len > F2FS_NAME_LEN) 256 return ERR_PTR(-ENAMETOOLONG); 257 258 de = f2fs_find_entry(dir, &dentry->d_name, &page); 259 if (!de) 260 return d_splice_alias(inode, dentry); 261 262 ino = le32_to_cpu(de->ino); 263 f2fs_dentry_kunmap(dir, page); 264 f2fs_put_page(page, 0); 265 266 inode = f2fs_iget(dir->i_sb, ino); 267 if (IS_ERR(inode)) 268 return ERR_CAST(inode); 269 270 if (f2fs_has_inline_dots(inode)) { 271 err = __recover_dot_dentries(inode, dir->i_ino); 272 if (err) 273 goto err_out; 274 } 275 return d_splice_alias(inode, dentry); 276 277 err_out: 278 iget_failed(inode); 279 return ERR_PTR(err); 280 } 281 282 static int f2fs_unlink(struct inode *dir, struct dentry *dentry) 283 { 284 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 285 struct inode *inode = d_inode(dentry); 286 struct f2fs_dir_entry *de; 287 struct page *page; 288 int err = -ENOENT; 289 290 trace_f2fs_unlink_enter(dir, dentry); 291 f2fs_balance_fs(sbi); 292 293 de = f2fs_find_entry(dir, &dentry->d_name, &page); 294 if (!de) 295 goto fail; 296 297 f2fs_lock_op(sbi); 298 err = acquire_orphan_inode(sbi); 299 if (err) { 300 f2fs_unlock_op(sbi); 301 f2fs_dentry_kunmap(dir, page); 302 f2fs_put_page(page, 0); 303 goto fail; 304 } 305 f2fs_delete_entry(de, page, dir, inode); 306 f2fs_unlock_op(sbi); 307 308 /* In order to evict this inode, we set it dirty */ 309 mark_inode_dirty(inode); 310 311 if (IS_DIRSYNC(dir)) 312 f2fs_sync_fs(sbi->sb, 1); 313 fail: 314 trace_f2fs_unlink_exit(inode, err); 315 return err; 316 } 317 318 static const char *f2fs_follow_link(struct dentry *dentry, void **cookie) 319 { 320 const char *link = page_follow_link_light(dentry, cookie); 321 if (!IS_ERR(link) && !*link) { 322 /* this is broken symlink case */ 323 page_put_link(NULL, *cookie); 324 link = ERR_PTR(-ENOENT); 325 } 326 return link; 327 } 328 329 static int f2fs_symlink(struct inode *dir, struct dentry *dentry, 330 const char *symname) 331 { 332 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 333 struct inode *inode; 334 size_t len = strlen(symname); 335 size_t p_len; 336 char *p_str; 337 struct f2fs_str disk_link = FSTR_INIT(NULL, 0); 338 struct f2fs_encrypted_symlink_data *sd = NULL; 339 int err; 340 341 if (len > dir->i_sb->s_blocksize) 342 return -ENAMETOOLONG; 343 344 f2fs_balance_fs(sbi); 345 346 inode = f2fs_new_inode(dir, S_IFLNK | S_IRWXUGO); 347 if (IS_ERR(inode)) 348 return PTR_ERR(inode); 349 350 if (f2fs_encrypted_inode(inode)) 351 inode->i_op = &f2fs_encrypted_symlink_inode_operations; 352 else 353 inode->i_op = &f2fs_symlink_inode_operations; 354 inode->i_mapping->a_ops = &f2fs_dblock_aops; 355 356 f2fs_lock_op(sbi); 357 err = f2fs_add_link(dentry, inode); 358 if (err) 359 goto out; 360 f2fs_unlock_op(sbi); 361 alloc_nid_done(sbi, inode->i_ino); 362 363 if (f2fs_encrypted_inode(dir)) { 364 struct qstr istr = QSTR_INIT(symname, len); 365 366 err = f2fs_get_encryption_info(inode); 367 if (err) 368 goto err_out; 369 370 err = f2fs_fname_crypto_alloc_buffer(inode, len, &disk_link); 371 if (err) 372 goto err_out; 373 374 err = f2fs_fname_usr_to_disk(inode, &istr, &disk_link); 375 if (err < 0) 376 goto err_out; 377 378 p_len = encrypted_symlink_data_len(disk_link.len) + 1; 379 380 if (p_len > dir->i_sb->s_blocksize) { 381 err = -ENAMETOOLONG; 382 goto err_out; 383 } 384 385 sd = kzalloc(p_len, GFP_NOFS); 386 if (!sd) { 387 err = -ENOMEM; 388 goto err_out; 389 } 390 memcpy(sd->encrypted_path, disk_link.name, disk_link.len); 391 sd->len = cpu_to_le16(disk_link.len); 392 p_str = (char *)sd; 393 } else { 394 p_len = len + 1; 395 p_str = (char *)symname; 396 } 397 398 err = page_symlink(inode, p_str, p_len); 399 400 err_out: 401 d_instantiate(dentry, inode); 402 unlock_new_inode(inode); 403 404 /* 405 * Let's flush symlink data in order to avoid broken symlink as much as 406 * possible. Nevertheless, fsyncing is the best way, but there is no 407 * way to get a file descriptor in order to flush that. 408 * 409 * Note that, it needs to do dir->fsync to make this recoverable. 410 * If the symlink path is stored into inline_data, there is no 411 * performance regression. 412 */ 413 if (!err) { 414 filemap_write_and_wait_range(inode->i_mapping, 0, p_len - 1); 415 416 if (IS_DIRSYNC(dir)) 417 f2fs_sync_fs(sbi->sb, 1); 418 } else { 419 f2fs_unlink(dir, dentry); 420 } 421 422 kfree(sd); 423 f2fs_fname_crypto_free_buffer(&disk_link); 424 return err; 425 out: 426 handle_failed_inode(inode); 427 return err; 428 } 429 430 static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 431 { 432 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 433 struct inode *inode; 434 int err; 435 436 f2fs_balance_fs(sbi); 437 438 inode = f2fs_new_inode(dir, S_IFDIR | mode); 439 if (IS_ERR(inode)) 440 return PTR_ERR(inode); 441 442 inode->i_op = &f2fs_dir_inode_operations; 443 inode->i_fop = &f2fs_dir_operations; 444 inode->i_mapping->a_ops = &f2fs_dblock_aops; 445 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_HIGH_ZERO); 446 447 set_inode_flag(F2FS_I(inode), FI_INC_LINK); 448 f2fs_lock_op(sbi); 449 err = f2fs_add_link(dentry, inode); 450 if (err) 451 goto out_fail; 452 f2fs_unlock_op(sbi); 453 454 alloc_nid_done(sbi, inode->i_ino); 455 456 d_instantiate(dentry, inode); 457 unlock_new_inode(inode); 458 459 if (IS_DIRSYNC(dir)) 460 f2fs_sync_fs(sbi->sb, 1); 461 return 0; 462 463 out_fail: 464 clear_inode_flag(F2FS_I(inode), FI_INC_LINK); 465 handle_failed_inode(inode); 466 return err; 467 } 468 469 static int f2fs_rmdir(struct inode *dir, struct dentry *dentry) 470 { 471 struct inode *inode = d_inode(dentry); 472 if (f2fs_empty_dir(inode)) 473 return f2fs_unlink(dir, dentry); 474 return -ENOTEMPTY; 475 } 476 477 static int f2fs_mknod(struct inode *dir, struct dentry *dentry, 478 umode_t mode, dev_t rdev) 479 { 480 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 481 struct inode *inode; 482 int err = 0; 483 484 f2fs_balance_fs(sbi); 485 486 inode = f2fs_new_inode(dir, mode); 487 if (IS_ERR(inode)) 488 return PTR_ERR(inode); 489 490 init_special_inode(inode, inode->i_mode, rdev); 491 inode->i_op = &f2fs_special_inode_operations; 492 493 f2fs_lock_op(sbi); 494 err = f2fs_add_link(dentry, inode); 495 if (err) 496 goto out; 497 f2fs_unlock_op(sbi); 498 499 alloc_nid_done(sbi, inode->i_ino); 500 501 d_instantiate(dentry, inode); 502 unlock_new_inode(inode); 503 504 if (IS_DIRSYNC(dir)) 505 f2fs_sync_fs(sbi->sb, 1); 506 return 0; 507 out: 508 handle_failed_inode(inode); 509 return err; 510 } 511 512 static int __f2fs_tmpfile(struct inode *dir, struct dentry *dentry, 513 umode_t mode, struct inode **whiteout) 514 { 515 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 516 struct inode *inode; 517 int err; 518 519 if (!whiteout) 520 f2fs_balance_fs(sbi); 521 522 inode = f2fs_new_inode(dir, mode); 523 if (IS_ERR(inode)) 524 return PTR_ERR(inode); 525 526 if (whiteout) { 527 init_special_inode(inode, inode->i_mode, WHITEOUT_DEV); 528 inode->i_op = &f2fs_special_inode_operations; 529 } else { 530 inode->i_op = &f2fs_file_inode_operations; 531 inode->i_fop = &f2fs_file_operations; 532 inode->i_mapping->a_ops = &f2fs_dblock_aops; 533 } 534 535 f2fs_lock_op(sbi); 536 err = acquire_orphan_inode(sbi); 537 if (err) 538 goto out; 539 540 err = f2fs_do_tmpfile(inode, dir); 541 if (err) 542 goto release_out; 543 544 /* 545 * add this non-linked tmpfile to orphan list, in this way we could 546 * remove all unused data of tmpfile after abnormal power-off. 547 */ 548 add_orphan_inode(sbi, inode->i_ino); 549 f2fs_unlock_op(sbi); 550 551 alloc_nid_done(sbi, inode->i_ino); 552 553 if (whiteout) { 554 inode_dec_link_count(inode); 555 *whiteout = inode; 556 } else { 557 d_tmpfile(dentry, inode); 558 } 559 unlock_new_inode(inode); 560 return 0; 561 562 release_out: 563 release_orphan_inode(sbi); 564 out: 565 handle_failed_inode(inode); 566 return err; 567 } 568 569 static int f2fs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode) 570 { 571 if (f2fs_encrypted_inode(dir)) { 572 int err = f2fs_get_encryption_info(dir); 573 if (err) 574 return err; 575 } 576 577 return __f2fs_tmpfile(dir, dentry, mode, NULL); 578 } 579 580 static int f2fs_create_whiteout(struct inode *dir, struct inode **whiteout) 581 { 582 return __f2fs_tmpfile(dir, NULL, S_IFCHR | WHITEOUT_MODE, whiteout); 583 } 584 585 static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry, 586 struct inode *new_dir, struct dentry *new_dentry, 587 unsigned int flags) 588 { 589 struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir); 590 struct inode *old_inode = d_inode(old_dentry); 591 struct inode *new_inode = d_inode(new_dentry); 592 struct inode *whiteout = NULL; 593 struct page *old_dir_page; 594 struct page *old_page, *new_page = NULL; 595 struct f2fs_dir_entry *old_dir_entry = NULL; 596 struct f2fs_dir_entry *old_entry; 597 struct f2fs_dir_entry *new_entry; 598 int err = -ENOENT; 599 600 if ((old_dir != new_dir) && f2fs_encrypted_inode(new_dir) && 601 !f2fs_is_child_context_consistent_with_parent(new_dir, 602 old_inode)) { 603 err = -EPERM; 604 goto out; 605 } 606 607 f2fs_balance_fs(sbi); 608 609 old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page); 610 if (!old_entry) 611 goto out; 612 613 if (S_ISDIR(old_inode->i_mode)) { 614 err = -EIO; 615 old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page); 616 if (!old_dir_entry) 617 goto out_old; 618 } 619 620 if (flags & RENAME_WHITEOUT) { 621 err = f2fs_create_whiteout(old_dir, &whiteout); 622 if (err) 623 goto out_dir; 624 } 625 626 if (new_inode) { 627 628 err = -ENOTEMPTY; 629 if (old_dir_entry && !f2fs_empty_dir(new_inode)) 630 goto out_whiteout; 631 632 err = -ENOENT; 633 new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, 634 &new_page); 635 if (!new_entry) 636 goto out_whiteout; 637 638 f2fs_lock_op(sbi); 639 640 err = acquire_orphan_inode(sbi); 641 if (err) 642 goto put_out_dir; 643 644 if (update_dent_inode(old_inode, new_inode, 645 &new_dentry->d_name)) { 646 release_orphan_inode(sbi); 647 goto put_out_dir; 648 } 649 650 f2fs_set_link(new_dir, new_entry, new_page, old_inode); 651 652 new_inode->i_ctime = CURRENT_TIME; 653 down_write(&F2FS_I(new_inode)->i_sem); 654 if (old_dir_entry) 655 drop_nlink(new_inode); 656 drop_nlink(new_inode); 657 up_write(&F2FS_I(new_inode)->i_sem); 658 659 mark_inode_dirty(new_inode); 660 661 if (!new_inode->i_nlink) 662 add_orphan_inode(sbi, new_inode->i_ino); 663 else 664 release_orphan_inode(sbi); 665 666 update_inode_page(old_inode); 667 update_inode_page(new_inode); 668 } else { 669 f2fs_lock_op(sbi); 670 671 err = f2fs_add_link(new_dentry, old_inode); 672 if (err) { 673 f2fs_unlock_op(sbi); 674 goto out_whiteout; 675 } 676 677 if (old_dir_entry) { 678 inc_nlink(new_dir); 679 update_inode_page(new_dir); 680 } 681 } 682 683 down_write(&F2FS_I(old_inode)->i_sem); 684 file_lost_pino(old_inode); 685 if (new_inode && file_enc_name(new_inode)) 686 file_set_enc_name(old_inode); 687 up_write(&F2FS_I(old_inode)->i_sem); 688 689 old_inode->i_ctime = CURRENT_TIME; 690 mark_inode_dirty(old_inode); 691 692 f2fs_delete_entry(old_entry, old_page, old_dir, NULL); 693 694 if (whiteout) { 695 whiteout->i_state |= I_LINKABLE; 696 set_inode_flag(F2FS_I(whiteout), FI_INC_LINK); 697 err = f2fs_add_link(old_dentry, whiteout); 698 if (err) 699 goto put_out_dir; 700 whiteout->i_state &= ~I_LINKABLE; 701 iput(whiteout); 702 } 703 704 if (old_dir_entry) { 705 if (old_dir != new_dir && !whiteout) { 706 f2fs_set_link(old_inode, old_dir_entry, 707 old_dir_page, new_dir); 708 update_inode_page(old_inode); 709 } else { 710 f2fs_dentry_kunmap(old_inode, old_dir_page); 711 f2fs_put_page(old_dir_page, 0); 712 } 713 drop_nlink(old_dir); 714 mark_inode_dirty(old_dir); 715 update_inode_page(old_dir); 716 } 717 718 f2fs_unlock_op(sbi); 719 720 if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir)) 721 f2fs_sync_fs(sbi->sb, 1); 722 return 0; 723 724 put_out_dir: 725 f2fs_unlock_op(sbi); 726 if (new_page) { 727 f2fs_dentry_kunmap(new_dir, new_page); 728 f2fs_put_page(new_page, 0); 729 } 730 out_whiteout: 731 if (whiteout) 732 iput(whiteout); 733 out_dir: 734 if (old_dir_entry) { 735 f2fs_dentry_kunmap(old_inode, old_dir_page); 736 f2fs_put_page(old_dir_page, 0); 737 } 738 out_old: 739 f2fs_dentry_kunmap(old_dir, old_page); 740 f2fs_put_page(old_page, 0); 741 out: 742 return err; 743 } 744 745 static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry, 746 struct inode *new_dir, struct dentry *new_dentry) 747 { 748 struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir); 749 struct inode *old_inode = d_inode(old_dentry); 750 struct inode *new_inode = d_inode(new_dentry); 751 struct page *old_dir_page, *new_dir_page; 752 struct page *old_page, *new_page; 753 struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL; 754 struct f2fs_dir_entry *old_entry, *new_entry; 755 int old_nlink = 0, new_nlink = 0; 756 int err = -ENOENT; 757 758 if ((f2fs_encrypted_inode(old_dir) || f2fs_encrypted_inode(new_dir)) && 759 (old_dir != new_dir) && 760 (!f2fs_is_child_context_consistent_with_parent(new_dir, 761 old_inode) || 762 !f2fs_is_child_context_consistent_with_parent(old_dir, 763 new_inode))) 764 return -EPERM; 765 766 f2fs_balance_fs(sbi); 767 768 old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page); 769 if (!old_entry) 770 goto out; 771 772 new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, &new_page); 773 if (!new_entry) 774 goto out_old; 775 776 /* prepare for updating ".." directory entry info later */ 777 if (old_dir != new_dir) { 778 if (S_ISDIR(old_inode->i_mode)) { 779 err = -EIO; 780 old_dir_entry = f2fs_parent_dir(old_inode, 781 &old_dir_page); 782 if (!old_dir_entry) 783 goto out_new; 784 } 785 786 if (S_ISDIR(new_inode->i_mode)) { 787 err = -EIO; 788 new_dir_entry = f2fs_parent_dir(new_inode, 789 &new_dir_page); 790 if (!new_dir_entry) 791 goto out_old_dir; 792 } 793 } 794 795 /* 796 * If cross rename between file and directory those are not 797 * in the same directory, we will inc nlink of file's parent 798 * later, so we should check upper boundary of its nlink. 799 */ 800 if ((!old_dir_entry || !new_dir_entry) && 801 old_dir_entry != new_dir_entry) { 802 old_nlink = old_dir_entry ? -1 : 1; 803 new_nlink = -old_nlink; 804 err = -EMLINK; 805 if ((old_nlink > 0 && old_inode->i_nlink >= F2FS_LINK_MAX) || 806 (new_nlink > 0 && new_inode->i_nlink >= F2FS_LINK_MAX)) 807 goto out_new_dir; 808 } 809 810 f2fs_lock_op(sbi); 811 812 err = update_dent_inode(old_inode, new_inode, &new_dentry->d_name); 813 if (err) 814 goto out_unlock; 815 if (file_enc_name(new_inode)) 816 file_set_enc_name(old_inode); 817 818 err = update_dent_inode(new_inode, old_inode, &old_dentry->d_name); 819 if (err) 820 goto out_undo; 821 if (file_enc_name(old_inode)) 822 file_set_enc_name(new_inode); 823 824 /* update ".." directory entry info of old dentry */ 825 if (old_dir_entry) 826 f2fs_set_link(old_inode, old_dir_entry, old_dir_page, new_dir); 827 828 /* update ".." directory entry info of new dentry */ 829 if (new_dir_entry) 830 f2fs_set_link(new_inode, new_dir_entry, new_dir_page, old_dir); 831 832 /* update directory entry info of old dir inode */ 833 f2fs_set_link(old_dir, old_entry, old_page, new_inode); 834 835 down_write(&F2FS_I(old_inode)->i_sem); 836 file_lost_pino(old_inode); 837 up_write(&F2FS_I(old_inode)->i_sem); 838 839 update_inode_page(old_inode); 840 841 old_dir->i_ctime = CURRENT_TIME; 842 if (old_nlink) { 843 down_write(&F2FS_I(old_dir)->i_sem); 844 if (old_nlink < 0) 845 drop_nlink(old_dir); 846 else 847 inc_nlink(old_dir); 848 up_write(&F2FS_I(old_dir)->i_sem); 849 } 850 mark_inode_dirty(old_dir); 851 update_inode_page(old_dir); 852 853 /* update directory entry info of new dir inode */ 854 f2fs_set_link(new_dir, new_entry, new_page, old_inode); 855 856 down_write(&F2FS_I(new_inode)->i_sem); 857 file_lost_pino(new_inode); 858 up_write(&F2FS_I(new_inode)->i_sem); 859 860 update_inode_page(new_inode); 861 862 new_dir->i_ctime = CURRENT_TIME; 863 if (new_nlink) { 864 down_write(&F2FS_I(new_dir)->i_sem); 865 if (new_nlink < 0) 866 drop_nlink(new_dir); 867 else 868 inc_nlink(new_dir); 869 up_write(&F2FS_I(new_dir)->i_sem); 870 } 871 mark_inode_dirty(new_dir); 872 update_inode_page(new_dir); 873 874 f2fs_unlock_op(sbi); 875 876 if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir)) 877 f2fs_sync_fs(sbi->sb, 1); 878 return 0; 879 out_undo: 880 /* 881 * Still we may fail to recover name info of f2fs_inode here 882 * Drop it, once its name is set as encrypted 883 */ 884 update_dent_inode(old_inode, old_inode, &old_dentry->d_name); 885 out_unlock: 886 f2fs_unlock_op(sbi); 887 out_new_dir: 888 if (new_dir_entry) { 889 f2fs_dentry_kunmap(new_inode, new_dir_page); 890 f2fs_put_page(new_dir_page, 0); 891 } 892 out_old_dir: 893 if (old_dir_entry) { 894 f2fs_dentry_kunmap(old_inode, old_dir_page); 895 f2fs_put_page(old_dir_page, 0); 896 } 897 out_new: 898 f2fs_dentry_kunmap(new_dir, new_page); 899 f2fs_put_page(new_page, 0); 900 out_old: 901 f2fs_dentry_kunmap(old_dir, old_page); 902 f2fs_put_page(old_page, 0); 903 out: 904 return err; 905 } 906 907 static int f2fs_rename2(struct inode *old_dir, struct dentry *old_dentry, 908 struct inode *new_dir, struct dentry *new_dentry, 909 unsigned int flags) 910 { 911 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT)) 912 return -EINVAL; 913 914 if (flags & RENAME_EXCHANGE) { 915 return f2fs_cross_rename(old_dir, old_dentry, 916 new_dir, new_dentry); 917 } 918 /* 919 * VFS has already handled the new dentry existence case, 920 * here, we just deal with "RENAME_NOREPLACE" as regular rename. 921 */ 922 return f2fs_rename(old_dir, old_dentry, new_dir, new_dentry, flags); 923 } 924 925 #ifdef CONFIG_F2FS_FS_ENCRYPTION 926 static const char *f2fs_encrypted_follow_link(struct dentry *dentry, void **cookie) 927 { 928 struct page *cpage = NULL; 929 char *caddr, *paddr = NULL; 930 struct f2fs_str cstr; 931 struct f2fs_str pstr = FSTR_INIT(NULL, 0); 932 struct inode *inode = d_inode(dentry); 933 struct f2fs_encrypted_symlink_data *sd; 934 loff_t size = min_t(loff_t, i_size_read(inode), PAGE_SIZE - 1); 935 u32 max_size = inode->i_sb->s_blocksize; 936 int res; 937 938 res = f2fs_get_encryption_info(inode); 939 if (res) 940 return ERR_PTR(res); 941 942 cpage = read_mapping_page(inode->i_mapping, 0, NULL); 943 if (IS_ERR(cpage)) 944 return ERR_CAST(cpage); 945 caddr = kmap(cpage); 946 caddr[size] = 0; 947 948 /* Symlink is encrypted */ 949 sd = (struct f2fs_encrypted_symlink_data *)caddr; 950 cstr.len = le16_to_cpu(sd->len); 951 cstr.name = kmalloc(cstr.len, GFP_NOFS); 952 if (!cstr.name) { 953 res = -ENOMEM; 954 goto errout; 955 } 956 memcpy(cstr.name, sd->encrypted_path, cstr.len); 957 958 /* this is broken symlink case */ 959 if (cstr.name[0] == 0 && cstr.len == 0) { 960 res = -ENOENT; 961 goto errout; 962 } 963 964 if ((cstr.len + sizeof(struct f2fs_encrypted_symlink_data) - 1) > 965 max_size) { 966 /* Symlink data on the disk is corrupted */ 967 res = -EIO; 968 goto errout; 969 } 970 res = f2fs_fname_crypto_alloc_buffer(inode, cstr.len, &pstr); 971 if (res) 972 goto errout; 973 974 res = f2fs_fname_disk_to_usr(inode, NULL, &cstr, &pstr); 975 if (res < 0) 976 goto errout; 977 978 kfree(cstr.name); 979 980 paddr = pstr.name; 981 982 /* Null-terminate the name */ 983 paddr[res] = '\0'; 984 985 kunmap(cpage); 986 page_cache_release(cpage); 987 return *cookie = paddr; 988 errout: 989 kfree(cstr.name); 990 f2fs_fname_crypto_free_buffer(&pstr); 991 kunmap(cpage); 992 page_cache_release(cpage); 993 return ERR_PTR(res); 994 } 995 996 const struct inode_operations f2fs_encrypted_symlink_inode_operations = { 997 .readlink = generic_readlink, 998 .follow_link = f2fs_encrypted_follow_link, 999 .put_link = kfree_put_link, 1000 .getattr = f2fs_getattr, 1001 .setattr = f2fs_setattr, 1002 .setxattr = generic_setxattr, 1003 .getxattr = generic_getxattr, 1004 .listxattr = f2fs_listxattr, 1005 .removexattr = generic_removexattr, 1006 }; 1007 #endif 1008 1009 const struct inode_operations f2fs_dir_inode_operations = { 1010 .create = f2fs_create, 1011 .lookup = f2fs_lookup, 1012 .link = f2fs_link, 1013 .unlink = f2fs_unlink, 1014 .symlink = f2fs_symlink, 1015 .mkdir = f2fs_mkdir, 1016 .rmdir = f2fs_rmdir, 1017 .mknod = f2fs_mknod, 1018 .rename2 = f2fs_rename2, 1019 .tmpfile = f2fs_tmpfile, 1020 .getattr = f2fs_getattr, 1021 .setattr = f2fs_setattr, 1022 .get_acl = f2fs_get_acl, 1023 .set_acl = f2fs_set_acl, 1024 #ifdef CONFIG_F2FS_FS_XATTR 1025 .setxattr = generic_setxattr, 1026 .getxattr = generic_getxattr, 1027 .listxattr = f2fs_listxattr, 1028 .removexattr = generic_removexattr, 1029 #endif 1030 }; 1031 1032 const struct inode_operations f2fs_symlink_inode_operations = { 1033 .readlink = generic_readlink, 1034 .follow_link = f2fs_follow_link, 1035 .put_link = page_put_link, 1036 .getattr = f2fs_getattr, 1037 .setattr = f2fs_setattr, 1038 #ifdef CONFIG_F2FS_FS_XATTR 1039 .setxattr = generic_setxattr, 1040 .getxattr = generic_getxattr, 1041 .listxattr = f2fs_listxattr, 1042 .removexattr = generic_removexattr, 1043 #endif 1044 }; 1045 1046 const struct inode_operations f2fs_special_inode_operations = { 1047 .getattr = f2fs_getattr, 1048 .setattr = f2fs_setattr, 1049 .get_acl = f2fs_get_acl, 1050 .set_acl = f2fs_set_acl, 1051 #ifdef CONFIG_F2FS_FS_XATTR 1052 .setxattr = generic_setxattr, 1053 .getxattr = generic_getxattr, 1054 .listxattr = f2fs_listxattr, 1055 .removexattr = generic_removexattr, 1056 #endif 1057 }; 1058