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