1 /* 2 * fs/f2fs/dir.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 "f2fs.h" 14 #include "node.h" 15 #include "acl.h" 16 #include "xattr.h" 17 18 static unsigned long dir_blocks(struct inode *inode) 19 { 20 return ((unsigned long long) (i_size_read(inode) + PAGE_SIZE - 1)) 21 >> PAGE_SHIFT; 22 } 23 24 static unsigned int dir_buckets(unsigned int level, int dir_level) 25 { 26 if (level + dir_level < MAX_DIR_HASH_DEPTH / 2) 27 return 1 << (level + dir_level); 28 else 29 return MAX_DIR_BUCKETS; 30 } 31 32 static unsigned int bucket_blocks(unsigned int level) 33 { 34 if (level < MAX_DIR_HASH_DEPTH / 2) 35 return 2; 36 else 37 return 4; 38 } 39 40 static unsigned char f2fs_filetype_table[F2FS_FT_MAX] = { 41 [F2FS_FT_UNKNOWN] = DT_UNKNOWN, 42 [F2FS_FT_REG_FILE] = DT_REG, 43 [F2FS_FT_DIR] = DT_DIR, 44 [F2FS_FT_CHRDEV] = DT_CHR, 45 [F2FS_FT_BLKDEV] = DT_BLK, 46 [F2FS_FT_FIFO] = DT_FIFO, 47 [F2FS_FT_SOCK] = DT_SOCK, 48 [F2FS_FT_SYMLINK] = DT_LNK, 49 }; 50 51 static unsigned char f2fs_type_by_mode[S_IFMT >> S_SHIFT] = { 52 [S_IFREG >> S_SHIFT] = F2FS_FT_REG_FILE, 53 [S_IFDIR >> S_SHIFT] = F2FS_FT_DIR, 54 [S_IFCHR >> S_SHIFT] = F2FS_FT_CHRDEV, 55 [S_IFBLK >> S_SHIFT] = F2FS_FT_BLKDEV, 56 [S_IFIFO >> S_SHIFT] = F2FS_FT_FIFO, 57 [S_IFSOCK >> S_SHIFT] = F2FS_FT_SOCK, 58 [S_IFLNK >> S_SHIFT] = F2FS_FT_SYMLINK, 59 }; 60 61 void set_de_type(struct f2fs_dir_entry *de, umode_t mode) 62 { 63 de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT]; 64 } 65 66 unsigned char get_de_type(struct f2fs_dir_entry *de) 67 { 68 if (de->file_type < F2FS_FT_MAX) 69 return f2fs_filetype_table[de->file_type]; 70 return DT_UNKNOWN; 71 } 72 73 static unsigned long dir_block_index(unsigned int level, 74 int dir_level, unsigned int idx) 75 { 76 unsigned long i; 77 unsigned long bidx = 0; 78 79 for (i = 0; i < level; i++) 80 bidx += dir_buckets(i, dir_level) * bucket_blocks(i); 81 bidx += idx * bucket_blocks(level); 82 return bidx; 83 } 84 85 static struct f2fs_dir_entry *find_in_block(struct page *dentry_page, 86 struct fscrypt_name *fname, 87 f2fs_hash_t namehash, 88 int *max_slots, 89 struct page **res_page) 90 { 91 struct f2fs_dentry_block *dentry_blk; 92 struct f2fs_dir_entry *de; 93 struct f2fs_dentry_ptr d; 94 95 dentry_blk = (struct f2fs_dentry_block *)kmap(dentry_page); 96 97 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1); 98 de = find_target_dentry(fname, namehash, max_slots, &d); 99 if (de) 100 *res_page = dentry_page; 101 else 102 kunmap(dentry_page); 103 104 return de; 105 } 106 107 struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *fname, 108 f2fs_hash_t namehash, int *max_slots, 109 struct f2fs_dentry_ptr *d) 110 { 111 struct f2fs_dir_entry *de; 112 unsigned long bit_pos = 0; 113 int max_len = 0; 114 struct fscrypt_str de_name = FSTR_INIT(NULL, 0); 115 struct fscrypt_str *name = &fname->disk_name; 116 117 if (max_slots) 118 *max_slots = 0; 119 while (bit_pos < d->max) { 120 if (!test_bit_le(bit_pos, d->bitmap)) { 121 bit_pos++; 122 max_len++; 123 continue; 124 } 125 126 de = &d->dentry[bit_pos]; 127 128 if (unlikely(!de->name_len)) { 129 bit_pos++; 130 continue; 131 } 132 133 /* encrypted case */ 134 de_name.name = d->filename[bit_pos]; 135 de_name.len = le16_to_cpu(de->name_len); 136 137 /* show encrypted name */ 138 if (fname->hash) { 139 if (de->hash_code == cpu_to_le32(fname->hash)) 140 goto found; 141 } else if (de_name.len == name->len && 142 de->hash_code == namehash && 143 !memcmp(de_name.name, name->name, name->len)) 144 goto found; 145 146 if (max_slots && max_len > *max_slots) 147 *max_slots = max_len; 148 max_len = 0; 149 150 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); 151 } 152 153 de = NULL; 154 found: 155 if (max_slots && max_len > *max_slots) 156 *max_slots = max_len; 157 return de; 158 } 159 160 static struct f2fs_dir_entry *find_in_level(struct inode *dir, 161 unsigned int level, 162 struct fscrypt_name *fname, 163 struct page **res_page) 164 { 165 struct qstr name = FSTR_TO_QSTR(&fname->disk_name); 166 int s = GET_DENTRY_SLOTS(name.len); 167 unsigned int nbucket, nblock; 168 unsigned int bidx, end_block; 169 struct page *dentry_page; 170 struct f2fs_dir_entry *de = NULL; 171 bool room = false; 172 int max_slots; 173 f2fs_hash_t namehash; 174 175 if(fname->hash) 176 namehash = cpu_to_le32(fname->hash); 177 else 178 namehash = f2fs_dentry_hash(&name); 179 180 nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level); 181 nblock = bucket_blocks(level); 182 183 bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level, 184 le32_to_cpu(namehash) % nbucket); 185 end_block = bidx + nblock; 186 187 for (; bidx < end_block; bidx++) { 188 /* no need to allocate new dentry pages to all the indices */ 189 dentry_page = find_data_page(dir, bidx); 190 if (IS_ERR(dentry_page)) { 191 if (PTR_ERR(dentry_page) == -ENOENT) { 192 room = true; 193 continue; 194 } else { 195 *res_page = dentry_page; 196 break; 197 } 198 } 199 200 de = find_in_block(dentry_page, fname, namehash, &max_slots, 201 res_page); 202 if (de) 203 break; 204 205 if (max_slots >= s) 206 room = true; 207 f2fs_put_page(dentry_page, 0); 208 } 209 210 /* This is to increase the speed of f2fs_create */ 211 if (!de && room) { 212 F2FS_I(dir)->task = current; 213 if (F2FS_I(dir)->chash != namehash) { 214 F2FS_I(dir)->chash = namehash; 215 F2FS_I(dir)->clevel = level; 216 } 217 } 218 219 return de; 220 } 221 222 struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir, 223 struct fscrypt_name *fname, struct page **res_page) 224 { 225 unsigned long npages = dir_blocks(dir); 226 struct f2fs_dir_entry *de = NULL; 227 unsigned int max_depth; 228 unsigned int level; 229 230 if (f2fs_has_inline_dentry(dir)) { 231 *res_page = NULL; 232 de = find_in_inline_dir(dir, fname, res_page); 233 goto out; 234 } 235 236 if (npages == 0) { 237 *res_page = NULL; 238 goto out; 239 } 240 241 max_depth = F2FS_I(dir)->i_current_depth; 242 if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) { 243 f2fs_msg(F2FS_I_SB(dir)->sb, KERN_WARNING, 244 "Corrupted max_depth of %lu: %u", 245 dir->i_ino, max_depth); 246 max_depth = MAX_DIR_HASH_DEPTH; 247 f2fs_i_depth_write(dir, max_depth); 248 } 249 250 for (level = 0; level < max_depth; level++) { 251 *res_page = NULL; 252 de = find_in_level(dir, level, fname, res_page); 253 if (de || IS_ERR(*res_page)) 254 break; 255 } 256 out: 257 return de; 258 } 259 260 /* 261 * Find an entry in the specified directory with the wanted name. 262 * It returns the page where the entry was found (as a parameter - res_page), 263 * and the entry itself. Page is returned mapped and unlocked. 264 * Entry is guaranteed to be valid. 265 */ 266 struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir, 267 const struct qstr *child, struct page **res_page) 268 { 269 struct f2fs_dir_entry *de = NULL; 270 struct fscrypt_name fname; 271 int err; 272 273 err = fscrypt_setup_filename(dir, child, 1, &fname); 274 if (err) { 275 if (err == -ENOENT) 276 *res_page = NULL; 277 else 278 *res_page = ERR_PTR(err); 279 return NULL; 280 } 281 282 de = __f2fs_find_entry(dir, &fname, res_page); 283 284 fscrypt_free_filename(&fname); 285 return de; 286 } 287 288 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p) 289 { 290 struct qstr dotdot = QSTR_INIT("..", 2); 291 292 return f2fs_find_entry(dir, &dotdot, p); 293 } 294 295 ino_t f2fs_inode_by_name(struct inode *dir, const struct qstr *qstr, 296 struct page **page) 297 { 298 ino_t res = 0; 299 struct f2fs_dir_entry *de; 300 301 de = f2fs_find_entry(dir, qstr, page); 302 if (de) { 303 res = le32_to_cpu(de->ino); 304 f2fs_dentry_kunmap(dir, *page); 305 f2fs_put_page(*page, 0); 306 } 307 308 return res; 309 } 310 311 void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de, 312 struct page *page, struct inode *inode) 313 { 314 enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA; 315 lock_page(page); 316 f2fs_wait_on_page_writeback(page, type, true); 317 de->ino = cpu_to_le32(inode->i_ino); 318 set_de_type(de, inode->i_mode); 319 f2fs_dentry_kunmap(dir, page); 320 set_page_dirty(page); 321 322 dir->i_mtime = dir->i_ctime = current_time(dir); 323 f2fs_mark_inode_dirty_sync(dir, false); 324 f2fs_put_page(page, 1); 325 } 326 327 static void init_dent_inode(const struct qstr *name, struct page *ipage) 328 { 329 struct f2fs_inode *ri; 330 331 f2fs_wait_on_page_writeback(ipage, NODE, true); 332 333 /* copy name info. to this inode page */ 334 ri = F2FS_INODE(ipage); 335 ri->i_namelen = cpu_to_le32(name->len); 336 memcpy(ri->i_name, name->name, name->len); 337 set_page_dirty(ipage); 338 } 339 340 int update_dent_inode(struct inode *inode, struct inode *to, 341 const struct qstr *name) 342 { 343 struct page *page; 344 345 if (file_enc_name(to)) 346 return 0; 347 348 page = get_node_page(F2FS_I_SB(inode), inode->i_ino); 349 if (IS_ERR(page)) 350 return PTR_ERR(page); 351 352 init_dent_inode(name, page); 353 f2fs_put_page(page, 1); 354 355 return 0; 356 } 357 358 void do_make_empty_dir(struct inode *inode, struct inode *parent, 359 struct f2fs_dentry_ptr *d) 360 { 361 struct qstr dot = QSTR_INIT(".", 1); 362 struct qstr dotdot = QSTR_INIT("..", 2); 363 364 /* update dirent of "." */ 365 f2fs_update_dentry(inode->i_ino, inode->i_mode, d, &dot, 0, 0); 366 367 /* update dirent of ".." */ 368 f2fs_update_dentry(parent->i_ino, parent->i_mode, d, &dotdot, 0, 1); 369 } 370 371 static int make_empty_dir(struct inode *inode, 372 struct inode *parent, struct page *page) 373 { 374 struct page *dentry_page; 375 struct f2fs_dentry_block *dentry_blk; 376 struct f2fs_dentry_ptr d; 377 378 if (f2fs_has_inline_dentry(inode)) 379 return make_empty_inline_dir(inode, parent, page); 380 381 dentry_page = get_new_data_page(inode, page, 0, true); 382 if (IS_ERR(dentry_page)) 383 return PTR_ERR(dentry_page); 384 385 dentry_blk = kmap_atomic(dentry_page); 386 387 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1); 388 do_make_empty_dir(inode, parent, &d); 389 390 kunmap_atomic(dentry_blk); 391 392 set_page_dirty(dentry_page); 393 f2fs_put_page(dentry_page, 1); 394 return 0; 395 } 396 397 struct page *init_inode_metadata(struct inode *inode, struct inode *dir, 398 const struct qstr *new_name, const struct qstr *orig_name, 399 struct page *dpage) 400 { 401 struct page *page; 402 int err; 403 404 if (is_inode_flag_set(inode, FI_NEW_INODE)) { 405 page = new_inode_page(inode); 406 if (IS_ERR(page)) 407 return page; 408 409 if (S_ISDIR(inode->i_mode)) { 410 /* in order to handle error case */ 411 get_page(page); 412 err = make_empty_dir(inode, dir, page); 413 if (err) { 414 lock_page(page); 415 goto put_error; 416 } 417 put_page(page); 418 } 419 420 err = f2fs_init_acl(inode, dir, page, dpage); 421 if (err) 422 goto put_error; 423 424 err = f2fs_init_security(inode, dir, orig_name, page); 425 if (err) 426 goto put_error; 427 428 if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode)) { 429 err = fscrypt_inherit_context(dir, inode, page, false); 430 if (err) 431 goto put_error; 432 } 433 } else { 434 page = get_node_page(F2FS_I_SB(dir), inode->i_ino); 435 if (IS_ERR(page)) 436 return page; 437 438 set_cold_node(inode, page); 439 } 440 441 if (new_name) 442 init_dent_inode(new_name, page); 443 444 /* 445 * This file should be checkpointed during fsync. 446 * We lost i_pino from now on. 447 */ 448 if (is_inode_flag_set(inode, FI_INC_LINK)) { 449 file_lost_pino(inode); 450 /* 451 * If link the tmpfile to alias through linkat path, 452 * we should remove this inode from orphan list. 453 */ 454 if (inode->i_nlink == 0) 455 remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino); 456 f2fs_i_links_write(inode, true); 457 } 458 return page; 459 460 put_error: 461 clear_nlink(inode); 462 update_inode(inode, page); 463 f2fs_put_page(page, 1); 464 return ERR_PTR(err); 465 } 466 467 void update_parent_metadata(struct inode *dir, struct inode *inode, 468 unsigned int current_depth) 469 { 470 if (inode && is_inode_flag_set(inode, FI_NEW_INODE)) { 471 if (S_ISDIR(inode->i_mode)) 472 f2fs_i_links_write(dir, true); 473 clear_inode_flag(inode, FI_NEW_INODE); 474 } 475 dir->i_mtime = dir->i_ctime = current_time(dir); 476 f2fs_mark_inode_dirty_sync(dir, false); 477 478 if (F2FS_I(dir)->i_current_depth != current_depth) 479 f2fs_i_depth_write(dir, current_depth); 480 481 if (inode && is_inode_flag_set(inode, FI_INC_LINK)) 482 clear_inode_flag(inode, FI_INC_LINK); 483 } 484 485 int room_for_filename(const void *bitmap, int slots, int max_slots) 486 { 487 int bit_start = 0; 488 int zero_start, zero_end; 489 next: 490 zero_start = find_next_zero_bit_le(bitmap, max_slots, bit_start); 491 if (zero_start >= max_slots) 492 return max_slots; 493 494 zero_end = find_next_bit_le(bitmap, max_slots, zero_start); 495 if (zero_end - zero_start >= slots) 496 return zero_start; 497 498 bit_start = zero_end + 1; 499 500 if (zero_end + 1 >= max_slots) 501 return max_slots; 502 goto next; 503 } 504 505 void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d, 506 const struct qstr *name, f2fs_hash_t name_hash, 507 unsigned int bit_pos) 508 { 509 struct f2fs_dir_entry *de; 510 int slots = GET_DENTRY_SLOTS(name->len); 511 int i; 512 513 de = &d->dentry[bit_pos]; 514 de->hash_code = name_hash; 515 de->name_len = cpu_to_le16(name->len); 516 memcpy(d->filename[bit_pos], name->name, name->len); 517 de->ino = cpu_to_le32(ino); 518 set_de_type(de, mode); 519 for (i = 0; i < slots; i++) { 520 __set_bit_le(bit_pos + i, (void *)d->bitmap); 521 /* avoid wrong garbage data for readdir */ 522 if (i) 523 (de + i)->name_len = 0; 524 } 525 } 526 527 int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name, 528 const struct qstr *orig_name, 529 struct inode *inode, nid_t ino, umode_t mode) 530 { 531 unsigned int bit_pos; 532 unsigned int level; 533 unsigned int current_depth; 534 unsigned long bidx, block; 535 f2fs_hash_t dentry_hash; 536 unsigned int nbucket, nblock; 537 struct page *dentry_page = NULL; 538 struct f2fs_dentry_block *dentry_blk = NULL; 539 struct f2fs_dentry_ptr d; 540 struct page *page = NULL; 541 int slots, err = 0; 542 543 level = 0; 544 slots = GET_DENTRY_SLOTS(new_name->len); 545 dentry_hash = f2fs_dentry_hash(new_name); 546 547 current_depth = F2FS_I(dir)->i_current_depth; 548 if (F2FS_I(dir)->chash == dentry_hash) { 549 level = F2FS_I(dir)->clevel; 550 F2FS_I(dir)->chash = 0; 551 } 552 553 start: 554 #ifdef CONFIG_F2FS_FAULT_INJECTION 555 if (time_to_inject(F2FS_I_SB(dir), FAULT_DIR_DEPTH)) { 556 f2fs_show_injection_info(FAULT_DIR_DEPTH); 557 return -ENOSPC; 558 } 559 #endif 560 if (unlikely(current_depth == MAX_DIR_HASH_DEPTH)) 561 return -ENOSPC; 562 563 /* Increase the depth, if required */ 564 if (level == current_depth) 565 ++current_depth; 566 567 nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level); 568 nblock = bucket_blocks(level); 569 570 bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level, 571 (le32_to_cpu(dentry_hash) % nbucket)); 572 573 for (block = bidx; block <= (bidx + nblock - 1); block++) { 574 dentry_page = get_new_data_page(dir, NULL, block, true); 575 if (IS_ERR(dentry_page)) 576 return PTR_ERR(dentry_page); 577 578 dentry_blk = kmap(dentry_page); 579 bit_pos = room_for_filename(&dentry_blk->dentry_bitmap, 580 slots, NR_DENTRY_IN_BLOCK); 581 if (bit_pos < NR_DENTRY_IN_BLOCK) 582 goto add_dentry; 583 584 kunmap(dentry_page); 585 f2fs_put_page(dentry_page, 1); 586 } 587 588 /* Move to next level to find the empty slot for new dentry */ 589 ++level; 590 goto start; 591 add_dentry: 592 f2fs_wait_on_page_writeback(dentry_page, DATA, true); 593 594 if (inode) { 595 down_write(&F2FS_I(inode)->i_sem); 596 page = init_inode_metadata(inode, dir, new_name, 597 orig_name, NULL); 598 if (IS_ERR(page)) { 599 err = PTR_ERR(page); 600 goto fail; 601 } 602 if (f2fs_encrypted_inode(dir)) 603 file_set_enc_name(inode); 604 } 605 606 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1); 607 f2fs_update_dentry(ino, mode, &d, new_name, dentry_hash, bit_pos); 608 609 set_page_dirty(dentry_page); 610 611 if (inode) { 612 f2fs_i_pino_write(inode, dir->i_ino); 613 f2fs_put_page(page, 1); 614 } 615 616 update_parent_metadata(dir, inode, current_depth); 617 fail: 618 if (inode) 619 up_write(&F2FS_I(inode)->i_sem); 620 621 kunmap(dentry_page); 622 f2fs_put_page(dentry_page, 1); 623 624 return err; 625 } 626 627 int __f2fs_do_add_link(struct inode *dir, struct fscrypt_name *fname, 628 struct inode *inode, nid_t ino, umode_t mode) 629 { 630 struct qstr new_name; 631 int err = -EAGAIN; 632 633 new_name.name = fname_name(fname); 634 new_name.len = fname_len(fname); 635 636 if (f2fs_has_inline_dentry(dir)) 637 err = f2fs_add_inline_entry(dir, &new_name, fname->usr_fname, 638 inode, ino, mode); 639 if (err == -EAGAIN) 640 err = f2fs_add_regular_entry(dir, &new_name, fname->usr_fname, 641 inode, ino, mode); 642 643 f2fs_update_time(F2FS_I_SB(dir), REQ_TIME); 644 return err; 645 } 646 647 /* 648 * Caller should grab and release a rwsem by calling f2fs_lock_op() and 649 * f2fs_unlock_op(). 650 */ 651 int __f2fs_add_link(struct inode *dir, const struct qstr *name, 652 struct inode *inode, nid_t ino, umode_t mode) 653 { 654 struct fscrypt_name fname; 655 struct page *page = NULL; 656 struct f2fs_dir_entry *de = NULL; 657 int err; 658 659 err = fscrypt_setup_filename(dir, name, 0, &fname); 660 if (err) 661 return err; 662 663 /* 664 * An immature stakable filesystem shows a race condition between lookup 665 * and create. If we have same task when doing lookup and create, it's 666 * definitely fine as expected by VFS normally. Otherwise, let's just 667 * verify on-disk dentry one more time, which guarantees filesystem 668 * consistency more. 669 */ 670 if (current != F2FS_I(dir)->task) { 671 de = __f2fs_find_entry(dir, &fname, &page); 672 F2FS_I(dir)->task = NULL; 673 } 674 if (de) { 675 f2fs_dentry_kunmap(dir, page); 676 f2fs_put_page(page, 0); 677 err = -EEXIST; 678 } else if (IS_ERR(page)) { 679 err = PTR_ERR(page); 680 } else { 681 err = __f2fs_do_add_link(dir, &fname, inode, ino, mode); 682 } 683 fscrypt_free_filename(&fname); 684 return err; 685 } 686 687 int f2fs_do_tmpfile(struct inode *inode, struct inode *dir) 688 { 689 struct page *page; 690 int err = 0; 691 692 down_write(&F2FS_I(inode)->i_sem); 693 page = init_inode_metadata(inode, dir, NULL, NULL, NULL); 694 if (IS_ERR(page)) { 695 err = PTR_ERR(page); 696 goto fail; 697 } 698 f2fs_put_page(page, 1); 699 700 clear_inode_flag(inode, FI_NEW_INODE); 701 fail: 702 up_write(&F2FS_I(inode)->i_sem); 703 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 704 return err; 705 } 706 707 void f2fs_drop_nlink(struct inode *dir, struct inode *inode) 708 { 709 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 710 711 down_write(&F2FS_I(inode)->i_sem); 712 713 if (S_ISDIR(inode->i_mode)) 714 f2fs_i_links_write(dir, false); 715 inode->i_ctime = current_time(inode); 716 717 f2fs_i_links_write(inode, false); 718 if (S_ISDIR(inode->i_mode)) { 719 f2fs_i_links_write(inode, false); 720 f2fs_i_size_write(inode, 0); 721 } 722 up_write(&F2FS_I(inode)->i_sem); 723 724 if (inode->i_nlink == 0) 725 add_orphan_inode(inode); 726 else 727 release_orphan_inode(sbi); 728 } 729 730 /* 731 * It only removes the dentry from the dentry page, corresponding name 732 * entry in name page does not need to be touched during deletion. 733 */ 734 void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, 735 struct inode *dir, struct inode *inode) 736 { 737 struct f2fs_dentry_block *dentry_blk; 738 unsigned int bit_pos; 739 int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len)); 740 int i; 741 742 f2fs_update_time(F2FS_I_SB(dir), REQ_TIME); 743 744 if (f2fs_has_inline_dentry(dir)) 745 return f2fs_delete_inline_entry(dentry, page, dir, inode); 746 747 lock_page(page); 748 f2fs_wait_on_page_writeback(page, DATA, true); 749 750 dentry_blk = page_address(page); 751 bit_pos = dentry - dentry_blk->dentry; 752 for (i = 0; i < slots; i++) 753 clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap); 754 755 /* Let's check and deallocate this dentry page */ 756 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, 757 NR_DENTRY_IN_BLOCK, 758 0); 759 kunmap(page); /* kunmap - pair of f2fs_find_entry */ 760 set_page_dirty(page); 761 762 dir->i_ctime = dir->i_mtime = current_time(dir); 763 f2fs_mark_inode_dirty_sync(dir, false); 764 765 if (inode) 766 f2fs_drop_nlink(dir, inode); 767 768 if (bit_pos == NR_DENTRY_IN_BLOCK && 769 !truncate_hole(dir, page->index, page->index + 1)) { 770 clear_page_dirty_for_io(page); 771 ClearPagePrivate(page); 772 ClearPageUptodate(page); 773 inode_dec_dirty_pages(dir); 774 remove_dirty_inode(dir); 775 } 776 f2fs_put_page(page, 1); 777 } 778 779 bool f2fs_empty_dir(struct inode *dir) 780 { 781 unsigned long bidx; 782 struct page *dentry_page; 783 unsigned int bit_pos; 784 struct f2fs_dentry_block *dentry_blk; 785 unsigned long nblock = dir_blocks(dir); 786 787 if (f2fs_has_inline_dentry(dir)) 788 return f2fs_empty_inline_dir(dir); 789 790 for (bidx = 0; bidx < nblock; bidx++) { 791 dentry_page = get_lock_data_page(dir, bidx, false); 792 if (IS_ERR(dentry_page)) { 793 if (PTR_ERR(dentry_page) == -ENOENT) 794 continue; 795 else 796 return false; 797 } 798 799 dentry_blk = kmap_atomic(dentry_page); 800 if (bidx == 0) 801 bit_pos = 2; 802 else 803 bit_pos = 0; 804 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, 805 NR_DENTRY_IN_BLOCK, 806 bit_pos); 807 kunmap_atomic(dentry_blk); 808 809 f2fs_put_page(dentry_page, 1); 810 811 if (bit_pos < NR_DENTRY_IN_BLOCK) 812 return false; 813 } 814 return true; 815 } 816 817 int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d, 818 unsigned int start_pos, struct fscrypt_str *fstr) 819 { 820 unsigned char d_type = DT_UNKNOWN; 821 unsigned int bit_pos; 822 struct f2fs_dir_entry *de = NULL; 823 struct fscrypt_str de_name = FSTR_INIT(NULL, 0); 824 825 bit_pos = ((unsigned long)ctx->pos % d->max); 826 827 while (bit_pos < d->max) { 828 bit_pos = find_next_bit_le(d->bitmap, d->max, bit_pos); 829 if (bit_pos >= d->max) 830 break; 831 832 de = &d->dentry[bit_pos]; 833 if (de->name_len == 0) { 834 bit_pos++; 835 ctx->pos = start_pos + bit_pos; 836 continue; 837 } 838 839 d_type = get_de_type(de); 840 841 de_name.name = d->filename[bit_pos]; 842 de_name.len = le16_to_cpu(de->name_len); 843 844 if (f2fs_encrypted_inode(d->inode)) { 845 int save_len = fstr->len; 846 int err; 847 848 err = fscrypt_fname_disk_to_usr(d->inode, 849 (u32)de->hash_code, 0, 850 &de_name, fstr); 851 if (err) 852 return err; 853 854 de_name = *fstr; 855 fstr->len = save_len; 856 } 857 858 if (!dir_emit(ctx, de_name.name, de_name.len, 859 le32_to_cpu(de->ino), d_type)) 860 return 1; 861 862 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); 863 ctx->pos = start_pos + bit_pos; 864 } 865 return 0; 866 } 867 868 static int f2fs_readdir(struct file *file, struct dir_context *ctx) 869 { 870 struct inode *inode = file_inode(file); 871 unsigned long npages = dir_blocks(inode); 872 struct f2fs_dentry_block *dentry_blk = NULL; 873 struct page *dentry_page = NULL; 874 struct file_ra_state *ra = &file->f_ra; 875 unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK); 876 struct f2fs_dentry_ptr d; 877 struct fscrypt_str fstr = FSTR_INIT(NULL, 0); 878 int err = 0; 879 880 if (f2fs_encrypted_inode(inode)) { 881 err = fscrypt_get_encryption_info(inode); 882 if (err && err != -ENOKEY) 883 return err; 884 885 err = fscrypt_fname_alloc_buffer(inode, F2FS_NAME_LEN, &fstr); 886 if (err < 0) 887 return err; 888 } 889 890 if (f2fs_has_inline_dentry(inode)) { 891 err = f2fs_read_inline_dir(file, ctx, &fstr); 892 goto out; 893 } 894 895 /* readahead for multi pages of dir */ 896 if (npages - n > 1 && !ra_has_index(ra, n)) 897 page_cache_sync_readahead(inode->i_mapping, ra, file, n, 898 min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES)); 899 900 for (; n < npages; n++) { 901 dentry_page = get_lock_data_page(inode, n, false); 902 if (IS_ERR(dentry_page)) { 903 err = PTR_ERR(dentry_page); 904 if (err == -ENOENT) { 905 err = 0; 906 continue; 907 } else { 908 goto out; 909 } 910 } 911 912 dentry_blk = kmap(dentry_page); 913 914 make_dentry_ptr(inode, &d, (void *)dentry_blk, 1); 915 916 err = f2fs_fill_dentries(ctx, &d, 917 n * NR_DENTRY_IN_BLOCK, &fstr); 918 if (err) { 919 kunmap(dentry_page); 920 f2fs_put_page(dentry_page, 1); 921 break; 922 } 923 924 ctx->pos = (n + 1) * NR_DENTRY_IN_BLOCK; 925 kunmap(dentry_page); 926 f2fs_put_page(dentry_page, 1); 927 } 928 out: 929 fscrypt_fname_free_buffer(&fstr); 930 return err < 0 ? err : 0; 931 } 932 933 static int f2fs_dir_open(struct inode *inode, struct file *filp) 934 { 935 if (f2fs_encrypted_inode(inode)) 936 return fscrypt_get_encryption_info(inode) ? -EACCES : 0; 937 return 0; 938 } 939 940 const struct file_operations f2fs_dir_operations = { 941 .llseek = generic_file_llseek, 942 .read = generic_read_dir, 943 .iterate_shared = f2fs_readdir, 944 .fsync = f2fs_sync_file, 945 .open = f2fs_dir_open, 946 .unlocked_ioctl = f2fs_ioctl, 947 #ifdef CONFIG_COMPAT 948 .compat_ioctl = f2fs_compat_ioctl, 949 #endif 950 }; 951