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