1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
9 #include <linux/f2fs_fs.h>
10 #include <linux/sched/signal.h>
11 #include <linux/unicode.h>
16 #include <trace/events/f2fs.h>
18 static unsigned long dir_blocks(struct inode
*inode
)
20 return ((unsigned long long) (i_size_read(inode
) + PAGE_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 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
,
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
,
61 static void set_de_type(struct f2fs_dir_entry
*de
, umode_t mode
)
63 de
->file_type
= f2fs_type_by_mode
[(mode
& S_IFMT
) >> S_SHIFT
];
66 unsigned char f2fs_get_de_type(struct f2fs_dir_entry
*de
)
68 if (de
->file_type
< F2FS_FT_MAX
)
69 return f2fs_filetype_table
[de
->file_type
];
73 /* If @dir is casefolded, initialize @fname->cf_name from @fname->usr_fname. */
74 int f2fs_init_casefolded_name(const struct inode
*dir
,
75 struct f2fs_filename
*fname
)
78 struct f2fs_sb_info
*sbi
= F2FS_SB(dir
->i_sb
);
80 if (IS_CASEFOLDED(dir
)) {
81 fname
->cf_name
.name
= f2fs_kmalloc(sbi
, F2FS_NAME_LEN
,
83 if (!fname
->cf_name
.name
)
85 fname
->cf_name
.len
= utf8_casefold(sbi
->s_encoding
,
89 if ((int)fname
->cf_name
.len
<= 0) {
90 kfree(fname
->cf_name
.name
);
91 fname
->cf_name
.name
= NULL
;
92 if (f2fs_has_strict_mode(sbi
))
94 /* fall back to treating name as opaque byte sequence */
101 static int __f2fs_setup_filename(const struct inode
*dir
,
102 const struct fscrypt_name
*crypt_name
,
103 struct f2fs_filename
*fname
)
107 memset(fname
, 0, sizeof(*fname
));
109 fname
->usr_fname
= crypt_name
->usr_fname
;
110 fname
->disk_name
= crypt_name
->disk_name
;
111 #ifdef CONFIG_FS_ENCRYPTION
112 fname
->crypto_buf
= crypt_name
->crypto_buf
;
114 if (crypt_name
->is_ciphertext_name
) {
115 /* hash was decoded from the no-key name */
116 fname
->hash
= cpu_to_le32(crypt_name
->hash
);
118 err
= f2fs_init_casefolded_name(dir
, fname
);
120 f2fs_free_filename(fname
);
123 f2fs_hash_filename(dir
, fname
);
129 * Prepare to search for @iname in @dir. This is similar to
130 * fscrypt_setup_filename(), but this also handles computing the casefolded name
131 * and the f2fs dirhash if needed, then packing all the information about this
132 * filename up into a 'struct f2fs_filename'.
134 int f2fs_setup_filename(struct inode
*dir
, const struct qstr
*iname
,
135 int lookup
, struct f2fs_filename
*fname
)
137 struct fscrypt_name crypt_name
;
140 err
= fscrypt_setup_filename(dir
, iname
, lookup
, &crypt_name
);
144 return __f2fs_setup_filename(dir
, &crypt_name
, fname
);
148 * Prepare to look up @dentry in @dir. This is similar to
149 * fscrypt_prepare_lookup(), but this also handles computing the casefolded name
150 * and the f2fs dirhash if needed, then packing all the information about this
151 * filename up into a 'struct f2fs_filename'.
153 int f2fs_prepare_lookup(struct inode
*dir
, struct dentry
*dentry
,
154 struct f2fs_filename
*fname
)
156 struct fscrypt_name crypt_name
;
159 err
= fscrypt_prepare_lookup(dir
, dentry
, &crypt_name
);
163 return __f2fs_setup_filename(dir
, &crypt_name
, fname
);
166 void f2fs_free_filename(struct f2fs_filename
*fname
)
168 #ifdef CONFIG_FS_ENCRYPTION
169 kfree(fname
->crypto_buf
.name
);
170 fname
->crypto_buf
.name
= NULL
;
172 #ifdef CONFIG_UNICODE
173 kfree(fname
->cf_name
.name
);
174 fname
->cf_name
.name
= NULL
;
178 static unsigned long dir_block_index(unsigned int level
,
179 int dir_level
, unsigned int idx
)
182 unsigned long bidx
= 0;
184 for (i
= 0; i
< level
; i
++)
185 bidx
+= dir_buckets(i
, dir_level
) * bucket_blocks(i
);
186 bidx
+= idx
* bucket_blocks(level
);
190 static struct f2fs_dir_entry
*find_in_block(struct inode
*dir
,
191 struct page
*dentry_page
,
192 const struct f2fs_filename
*fname
,
194 struct page
**res_page
)
196 struct f2fs_dentry_block
*dentry_blk
;
197 struct f2fs_dir_entry
*de
;
198 struct f2fs_dentry_ptr d
;
200 dentry_blk
= (struct f2fs_dentry_block
*)page_address(dentry_page
);
202 make_dentry_ptr_block(dir
, &d
, dentry_blk
);
203 de
= f2fs_find_target_dentry(&d
, fname
, max_slots
);
205 *res_page
= dentry_page
;
210 #ifdef CONFIG_UNICODE
212 * Test whether a case-insensitive directory entry matches the filename
213 * being searched for.
215 static bool f2fs_match_ci_name(const struct inode
*dir
, const struct qstr
*name
,
216 const u8
*de_name
, u32 de_name_len
)
218 const struct f2fs_sb_info
*sbi
= F2FS_SB(dir
->i_sb
);
219 const struct unicode_map
*um
= sbi
->s_encoding
;
220 struct qstr entry
= QSTR_INIT(de_name
, de_name_len
);
223 res
= utf8_strncasecmp_folded(um
, name
, &entry
);
226 * In strict mode, ignore invalid names. In non-strict mode,
227 * fall back to treating them as opaque byte sequences.
229 if (f2fs_has_strict_mode(sbi
) || name
->len
!= entry
.len
)
231 return !memcmp(name
->name
, entry
.name
, name
->len
);
235 #endif /* CONFIG_UNICODE */
237 static inline bool f2fs_match_name(const struct inode
*dir
,
238 const struct f2fs_filename
*fname
,
239 const u8
*de_name
, u32 de_name_len
)
241 struct fscrypt_name f
;
243 #ifdef CONFIG_UNICODE
244 if (fname
->cf_name
.name
) {
245 struct qstr cf
= FSTR_TO_QSTR(&fname
->cf_name
);
247 return f2fs_match_ci_name(dir
, &cf
, de_name
, de_name_len
);
250 f
.usr_fname
= fname
->usr_fname
;
251 f
.disk_name
= fname
->disk_name
;
252 #ifdef CONFIG_FS_ENCRYPTION
253 f
.crypto_buf
= fname
->crypto_buf
;
255 return fscrypt_match_name(&f
, de_name
, de_name_len
);
258 struct f2fs_dir_entry
*f2fs_find_target_dentry(const struct f2fs_dentry_ptr
*d
,
259 const struct f2fs_filename
*fname
, int *max_slots
)
261 struct f2fs_dir_entry
*de
;
262 unsigned long bit_pos
= 0;
267 while (bit_pos
< d
->max
) {
268 if (!test_bit_le(bit_pos
, d
->bitmap
)) {
274 de
= &d
->dentry
[bit_pos
];
276 if (unlikely(!de
->name_len
)) {
281 if (de
->hash_code
== fname
->hash
&&
282 f2fs_match_name(d
->inode
, fname
, d
->filename
[bit_pos
],
283 le16_to_cpu(de
->name_len
)))
286 if (max_slots
&& max_len
> *max_slots
)
287 *max_slots
= max_len
;
290 bit_pos
+= GET_DENTRY_SLOTS(le16_to_cpu(de
->name_len
));
295 if (max_slots
&& max_len
> *max_slots
)
296 *max_slots
= max_len
;
300 static struct f2fs_dir_entry
*find_in_level(struct inode
*dir
,
302 const struct f2fs_filename
*fname
,
303 struct page
**res_page
)
305 int s
= GET_DENTRY_SLOTS(fname
->disk_name
.len
);
306 unsigned int nbucket
, nblock
;
307 unsigned int bidx
, end_block
;
308 struct page
*dentry_page
;
309 struct f2fs_dir_entry
*de
= NULL
;
313 nbucket
= dir_buckets(level
, F2FS_I(dir
)->i_dir_level
);
314 nblock
= bucket_blocks(level
);
316 bidx
= dir_block_index(level
, F2FS_I(dir
)->i_dir_level
,
317 le32_to_cpu(fname
->hash
) % nbucket
);
318 end_block
= bidx
+ nblock
;
320 for (; bidx
< end_block
; bidx
++) {
321 /* no need to allocate new dentry pages to all the indices */
322 dentry_page
= f2fs_find_data_page(dir
, bidx
);
323 if (IS_ERR(dentry_page
)) {
324 if (PTR_ERR(dentry_page
) == -ENOENT
) {
328 *res_page
= dentry_page
;
333 de
= find_in_block(dir
, dentry_page
, fname
, &max_slots
,
340 f2fs_put_page(dentry_page
, 0);
343 if (!de
&& room
&& F2FS_I(dir
)->chash
!= fname
->hash
) {
344 F2FS_I(dir
)->chash
= fname
->hash
;
345 F2FS_I(dir
)->clevel
= level
;
351 struct f2fs_dir_entry
*__f2fs_find_entry(struct inode
*dir
,
352 const struct f2fs_filename
*fname
,
353 struct page
**res_page
)
355 unsigned long npages
= dir_blocks(dir
);
356 struct f2fs_dir_entry
*de
= NULL
;
357 unsigned int max_depth
;
360 if (f2fs_has_inline_dentry(dir
)) {
362 de
= f2fs_find_in_inline_dir(dir
, fname
, res_page
);
371 max_depth
= F2FS_I(dir
)->i_current_depth
;
372 if (unlikely(max_depth
> MAX_DIR_HASH_DEPTH
)) {
373 f2fs_warn(F2FS_I_SB(dir
), "Corrupted max_depth of %lu: %u",
374 dir
->i_ino
, max_depth
);
375 max_depth
= MAX_DIR_HASH_DEPTH
;
376 f2fs_i_depth_write(dir
, max_depth
);
379 for (level
= 0; level
< max_depth
; level
++) {
381 de
= find_in_level(dir
, level
, fname
, res_page
);
382 if (de
|| IS_ERR(*res_page
))
386 /* This is to increase the speed of f2fs_create */
388 F2FS_I(dir
)->task
= current
;
393 * Find an entry in the specified directory with the wanted name.
394 * It returns the page where the entry was found (as a parameter - res_page),
395 * and the entry itself. Page is returned mapped and unlocked.
396 * Entry is guaranteed to be valid.
398 struct f2fs_dir_entry
*f2fs_find_entry(struct inode
*dir
,
399 const struct qstr
*child
, struct page
**res_page
)
401 struct f2fs_dir_entry
*de
= NULL
;
402 struct f2fs_filename fname
;
405 err
= f2fs_setup_filename(dir
, child
, 1, &fname
);
410 *res_page
= ERR_PTR(err
);
414 de
= __f2fs_find_entry(dir
, &fname
, res_page
);
416 f2fs_free_filename(&fname
);
420 struct f2fs_dir_entry
*f2fs_parent_dir(struct inode
*dir
, struct page
**p
)
422 struct qstr dotdot
= QSTR_INIT("..", 2);
424 return f2fs_find_entry(dir
, &dotdot
, p
);
427 ino_t
f2fs_inode_by_name(struct inode
*dir
, const struct qstr
*qstr
,
431 struct f2fs_dir_entry
*de
;
433 de
= f2fs_find_entry(dir
, qstr
, page
);
435 res
= le32_to_cpu(de
->ino
);
436 f2fs_put_page(*page
, 0);
442 void f2fs_set_link(struct inode
*dir
, struct f2fs_dir_entry
*de
,
443 struct page
*page
, struct inode
*inode
)
445 enum page_type type
= f2fs_has_inline_dentry(dir
) ? NODE
: DATA
;
447 f2fs_wait_on_page_writeback(page
, type
, true, true);
448 de
->ino
= cpu_to_le32(inode
->i_ino
);
449 set_de_type(de
, inode
->i_mode
);
450 set_page_dirty(page
);
452 dir
->i_mtime
= dir
->i_ctime
= current_time(dir
);
453 f2fs_mark_inode_dirty_sync(dir
, false);
454 f2fs_put_page(page
, 1);
457 static void init_dent_inode(const struct f2fs_filename
*fname
,
460 struct f2fs_inode
*ri
;
462 f2fs_wait_on_page_writeback(ipage
, NODE
, true, true);
464 /* copy name info. to this inode page */
465 ri
= F2FS_INODE(ipage
);
466 ri
->i_namelen
= cpu_to_le32(fname
->disk_name
.len
);
467 memcpy(ri
->i_name
, fname
->disk_name
.name
, fname
->disk_name
.len
);
468 set_page_dirty(ipage
);
471 void f2fs_do_make_empty_dir(struct inode
*inode
, struct inode
*parent
,
472 struct f2fs_dentry_ptr
*d
)
474 struct fscrypt_str dot
= FSTR_INIT(".", 1);
475 struct fscrypt_str dotdot
= FSTR_INIT("..", 2);
477 /* update dirent of "." */
478 f2fs_update_dentry(inode
->i_ino
, inode
->i_mode
, d
, &dot
, 0, 0);
480 /* update dirent of ".." */
481 f2fs_update_dentry(parent
->i_ino
, parent
->i_mode
, d
, &dotdot
, 0, 1);
484 static int make_empty_dir(struct inode
*inode
,
485 struct inode
*parent
, struct page
*page
)
487 struct page
*dentry_page
;
488 struct f2fs_dentry_block
*dentry_blk
;
489 struct f2fs_dentry_ptr d
;
491 if (f2fs_has_inline_dentry(inode
))
492 return f2fs_make_empty_inline_dir(inode
, parent
, page
);
494 dentry_page
= f2fs_get_new_data_page(inode
, page
, 0, true);
495 if (IS_ERR(dentry_page
))
496 return PTR_ERR(dentry_page
);
498 dentry_blk
= page_address(dentry_page
);
500 make_dentry_ptr_block(NULL
, &d
, dentry_blk
);
501 f2fs_do_make_empty_dir(inode
, parent
, &d
);
503 set_page_dirty(dentry_page
);
504 f2fs_put_page(dentry_page
, 1);
508 struct page
*f2fs_init_inode_metadata(struct inode
*inode
, struct inode
*dir
,
509 const struct f2fs_filename
*fname
, struct page
*dpage
)
514 if (is_inode_flag_set(inode
, FI_NEW_INODE
)) {
515 page
= f2fs_new_inode_page(inode
);
519 if (S_ISDIR(inode
->i_mode
)) {
520 /* in order to handle error case */
522 err
= make_empty_dir(inode
, dir
, page
);
530 err
= f2fs_init_acl(inode
, dir
, page
, dpage
);
534 err
= f2fs_init_security(inode
, dir
,
535 fname
? fname
->usr_fname
: NULL
, page
);
539 if (IS_ENCRYPTED(inode
)) {
540 err
= fscrypt_inherit_context(dir
, inode
, page
, false);
545 page
= f2fs_get_node_page(F2FS_I_SB(dir
), inode
->i_ino
);
551 init_dent_inode(fname
, page
);
552 if (IS_ENCRYPTED(dir
))
553 file_set_enc_name(inode
);
557 * This file should be checkpointed during fsync.
558 * We lost i_pino from now on.
560 if (is_inode_flag_set(inode
, FI_INC_LINK
)) {
561 if (!S_ISDIR(inode
->i_mode
))
562 file_lost_pino(inode
);
564 * If link the tmpfile to alias through linkat path,
565 * we should remove this inode from orphan list.
567 if (inode
->i_nlink
== 0)
568 f2fs_remove_orphan_inode(F2FS_I_SB(dir
), inode
->i_ino
);
569 f2fs_i_links_write(inode
, true);
575 f2fs_update_inode(inode
, page
);
576 f2fs_put_page(page
, 1);
580 void f2fs_update_parent_metadata(struct inode
*dir
, struct inode
*inode
,
581 unsigned int current_depth
)
583 if (inode
&& is_inode_flag_set(inode
, FI_NEW_INODE
)) {
584 if (S_ISDIR(inode
->i_mode
))
585 f2fs_i_links_write(dir
, true);
586 clear_inode_flag(inode
, FI_NEW_INODE
);
588 dir
->i_mtime
= dir
->i_ctime
= current_time(dir
);
589 f2fs_mark_inode_dirty_sync(dir
, false);
591 if (F2FS_I(dir
)->i_current_depth
!= current_depth
)
592 f2fs_i_depth_write(dir
, current_depth
);
594 if (inode
&& is_inode_flag_set(inode
, FI_INC_LINK
))
595 clear_inode_flag(inode
, FI_INC_LINK
);
598 int f2fs_room_for_filename(const void *bitmap
, int slots
, int max_slots
)
601 int zero_start
, zero_end
;
603 zero_start
= find_next_zero_bit_le(bitmap
, max_slots
, bit_start
);
604 if (zero_start
>= max_slots
)
607 zero_end
= find_next_bit_le(bitmap
, max_slots
, zero_start
);
608 if (zero_end
- zero_start
>= slots
)
611 bit_start
= zero_end
+ 1;
613 if (zero_end
+ 1 >= max_slots
)
618 bool f2fs_has_enough_room(struct inode
*dir
, struct page
*ipage
,
619 const struct f2fs_filename
*fname
)
621 struct f2fs_dentry_ptr d
;
622 unsigned int bit_pos
;
623 int slots
= GET_DENTRY_SLOTS(fname
->disk_name
.len
);
625 make_dentry_ptr_inline(dir
, &d
, inline_data_addr(dir
, ipage
));
627 bit_pos
= f2fs_room_for_filename(d
.bitmap
, slots
, d
.max
);
629 return bit_pos
< d
.max
;
632 void f2fs_update_dentry(nid_t ino
, umode_t mode
, struct f2fs_dentry_ptr
*d
,
633 const struct fscrypt_str
*name
, f2fs_hash_t name_hash
,
634 unsigned int bit_pos
)
636 struct f2fs_dir_entry
*de
;
637 int slots
= GET_DENTRY_SLOTS(name
->len
);
640 de
= &d
->dentry
[bit_pos
];
641 de
->hash_code
= name_hash
;
642 de
->name_len
= cpu_to_le16(name
->len
);
643 memcpy(d
->filename
[bit_pos
], name
->name
, name
->len
);
644 de
->ino
= cpu_to_le32(ino
);
645 set_de_type(de
, mode
);
646 for (i
= 0; i
< slots
; i
++) {
647 __set_bit_le(bit_pos
+ i
, (void *)d
->bitmap
);
648 /* avoid wrong garbage data for readdir */
650 (de
+ i
)->name_len
= 0;
654 int f2fs_add_regular_entry(struct inode
*dir
, const struct f2fs_filename
*fname
,
655 struct inode
*inode
, nid_t ino
, umode_t mode
)
657 unsigned int bit_pos
;
659 unsigned int current_depth
;
660 unsigned long bidx
, block
;
661 unsigned int nbucket
, nblock
;
662 struct page
*dentry_page
= NULL
;
663 struct f2fs_dentry_block
*dentry_blk
= NULL
;
664 struct f2fs_dentry_ptr d
;
665 struct page
*page
= NULL
;
669 slots
= GET_DENTRY_SLOTS(fname
->disk_name
.len
);
671 current_depth
= F2FS_I(dir
)->i_current_depth
;
672 if (F2FS_I(dir
)->chash
== fname
->hash
) {
673 level
= F2FS_I(dir
)->clevel
;
674 F2FS_I(dir
)->chash
= 0;
678 if (time_to_inject(F2FS_I_SB(dir
), FAULT_DIR_DEPTH
)) {
679 f2fs_show_injection_info(F2FS_I_SB(dir
), FAULT_DIR_DEPTH
);
683 if (unlikely(current_depth
== MAX_DIR_HASH_DEPTH
))
686 /* Increase the depth, if required */
687 if (level
== current_depth
)
690 nbucket
= dir_buckets(level
, F2FS_I(dir
)->i_dir_level
);
691 nblock
= bucket_blocks(level
);
693 bidx
= dir_block_index(level
, F2FS_I(dir
)->i_dir_level
,
694 (le32_to_cpu(fname
->hash
) % nbucket
));
696 for (block
= bidx
; block
<= (bidx
+ nblock
- 1); block
++) {
697 dentry_page
= f2fs_get_new_data_page(dir
, NULL
, block
, true);
698 if (IS_ERR(dentry_page
))
699 return PTR_ERR(dentry_page
);
701 dentry_blk
= page_address(dentry_page
);
702 bit_pos
= f2fs_room_for_filename(&dentry_blk
->dentry_bitmap
,
703 slots
, NR_DENTRY_IN_BLOCK
);
704 if (bit_pos
< NR_DENTRY_IN_BLOCK
)
707 f2fs_put_page(dentry_page
, 1);
710 /* Move to next level to find the empty slot for new dentry */
714 f2fs_wait_on_page_writeback(dentry_page
, DATA
, true, true);
717 down_write(&F2FS_I(inode
)->i_sem
);
718 page
= f2fs_init_inode_metadata(inode
, dir
, fname
, NULL
);
725 make_dentry_ptr_block(NULL
, &d
, dentry_blk
);
726 f2fs_update_dentry(ino
, mode
, &d
, &fname
->disk_name
, fname
->hash
,
729 set_page_dirty(dentry_page
);
732 f2fs_i_pino_write(inode
, dir
->i_ino
);
734 /* synchronize inode page's data from inode cache */
735 if (is_inode_flag_set(inode
, FI_NEW_INODE
))
736 f2fs_update_inode(inode
, page
);
738 f2fs_put_page(page
, 1);
741 f2fs_update_parent_metadata(dir
, inode
, current_depth
);
744 up_write(&F2FS_I(inode
)->i_sem
);
746 f2fs_put_page(dentry_page
, 1);
751 int f2fs_add_dentry(struct inode
*dir
, const struct f2fs_filename
*fname
,
752 struct inode
*inode
, nid_t ino
, umode_t mode
)
756 if (f2fs_has_inline_dentry(dir
))
757 err
= f2fs_add_inline_entry(dir
, fname
, inode
, ino
, mode
);
759 err
= f2fs_add_regular_entry(dir
, fname
, inode
, ino
, mode
);
761 f2fs_update_time(F2FS_I_SB(dir
), REQ_TIME
);
766 * Caller should grab and release a rwsem by calling f2fs_lock_op() and
769 int f2fs_do_add_link(struct inode
*dir
, const struct qstr
*name
,
770 struct inode
*inode
, nid_t ino
, umode_t mode
)
772 struct f2fs_filename fname
;
773 struct page
*page
= NULL
;
774 struct f2fs_dir_entry
*de
= NULL
;
777 err
= f2fs_setup_filename(dir
, name
, 0, &fname
);
782 * An immature stackable filesystem shows a race condition between lookup
783 * and create. If we have same task when doing lookup and create, it's
784 * definitely fine as expected by VFS normally. Otherwise, let's just
785 * verify on-disk dentry one more time, which guarantees filesystem
788 if (current
!= F2FS_I(dir
)->task
) {
789 de
= __f2fs_find_entry(dir
, &fname
, &page
);
790 F2FS_I(dir
)->task
= NULL
;
793 f2fs_put_page(page
, 0);
795 } else if (IS_ERR(page
)) {
798 err
= f2fs_add_dentry(dir
, &fname
, inode
, ino
, mode
);
800 f2fs_free_filename(&fname
);
804 int f2fs_do_tmpfile(struct inode
*inode
, struct inode
*dir
)
809 down_write(&F2FS_I(inode
)->i_sem
);
810 page
= f2fs_init_inode_metadata(inode
, dir
, NULL
, NULL
);
815 f2fs_put_page(page
, 1);
817 clear_inode_flag(inode
, FI_NEW_INODE
);
818 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
820 up_write(&F2FS_I(inode
)->i_sem
);
824 void f2fs_drop_nlink(struct inode
*dir
, struct inode
*inode
)
826 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
828 down_write(&F2FS_I(inode
)->i_sem
);
830 if (S_ISDIR(inode
->i_mode
))
831 f2fs_i_links_write(dir
, false);
832 inode
->i_ctime
= current_time(inode
);
834 f2fs_i_links_write(inode
, false);
835 if (S_ISDIR(inode
->i_mode
)) {
836 f2fs_i_links_write(inode
, false);
837 f2fs_i_size_write(inode
, 0);
839 up_write(&F2FS_I(inode
)->i_sem
);
841 if (inode
->i_nlink
== 0)
842 f2fs_add_orphan_inode(inode
);
844 f2fs_release_orphan_inode(sbi
);
848 * It only removes the dentry from the dentry page, corresponding name
849 * entry in name page does not need to be touched during deletion.
851 void f2fs_delete_entry(struct f2fs_dir_entry
*dentry
, struct page
*page
,
852 struct inode
*dir
, struct inode
*inode
)
854 struct f2fs_dentry_block
*dentry_blk
;
855 unsigned int bit_pos
;
856 int slots
= GET_DENTRY_SLOTS(le16_to_cpu(dentry
->name_len
));
859 f2fs_update_time(F2FS_I_SB(dir
), REQ_TIME
);
861 if (F2FS_OPTION(F2FS_I_SB(dir
)).fsync_mode
== FSYNC_MODE_STRICT
)
862 f2fs_add_ino_entry(F2FS_I_SB(dir
), dir
->i_ino
, TRANS_DIR_INO
);
864 if (f2fs_has_inline_dentry(dir
))
865 return f2fs_delete_inline_entry(dentry
, page
, dir
, inode
);
868 f2fs_wait_on_page_writeback(page
, DATA
, true, true);
870 dentry_blk
= page_address(page
);
871 bit_pos
= dentry
- dentry_blk
->dentry
;
872 for (i
= 0; i
< slots
; i
++)
873 __clear_bit_le(bit_pos
+ i
, &dentry_blk
->dentry_bitmap
);
875 /* Let's check and deallocate this dentry page */
876 bit_pos
= find_next_bit_le(&dentry_blk
->dentry_bitmap
,
879 set_page_dirty(page
);
881 if (bit_pos
== NR_DENTRY_IN_BLOCK
&&
882 !f2fs_truncate_hole(dir
, page
->index
, page
->index
+ 1)) {
883 f2fs_clear_page_cache_dirty_tag(page
);
884 clear_page_dirty_for_io(page
);
885 f2fs_clear_page_private(page
);
886 ClearPageUptodate(page
);
887 clear_cold_data(page
);
888 inode_dec_dirty_pages(dir
);
889 f2fs_remove_dirty_inode(dir
);
891 f2fs_put_page(page
, 1);
893 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
894 f2fs_mark_inode_dirty_sync(dir
, false);
897 f2fs_drop_nlink(dir
, inode
);
900 bool f2fs_empty_dir(struct inode
*dir
)
903 struct page
*dentry_page
;
904 unsigned int bit_pos
;
905 struct f2fs_dentry_block
*dentry_blk
;
906 unsigned long nblock
= dir_blocks(dir
);
908 if (f2fs_has_inline_dentry(dir
))
909 return f2fs_empty_inline_dir(dir
);
911 for (bidx
= 0; bidx
< nblock
; bidx
++) {
912 dentry_page
= f2fs_get_lock_data_page(dir
, bidx
, false);
913 if (IS_ERR(dentry_page
)) {
914 if (PTR_ERR(dentry_page
) == -ENOENT
)
920 dentry_blk
= page_address(dentry_page
);
925 bit_pos
= find_next_bit_le(&dentry_blk
->dentry_bitmap
,
929 f2fs_put_page(dentry_page
, 1);
931 if (bit_pos
< NR_DENTRY_IN_BLOCK
)
937 int f2fs_fill_dentries(struct dir_context
*ctx
, struct f2fs_dentry_ptr
*d
,
938 unsigned int start_pos
, struct fscrypt_str
*fstr
)
940 unsigned char d_type
= DT_UNKNOWN
;
941 unsigned int bit_pos
;
942 struct f2fs_dir_entry
*de
= NULL
;
943 struct fscrypt_str de_name
= FSTR_INIT(NULL
, 0);
944 struct f2fs_sb_info
*sbi
= F2FS_I_SB(d
->inode
);
945 struct blk_plug plug
;
946 bool readdir_ra
= sbi
->readdir_ra
== 1;
949 bit_pos
= ((unsigned long)ctx
->pos
% d
->max
);
952 blk_start_plug(&plug
);
954 while (bit_pos
< d
->max
) {
955 bit_pos
= find_next_bit_le(d
->bitmap
, d
->max
, bit_pos
);
956 if (bit_pos
>= d
->max
)
959 de
= &d
->dentry
[bit_pos
];
960 if (de
->name_len
== 0) {
962 ctx
->pos
= start_pos
+ bit_pos
;
964 "%sF2FS-fs (%s): invalid namelen(0), ino:%u, run fsck to fix.",
965 KERN_WARNING
, sbi
->sb
->s_id
,
966 le32_to_cpu(de
->ino
));
967 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
971 d_type
= f2fs_get_de_type(de
);
973 de_name
.name
= d
->filename
[bit_pos
];
974 de_name
.len
= le16_to_cpu(de
->name_len
);
976 /* check memory boundary before moving forward */
977 bit_pos
+= GET_DENTRY_SLOTS(le16_to_cpu(de
->name_len
));
978 if (unlikely(bit_pos
> d
->max
||
979 le16_to_cpu(de
->name_len
) > F2FS_NAME_LEN
)) {
980 f2fs_warn(sbi
, "%s: corrupted namelen=%d, run fsck to fix.",
981 __func__
, le16_to_cpu(de
->name_len
));
982 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
987 if (IS_ENCRYPTED(d
->inode
)) {
988 int save_len
= fstr
->len
;
990 err
= fscrypt_fname_disk_to_usr(d
->inode
,
991 (u32
)le32_to_cpu(de
->hash_code
),
997 fstr
->len
= save_len
;
1000 if (!dir_emit(ctx
, de_name
.name
, de_name
.len
,
1001 le32_to_cpu(de
->ino
), d_type
)) {
1007 f2fs_ra_node_page(sbi
, le32_to_cpu(de
->ino
));
1009 ctx
->pos
= start_pos
+ bit_pos
;
1013 blk_finish_plug(&plug
);
1017 static int f2fs_readdir(struct file
*file
, struct dir_context
*ctx
)
1019 struct inode
*inode
= file_inode(file
);
1020 unsigned long npages
= dir_blocks(inode
);
1021 struct f2fs_dentry_block
*dentry_blk
= NULL
;
1022 struct page
*dentry_page
= NULL
;
1023 struct file_ra_state
*ra
= &file
->f_ra
;
1024 loff_t start_pos
= ctx
->pos
;
1025 unsigned int n
= ((unsigned long)ctx
->pos
/ NR_DENTRY_IN_BLOCK
);
1026 struct f2fs_dentry_ptr d
;
1027 struct fscrypt_str fstr
= FSTR_INIT(NULL
, 0);
1030 if (IS_ENCRYPTED(inode
)) {
1031 err
= fscrypt_get_encryption_info(inode
);
1035 err
= fscrypt_fname_alloc_buffer(F2FS_NAME_LEN
, &fstr
);
1040 if (f2fs_has_inline_dentry(inode
)) {
1041 err
= f2fs_read_inline_dir(file
, ctx
, &fstr
);
1045 for (; n
< npages
; n
++, ctx
->pos
= n
* NR_DENTRY_IN_BLOCK
) {
1047 /* allow readdir() to be interrupted */
1048 if (fatal_signal_pending(current
)) {
1054 /* readahead for multi pages of dir */
1055 if (npages
- n
> 1 && !ra_has_index(ra
, n
))
1056 page_cache_sync_readahead(inode
->i_mapping
, ra
, file
, n
,
1057 min(npages
- n
, (pgoff_t
)MAX_DIR_RA_PAGES
));
1059 dentry_page
= f2fs_find_data_page(inode
, n
);
1060 if (IS_ERR(dentry_page
)) {
1061 err
= PTR_ERR(dentry_page
);
1062 if (err
== -ENOENT
) {
1070 dentry_blk
= page_address(dentry_page
);
1072 make_dentry_ptr_block(inode
, &d
, dentry_blk
);
1074 err
= f2fs_fill_dentries(ctx
, &d
,
1075 n
* NR_DENTRY_IN_BLOCK
, &fstr
);
1077 f2fs_put_page(dentry_page
, 0);
1081 f2fs_put_page(dentry_page
, 0);
1084 fscrypt_fname_free_buffer(&fstr
);
1086 trace_f2fs_readdir(inode
, start_pos
, ctx
->pos
, err
);
1087 return err
< 0 ? err
: 0;
1090 static int f2fs_dir_open(struct inode
*inode
, struct file
*filp
)
1092 if (IS_ENCRYPTED(inode
))
1093 return fscrypt_get_encryption_info(inode
) ? -EACCES
: 0;
1097 const struct file_operations f2fs_dir_operations
= {
1098 .llseek
= generic_file_llseek
,
1099 .read
= generic_read_dir
,
1100 .iterate_shared
= f2fs_readdir
,
1101 .fsync
= f2fs_sync_file
,
1102 .open
= f2fs_dir_open
,
1103 .unlocked_ioctl
= f2fs_ioctl
,
1104 #ifdef CONFIG_COMPAT
1105 .compat_ioctl
= f2fs_compat_ioctl
,
1109 #ifdef CONFIG_UNICODE
1110 static int f2fs_d_compare(const struct dentry
*dentry
, unsigned int len
,
1111 const char *str
, const struct qstr
*name
)
1113 const struct dentry
*parent
= READ_ONCE(dentry
->d_parent
);
1114 const struct inode
*dir
= READ_ONCE(parent
->d_inode
);
1115 const struct f2fs_sb_info
*sbi
= F2FS_SB(dentry
->d_sb
);
1116 struct qstr entry
= QSTR_INIT(str
, len
);
1117 char strbuf
[DNAME_INLINE_LEN
];
1120 if (!dir
|| !IS_CASEFOLDED(dir
))
1124 * If the dentry name is stored in-line, then it may be concurrently
1125 * modified by a rename. If this happens, the VFS will eventually retry
1126 * the lookup, so it doesn't matter what ->d_compare() returns.
1127 * However, it's unsafe to call utf8_strncasecmp() with an unstable
1128 * string. Therefore, we have to copy the name into a temporary buffer.
1130 if (len
<= DNAME_INLINE_LEN
- 1) {
1131 memcpy(strbuf
, str
, len
);
1133 entry
.name
= strbuf
;
1134 /* prevent compiler from optimizing out the temporary buffer */
1138 res
= utf8_strncasecmp(sbi
->s_encoding
, name
, &entry
);
1142 if (f2fs_has_strict_mode(sbi
))
1145 if (len
!= name
->len
)
1147 return !!memcmp(str
, name
->name
, len
);
1150 static int f2fs_d_hash(const struct dentry
*dentry
, struct qstr
*str
)
1152 struct f2fs_sb_info
*sbi
= F2FS_SB(dentry
->d_sb
);
1153 const struct unicode_map
*um
= sbi
->s_encoding
;
1154 const struct inode
*inode
= READ_ONCE(dentry
->d_inode
);
1155 unsigned char *norm
;
1158 if (!inode
|| !IS_CASEFOLDED(inode
))
1161 norm
= f2fs_kmalloc(sbi
, PATH_MAX
, GFP_ATOMIC
);
1165 len
= utf8_casefold(um
, str
, norm
, PATH_MAX
);
1167 if (f2fs_has_strict_mode(sbi
))
1171 str
->hash
= full_name_hash(dentry
, norm
, len
);
1177 const struct dentry_operations f2fs_dentry_ops
= {
1178 .d_hash
= f2fs_d_hash
,
1179 .d_compare
= f2fs_d_compare
,