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 bool early_match_name(size_t namelen
, f2fs_hash_t namehash
,
80 struct f2fs_dir_entry
*de
)
82 if (le16_to_cpu(de
->name_len
) != namelen
)
85 if (de
->hash_code
!= namehash
)
91 static struct f2fs_dir_entry
*find_in_block(struct page
*dentry_page
,
92 struct qstr
*name
, int *max_slots
,
93 struct page
**res_page
)
95 struct f2fs_dentry_block
*dentry_blk
;
96 struct f2fs_dir_entry
*de
;
97 struct f2fs_dentry_ptr d
;
99 dentry_blk
= (struct f2fs_dentry_block
*)kmap(dentry_page
);
101 make_dentry_ptr(&d
, (void *)dentry_blk
, 1);
102 de
= find_target_dentry(name
, max_slots
, &d
);
105 *res_page
= dentry_page
;
110 * For the most part, it should be a bug when name_len is zero.
111 * We stop here for figuring out where the bugs has occurred.
113 f2fs_bug_on(F2FS_P_SB(dentry_page
), d
.max
< 0);
117 struct f2fs_dir_entry
*find_target_dentry(struct qstr
*name
, int *max_slots
,
118 struct f2fs_dentry_ptr
*d
)
120 struct f2fs_dir_entry
*de
;
121 unsigned long bit_pos
= 0;
122 f2fs_hash_t namehash
= f2fs_dentry_hash(name
);
127 while (bit_pos
< d
->max
) {
128 if (!test_bit_le(bit_pos
, d
->bitmap
)) {
134 de
= &d
->dentry
[bit_pos
];
135 if (early_match_name(name
->len
, namehash
, de
) &&
136 !memcmp(d
->filename
[bit_pos
], name
->name
, name
->len
))
139 if (max_slots
&& max_len
> *max_slots
)
140 *max_slots
= max_len
;
143 /* remain bug on condition */
144 if (unlikely(!de
->name_len
))
147 bit_pos
+= GET_DENTRY_SLOTS(le16_to_cpu(de
->name_len
));
152 if (max_slots
&& max_len
> *max_slots
)
153 *max_slots
= max_len
;
157 static struct f2fs_dir_entry
*find_in_level(struct inode
*dir
,
158 unsigned int level
, struct qstr
*name
,
159 f2fs_hash_t namehash
, struct page
**res_page
)
161 int s
= GET_DENTRY_SLOTS(name
->len
);
162 unsigned int nbucket
, nblock
;
163 unsigned int bidx
, end_block
;
164 struct page
*dentry_page
;
165 struct f2fs_dir_entry
*de
= NULL
;
169 f2fs_bug_on(F2FS_I_SB(dir
), level
> MAX_DIR_HASH_DEPTH
);
171 nbucket
= dir_buckets(level
, F2FS_I(dir
)->i_dir_level
);
172 nblock
= bucket_blocks(level
);
174 bidx
= dir_block_index(level
, F2FS_I(dir
)->i_dir_level
,
175 le32_to_cpu(namehash
) % nbucket
);
176 end_block
= bidx
+ nblock
;
178 for (; bidx
< end_block
; bidx
++) {
179 /* no need to allocate new dentry pages to all the indices */
180 dentry_page
= find_data_page(dir
, bidx
, true);
181 if (IS_ERR(dentry_page
)) {
186 de
= find_in_block(dentry_page
, name
, &max_slots
, res_page
);
192 f2fs_put_page(dentry_page
, 0);
195 if (!de
&& room
&& F2FS_I(dir
)->chash
!= namehash
) {
196 F2FS_I(dir
)->chash
= namehash
;
197 F2FS_I(dir
)->clevel
= level
;
204 * Find an entry in the specified directory with the wanted name.
205 * It returns the page where the entry was found (as a parameter - res_page),
206 * and the entry itself. Page is returned mapped and unlocked.
207 * Entry is guaranteed to be valid.
209 struct f2fs_dir_entry
*f2fs_find_entry(struct inode
*dir
,
210 struct qstr
*child
, struct page
**res_page
)
212 unsigned long npages
= dir_blocks(dir
);
213 struct f2fs_dir_entry
*de
= NULL
;
214 f2fs_hash_t name_hash
;
215 unsigned int max_depth
;
220 if (f2fs_has_inline_dentry(dir
))
221 return find_in_inline_dir(dir
, child
, res_page
);
226 name_hash
= f2fs_dentry_hash(child
);
227 max_depth
= F2FS_I(dir
)->i_current_depth
;
229 for (level
= 0; level
< max_depth
; level
++) {
230 de
= find_in_level(dir
, level
, child
, name_hash
, res_page
);
234 if (!de
&& F2FS_I(dir
)->chash
!= name_hash
) {
235 F2FS_I(dir
)->chash
= name_hash
;
236 F2FS_I(dir
)->clevel
= level
- 1;
241 struct f2fs_dir_entry
*f2fs_parent_dir(struct inode
*dir
, struct page
**p
)
244 struct f2fs_dir_entry
*de
;
245 struct f2fs_dentry_block
*dentry_blk
;
247 if (f2fs_has_inline_dentry(dir
))
248 return f2fs_parent_inline_dir(dir
, p
);
250 page
= get_lock_data_page(dir
, 0);
254 dentry_blk
= kmap(page
);
255 de
= &dentry_blk
->dentry
[1];
261 ino_t
f2fs_inode_by_name(struct inode
*dir
, struct qstr
*qstr
)
264 struct f2fs_dir_entry
*de
;
267 de
= f2fs_find_entry(dir
, qstr
, &page
);
269 res
= le32_to_cpu(de
->ino
);
270 f2fs_dentry_kunmap(dir
, page
);
271 f2fs_put_page(page
, 0);
277 void f2fs_set_link(struct inode
*dir
, struct f2fs_dir_entry
*de
,
278 struct page
*page
, struct inode
*inode
)
280 enum page_type type
= f2fs_has_inline_dentry(dir
) ? NODE
: DATA
;
282 f2fs_wait_on_page_writeback(page
, type
);
283 de
->ino
= cpu_to_le32(inode
->i_ino
);
284 set_de_type(de
, inode
->i_mode
);
285 f2fs_dentry_kunmap(dir
, page
);
286 set_page_dirty(page
);
287 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
288 mark_inode_dirty(dir
);
290 f2fs_put_page(page
, 1);
293 static void init_dent_inode(const struct qstr
*name
, struct page
*ipage
)
295 struct f2fs_inode
*ri
;
297 f2fs_wait_on_page_writeback(ipage
, NODE
);
299 /* copy name info. to this inode page */
300 ri
= F2FS_INODE(ipage
);
301 ri
->i_namelen
= cpu_to_le32(name
->len
);
302 memcpy(ri
->i_name
, name
->name
, name
->len
);
303 set_page_dirty(ipage
);
306 int update_dent_inode(struct inode
*inode
, const struct qstr
*name
)
310 page
= get_node_page(F2FS_I_SB(inode
), inode
->i_ino
);
312 return PTR_ERR(page
);
314 init_dent_inode(name
, page
);
315 f2fs_put_page(page
, 1);
320 void do_make_empty_dir(struct inode
*inode
, struct inode
*parent
,
321 struct f2fs_dentry_ptr
*d
)
323 struct f2fs_dir_entry
*de
;
326 de
->name_len
= cpu_to_le16(1);
328 de
->ino
= cpu_to_le32(inode
->i_ino
);
329 memcpy(d
->filename
[0], ".", 1);
330 set_de_type(de
, inode
->i_mode
);
334 de
->name_len
= cpu_to_le16(2);
335 de
->ino
= cpu_to_le32(parent
->i_ino
);
336 memcpy(d
->filename
[1], "..", 2);
337 set_de_type(de
, parent
->i_mode
);
339 test_and_set_bit_le(0, (void *)d
->bitmap
);
340 test_and_set_bit_le(1, (void *)d
->bitmap
);
343 static int make_empty_dir(struct inode
*inode
,
344 struct inode
*parent
, struct page
*page
)
346 struct page
*dentry_page
;
347 struct f2fs_dentry_block
*dentry_blk
;
348 struct f2fs_dentry_ptr d
;
350 if (f2fs_has_inline_dentry(inode
))
351 return make_empty_inline_dir(inode
, parent
, page
);
353 dentry_page
= get_new_data_page(inode
, page
, 0, true);
354 if (IS_ERR(dentry_page
))
355 return PTR_ERR(dentry_page
);
357 dentry_blk
= kmap_atomic(dentry_page
);
359 make_dentry_ptr(&d
, (void *)dentry_blk
, 1);
360 do_make_empty_dir(inode
, parent
, &d
);
362 kunmap_atomic(dentry_blk
);
364 set_page_dirty(dentry_page
);
365 f2fs_put_page(dentry_page
, 1);
369 struct page
*init_inode_metadata(struct inode
*inode
, struct inode
*dir
,
370 const struct qstr
*name
, struct page
*dpage
)
375 if (is_inode_flag_set(F2FS_I(inode
), FI_NEW_INODE
)) {
376 page
= new_inode_page(inode
);
380 if (S_ISDIR(inode
->i_mode
)) {
381 err
= make_empty_dir(inode
, dir
, page
);
386 err
= f2fs_init_acl(inode
, dir
, page
, dpage
);
390 err
= f2fs_init_security(inode
, dir
, name
, page
);
394 page
= get_node_page(F2FS_I_SB(dir
), inode
->i_ino
);
398 set_cold_node(inode
, page
);
402 init_dent_inode(name
, page
);
405 * This file should be checkpointed during fsync.
406 * We lost i_pino from now on.
408 if (is_inode_flag_set(F2FS_I(inode
), FI_INC_LINK
)) {
409 file_lost_pino(inode
);
411 * If link the tmpfile to alias through linkat path,
412 * we should remove this inode from orphan list.
414 if (inode
->i_nlink
== 0)
415 remove_orphan_inode(F2FS_I_SB(dir
), inode
->i_ino
);
421 f2fs_put_page(page
, 1);
423 /* once the failed inode becomes a bad inode, i_mode is S_IFREG */
424 truncate_inode_pages(&inode
->i_data
, 0);
425 truncate_blocks(inode
, 0, false);
426 remove_dirty_dir_inode(inode
);
427 remove_inode_page(inode
);
431 void update_parent_metadata(struct inode
*dir
, struct inode
*inode
,
432 unsigned int current_depth
)
434 if (inode
&& is_inode_flag_set(F2FS_I(inode
), FI_NEW_INODE
)) {
435 if (S_ISDIR(inode
->i_mode
)) {
437 set_inode_flag(F2FS_I(dir
), FI_UPDATE_DIR
);
439 clear_inode_flag(F2FS_I(inode
), FI_NEW_INODE
);
441 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
442 mark_inode_dirty(dir
);
444 if (F2FS_I(dir
)->i_current_depth
!= current_depth
) {
445 F2FS_I(dir
)->i_current_depth
= current_depth
;
446 set_inode_flag(F2FS_I(dir
), FI_UPDATE_DIR
);
449 if (inode
&& is_inode_flag_set(F2FS_I(inode
), FI_INC_LINK
))
450 clear_inode_flag(F2FS_I(inode
), FI_INC_LINK
);
453 int room_for_filename(const void *bitmap
, int slots
, int max_slots
)
456 int zero_start
, zero_end
;
458 zero_start
= find_next_zero_bit_le(bitmap
, max_slots
, bit_start
);
459 if (zero_start
>= max_slots
)
462 zero_end
= find_next_bit_le(bitmap
, max_slots
, zero_start
);
463 if (zero_end
- zero_start
>= slots
)
466 bit_start
= zero_end
+ 1;
468 if (zero_end
+ 1 >= max_slots
)
473 void f2fs_update_dentry(nid_t ino
, umode_t mode
, struct f2fs_dentry_ptr
*d
,
474 const struct qstr
*name
, f2fs_hash_t name_hash
,
475 unsigned int bit_pos
)
477 struct f2fs_dir_entry
*de
;
478 int slots
= GET_DENTRY_SLOTS(name
->len
);
481 de
= &d
->dentry
[bit_pos
];
482 de
->hash_code
= name_hash
;
483 de
->name_len
= cpu_to_le16(name
->len
);
484 memcpy(d
->filename
[bit_pos
], name
->name
, name
->len
);
485 de
->ino
= cpu_to_le32(ino
);
486 set_de_type(de
, mode
);
487 for (i
= 0; i
< slots
; i
++)
488 test_and_set_bit_le(bit_pos
+ i
, (void *)d
->bitmap
);
492 * Caller should grab and release a rwsem by calling f2fs_lock_op() and
495 int __f2fs_add_link(struct inode
*dir
, const struct qstr
*name
,
496 struct inode
*inode
, nid_t ino
, umode_t mode
)
498 unsigned int bit_pos
;
500 unsigned int current_depth
;
501 unsigned long bidx
, block
;
502 f2fs_hash_t dentry_hash
;
503 unsigned int nbucket
, nblock
;
504 size_t namelen
= name
->len
;
505 struct page
*dentry_page
= NULL
;
506 struct f2fs_dentry_block
*dentry_blk
= NULL
;
507 struct f2fs_dentry_ptr d
;
508 int slots
= GET_DENTRY_SLOTS(namelen
);
509 struct page
*page
= NULL
;
512 if (f2fs_has_inline_dentry(dir
)) {
513 err
= f2fs_add_inline_entry(dir
, name
, inode
, ino
, mode
);
514 if (!err
|| err
!= -EAGAIN
)
520 dentry_hash
= f2fs_dentry_hash(name
);
522 current_depth
= F2FS_I(dir
)->i_current_depth
;
523 if (F2FS_I(dir
)->chash
== dentry_hash
) {
524 level
= F2FS_I(dir
)->clevel
;
525 F2FS_I(dir
)->chash
= 0;
529 if (unlikely(current_depth
== MAX_DIR_HASH_DEPTH
))
532 /* Increase the depth, if required */
533 if (level
== current_depth
)
536 nbucket
= dir_buckets(level
, F2FS_I(dir
)->i_dir_level
);
537 nblock
= bucket_blocks(level
);
539 bidx
= dir_block_index(level
, F2FS_I(dir
)->i_dir_level
,
540 (le32_to_cpu(dentry_hash
) % nbucket
));
542 for (block
= bidx
; block
<= (bidx
+ nblock
- 1); block
++) {
543 dentry_page
= get_new_data_page(dir
, NULL
, block
, true);
544 if (IS_ERR(dentry_page
))
545 return PTR_ERR(dentry_page
);
547 dentry_blk
= kmap(dentry_page
);
548 bit_pos
= room_for_filename(&dentry_blk
->dentry_bitmap
,
549 slots
, NR_DENTRY_IN_BLOCK
);
550 if (bit_pos
< NR_DENTRY_IN_BLOCK
)
554 f2fs_put_page(dentry_page
, 1);
557 /* Move to next level to find the empty slot for new dentry */
561 f2fs_wait_on_page_writeback(dentry_page
, DATA
);
564 down_write(&F2FS_I(inode
)->i_sem
);
565 page
= init_inode_metadata(inode
, dir
, name
, NULL
);
572 make_dentry_ptr(&d
, (void *)dentry_blk
, 1);
573 f2fs_update_dentry(ino
, mode
, &d
, name
, dentry_hash
, bit_pos
);
575 set_page_dirty(dentry_page
);
578 /* we don't need to mark_inode_dirty now */
579 F2FS_I(inode
)->i_pino
= dir
->i_ino
;
580 update_inode(inode
, page
);
581 f2fs_put_page(page
, 1);
584 update_parent_metadata(dir
, inode
, current_depth
);
587 up_write(&F2FS_I(inode
)->i_sem
);
589 if (is_inode_flag_set(F2FS_I(dir
), FI_UPDATE_DIR
)) {
590 update_inode_page(dir
);
591 clear_inode_flag(F2FS_I(dir
), FI_UPDATE_DIR
);
594 f2fs_put_page(dentry_page
, 1);
598 int f2fs_do_tmpfile(struct inode
*inode
, struct inode
*dir
)
603 down_write(&F2FS_I(inode
)->i_sem
);
604 page
= init_inode_metadata(inode
, dir
, NULL
, NULL
);
609 /* we don't need to mark_inode_dirty now */
610 update_inode(inode
, page
);
611 f2fs_put_page(page
, 1);
613 clear_inode_flag(F2FS_I(inode
), FI_NEW_INODE
);
615 up_write(&F2FS_I(inode
)->i_sem
);
619 void f2fs_drop_nlink(struct inode
*dir
, struct inode
*inode
, struct page
*page
)
621 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
623 down_write(&F2FS_I(inode
)->i_sem
);
625 if (S_ISDIR(inode
->i_mode
)) {
628 update_inode(dir
, page
);
630 update_inode_page(dir
);
632 inode
->i_ctime
= CURRENT_TIME
;
635 if (S_ISDIR(inode
->i_mode
)) {
637 i_size_write(inode
, 0);
639 up_write(&F2FS_I(inode
)->i_sem
);
640 update_inode_page(inode
);
642 if (inode
->i_nlink
== 0)
643 add_orphan_inode(sbi
, inode
->i_ino
);
645 release_orphan_inode(sbi
);
649 * It only removes the dentry from the dentry page, corresponding name
650 * entry in name page does not need to be touched during deletion.
652 void f2fs_delete_entry(struct f2fs_dir_entry
*dentry
, struct page
*page
,
653 struct inode
*dir
, struct inode
*inode
)
655 struct f2fs_dentry_block
*dentry_blk
;
656 unsigned int bit_pos
;
657 int slots
= GET_DENTRY_SLOTS(le16_to_cpu(dentry
->name_len
));
660 if (f2fs_has_inline_dentry(dir
))
661 return f2fs_delete_inline_entry(dentry
, page
, dir
, inode
);
664 f2fs_wait_on_page_writeback(page
, DATA
);
666 dentry_blk
= page_address(page
);
667 bit_pos
= dentry
- dentry_blk
->dentry
;
668 for (i
= 0; i
< slots
; i
++)
669 clear_bit_le(bit_pos
+ i
, &dentry_blk
->dentry_bitmap
);
671 /* Let's check and deallocate this dentry page */
672 bit_pos
= find_next_bit_le(&dentry_blk
->dentry_bitmap
,
675 kunmap(page
); /* kunmap - pair of f2fs_find_entry */
676 set_page_dirty(page
);
678 dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
681 f2fs_drop_nlink(dir
, inode
, NULL
);
683 if (bit_pos
== NR_DENTRY_IN_BLOCK
) {
684 truncate_hole(dir
, page
->index
, page
->index
+ 1);
685 clear_page_dirty_for_io(page
);
686 ClearPagePrivate(page
);
687 ClearPageUptodate(page
);
688 inode_dec_dirty_pages(dir
);
690 f2fs_put_page(page
, 1);
693 bool f2fs_empty_dir(struct inode
*dir
)
696 struct page
*dentry_page
;
697 unsigned int bit_pos
;
698 struct f2fs_dentry_block
*dentry_blk
;
699 unsigned long nblock
= dir_blocks(dir
);
701 if (f2fs_has_inline_dentry(dir
))
702 return f2fs_empty_inline_dir(dir
);
704 for (bidx
= 0; bidx
< nblock
; bidx
++) {
705 dentry_page
= get_lock_data_page(dir
, bidx
);
706 if (IS_ERR(dentry_page
)) {
707 if (PTR_ERR(dentry_page
) == -ENOENT
)
713 dentry_blk
= kmap_atomic(dentry_page
);
718 bit_pos
= find_next_bit_le(&dentry_blk
->dentry_bitmap
,
721 kunmap_atomic(dentry_blk
);
723 f2fs_put_page(dentry_page
, 1);
725 if (bit_pos
< NR_DENTRY_IN_BLOCK
)
731 bool f2fs_fill_dentries(struct dir_context
*ctx
, struct f2fs_dentry_ptr
*d
,
732 unsigned int start_pos
)
734 unsigned char d_type
= DT_UNKNOWN
;
735 unsigned int bit_pos
;
736 struct f2fs_dir_entry
*de
= NULL
;
738 bit_pos
= ((unsigned long)ctx
->pos
% d
->max
);
740 while (bit_pos
< d
->max
) {
741 bit_pos
= find_next_bit_le(d
->bitmap
, d
->max
, bit_pos
);
742 if (bit_pos
>= d
->max
)
745 de
= &d
->dentry
[bit_pos
];
746 if (de
->file_type
< F2FS_FT_MAX
)
747 d_type
= f2fs_filetype_table
[de
->file_type
];
750 if (!dir_emit(ctx
, d
->filename
[bit_pos
],
751 le16_to_cpu(de
->name_len
),
752 le32_to_cpu(de
->ino
), d_type
))
755 bit_pos
+= GET_DENTRY_SLOTS(le16_to_cpu(de
->name_len
));
756 ctx
->pos
= start_pos
+ bit_pos
;
761 static int f2fs_readdir(struct file
*file
, struct dir_context
*ctx
)
763 struct inode
*inode
= file_inode(file
);
764 unsigned long npages
= dir_blocks(inode
);
765 struct f2fs_dentry_block
*dentry_blk
= NULL
;
766 struct page
*dentry_page
= NULL
;
767 struct file_ra_state
*ra
= &file
->f_ra
;
768 unsigned int n
= ((unsigned long)ctx
->pos
/ NR_DENTRY_IN_BLOCK
);
769 struct f2fs_dentry_ptr d
;
771 if (f2fs_has_inline_dentry(inode
))
772 return f2fs_read_inline_dir(file
, ctx
);
774 /* readahead for multi pages of dir */
775 if (npages
- n
> 1 && !ra_has_index(ra
, n
))
776 page_cache_sync_readahead(inode
->i_mapping
, ra
, file
, n
,
777 min(npages
- n
, (pgoff_t
)MAX_DIR_RA_PAGES
));
779 for (; n
< npages
; n
++) {
780 dentry_page
= get_lock_data_page(inode
, n
);
781 if (IS_ERR(dentry_page
))
784 dentry_blk
= kmap(dentry_page
);
786 make_dentry_ptr(&d
, (void *)dentry_blk
, 1);
788 if (f2fs_fill_dentries(ctx
, &d
, n
* NR_DENTRY_IN_BLOCK
))
791 ctx
->pos
= (n
+ 1) * NR_DENTRY_IN_BLOCK
;
793 f2fs_put_page(dentry_page
, 1);
797 if (dentry_page
&& !IS_ERR(dentry_page
)) {
799 f2fs_put_page(dentry_page
, 1);
805 const struct file_operations f2fs_dir_operations
= {
806 .llseek
= generic_file_llseek
,
807 .read
= generic_read_dir
,
808 .iterate
= f2fs_readdir
,
809 .fsync
= f2fs_sync_file
,
810 .unlocked_ioctl
= f2fs_ioctl
,