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 if (!de && room && F2FS_I(dir)->chash != namehash) { 211 F2FS_I(dir)->chash = namehash; 212 F2FS_I(dir)->clevel = level; 213 } 214 215 return de; 216 } 217 218 struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir, 219 struct fscrypt_name *fname, struct page **res_page) 220 { 221 unsigned long npages = dir_blocks(dir); 222 struct f2fs_dir_entry *de = NULL; 223 unsigned int max_depth; 224 unsigned int level; 225 226 if (f2fs_has_inline_dentry(dir)) { 227 *res_page = NULL; 228 de = find_in_inline_dir(dir, fname, res_page); 229 goto out; 230 } 231 232 if (npages == 0) { 233 *res_page = NULL; 234 goto out; 235 } 236 237 max_depth = F2FS_I(dir)->i_current_depth; 238 if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) { 239 f2fs_msg(F2FS_I_SB(dir)->sb, KERN_WARNING, 240 "Corrupted max_depth of %lu: %u", 241 dir->i_ino, max_depth); 242 max_depth = MAX_DIR_HASH_DEPTH; 243 f2fs_i_depth_write(dir, max_depth); 244 } 245 246 for (level = 0; level < max_depth; level++) { 247 *res_page = NULL; 248 de = find_in_level(dir, level, fname, res_page); 249 if (de || IS_ERR(*res_page)) 250 break; 251 } 252 out: 253 return de; 254 } 255 256 /* 257 * Find an entry in the specified directory with the wanted name. 258 * It returns the page where the entry was found (as a parameter - res_page), 259 * and the entry itself. Page is returned mapped and unlocked. 260 * Entry is guaranteed to be valid. 261 */ 262 struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir, 263 const struct qstr *child, struct page **res_page) 264 { 265 struct f2fs_dir_entry *de = NULL; 266 struct fscrypt_name fname; 267 int err; 268 269 err = fscrypt_setup_filename(dir, child, 1, &fname); 270 if (err) { 271 if (err == -ENOENT) 272 *res_page = NULL; 273 else 274 *res_page = ERR_PTR(err); 275 return NULL; 276 } 277 278 de = __f2fs_find_entry(dir, &fname, res_page); 279 280 fscrypt_free_filename(&fname); 281 return de; 282 } 283 284 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p) 285 { 286 struct qstr dotdot = QSTR_INIT("..", 2); 287 288 return f2fs_find_entry(dir, &dotdot, p); 289 } 290 291 ino_t f2fs_inode_by_name(struct inode *dir, const struct qstr *qstr, 292 struct page **page) 293 { 294 ino_t res = 0; 295 struct f2fs_dir_entry *de; 296 297 de = f2fs_find_entry(dir, qstr, page); 298 if (de) { 299 res = le32_to_cpu(de->ino); 300 f2fs_dentry_kunmap(dir, *page); 301 f2fs_put_page(*page, 0); 302 } 303 304 return res; 305 } 306 307 void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de, 308 struct page *page, struct inode *inode) 309 { 310 enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA; 311 lock_page(page); 312 f2fs_wait_on_page_writeback(page, type, true); 313 de->ino = cpu_to_le32(inode->i_ino); 314 set_de_type(de, inode->i_mode); 315 f2fs_dentry_kunmap(dir, page); 316 set_page_dirty(page); 317 318 dir->i_mtime = dir->i_ctime = current_time(dir); 319 f2fs_mark_inode_dirty_sync(dir, false); 320 f2fs_put_page(page, 1); 321 } 322 323 static void init_dent_inode(const struct qstr *name, struct page *ipage) 324 { 325 struct f2fs_inode *ri; 326 327 f2fs_wait_on_page_writeback(ipage, NODE, true); 328 329 /* copy name info. to this inode page */ 330 ri = F2FS_INODE(ipage); 331 ri->i_namelen = cpu_to_le32(name->len); 332 memcpy(ri->i_name, name->name, name->len); 333 set_page_dirty(ipage); 334 } 335 336 int update_dent_inode(struct inode *inode, struct inode *to, 337 const struct qstr *name) 338 { 339 struct page *page; 340 341 if (file_enc_name(to)) 342 return 0; 343 344 page = get_node_page(F2FS_I_SB(inode), inode->i_ino); 345 if (IS_ERR(page)) 346 return PTR_ERR(page); 347 348 init_dent_inode(name, page); 349 f2fs_put_page(page, 1); 350 351 return 0; 352 } 353 354 void do_make_empty_dir(struct inode *inode, struct inode *parent, 355 struct f2fs_dentry_ptr *d) 356 { 357 struct qstr dot = QSTR_INIT(".", 1); 358 struct qstr dotdot = QSTR_INIT("..", 2); 359 360 /* update dirent of "." */ 361 f2fs_update_dentry(inode->i_ino, inode->i_mode, d, &dot, 0, 0); 362 363 /* update dirent of ".." */ 364 f2fs_update_dentry(parent->i_ino, parent->i_mode, d, &dotdot, 0, 1); 365 } 366 367 static int make_empty_dir(struct inode *inode, 368 struct inode *parent, struct page *page) 369 { 370 struct page *dentry_page; 371 struct f2fs_dentry_block *dentry_blk; 372 struct f2fs_dentry_ptr d; 373 374 if (f2fs_has_inline_dentry(inode)) 375 return make_empty_inline_dir(inode, parent, page); 376 377 dentry_page = get_new_data_page(inode, page, 0, true); 378 if (IS_ERR(dentry_page)) 379 return PTR_ERR(dentry_page); 380 381 dentry_blk = kmap_atomic(dentry_page); 382 383 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1); 384 do_make_empty_dir(inode, parent, &d); 385 386 kunmap_atomic(dentry_blk); 387 388 set_page_dirty(dentry_page); 389 f2fs_put_page(dentry_page, 1); 390 return 0; 391 } 392 393 struct page *init_inode_metadata(struct inode *inode, struct inode *dir, 394 const struct qstr *new_name, const struct qstr *orig_name, 395 struct page *dpage) 396 { 397 struct page *page; 398 int err; 399 400 if (is_inode_flag_set(inode, FI_NEW_INODE)) { 401 page = new_inode_page(inode); 402 if (IS_ERR(page)) 403 return page; 404 405 if (S_ISDIR(inode->i_mode)) { 406 /* in order to handle error case */ 407 get_page(page); 408 err = make_empty_dir(inode, dir, page); 409 if (err) { 410 lock_page(page); 411 goto put_error; 412 } 413 put_page(page); 414 } 415 416 err = f2fs_init_acl(inode, dir, page, dpage); 417 if (err) 418 goto put_error; 419 420 err = f2fs_init_security(inode, dir, orig_name, page); 421 if (err) 422 goto put_error; 423 424 if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode)) { 425 err = fscrypt_inherit_context(dir, inode, page, false); 426 if (err) 427 goto put_error; 428 } 429 } else { 430 page = get_node_page(F2FS_I_SB(dir), inode->i_ino); 431 if (IS_ERR(page)) 432 return page; 433 434 set_cold_node(inode, page); 435 } 436 437 if (new_name) 438 init_dent_inode(new_name, page); 439 440 /* 441 * This file should be checkpointed during fsync. 442 * We lost i_pino from now on. 443 */ 444 if (is_inode_flag_set(inode, FI_INC_LINK)) { 445 file_lost_pino(inode); 446 /* 447 * If link the tmpfile to alias through linkat path, 448 * we should remove this inode from orphan list. 449 */ 450 if (inode->i_nlink == 0) 451 remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino); 452 f2fs_i_links_write(inode, true); 453 } 454 return page; 455 456 put_error: 457 clear_nlink(inode); 458 update_inode(inode, page); 459 f2fs_put_page(page, 1); 460 return ERR_PTR(err); 461 } 462 463 void update_parent_metadata(struct inode *dir, struct inode *inode, 464 unsigned int current_depth) 465 { 466 if (inode && is_inode_flag_set(inode, FI_NEW_INODE)) { 467 if (S_ISDIR(inode->i_mode)) 468 f2fs_i_links_write(dir, true); 469 clear_inode_flag(inode, FI_NEW_INODE); 470 } 471 dir->i_mtime = dir->i_ctime = current_time(dir); 472 f2fs_mark_inode_dirty_sync(dir, false); 473 474 if (F2FS_I(dir)->i_current_depth != current_depth) 475 f2fs_i_depth_write(dir, current_depth); 476 477 if (inode && is_inode_flag_set(inode, FI_INC_LINK)) 478 clear_inode_flag(inode, FI_INC_LINK); 479 } 480 481 int room_for_filename(const void *bitmap, int slots, int max_slots) 482 { 483 int bit_start = 0; 484 int zero_start, zero_end; 485 next: 486 zero_start = find_next_zero_bit_le(bitmap, max_slots, bit_start); 487 if (zero_start >= max_slots) 488 return max_slots; 489 490 zero_end = find_next_bit_le(bitmap, max_slots, zero_start); 491 if (zero_end - zero_start >= slots) 492 return zero_start; 493 494 bit_start = zero_end + 1; 495 496 if (zero_end + 1 >= max_slots) 497 return max_slots; 498 goto next; 499 } 500 501 void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d, 502 const struct qstr *name, f2fs_hash_t name_hash, 503 unsigned int bit_pos) 504 { 505 struct f2fs_dir_entry *de; 506 int slots = GET_DENTRY_SLOTS(name->len); 507 int i; 508 509 de = &d->dentry[bit_pos]; 510 de->hash_code = name_hash; 511 de->name_len = cpu_to_le16(name->len); 512 memcpy(d->filename[bit_pos], name->name, name->len); 513 de->ino = cpu_to_le32(ino); 514 set_de_type(de, mode); 515 for (i = 0; i < slots; i++) { 516 __set_bit_le(bit_pos + i, (void *)d->bitmap); 517 /* avoid wrong garbage data for readdir */ 518 if (i) 519 (de + i)->name_len = 0; 520 } 521 } 522 523 int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name, 524 const struct qstr *orig_name, 525 struct inode *inode, nid_t ino, umode_t mode) 526 { 527 unsigned int bit_pos; 528 unsigned int level; 529 unsigned int current_depth; 530 unsigned long bidx, block; 531 f2fs_hash_t dentry_hash; 532 unsigned int nbucket, nblock; 533 struct page *dentry_page = NULL; 534 struct f2fs_dentry_block *dentry_blk = NULL; 535 struct f2fs_dentry_ptr d; 536 struct page *page = NULL; 537 int slots, err = 0; 538 539 level = 0; 540 slots = GET_DENTRY_SLOTS(new_name->len); 541 dentry_hash = f2fs_dentry_hash(new_name); 542 543 current_depth = F2FS_I(dir)->i_current_depth; 544 if (F2FS_I(dir)->chash == dentry_hash) { 545 level = F2FS_I(dir)->clevel; 546 F2FS_I(dir)->chash = 0; 547 } 548 549 start: 550 #ifdef CONFIG_F2FS_FAULT_INJECTION 551 if (time_to_inject(F2FS_I_SB(dir), FAULT_DIR_DEPTH)) 552 return -ENOSPC; 553 #endif 554 if (unlikely(current_depth == MAX_DIR_HASH_DEPTH)) 555 return -ENOSPC; 556 557 /* Increase the depth, if required */ 558 if (level == current_depth) 559 ++current_depth; 560 561 nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level); 562 nblock = bucket_blocks(level); 563 564 bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level, 565 (le32_to_cpu(dentry_hash) % nbucket)); 566 567 for (block = bidx; block <= (bidx + nblock - 1); block++) { 568 dentry_page = get_new_data_page(dir, NULL, block, true); 569 if (IS_ERR(dentry_page)) 570 return PTR_ERR(dentry_page); 571 572 dentry_blk = kmap(dentry_page); 573 bit_pos = room_for_filename(&dentry_blk->dentry_bitmap, 574 slots, NR_DENTRY_IN_BLOCK); 575 if (bit_pos < NR_DENTRY_IN_BLOCK) 576 goto add_dentry; 577 578 kunmap(dentry_page); 579 f2fs_put_page(dentry_page, 1); 580 } 581 582 /* Move to next level to find the empty slot for new dentry */ 583 ++level; 584 goto start; 585 add_dentry: 586 f2fs_wait_on_page_writeback(dentry_page, DATA, true); 587 588 if (inode) { 589 down_write(&F2FS_I(inode)->i_sem); 590 page = init_inode_metadata(inode, dir, new_name, 591 orig_name, NULL); 592 if (IS_ERR(page)) { 593 err = PTR_ERR(page); 594 goto fail; 595 } 596 if (f2fs_encrypted_inode(dir)) 597 file_set_enc_name(inode); 598 } 599 600 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1); 601 f2fs_update_dentry(ino, mode, &d, new_name, dentry_hash, bit_pos); 602 603 set_page_dirty(dentry_page); 604 605 if (inode) { 606 f2fs_i_pino_write(inode, dir->i_ino); 607 f2fs_put_page(page, 1); 608 } 609 610 update_parent_metadata(dir, inode, current_depth); 611 fail: 612 if (inode) 613 up_write(&F2FS_I(inode)->i_sem); 614 615 kunmap(dentry_page); 616 f2fs_put_page(dentry_page, 1); 617 618 return err; 619 } 620 621 int __f2fs_do_add_link(struct inode *dir, struct fscrypt_name *fname, 622 struct inode *inode, nid_t ino, umode_t mode) 623 { 624 struct qstr new_name; 625 int err = -EAGAIN; 626 627 new_name.name = fname_name(fname); 628 new_name.len = fname_len(fname); 629 630 if (f2fs_has_inline_dentry(dir)) 631 err = f2fs_add_inline_entry(dir, &new_name, fname->usr_fname, 632 inode, ino, mode); 633 if (err == -EAGAIN) 634 err = f2fs_add_regular_entry(dir, &new_name, fname->usr_fname, 635 inode, ino, mode); 636 637 f2fs_update_time(F2FS_I_SB(dir), REQ_TIME); 638 return err; 639 } 640 641 /* 642 * Caller should grab and release a rwsem by calling f2fs_lock_op() and 643 * f2fs_unlock_op(). 644 */ 645 int __f2fs_add_link(struct inode *dir, const struct qstr *name, 646 struct inode *inode, nid_t ino, umode_t mode) 647 { 648 struct fscrypt_name fname; 649 int err; 650 651 err = fscrypt_setup_filename(dir, name, 0, &fname); 652 if (err) 653 return err; 654 655 err = __f2fs_do_add_link(dir, &fname, inode, ino, mode); 656 657 fscrypt_free_filename(&fname); 658 return err; 659 } 660 661 int f2fs_do_tmpfile(struct inode *inode, struct inode *dir) 662 { 663 struct page *page; 664 int err = 0; 665 666 down_write(&F2FS_I(inode)->i_sem); 667 page = init_inode_metadata(inode, dir, NULL, NULL, NULL); 668 if (IS_ERR(page)) { 669 err = PTR_ERR(page); 670 goto fail; 671 } 672 f2fs_put_page(page, 1); 673 674 clear_inode_flag(inode, FI_NEW_INODE); 675 fail: 676 up_write(&F2FS_I(inode)->i_sem); 677 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 678 return err; 679 } 680 681 void f2fs_drop_nlink(struct inode *dir, struct inode *inode) 682 { 683 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 684 685 down_write(&F2FS_I(inode)->i_sem); 686 687 if (S_ISDIR(inode->i_mode)) 688 f2fs_i_links_write(dir, false); 689 inode->i_ctime = current_time(inode); 690 691 f2fs_i_links_write(inode, false); 692 if (S_ISDIR(inode->i_mode)) { 693 f2fs_i_links_write(inode, false); 694 f2fs_i_size_write(inode, 0); 695 } 696 up_write(&F2FS_I(inode)->i_sem); 697 698 if (inode->i_nlink == 0) 699 add_orphan_inode(inode); 700 else 701 release_orphan_inode(sbi); 702 } 703 704 /* 705 * It only removes the dentry from the dentry page, corresponding name 706 * entry in name page does not need to be touched during deletion. 707 */ 708 void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, 709 struct inode *dir, struct inode *inode) 710 { 711 struct f2fs_dentry_block *dentry_blk; 712 unsigned int bit_pos; 713 int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len)); 714 int i; 715 716 f2fs_update_time(F2FS_I_SB(dir), REQ_TIME); 717 718 if (f2fs_has_inline_dentry(dir)) 719 return f2fs_delete_inline_entry(dentry, page, dir, inode); 720 721 lock_page(page); 722 f2fs_wait_on_page_writeback(page, DATA, true); 723 724 dentry_blk = page_address(page); 725 bit_pos = dentry - dentry_blk->dentry; 726 for (i = 0; i < slots; i++) 727 clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap); 728 729 /* Let's check and deallocate this dentry page */ 730 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, 731 NR_DENTRY_IN_BLOCK, 732 0); 733 kunmap(page); /* kunmap - pair of f2fs_find_entry */ 734 set_page_dirty(page); 735 736 dir->i_ctime = dir->i_mtime = current_time(dir); 737 f2fs_mark_inode_dirty_sync(dir, false); 738 739 if (inode) 740 f2fs_drop_nlink(dir, inode); 741 742 if (bit_pos == NR_DENTRY_IN_BLOCK && 743 !truncate_hole(dir, page->index, page->index + 1)) { 744 clear_page_dirty_for_io(page); 745 ClearPagePrivate(page); 746 ClearPageUptodate(page); 747 inode_dec_dirty_pages(dir); 748 remove_dirty_inode(dir); 749 } 750 f2fs_put_page(page, 1); 751 } 752 753 bool f2fs_empty_dir(struct inode *dir) 754 { 755 unsigned long bidx; 756 struct page *dentry_page; 757 unsigned int bit_pos; 758 struct f2fs_dentry_block *dentry_blk; 759 unsigned long nblock = dir_blocks(dir); 760 761 if (f2fs_has_inline_dentry(dir)) 762 return f2fs_empty_inline_dir(dir); 763 764 for (bidx = 0; bidx < nblock; bidx++) { 765 dentry_page = get_lock_data_page(dir, bidx, false); 766 if (IS_ERR(dentry_page)) { 767 if (PTR_ERR(dentry_page) == -ENOENT) 768 continue; 769 else 770 return false; 771 } 772 773 dentry_blk = kmap_atomic(dentry_page); 774 if (bidx == 0) 775 bit_pos = 2; 776 else 777 bit_pos = 0; 778 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, 779 NR_DENTRY_IN_BLOCK, 780 bit_pos); 781 kunmap_atomic(dentry_blk); 782 783 f2fs_put_page(dentry_page, 1); 784 785 if (bit_pos < NR_DENTRY_IN_BLOCK) 786 return false; 787 } 788 return true; 789 } 790 791 int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d, 792 unsigned int start_pos, struct fscrypt_str *fstr) 793 { 794 unsigned char d_type = DT_UNKNOWN; 795 unsigned int bit_pos; 796 struct f2fs_dir_entry *de = NULL; 797 struct fscrypt_str de_name = FSTR_INIT(NULL, 0); 798 799 bit_pos = ((unsigned long)ctx->pos % d->max); 800 801 while (bit_pos < d->max) { 802 bit_pos = find_next_bit_le(d->bitmap, d->max, bit_pos); 803 if (bit_pos >= d->max) 804 break; 805 806 de = &d->dentry[bit_pos]; 807 if (de->name_len == 0) { 808 bit_pos++; 809 ctx->pos = start_pos + bit_pos; 810 continue; 811 } 812 813 d_type = get_de_type(de); 814 815 de_name.name = d->filename[bit_pos]; 816 de_name.len = le16_to_cpu(de->name_len); 817 818 if (f2fs_encrypted_inode(d->inode)) { 819 int save_len = fstr->len; 820 int err; 821 822 err = fscrypt_fname_disk_to_usr(d->inode, 823 (u32)de->hash_code, 0, 824 &de_name, fstr); 825 if (err) 826 return err; 827 828 de_name = *fstr; 829 fstr->len = save_len; 830 } 831 832 if (!dir_emit(ctx, de_name.name, de_name.len, 833 le32_to_cpu(de->ino), d_type)) 834 return 1; 835 836 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); 837 ctx->pos = start_pos + bit_pos; 838 } 839 return 0; 840 } 841 842 static int f2fs_readdir(struct file *file, struct dir_context *ctx) 843 { 844 struct inode *inode = file_inode(file); 845 unsigned long npages = dir_blocks(inode); 846 struct f2fs_dentry_block *dentry_blk = NULL; 847 struct page *dentry_page = NULL; 848 struct file_ra_state *ra = &file->f_ra; 849 unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK); 850 struct f2fs_dentry_ptr d; 851 struct fscrypt_str fstr = FSTR_INIT(NULL, 0); 852 int err = 0; 853 854 if (f2fs_encrypted_inode(inode)) { 855 err = fscrypt_get_encryption_info(inode); 856 if (err && err != -ENOKEY) 857 return err; 858 859 err = fscrypt_fname_alloc_buffer(inode, F2FS_NAME_LEN, &fstr); 860 if (err < 0) 861 return err; 862 } 863 864 if (f2fs_has_inline_dentry(inode)) { 865 err = f2fs_read_inline_dir(file, ctx, &fstr); 866 goto out; 867 } 868 869 /* readahead for multi pages of dir */ 870 if (npages - n > 1 && !ra_has_index(ra, n)) 871 page_cache_sync_readahead(inode->i_mapping, ra, file, n, 872 min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES)); 873 874 for (; n < npages; n++) { 875 dentry_page = get_lock_data_page(inode, n, false); 876 if (IS_ERR(dentry_page)) { 877 err = PTR_ERR(dentry_page); 878 if (err == -ENOENT) { 879 err = 0; 880 continue; 881 } else { 882 goto out; 883 } 884 } 885 886 dentry_blk = kmap(dentry_page); 887 888 make_dentry_ptr(inode, &d, (void *)dentry_blk, 1); 889 890 err = f2fs_fill_dentries(ctx, &d, 891 n * NR_DENTRY_IN_BLOCK, &fstr); 892 if (err) { 893 kunmap(dentry_page); 894 f2fs_put_page(dentry_page, 1); 895 break; 896 } 897 898 ctx->pos = (n + 1) * NR_DENTRY_IN_BLOCK; 899 kunmap(dentry_page); 900 f2fs_put_page(dentry_page, 1); 901 } 902 out: 903 fscrypt_fname_free_buffer(&fstr); 904 return err < 0 ? err : 0; 905 } 906 907 static int f2fs_dir_open(struct inode *inode, struct file *filp) 908 { 909 if (f2fs_encrypted_inode(inode)) 910 return fscrypt_get_encryption_info(inode) ? -EACCES : 0; 911 return 0; 912 } 913 914 const struct file_operations f2fs_dir_operations = { 915 .llseek = generic_file_llseek, 916 .read = generic_read_dir, 917 .iterate_shared = f2fs_readdir, 918 .fsync = f2fs_sync_file, 919 .open = f2fs_dir_open, 920 .unlocked_ioctl = f2fs_ioctl, 921 #ifdef CONFIG_COMPAT 922 .compat_ioctl = f2fs_compat_ioctl, 923 #endif 924 }; 925