4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
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.
12 #include <linux/f2fs_fs.h>
18 static unsigned long dir_blocks(struct inode
*inode
)
20 return ((unsigned long long) (i_size_read(inode
) + PAGE_CACHE_SIZE
- 1))
24 static unsigned int dir_buckets(unsigned int level
, int dir_level
)
26 if (level
+ dir_level
< MAX_DIR_HASH_DEPTH
/ 2)
27 return 1 << (level
+ dir_level
);
29 return MAX_DIR_BUCKETS
;
32 static unsigned int bucket_blocks(unsigned int level
)
34 if (level
< MAX_DIR_HASH_DEPTH
/ 2)
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
,
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
,
62 void set_de_type(struct f2fs_dir_entry
*de
, umode_t mode
)
64 de
->file_type
= f2fs_type_by_mode
[(mode
& S_IFMT
) >> S_SHIFT
];
67 static unsigned long dir_block_index(unsigned int level
,
68 int dir_level
, unsigned int idx
)
71 unsigned long bidx
= 0;
73 for (i
= 0; i
< level
; i
++)
74 bidx
+= dir_buckets(i
, dir_level
) * bucket_blocks(i
);
75 bidx
+= idx
* bucket_blocks(level
);
79 static struct f2fs_dir_entry
*find_in_block(struct page
*dentry_page
,
80 struct fscrypt_name
*fname
,
83 struct page
**res_page
)
85 struct f2fs_dentry_block
*dentry_blk
;
86 struct f2fs_dir_entry
*de
;
87 struct f2fs_dentry_ptr d
;
89 dentry_blk
= (struct f2fs_dentry_block
*)kmap(dentry_page
);
91 make_dentry_ptr(NULL
, &d
, (void *)dentry_blk
, 1);
92 de
= find_target_dentry(fname
, namehash
, max_slots
, &d
);
94 *res_page
= dentry_page
;
99 * For the most part, it should be a bug when name_len is zero.
100 * We stop here for figuring out where the bugs has occurred.
102 f2fs_bug_on(F2FS_P_SB(dentry_page
), d
.max
< 0);
106 struct f2fs_dir_entry
*find_target_dentry(struct fscrypt_name
*fname
,
107 f2fs_hash_t namehash
, int *max_slots
,
108 struct f2fs_dentry_ptr
*d
)
110 struct f2fs_dir_entry
*de
;
111 unsigned long bit_pos
= 0;
113 struct fscrypt_str de_name
= FSTR_INIT(NULL
, 0);
114 struct fscrypt_str
*name
= &fname
->disk_name
;
118 while (bit_pos
< d
->max
) {
119 if (!test_bit_le(bit_pos
, d
->bitmap
)) {
125 de
= &d
->dentry
[bit_pos
];
128 de_name
.name
= d
->filename
[bit_pos
];
129 de_name
.len
= le16_to_cpu(de
->name_len
);
131 /* show encrypted name */
133 if (de
->hash_code
== fname
->hash
)
135 } else if (de_name
.len
== name
->len
&&
136 de
->hash_code
== namehash
&&
137 !memcmp(de_name
.name
, name
->name
, name
->len
))
140 if (max_slots
&& max_len
> *max_slots
)
141 *max_slots
= max_len
;
144 /* remain bug on condition */
145 if (unlikely(!de
->name_len
))
148 bit_pos
+= GET_DENTRY_SLOTS(le16_to_cpu(de
->name_len
));
153 if (max_slots
&& max_len
> *max_slots
)
154 *max_slots
= max_len
;
158 static struct f2fs_dir_entry
*find_in_level(struct inode
*dir
,
160 struct fscrypt_name
*fname
,
161 struct page
**res_page
)
163 struct qstr name
= FSTR_TO_QSTR(&fname
->disk_name
);
164 int s
= GET_DENTRY_SLOTS(name
.len
);
165 unsigned int nbucket
, nblock
;
166 unsigned int bidx
, end_block
;
167 struct page
*dentry_page
;
168 struct f2fs_dir_entry
*de
= NULL
;
171 f2fs_hash_t namehash
;
173 namehash
= f2fs_dentry_hash(&name
);
175 nbucket
= dir_buckets(level
, F2FS_I(dir
)->i_dir_level
);
176 nblock
= bucket_blocks(level
);
178 bidx
= dir_block_index(level
, F2FS_I(dir
)->i_dir_level
,
179 le32_to_cpu(namehash
) % nbucket
);
180 end_block
= bidx
+ nblock
;
182 for (; bidx
< end_block
; bidx
++) {
183 /* no need to allocate new dentry pages to all the indices */
184 dentry_page
= find_data_page(dir
, bidx
);
185 if (IS_ERR(dentry_page
)) {
190 de
= find_in_block(dentry_page
, fname
, namehash
, &max_slots
,
197 f2fs_put_page(dentry_page
, 0);
200 if (!de
&& room
&& F2FS_I(dir
)->chash
!= namehash
) {
201 F2FS_I(dir
)->chash
= namehash
;
202 F2FS_I(dir
)->clevel
= level
;
209 * Find an entry in the specified directory with the wanted name.
210 * It returns the page where the entry was found (as a parameter - res_page),
211 * and the entry itself. Page is returned mapped and unlocked.
212 * Entry is guaranteed to be valid.
214 struct f2fs_dir_entry
*f2fs_find_entry(struct inode
*dir
,
215 struct qstr
*child
, struct page
**res_page
)
217 unsigned long npages
= dir_blocks(dir
);
218 struct f2fs_dir_entry
*de
= NULL
;
219 unsigned int max_depth
;
221 struct fscrypt_name fname
;
226 err
= fscrypt_setup_filename(dir
, child
, 1, &fname
);
230 if (f2fs_has_inline_dentry(dir
)) {
231 de
= find_in_inline_dir(dir
, &fname
, res_page
);
238 max_depth
= F2FS_I(dir
)->i_current_depth
;
239 if (unlikely(max_depth
> MAX_DIR_HASH_DEPTH
)) {
240 f2fs_msg(F2FS_I_SB(dir
)->sb
, KERN_WARNING
,
241 "Corrupted max_depth of %lu: %u",
242 dir
->i_ino
, max_depth
);
243 max_depth
= MAX_DIR_HASH_DEPTH
;
244 F2FS_I(dir
)->i_current_depth
= max_depth
;
245 mark_inode_dirty(dir
);
248 for (level
= 0; level
< max_depth
; level
++) {
249 de
= find_in_level(dir
, level
, &fname
, res_page
);
254 fscrypt_free_filename(&fname
);
258 struct f2fs_dir_entry
*f2fs_parent_dir(struct inode
*dir
, struct page
**p
)
261 struct f2fs_dir_entry
*de
;
262 struct f2fs_dentry_block
*dentry_blk
;
264 if (f2fs_has_inline_dentry(dir
))
265 return f2fs_parent_inline_dir(dir
, p
);
267 page
= get_lock_data_page(dir
, 0, false);
271 dentry_blk
= kmap(page
);
272 de
= &dentry_blk
->dentry
[1];
278 ino_t
f2fs_inode_by_name(struct inode
*dir
, struct qstr
*qstr
)
281 struct f2fs_dir_entry
*de
;
284 de
= f2fs_find_entry(dir
, qstr
, &page
);
286 res
= le32_to_cpu(de
->ino
);
287 f2fs_dentry_kunmap(dir
, page
);
288 f2fs_put_page(page
, 0);
294 void f2fs_set_link(struct inode
*dir
, struct f2fs_dir_entry
*de
,
295 struct page
*page
, struct inode
*inode
)
297 enum page_type type
= f2fs_has_inline_dentry(dir
) ? NODE
: DATA
;
299 f2fs_wait_on_page_writeback(page
, type
, true);
300 de
->ino
= cpu_to_le32(inode
->i_ino
);
301 set_de_type(de
, inode
->i_mode
);
302 f2fs_dentry_kunmap(dir
, page
);
303 set_page_dirty(page
);
304 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
305 mark_inode_dirty(dir
);
307 f2fs_put_page(page
, 1);
310 static void init_dent_inode(const struct qstr
*name
, struct page
*ipage
)
312 struct f2fs_inode
*ri
;
314 f2fs_wait_on_page_writeback(ipage
, NODE
, true);
316 /* copy name info. to this inode page */
317 ri
= F2FS_INODE(ipage
);
318 ri
->i_namelen
= cpu_to_le32(name
->len
);
319 memcpy(ri
->i_name
, name
->name
, name
->len
);
320 set_page_dirty(ipage
);
323 int update_dent_inode(struct inode
*inode
, struct inode
*to
,
324 const struct qstr
*name
)
328 if (file_enc_name(to
))
331 page
= get_node_page(F2FS_I_SB(inode
), inode
->i_ino
);
333 return PTR_ERR(page
);
335 init_dent_inode(name
, page
);
336 f2fs_put_page(page
, 1);
341 void do_make_empty_dir(struct inode
*inode
, struct inode
*parent
,
342 struct f2fs_dentry_ptr
*d
)
344 struct f2fs_dir_entry
*de
;
347 de
->name_len
= cpu_to_le16(1);
349 de
->ino
= cpu_to_le32(inode
->i_ino
);
350 memcpy(d
->filename
[0], ".", 1);
351 set_de_type(de
, inode
->i_mode
);
355 de
->name_len
= cpu_to_le16(2);
356 de
->ino
= cpu_to_le32(parent
->i_ino
);
357 memcpy(d
->filename
[1], "..", 2);
358 set_de_type(de
, parent
->i_mode
);
360 test_and_set_bit_le(0, (void *)d
->bitmap
);
361 test_and_set_bit_le(1, (void *)d
->bitmap
);
364 static int make_empty_dir(struct inode
*inode
,
365 struct inode
*parent
, struct page
*page
)
367 struct page
*dentry_page
;
368 struct f2fs_dentry_block
*dentry_blk
;
369 struct f2fs_dentry_ptr d
;
371 if (f2fs_has_inline_dentry(inode
))
372 return make_empty_inline_dir(inode
, parent
, page
);
374 dentry_page
= get_new_data_page(inode
, page
, 0, true);
375 if (IS_ERR(dentry_page
))
376 return PTR_ERR(dentry_page
);
378 dentry_blk
= kmap_atomic(dentry_page
);
380 make_dentry_ptr(NULL
, &d
, (void *)dentry_blk
, 1);
381 do_make_empty_dir(inode
, parent
, &d
);
383 kunmap_atomic(dentry_blk
);
385 set_page_dirty(dentry_page
);
386 f2fs_put_page(dentry_page
, 1);
390 struct page
*init_inode_metadata(struct inode
*inode
, struct inode
*dir
,
391 const struct qstr
*name
, struct page
*dpage
)
396 if (is_inode_flag_set(F2FS_I(inode
), FI_NEW_INODE
)) {
397 page
= new_inode_page(inode
);
401 if (S_ISDIR(inode
->i_mode
)) {
402 err
= make_empty_dir(inode
, dir
, page
);
407 err
= f2fs_init_acl(inode
, dir
, page
, dpage
);
411 err
= f2fs_init_security(inode
, dir
, name
, page
);
415 if (f2fs_encrypted_inode(dir
) && f2fs_may_encrypt(inode
)) {
416 err
= fscrypt_inherit_context(dir
, inode
, page
, false);
421 page
= get_node_page(F2FS_I_SB(dir
), inode
->i_ino
);
425 set_cold_node(inode
, page
);
429 init_dent_inode(name
, page
);
432 * This file should be checkpointed during fsync.
433 * We lost i_pino from now on.
435 if (is_inode_flag_set(F2FS_I(inode
), FI_INC_LINK
)) {
436 file_lost_pino(inode
);
438 * If link the tmpfile to alias through linkat path,
439 * we should remove this inode from orphan list.
441 if (inode
->i_nlink
== 0)
442 remove_orphan_inode(F2FS_I_SB(dir
), inode
->i_ino
);
448 f2fs_put_page(page
, 1);
450 /* once the failed inode becomes a bad inode, i_mode is S_IFREG */
451 truncate_inode_pages(&inode
->i_data
, 0);
452 truncate_blocks(inode
, 0, false);
453 remove_dirty_inode(inode
);
454 remove_inode_page(inode
);
458 void update_parent_metadata(struct inode
*dir
, struct inode
*inode
,
459 unsigned int current_depth
)
461 if (inode
&& is_inode_flag_set(F2FS_I(inode
), FI_NEW_INODE
)) {
462 if (S_ISDIR(inode
->i_mode
)) {
464 set_inode_flag(F2FS_I(dir
), FI_UPDATE_DIR
);
466 clear_inode_flag(F2FS_I(inode
), FI_NEW_INODE
);
468 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
469 mark_inode_dirty(dir
);
471 if (F2FS_I(dir
)->i_current_depth
!= current_depth
) {
472 F2FS_I(dir
)->i_current_depth
= current_depth
;
473 set_inode_flag(F2FS_I(dir
), FI_UPDATE_DIR
);
476 if (inode
&& is_inode_flag_set(F2FS_I(inode
), FI_INC_LINK
))
477 clear_inode_flag(F2FS_I(inode
), FI_INC_LINK
);
480 int room_for_filename(const void *bitmap
, int slots
, int max_slots
)
483 int zero_start
, zero_end
;
485 zero_start
= find_next_zero_bit_le(bitmap
, max_slots
, bit_start
);
486 if (zero_start
>= max_slots
)
489 zero_end
= find_next_bit_le(bitmap
, max_slots
, zero_start
);
490 if (zero_end
- zero_start
>= slots
)
493 bit_start
= zero_end
+ 1;
495 if (zero_end
+ 1 >= max_slots
)
500 void f2fs_update_dentry(nid_t ino
, umode_t mode
, struct f2fs_dentry_ptr
*d
,
501 const struct qstr
*name
, f2fs_hash_t name_hash
,
502 unsigned int bit_pos
)
504 struct f2fs_dir_entry
*de
;
505 int slots
= GET_DENTRY_SLOTS(name
->len
);
508 de
= &d
->dentry
[bit_pos
];
509 de
->hash_code
= name_hash
;
510 de
->name_len
= cpu_to_le16(name
->len
);
511 memcpy(d
->filename
[bit_pos
], name
->name
, name
->len
);
512 de
->ino
= cpu_to_le32(ino
);
513 set_de_type(de
, mode
);
514 for (i
= 0; i
< slots
; i
++) {
515 test_and_set_bit_le(bit_pos
+ i
, (void *)d
->bitmap
);
516 /* avoid wrong garbage data for readdir */
518 (de
+ i
)->name_len
= 0;
523 * Caller should grab and release a rwsem by calling f2fs_lock_op() and
526 int __f2fs_add_link(struct inode
*dir
, const struct qstr
*name
,
527 struct inode
*inode
, nid_t ino
, umode_t mode
)
529 unsigned int bit_pos
;
531 unsigned int current_depth
;
532 unsigned long bidx
, block
;
533 f2fs_hash_t dentry_hash
;
534 unsigned int nbucket
, nblock
;
535 struct page
*dentry_page
= NULL
;
536 struct f2fs_dentry_block
*dentry_blk
= NULL
;
537 struct f2fs_dentry_ptr d
;
538 struct page
*page
= NULL
;
539 struct fscrypt_name fname
;
540 struct qstr new_name
;
543 err
= fscrypt_setup_filename(dir
, name
, 0, &fname
);
547 new_name
.name
= fname_name(&fname
);
548 new_name
.len
= fname_len(&fname
);
550 if (f2fs_has_inline_dentry(dir
)) {
551 err
= f2fs_add_inline_entry(dir
, &new_name
, inode
, ino
, mode
);
552 if (!err
|| err
!= -EAGAIN
)
559 slots
= GET_DENTRY_SLOTS(new_name
.len
);
560 dentry_hash
= f2fs_dentry_hash(&new_name
);
562 current_depth
= F2FS_I(dir
)->i_current_depth
;
563 if (F2FS_I(dir
)->chash
== dentry_hash
) {
564 level
= F2FS_I(dir
)->clevel
;
565 F2FS_I(dir
)->chash
= 0;
569 if (unlikely(current_depth
== MAX_DIR_HASH_DEPTH
)) {
574 /* Increase the depth, if required */
575 if (level
== current_depth
)
578 nbucket
= dir_buckets(level
, F2FS_I(dir
)->i_dir_level
);
579 nblock
= bucket_blocks(level
);
581 bidx
= dir_block_index(level
, F2FS_I(dir
)->i_dir_level
,
582 (le32_to_cpu(dentry_hash
) % nbucket
));
584 for (block
= bidx
; block
<= (bidx
+ nblock
- 1); block
++) {
585 dentry_page
= get_new_data_page(dir
, NULL
, block
, true);
586 if (IS_ERR(dentry_page
)) {
587 err
= PTR_ERR(dentry_page
);
591 dentry_blk
= kmap(dentry_page
);
592 bit_pos
= room_for_filename(&dentry_blk
->dentry_bitmap
,
593 slots
, NR_DENTRY_IN_BLOCK
);
594 if (bit_pos
< NR_DENTRY_IN_BLOCK
)
598 f2fs_put_page(dentry_page
, 1);
601 /* Move to next level to find the empty slot for new dentry */
605 f2fs_wait_on_page_writeback(dentry_page
, DATA
, true);
608 down_write(&F2FS_I(inode
)->i_sem
);
609 page
= init_inode_metadata(inode
, dir
, &new_name
, NULL
);
614 if (f2fs_encrypted_inode(dir
))
615 file_set_enc_name(inode
);
618 make_dentry_ptr(NULL
, &d
, (void *)dentry_blk
, 1);
619 f2fs_update_dentry(ino
, mode
, &d
, &new_name
, dentry_hash
, bit_pos
);
621 set_page_dirty(dentry_page
);
624 /* we don't need to mark_inode_dirty now */
625 F2FS_I(inode
)->i_pino
= dir
->i_ino
;
626 update_inode(inode
, page
);
627 f2fs_put_page(page
, 1);
630 update_parent_metadata(dir
, inode
, current_depth
);
633 up_write(&F2FS_I(inode
)->i_sem
);
635 if (is_inode_flag_set(F2FS_I(dir
), FI_UPDATE_DIR
)) {
636 update_inode_page(dir
);
637 clear_inode_flag(F2FS_I(dir
), FI_UPDATE_DIR
);
640 f2fs_put_page(dentry_page
, 1);
642 fscrypt_free_filename(&fname
);
643 f2fs_update_time(F2FS_I_SB(dir
), REQ_TIME
);
647 int f2fs_do_tmpfile(struct inode
*inode
, struct inode
*dir
)
652 down_write(&F2FS_I(inode
)->i_sem
);
653 page
= init_inode_metadata(inode
, dir
, NULL
, NULL
);
658 /* we don't need to mark_inode_dirty now */
659 update_inode(inode
, page
);
660 f2fs_put_page(page
, 1);
662 clear_inode_flag(F2FS_I(inode
), FI_NEW_INODE
);
664 up_write(&F2FS_I(inode
)->i_sem
);
665 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
669 void f2fs_drop_nlink(struct inode
*dir
, struct inode
*inode
, struct page
*page
)
671 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
673 down_write(&F2FS_I(inode
)->i_sem
);
675 if (S_ISDIR(inode
->i_mode
)) {
678 update_inode(dir
, page
);
680 update_inode_page(dir
);
682 inode
->i_ctime
= CURRENT_TIME
;
685 if (S_ISDIR(inode
->i_mode
)) {
687 i_size_write(inode
, 0);
689 up_write(&F2FS_I(inode
)->i_sem
);
690 update_inode_page(inode
);
692 if (inode
->i_nlink
== 0)
693 add_orphan_inode(sbi
, inode
->i_ino
);
695 release_orphan_inode(sbi
);
699 * It only removes the dentry from the dentry page, corresponding name
700 * entry in name page does not need to be touched during deletion.
702 void f2fs_delete_entry(struct f2fs_dir_entry
*dentry
, struct page
*page
,
703 struct inode
*dir
, struct inode
*inode
)
705 struct f2fs_dentry_block
*dentry_blk
;
706 unsigned int bit_pos
;
707 int slots
= GET_DENTRY_SLOTS(le16_to_cpu(dentry
->name_len
));
710 f2fs_update_time(F2FS_I_SB(dir
), REQ_TIME
);
712 if (f2fs_has_inline_dentry(dir
))
713 return f2fs_delete_inline_entry(dentry
, page
, dir
, inode
);
716 f2fs_wait_on_page_writeback(page
, DATA
, true);
718 dentry_blk
= page_address(page
);
719 bit_pos
= dentry
- dentry_blk
->dentry
;
720 for (i
= 0; i
< slots
; i
++)
721 clear_bit_le(bit_pos
+ i
, &dentry_blk
->dentry_bitmap
);
723 /* Let's check and deallocate this dentry page */
724 bit_pos
= find_next_bit_le(&dentry_blk
->dentry_bitmap
,
727 kunmap(page
); /* kunmap - pair of f2fs_find_entry */
728 set_page_dirty(page
);
730 dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
733 f2fs_drop_nlink(dir
, inode
, NULL
);
735 if (bit_pos
== NR_DENTRY_IN_BLOCK
&&
736 !truncate_hole(dir
, page
->index
, page
->index
+ 1)) {
737 clear_page_dirty_for_io(page
);
738 ClearPagePrivate(page
);
739 ClearPageUptodate(page
);
740 inode_dec_dirty_pages(dir
);
742 f2fs_put_page(page
, 1);
745 bool f2fs_empty_dir(struct inode
*dir
)
748 struct page
*dentry_page
;
749 unsigned int bit_pos
;
750 struct f2fs_dentry_block
*dentry_blk
;
751 unsigned long nblock
= dir_blocks(dir
);
753 if (f2fs_has_inline_dentry(dir
))
754 return f2fs_empty_inline_dir(dir
);
756 for (bidx
= 0; bidx
< nblock
; bidx
++) {
757 dentry_page
= get_lock_data_page(dir
, bidx
, false);
758 if (IS_ERR(dentry_page
)) {
759 if (PTR_ERR(dentry_page
) == -ENOENT
)
765 dentry_blk
= kmap_atomic(dentry_page
);
770 bit_pos
= find_next_bit_le(&dentry_blk
->dentry_bitmap
,
773 kunmap_atomic(dentry_blk
);
775 f2fs_put_page(dentry_page
, 1);
777 if (bit_pos
< NR_DENTRY_IN_BLOCK
)
783 bool f2fs_fill_dentries(struct dir_context
*ctx
, struct f2fs_dentry_ptr
*d
,
784 unsigned int start_pos
, struct fscrypt_str
*fstr
)
786 unsigned char d_type
= DT_UNKNOWN
;
787 unsigned int bit_pos
;
788 struct f2fs_dir_entry
*de
= NULL
;
789 struct fscrypt_str de_name
= FSTR_INIT(NULL
, 0);
791 bit_pos
= ((unsigned long)ctx
->pos
% d
->max
);
793 while (bit_pos
< d
->max
) {
794 bit_pos
= find_next_bit_le(d
->bitmap
, d
->max
, bit_pos
);
795 if (bit_pos
>= d
->max
)
798 de
= &d
->dentry
[bit_pos
];
799 if (de
->name_len
== 0) {
801 ctx
->pos
= start_pos
+ bit_pos
;
805 if (de
->file_type
< F2FS_FT_MAX
)
806 d_type
= f2fs_filetype_table
[de
->file_type
];
810 de_name
.name
= d
->filename
[bit_pos
];
811 de_name
.len
= le16_to_cpu(de
->name_len
);
813 if (f2fs_encrypted_inode(d
->inode
)) {
814 int save_len
= fstr
->len
;
817 de_name
.name
= kmalloc(de_name
.len
, GFP_NOFS
);
821 memcpy(de_name
.name
, d
->filename
[bit_pos
], de_name
.len
);
823 ret
= fscrypt_fname_disk_to_usr(d
->inode
,
824 (u32
)de
->hash_code
, 0,
831 fstr
->len
= save_len
;
834 if (!dir_emit(ctx
, de_name
.name
, de_name
.len
,
835 le32_to_cpu(de
->ino
), d_type
))
838 bit_pos
+= GET_DENTRY_SLOTS(le16_to_cpu(de
->name_len
));
839 ctx
->pos
= start_pos
+ bit_pos
;
844 static int f2fs_readdir(struct file
*file
, struct dir_context
*ctx
)
846 struct inode
*inode
= file_inode(file
);
847 unsigned long npages
= dir_blocks(inode
);
848 struct f2fs_dentry_block
*dentry_blk
= NULL
;
849 struct page
*dentry_page
= NULL
;
850 struct file_ra_state
*ra
= &file
->f_ra
;
851 unsigned int n
= ((unsigned long)ctx
->pos
/ NR_DENTRY_IN_BLOCK
);
852 struct f2fs_dentry_ptr d
;
853 struct fscrypt_str fstr
= FSTR_INIT(NULL
, 0);
856 if (f2fs_encrypted_inode(inode
)) {
857 err
= fscrypt_get_encryption_info(inode
);
858 if (err
&& err
!= -ENOKEY
)
861 err
= fscrypt_fname_alloc_buffer(inode
, F2FS_NAME_LEN
, &fstr
);
866 if (f2fs_has_inline_dentry(inode
)) {
867 err
= f2fs_read_inline_dir(file
, ctx
, &fstr
);
871 /* readahead for multi pages of dir */
872 if (npages
- n
> 1 && !ra_has_index(ra
, n
))
873 page_cache_sync_readahead(inode
->i_mapping
, ra
, file
, n
,
874 min(npages
- n
, (pgoff_t
)MAX_DIR_RA_PAGES
));
876 for (; n
< npages
; n
++) {
877 dentry_page
= get_lock_data_page(inode
, n
, false);
878 if (IS_ERR(dentry_page
)) {
879 err
= PTR_ERR(dentry_page
);
886 dentry_blk
= kmap(dentry_page
);
888 make_dentry_ptr(inode
, &d
, (void *)dentry_blk
, 1);
890 if (f2fs_fill_dentries(ctx
, &d
, n
* NR_DENTRY_IN_BLOCK
, &fstr
)) {
892 f2fs_put_page(dentry_page
, 1);
896 ctx
->pos
= (n
+ 1) * NR_DENTRY_IN_BLOCK
;
898 f2fs_put_page(dentry_page
, 1);
901 fscrypt_fname_free_buffer(&fstr
);
905 static int f2fs_dir_open(struct inode
*inode
, struct file
*filp
)
907 if (f2fs_encrypted_inode(inode
))
908 return fscrypt_get_encryption_info(inode
) ? -EACCES
: 0;
912 const struct file_operations f2fs_dir_operations
= {
913 .llseek
= generic_file_llseek
,
914 .read
= generic_read_dir
,
915 .iterate
= f2fs_readdir
,
916 .fsync
= f2fs_sync_file
,
917 .open
= f2fs_dir_open
,
918 .unlocked_ioctl
= f2fs_ioctl
,
920 .compat_ioctl
= f2fs_compat_ioctl
,