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_CACHE_SIZE - 1)) 21 >> PAGE_CACHE_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 #define S_SHIFT 12 52 static unsigned char f2fs_type_by_mode[S_IFMT >> S_SHIFT] = { 53 [S_IFREG >> S_SHIFT] = F2FS_FT_REG_FILE, 54 [S_IFDIR >> S_SHIFT] = F2FS_FT_DIR, 55 [S_IFCHR >> S_SHIFT] = F2FS_FT_CHRDEV, 56 [S_IFBLK >> S_SHIFT] = F2FS_FT_BLKDEV, 57 [S_IFIFO >> S_SHIFT] = F2FS_FT_FIFO, 58 [S_IFSOCK >> S_SHIFT] = F2FS_FT_SOCK, 59 [S_IFLNK >> S_SHIFT] = F2FS_FT_SYMLINK, 60 }; 61 62 static void set_de_type(struct f2fs_dir_entry *de, struct inode *inode) 63 { 64 umode_t mode = inode->i_mode; 65 de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT]; 66 } 67 68 static unsigned long dir_block_index(unsigned int level, 69 int dir_level, unsigned int idx) 70 { 71 unsigned long i; 72 unsigned long bidx = 0; 73 74 for (i = 0; i < level; i++) 75 bidx += dir_buckets(i, dir_level) * bucket_blocks(i); 76 bidx += idx * bucket_blocks(level); 77 return bidx; 78 } 79 80 static bool early_match_name(const char *name, size_t namelen, 81 f2fs_hash_t namehash, struct f2fs_dir_entry *de) 82 { 83 if (le16_to_cpu(de->name_len) != namelen) 84 return false; 85 86 if (de->hash_code != namehash) 87 return false; 88 89 return true; 90 } 91 92 static struct f2fs_dir_entry *find_in_block(struct page *dentry_page, 93 const char *name, size_t namelen, int *max_slots, 94 f2fs_hash_t namehash, struct page **res_page) 95 { 96 struct f2fs_dir_entry *de; 97 unsigned long bit_pos = 0; 98 struct f2fs_dentry_block *dentry_blk = kmap(dentry_page); 99 const void *dentry_bits = &dentry_blk->dentry_bitmap; 100 int max_len = 0; 101 102 while (bit_pos < NR_DENTRY_IN_BLOCK) { 103 if (!test_bit_le(bit_pos, dentry_bits)) { 104 if (bit_pos == 0) 105 max_len = 1; 106 else if (!test_bit_le(bit_pos - 1, dentry_bits)) 107 max_len++; 108 bit_pos++; 109 continue; 110 } 111 de = &dentry_blk->dentry[bit_pos]; 112 if (early_match_name(name, namelen, namehash, de)) { 113 if (!memcmp(dentry_blk->filename[bit_pos], 114 name, namelen)) { 115 *res_page = dentry_page; 116 goto found; 117 } 118 } 119 if (max_len > *max_slots) { 120 *max_slots = max_len; 121 max_len = 0; 122 } 123 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); 124 } 125 126 de = NULL; 127 kunmap(dentry_page); 128 found: 129 if (max_len > *max_slots) 130 *max_slots = max_len; 131 return de; 132 } 133 134 static struct f2fs_dir_entry *find_in_level(struct inode *dir, 135 unsigned int level, const char *name, size_t namelen, 136 f2fs_hash_t namehash, struct page **res_page) 137 { 138 int s = GET_DENTRY_SLOTS(namelen); 139 unsigned int nbucket, nblock; 140 unsigned int bidx, end_block; 141 struct page *dentry_page; 142 struct f2fs_dir_entry *de = NULL; 143 bool room = false; 144 int max_slots = 0; 145 146 f2fs_bug_on(level > MAX_DIR_HASH_DEPTH); 147 148 nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level); 149 nblock = bucket_blocks(level); 150 151 bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level, 152 le32_to_cpu(namehash) % nbucket); 153 end_block = bidx + nblock; 154 155 for (; bidx < end_block; bidx++) { 156 /* no need to allocate new dentry pages to all the indices */ 157 dentry_page = find_data_page(dir, bidx, true); 158 if (IS_ERR(dentry_page)) { 159 room = true; 160 continue; 161 } 162 163 de = find_in_block(dentry_page, name, namelen, 164 &max_slots, namehash, res_page); 165 if (de) 166 break; 167 168 if (max_slots >= s) 169 room = true; 170 f2fs_put_page(dentry_page, 0); 171 } 172 173 if (!de && room && F2FS_I(dir)->chash != namehash) { 174 F2FS_I(dir)->chash = namehash; 175 F2FS_I(dir)->clevel = level; 176 } 177 178 return de; 179 } 180 181 /* 182 * Find an entry in the specified directory with the wanted name. 183 * It returns the page where the entry was found (as a parameter - res_page), 184 * and the entry itself. Page is returned mapped and unlocked. 185 * Entry is guaranteed to be valid. 186 */ 187 struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir, 188 struct qstr *child, struct page **res_page) 189 { 190 const char *name = child->name; 191 size_t namelen = child->len; 192 unsigned long npages = dir_blocks(dir); 193 struct f2fs_dir_entry *de = NULL; 194 f2fs_hash_t name_hash; 195 unsigned int max_depth; 196 unsigned int level; 197 198 if (npages == 0) 199 return NULL; 200 201 *res_page = NULL; 202 203 name_hash = f2fs_dentry_hash(name, namelen); 204 max_depth = F2FS_I(dir)->i_current_depth; 205 206 for (level = 0; level < max_depth; level++) { 207 de = find_in_level(dir, level, name, 208 namelen, name_hash, res_page); 209 if (de) 210 break; 211 } 212 if (!de && F2FS_I(dir)->chash != name_hash) { 213 F2FS_I(dir)->chash = name_hash; 214 F2FS_I(dir)->clevel = level - 1; 215 } 216 return de; 217 } 218 219 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p) 220 { 221 struct page *page; 222 struct f2fs_dir_entry *de; 223 struct f2fs_dentry_block *dentry_blk; 224 225 page = get_lock_data_page(dir, 0); 226 if (IS_ERR(page)) 227 return NULL; 228 229 dentry_blk = kmap(page); 230 de = &dentry_blk->dentry[1]; 231 *p = page; 232 unlock_page(page); 233 return de; 234 } 235 236 ino_t f2fs_inode_by_name(struct inode *dir, struct qstr *qstr) 237 { 238 ino_t res = 0; 239 struct f2fs_dir_entry *de; 240 struct page *page; 241 242 de = f2fs_find_entry(dir, qstr, &page); 243 if (de) { 244 res = le32_to_cpu(de->ino); 245 kunmap(page); 246 f2fs_put_page(page, 0); 247 } 248 249 return res; 250 } 251 252 void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de, 253 struct page *page, struct inode *inode) 254 { 255 lock_page(page); 256 f2fs_wait_on_page_writeback(page, DATA); 257 de->ino = cpu_to_le32(inode->i_ino); 258 set_de_type(de, inode); 259 kunmap(page); 260 set_page_dirty(page); 261 dir->i_mtime = dir->i_ctime = CURRENT_TIME; 262 mark_inode_dirty(dir); 263 264 f2fs_put_page(page, 1); 265 } 266 267 static void init_dent_inode(const struct qstr *name, struct page *ipage) 268 { 269 struct f2fs_inode *ri; 270 271 f2fs_wait_on_page_writeback(ipage, NODE); 272 273 /* copy name info. to this inode page */ 274 ri = F2FS_INODE(ipage); 275 ri->i_namelen = cpu_to_le32(name->len); 276 memcpy(ri->i_name, name->name, name->len); 277 set_page_dirty(ipage); 278 } 279 280 int update_dent_inode(struct inode *inode, const struct qstr *name) 281 { 282 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb); 283 struct page *page; 284 285 page = get_node_page(sbi, inode->i_ino); 286 if (IS_ERR(page)) 287 return PTR_ERR(page); 288 289 init_dent_inode(name, page); 290 f2fs_put_page(page, 1); 291 292 return 0; 293 } 294 295 static int make_empty_dir(struct inode *inode, 296 struct inode *parent, struct page *page) 297 { 298 struct page *dentry_page; 299 struct f2fs_dentry_block *dentry_blk; 300 struct f2fs_dir_entry *de; 301 void *kaddr; 302 303 dentry_page = get_new_data_page(inode, page, 0, true); 304 if (IS_ERR(dentry_page)) 305 return PTR_ERR(dentry_page); 306 307 kaddr = kmap_atomic(dentry_page); 308 dentry_blk = (struct f2fs_dentry_block *)kaddr; 309 310 de = &dentry_blk->dentry[0]; 311 de->name_len = cpu_to_le16(1); 312 de->hash_code = 0; 313 de->ino = cpu_to_le32(inode->i_ino); 314 memcpy(dentry_blk->filename[0], ".", 1); 315 set_de_type(de, inode); 316 317 de = &dentry_blk->dentry[1]; 318 de->hash_code = 0; 319 de->name_len = cpu_to_le16(2); 320 de->ino = cpu_to_le32(parent->i_ino); 321 memcpy(dentry_blk->filename[1], "..", 2); 322 set_de_type(de, inode); 323 324 test_and_set_bit_le(0, &dentry_blk->dentry_bitmap); 325 test_and_set_bit_le(1, &dentry_blk->dentry_bitmap); 326 kunmap_atomic(kaddr); 327 328 set_page_dirty(dentry_page); 329 f2fs_put_page(dentry_page, 1); 330 return 0; 331 } 332 333 static struct page *init_inode_metadata(struct inode *inode, 334 struct inode *dir, const struct qstr *name) 335 { 336 struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); 337 struct page *page; 338 int err; 339 340 if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) { 341 page = new_inode_page(inode); 342 if (IS_ERR(page)) 343 return page; 344 345 if (S_ISDIR(inode->i_mode)) { 346 err = make_empty_dir(inode, dir, page); 347 if (err) 348 goto error; 349 } 350 351 err = f2fs_init_acl(inode, dir, page); 352 if (err) 353 goto put_error; 354 355 err = f2fs_init_security(inode, dir, name, page); 356 if (err) 357 goto put_error; 358 } else { 359 page = get_node_page(F2FS_SB(dir->i_sb), inode->i_ino); 360 if (IS_ERR(page)) 361 return page; 362 363 set_cold_node(inode, page); 364 } 365 366 if (name) 367 init_dent_inode(name, page); 368 369 /* 370 * This file should be checkpointed during fsync. 371 * We lost i_pino from now on. 372 */ 373 if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK)) { 374 file_lost_pino(inode); 375 /* 376 * If link the tmpfile to alias through linkat path, 377 * we should remove this inode from orphan list. 378 */ 379 if (inode->i_nlink == 0) 380 remove_orphan_inode(sbi, inode->i_ino); 381 inc_nlink(inode); 382 } 383 return page; 384 385 put_error: 386 f2fs_put_page(page, 1); 387 error: 388 /* once the failed inode becomes a bad inode, i_mode is S_IFREG */ 389 truncate_inode_pages(&inode->i_data, 0); 390 truncate_blocks(inode, 0); 391 remove_dirty_dir_inode(inode); 392 remove_inode_page(inode); 393 return ERR_PTR(err); 394 } 395 396 static void update_parent_metadata(struct inode *dir, struct inode *inode, 397 unsigned int current_depth) 398 { 399 if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) { 400 if (S_ISDIR(inode->i_mode)) { 401 inc_nlink(dir); 402 set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR); 403 } 404 clear_inode_flag(F2FS_I(inode), FI_NEW_INODE); 405 } 406 dir->i_mtime = dir->i_ctime = CURRENT_TIME; 407 mark_inode_dirty(dir); 408 409 if (F2FS_I(dir)->i_current_depth != current_depth) { 410 F2FS_I(dir)->i_current_depth = current_depth; 411 set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR); 412 } 413 414 if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK)) 415 clear_inode_flag(F2FS_I(inode), FI_INC_LINK); 416 } 417 418 static int room_for_filename(struct f2fs_dentry_block *dentry_blk, int slots) 419 { 420 int bit_start = 0; 421 int zero_start, zero_end; 422 next: 423 zero_start = find_next_zero_bit_le(&dentry_blk->dentry_bitmap, 424 NR_DENTRY_IN_BLOCK, 425 bit_start); 426 if (zero_start >= NR_DENTRY_IN_BLOCK) 427 return NR_DENTRY_IN_BLOCK; 428 429 zero_end = find_next_bit_le(&dentry_blk->dentry_bitmap, 430 NR_DENTRY_IN_BLOCK, 431 zero_start); 432 if (zero_end - zero_start >= slots) 433 return zero_start; 434 435 bit_start = zero_end + 1; 436 437 if (zero_end + 1 >= NR_DENTRY_IN_BLOCK) 438 return NR_DENTRY_IN_BLOCK; 439 goto next; 440 } 441 442 /* 443 * Caller should grab and release a rwsem by calling f2fs_lock_op() and 444 * f2fs_unlock_op(). 445 */ 446 int __f2fs_add_link(struct inode *dir, const struct qstr *name, 447 struct inode *inode) 448 { 449 unsigned int bit_pos; 450 unsigned int level; 451 unsigned int current_depth; 452 unsigned long bidx, block; 453 f2fs_hash_t dentry_hash; 454 struct f2fs_dir_entry *de; 455 unsigned int nbucket, nblock; 456 size_t namelen = name->len; 457 struct page *dentry_page = NULL; 458 struct f2fs_dentry_block *dentry_blk = NULL; 459 int slots = GET_DENTRY_SLOTS(namelen); 460 struct page *page; 461 int err = 0; 462 int i; 463 464 dentry_hash = f2fs_dentry_hash(name->name, name->len); 465 level = 0; 466 current_depth = F2FS_I(dir)->i_current_depth; 467 if (F2FS_I(dir)->chash == dentry_hash) { 468 level = F2FS_I(dir)->clevel; 469 F2FS_I(dir)->chash = 0; 470 } 471 472 start: 473 if (unlikely(current_depth == MAX_DIR_HASH_DEPTH)) 474 return -ENOSPC; 475 476 /* Increase the depth, if required */ 477 if (level == current_depth) 478 ++current_depth; 479 480 nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level); 481 nblock = bucket_blocks(level); 482 483 bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level, 484 (le32_to_cpu(dentry_hash) % nbucket)); 485 486 for (block = bidx; block <= (bidx + nblock - 1); block++) { 487 dentry_page = get_new_data_page(dir, NULL, block, true); 488 if (IS_ERR(dentry_page)) 489 return PTR_ERR(dentry_page); 490 491 dentry_blk = kmap(dentry_page); 492 bit_pos = room_for_filename(dentry_blk, slots); 493 if (bit_pos < NR_DENTRY_IN_BLOCK) 494 goto add_dentry; 495 496 kunmap(dentry_page); 497 f2fs_put_page(dentry_page, 1); 498 } 499 500 /* Move to next level to find the empty slot for new dentry */ 501 ++level; 502 goto start; 503 add_dentry: 504 f2fs_wait_on_page_writeback(dentry_page, DATA); 505 506 down_write(&F2FS_I(inode)->i_sem); 507 page = init_inode_metadata(inode, dir, name); 508 if (IS_ERR(page)) { 509 err = PTR_ERR(page); 510 goto fail; 511 } 512 de = &dentry_blk->dentry[bit_pos]; 513 de->hash_code = dentry_hash; 514 de->name_len = cpu_to_le16(namelen); 515 memcpy(dentry_blk->filename[bit_pos], name->name, name->len); 516 de->ino = cpu_to_le32(inode->i_ino); 517 set_de_type(de, inode); 518 for (i = 0; i < slots; i++) 519 test_and_set_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap); 520 set_page_dirty(dentry_page); 521 522 /* we don't need to mark_inode_dirty now */ 523 F2FS_I(inode)->i_pino = dir->i_ino; 524 update_inode(inode, page); 525 f2fs_put_page(page, 1); 526 527 update_parent_metadata(dir, inode, current_depth); 528 fail: 529 up_write(&F2FS_I(inode)->i_sem); 530 531 if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) { 532 update_inode_page(dir); 533 clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR); 534 } 535 kunmap(dentry_page); 536 f2fs_put_page(dentry_page, 1); 537 return err; 538 } 539 540 int f2fs_do_tmpfile(struct inode *inode, struct inode *dir) 541 { 542 struct page *page; 543 int err = 0; 544 545 down_write(&F2FS_I(inode)->i_sem); 546 page = init_inode_metadata(inode, dir, NULL); 547 if (IS_ERR(page)) { 548 err = PTR_ERR(page); 549 goto fail; 550 } 551 /* we don't need to mark_inode_dirty now */ 552 update_inode(inode, page); 553 f2fs_put_page(page, 1); 554 555 clear_inode_flag(F2FS_I(inode), FI_NEW_INODE); 556 fail: 557 up_write(&F2FS_I(inode)->i_sem); 558 return err; 559 } 560 561 /* 562 * It only removes the dentry from the dentry page,corresponding name 563 * entry in name page does not need to be touched during deletion. 564 */ 565 void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, 566 struct inode *inode) 567 { 568 struct f2fs_dentry_block *dentry_blk; 569 unsigned int bit_pos; 570 struct address_space *mapping = page->mapping; 571 struct inode *dir = mapping->host; 572 int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len)); 573 void *kaddr = page_address(page); 574 int i; 575 576 lock_page(page); 577 f2fs_wait_on_page_writeback(page, DATA); 578 579 dentry_blk = (struct f2fs_dentry_block *)kaddr; 580 bit_pos = dentry - (struct f2fs_dir_entry *)dentry_blk->dentry; 581 for (i = 0; i < slots; i++) 582 test_and_clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap); 583 584 /* Let's check and deallocate this dentry page */ 585 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, 586 NR_DENTRY_IN_BLOCK, 587 0); 588 kunmap(page); /* kunmap - pair of f2fs_find_entry */ 589 set_page_dirty(page); 590 591 dir->i_ctime = dir->i_mtime = CURRENT_TIME; 592 593 if (inode) { 594 struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); 595 596 down_write(&F2FS_I(inode)->i_sem); 597 598 if (S_ISDIR(inode->i_mode)) { 599 drop_nlink(dir); 600 update_inode_page(dir); 601 } 602 inode->i_ctime = CURRENT_TIME; 603 drop_nlink(inode); 604 if (S_ISDIR(inode->i_mode)) { 605 drop_nlink(inode); 606 i_size_write(inode, 0); 607 } 608 up_write(&F2FS_I(inode)->i_sem); 609 update_inode_page(inode); 610 611 if (inode->i_nlink == 0) 612 add_orphan_inode(sbi, inode->i_ino); 613 else 614 release_orphan_inode(sbi); 615 } 616 617 if (bit_pos == NR_DENTRY_IN_BLOCK) { 618 truncate_hole(dir, page->index, page->index + 1); 619 clear_page_dirty_for_io(page); 620 ClearPageUptodate(page); 621 inode_dec_dirty_dents(dir); 622 } 623 f2fs_put_page(page, 1); 624 } 625 626 bool f2fs_empty_dir(struct inode *dir) 627 { 628 unsigned long bidx; 629 struct page *dentry_page; 630 unsigned int bit_pos; 631 struct f2fs_dentry_block *dentry_blk; 632 unsigned long nblock = dir_blocks(dir); 633 634 for (bidx = 0; bidx < nblock; bidx++) { 635 void *kaddr; 636 dentry_page = get_lock_data_page(dir, bidx); 637 if (IS_ERR(dentry_page)) { 638 if (PTR_ERR(dentry_page) == -ENOENT) 639 continue; 640 else 641 return false; 642 } 643 644 kaddr = kmap_atomic(dentry_page); 645 dentry_blk = (struct f2fs_dentry_block *)kaddr; 646 if (bidx == 0) 647 bit_pos = 2; 648 else 649 bit_pos = 0; 650 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, 651 NR_DENTRY_IN_BLOCK, 652 bit_pos); 653 kunmap_atomic(kaddr); 654 655 f2fs_put_page(dentry_page, 1); 656 657 if (bit_pos < NR_DENTRY_IN_BLOCK) 658 return false; 659 } 660 return true; 661 } 662 663 static int f2fs_readdir(struct file *file, struct dir_context *ctx) 664 { 665 struct inode *inode = file_inode(file); 666 unsigned long npages = dir_blocks(inode); 667 unsigned int bit_pos = 0; 668 struct f2fs_dentry_block *dentry_blk = NULL; 669 struct f2fs_dir_entry *de = NULL; 670 struct page *dentry_page = NULL; 671 struct file_ra_state *ra = &file->f_ra; 672 unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK); 673 unsigned char d_type = DT_UNKNOWN; 674 675 bit_pos = ((unsigned long)ctx->pos % NR_DENTRY_IN_BLOCK); 676 677 /* readahead for multi pages of dir */ 678 if (npages - n > 1 && !ra_has_index(ra, n)) 679 page_cache_sync_readahead(inode->i_mapping, ra, file, n, 680 min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES)); 681 682 for (; n < npages; n++) { 683 dentry_page = get_lock_data_page(inode, n); 684 if (IS_ERR(dentry_page)) 685 continue; 686 687 dentry_blk = kmap(dentry_page); 688 while (bit_pos < NR_DENTRY_IN_BLOCK) { 689 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, 690 NR_DENTRY_IN_BLOCK, 691 bit_pos); 692 if (bit_pos >= NR_DENTRY_IN_BLOCK) 693 break; 694 695 de = &dentry_blk->dentry[bit_pos]; 696 if (de->file_type < F2FS_FT_MAX) 697 d_type = f2fs_filetype_table[de->file_type]; 698 else 699 d_type = DT_UNKNOWN; 700 if (!dir_emit(ctx, 701 dentry_blk->filename[bit_pos], 702 le16_to_cpu(de->name_len), 703 le32_to_cpu(de->ino), d_type)) 704 goto stop; 705 706 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); 707 ctx->pos = n * NR_DENTRY_IN_BLOCK + bit_pos; 708 } 709 bit_pos = 0; 710 ctx->pos = (n + 1) * NR_DENTRY_IN_BLOCK; 711 kunmap(dentry_page); 712 f2fs_put_page(dentry_page, 1); 713 dentry_page = NULL; 714 } 715 stop: 716 if (dentry_page && !IS_ERR(dentry_page)) { 717 kunmap(dentry_page); 718 f2fs_put_page(dentry_page, 1); 719 } 720 721 return 0; 722 } 723 724 const struct file_operations f2fs_dir_operations = { 725 .llseek = generic_file_llseek, 726 .read = generic_read_dir, 727 .iterate = f2fs_readdir, 728 .fsync = f2fs_sync_file, 729 .unlocked_ioctl = f2fs_ioctl, 730 }; 731