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