1 // SPDX-License-Identifier: GPL-2.0
3 * linux/fs/ext4/namei.c
5 * Copyright (C) 1992, 1993, 1994, 1995
6 * Remy Card (card@masi.ibp.fr)
7 * Laboratoire MASI - Institut Blaise Pascal
8 * Universite Pierre et Marie Curie (Paris VI)
12 * linux/fs/minix/namei.c
14 * Copyright (C) 1991, 1992 Linus Torvalds
16 * Big-endian to little-endian byte-swapping/bitmaps by
17 * David S. Miller (davem@caip.rutgers.edu), 1995
18 * Directory entry file type support and forward compatibility hooks
19 * for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
20 * Hash Tree Directory indexing (c)
21 * Daniel Phillips, 2001
22 * Hash Tree Directory indexing porting
23 * Christopher Li, 2002
24 * Hash Tree Directory indexing cleanup
29 #include <linux/pagemap.h>
30 #include <linux/time.h>
31 #include <linux/fcntl.h>
32 #include <linux/stat.h>
33 #include <linux/string.h>
34 #include <linux/quotaops.h>
35 #include <linux/buffer_head.h>
36 #include <linux/bio.h>
37 #include <linux/iversion.h>
38 #include <linux/unicode.h>
40 #include "ext4_jbd2.h"
45 #include <trace/events/ext4.h>
47 * define how far ahead to read directories while searching them.
49 #define NAMEI_RA_CHUNKS 2
50 #define NAMEI_RA_BLOCKS 4
51 #define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
53 static struct buffer_head
*ext4_append(handle_t
*handle
,
57 struct ext4_map_blocks map
;
58 struct buffer_head
*bh
;
61 if (unlikely(EXT4_SB(inode
->i_sb
)->s_max_dir_size_kb
&&
62 ((inode
->i_size
>> 10) >=
63 EXT4_SB(inode
->i_sb
)->s_max_dir_size_kb
)))
64 return ERR_PTR(-ENOSPC
);
66 *block
= inode
->i_size
>> inode
->i_sb
->s_blocksize_bits
;
71 * We're appending new directory block. Make sure the block is not
72 * allocated yet, otherwise we will end up corrupting the
75 err
= ext4_map_blocks(NULL
, inode
, &map
, 0);
79 EXT4_ERROR_INODE(inode
, "Logical block already allocated");
80 return ERR_PTR(-EFSCORRUPTED
);
83 bh
= ext4_bread(handle
, inode
, *block
, EXT4_GET_BLOCKS_CREATE
);
86 inode
->i_size
+= inode
->i_sb
->s_blocksize
;
87 EXT4_I(inode
)->i_disksize
= inode
->i_size
;
88 err
= ext4_mark_inode_dirty(handle
, inode
);
91 BUFFER_TRACE(bh
, "get_write_access");
92 err
= ext4_journal_get_write_access(handle
, inode
->i_sb
, bh
,
100 ext4_std_error(inode
->i_sb
, err
);
104 static int ext4_dx_csum_verify(struct inode
*inode
,
105 struct ext4_dir_entry
*dirent
);
108 * Hints to ext4_read_dirblock regarding whether we expect a directory
109 * block being read to be an index block, or a block containing
110 * directory entries (and if the latter, whether it was found via a
111 * logical block in an htree index block). This is used to control
112 * what sort of sanity checkinig ext4_read_dirblock() will do on the
113 * directory block read from the storage device. EITHER will means
114 * the caller doesn't know what kind of directory block will be read,
115 * so no specific verification will be done.
118 EITHER
, INDEX
, DIRENT
, DIRENT_HTREE
121 #define ext4_read_dirblock(inode, block, type) \
122 __ext4_read_dirblock((inode), (block), (type), __func__, __LINE__)
124 static struct buffer_head
*__ext4_read_dirblock(struct inode
*inode
,
126 dirblock_type_t type
,
130 struct buffer_head
*bh
;
131 struct ext4_dir_entry
*dirent
;
134 if (block
>= inode
->i_size
>> inode
->i_blkbits
) {
135 ext4_error_inode(inode
, func
, line
, block
,
136 "Attempting to read directory block (%u) that is past i_size (%llu)",
137 block
, inode
->i_size
);
138 return ERR_PTR(-EFSCORRUPTED
);
141 if (ext4_simulate_fail(inode
->i_sb
, EXT4_SIM_DIRBLOCK_EIO
))
144 bh
= ext4_bread(NULL
, inode
, block
, 0);
146 __ext4_warning(inode
->i_sb
, func
, line
,
147 "inode #%lu: lblock %lu: comm %s: "
148 "error %ld reading directory block",
149 inode
->i_ino
, (unsigned long)block
,
150 current
->comm
, PTR_ERR(bh
));
154 if (!bh
&& (type
== INDEX
|| type
== DIRENT_HTREE
)) {
155 ext4_error_inode(inode
, func
, line
, block
,
156 "Directory hole found for htree %s block",
157 (type
== INDEX
) ? "index" : "leaf");
158 return ERR_PTR(-EFSCORRUPTED
);
162 dirent
= (struct ext4_dir_entry
*) bh
->b_data
;
163 /* Determine whether or not we have an index block */
167 else if (ext4_rec_len_from_disk(dirent
->rec_len
,
168 inode
->i_sb
->s_blocksize
) ==
169 inode
->i_sb
->s_blocksize
)
172 if (!is_dx_block
&& type
== INDEX
) {
173 ext4_error_inode(inode
, func
, line
, block
,
174 "directory leaf block found instead of index block");
176 return ERR_PTR(-EFSCORRUPTED
);
178 if (!ext4_has_metadata_csum(inode
->i_sb
) ||
183 * An empty leaf block can get mistaken for a index block; for
184 * this reason, we can only check the index checksum when the
185 * caller is sure it should be an index block.
187 if (is_dx_block
&& type
== INDEX
) {
188 if (ext4_dx_csum_verify(inode
, dirent
) &&
189 !ext4_simulate_fail(inode
->i_sb
, EXT4_SIM_DIRBLOCK_CRC
))
190 set_buffer_verified(bh
);
192 ext4_error_inode_err(inode
, func
, line
, block
,
194 "Directory index failed checksum");
196 return ERR_PTR(-EFSBADCRC
);
200 if (ext4_dirblock_csum_verify(inode
, bh
) &&
201 !ext4_simulate_fail(inode
->i_sb
, EXT4_SIM_DIRBLOCK_CRC
))
202 set_buffer_verified(bh
);
204 ext4_error_inode_err(inode
, func
, line
, block
,
206 "Directory block failed checksum");
208 return ERR_PTR(-EFSBADCRC
);
215 #define dxtrace(command) command
217 #define dxtrace(command)
241 * dx_root_info is laid out so that if it should somehow get overlaid by a
242 * dirent the two low bits of the hash version will be zero. Therefore, the
243 * hash version mod 4 should never be 0. Sincerely, the paranoia department.
248 struct fake_dirent dot
;
250 struct fake_dirent dotdot
;
254 __le32 reserved_zero
;
256 u8 info_length
; /* 8 */
261 struct dx_entry entries
[];
266 struct fake_dirent fake
;
267 struct dx_entry entries
[];
273 struct buffer_head
*bh
;
274 struct dx_entry
*entries
;
286 * This goes at the end of each htree block.
290 __le32 dt_checksum
; /* crc32c(uuid+inum+dirblock) */
293 static inline ext4_lblk_t
dx_get_block(struct dx_entry
*entry
);
294 static void dx_set_block(struct dx_entry
*entry
, ext4_lblk_t value
);
295 static inline unsigned dx_get_hash(struct dx_entry
*entry
);
296 static void dx_set_hash(struct dx_entry
*entry
, unsigned value
);
297 static unsigned dx_get_count(struct dx_entry
*entries
);
298 static unsigned dx_get_limit(struct dx_entry
*entries
);
299 static void dx_set_count(struct dx_entry
*entries
, unsigned value
);
300 static void dx_set_limit(struct dx_entry
*entries
, unsigned value
);
301 static unsigned dx_root_limit(struct inode
*dir
, unsigned infosize
);
302 static unsigned dx_node_limit(struct inode
*dir
);
303 static struct dx_frame
*dx_probe(struct ext4_filename
*fname
,
305 struct dx_hash_info
*hinfo
,
306 struct dx_frame
*frame
);
307 static void dx_release(struct dx_frame
*frames
);
308 static int dx_make_map(struct inode
*dir
, struct buffer_head
*bh
,
309 struct dx_hash_info
*hinfo
,
310 struct dx_map_entry
*map_tail
);
311 static void dx_sort_map(struct dx_map_entry
*map
, unsigned count
);
312 static struct ext4_dir_entry_2
*dx_move_dirents(struct inode
*dir
, char *from
,
313 char *to
, struct dx_map_entry
*offsets
,
314 int count
, unsigned int blocksize
);
315 static struct ext4_dir_entry_2
*dx_pack_dirents(struct inode
*dir
, char *base
,
316 unsigned int blocksize
);
317 static void dx_insert_block(struct dx_frame
*frame
,
318 u32 hash
, ext4_lblk_t block
);
319 static int ext4_htree_next_block(struct inode
*dir
, __u32 hash
,
320 struct dx_frame
*frame
,
321 struct dx_frame
*frames
,
323 static struct buffer_head
* ext4_dx_find_entry(struct inode
*dir
,
324 struct ext4_filename
*fname
,
325 struct ext4_dir_entry_2
**res_dir
);
326 static int ext4_dx_add_entry(handle_t
*handle
, struct ext4_filename
*fname
,
327 struct inode
*dir
, struct inode
*inode
);
329 /* checksumming functions */
330 void ext4_initialize_dirent_tail(struct buffer_head
*bh
,
331 unsigned int blocksize
)
333 struct ext4_dir_entry_tail
*t
= EXT4_DIRENT_TAIL(bh
->b_data
, blocksize
);
335 memset(t
, 0, sizeof(struct ext4_dir_entry_tail
));
336 t
->det_rec_len
= ext4_rec_len_to_disk(
337 sizeof(struct ext4_dir_entry_tail
), blocksize
);
338 t
->det_reserved_ft
= EXT4_FT_DIR_CSUM
;
341 /* Walk through a dirent block to find a checksum "dirent" at the tail */
342 static struct ext4_dir_entry_tail
*get_dirent_tail(struct inode
*inode
,
343 struct buffer_head
*bh
)
345 struct ext4_dir_entry_tail
*t
;
348 struct ext4_dir_entry
*d
, *top
;
350 d
= (struct ext4_dir_entry
*)bh
->b_data
;
351 top
= (struct ext4_dir_entry
*)(bh
->b_data
+
352 (EXT4_BLOCK_SIZE(inode
->i_sb
) -
353 sizeof(struct ext4_dir_entry_tail
)));
354 while (d
< top
&& d
->rec_len
)
355 d
= (struct ext4_dir_entry
*)(((void *)d
) +
356 le16_to_cpu(d
->rec_len
));
361 t
= (struct ext4_dir_entry_tail
*)d
;
363 t
= EXT4_DIRENT_TAIL(bh
->b_data
, EXT4_BLOCK_SIZE(inode
->i_sb
));
366 if (t
->det_reserved_zero1
||
367 le16_to_cpu(t
->det_rec_len
) != sizeof(struct ext4_dir_entry_tail
) ||
368 t
->det_reserved_zero2
||
369 t
->det_reserved_ft
!= EXT4_FT_DIR_CSUM
)
375 static __le32
ext4_dirblock_csum(struct inode
*inode
, void *dirent
, int size
)
377 struct ext4_sb_info
*sbi
= EXT4_SB(inode
->i_sb
);
378 struct ext4_inode_info
*ei
= EXT4_I(inode
);
381 csum
= ext4_chksum(sbi
, ei
->i_csum_seed
, (__u8
*)dirent
, size
);
382 return cpu_to_le32(csum
);
385 #define warn_no_space_for_csum(inode) \
386 __warn_no_space_for_csum((inode), __func__, __LINE__)
388 static void __warn_no_space_for_csum(struct inode
*inode
, const char *func
,
391 __ext4_warning_inode(inode
, func
, line
,
392 "No space for directory leaf checksum. Please run e2fsck -D.");
395 int ext4_dirblock_csum_verify(struct inode
*inode
, struct buffer_head
*bh
)
397 struct ext4_dir_entry_tail
*t
;
399 if (!ext4_has_metadata_csum(inode
->i_sb
))
402 t
= get_dirent_tail(inode
, bh
);
404 warn_no_space_for_csum(inode
);
408 if (t
->det_checksum
!= ext4_dirblock_csum(inode
, bh
->b_data
,
409 (char *)t
- bh
->b_data
))
415 static void ext4_dirblock_csum_set(struct inode
*inode
,
416 struct buffer_head
*bh
)
418 struct ext4_dir_entry_tail
*t
;
420 if (!ext4_has_metadata_csum(inode
->i_sb
))
423 t
= get_dirent_tail(inode
, bh
);
425 warn_no_space_for_csum(inode
);
429 t
->det_checksum
= ext4_dirblock_csum(inode
, bh
->b_data
,
430 (char *)t
- bh
->b_data
);
433 int ext4_handle_dirty_dirblock(handle_t
*handle
,
435 struct buffer_head
*bh
)
437 ext4_dirblock_csum_set(inode
, bh
);
438 return ext4_handle_dirty_metadata(handle
, inode
, bh
);
441 static struct dx_countlimit
*get_dx_countlimit(struct inode
*inode
,
442 struct ext4_dir_entry
*dirent
,
445 struct ext4_dir_entry
*dp
;
446 struct dx_root_info
*root
;
449 if (le16_to_cpu(dirent
->rec_len
) == EXT4_BLOCK_SIZE(inode
->i_sb
))
451 else if (le16_to_cpu(dirent
->rec_len
) == 12) {
452 dp
= (struct ext4_dir_entry
*)(((void *)dirent
) + 12);
453 if (le16_to_cpu(dp
->rec_len
) !=
454 EXT4_BLOCK_SIZE(inode
->i_sb
) - 12)
456 root
= (struct dx_root_info
*)(((void *)dp
+ 12));
457 if (root
->reserved_zero
||
458 root
->info_length
!= sizeof(struct dx_root_info
))
465 *offset
= count_offset
;
466 return (struct dx_countlimit
*)(((void *)dirent
) + count_offset
);
469 static __le32
ext4_dx_csum(struct inode
*inode
, struct ext4_dir_entry
*dirent
,
470 int count_offset
, int count
, struct dx_tail
*t
)
472 struct ext4_sb_info
*sbi
= EXT4_SB(inode
->i_sb
);
473 struct ext4_inode_info
*ei
= EXT4_I(inode
);
476 __u32 dummy_csum
= 0;
477 int offset
= offsetof(struct dx_tail
, dt_checksum
);
479 size
= count_offset
+ (count
* sizeof(struct dx_entry
));
480 csum
= ext4_chksum(sbi
, ei
->i_csum_seed
, (__u8
*)dirent
, size
);
481 csum
= ext4_chksum(sbi
, csum
, (__u8
*)t
, offset
);
482 csum
= ext4_chksum(sbi
, csum
, (__u8
*)&dummy_csum
, sizeof(dummy_csum
));
484 return cpu_to_le32(csum
);
487 static int ext4_dx_csum_verify(struct inode
*inode
,
488 struct ext4_dir_entry
*dirent
)
490 struct dx_countlimit
*c
;
492 int count_offset
, limit
, count
;
494 if (!ext4_has_metadata_csum(inode
->i_sb
))
497 c
= get_dx_countlimit(inode
, dirent
, &count_offset
);
499 EXT4_ERROR_INODE(inode
, "dir seems corrupt? Run e2fsck -D.");
502 limit
= le16_to_cpu(c
->limit
);
503 count
= le16_to_cpu(c
->count
);
504 if (count_offset
+ (limit
* sizeof(struct dx_entry
)) >
505 EXT4_BLOCK_SIZE(inode
->i_sb
) - sizeof(struct dx_tail
)) {
506 warn_no_space_for_csum(inode
);
509 t
= (struct dx_tail
*)(((struct dx_entry
*)c
) + limit
);
511 if (t
->dt_checksum
!= ext4_dx_csum(inode
, dirent
, count_offset
,
517 static void ext4_dx_csum_set(struct inode
*inode
, struct ext4_dir_entry
*dirent
)
519 struct dx_countlimit
*c
;
521 int count_offset
, limit
, count
;
523 if (!ext4_has_metadata_csum(inode
->i_sb
))
526 c
= get_dx_countlimit(inode
, dirent
, &count_offset
);
528 EXT4_ERROR_INODE(inode
, "dir seems corrupt? Run e2fsck -D.");
531 limit
= le16_to_cpu(c
->limit
);
532 count
= le16_to_cpu(c
->count
);
533 if (count_offset
+ (limit
* sizeof(struct dx_entry
)) >
534 EXT4_BLOCK_SIZE(inode
->i_sb
) - sizeof(struct dx_tail
)) {
535 warn_no_space_for_csum(inode
);
538 t
= (struct dx_tail
*)(((struct dx_entry
*)c
) + limit
);
540 t
->dt_checksum
= ext4_dx_csum(inode
, dirent
, count_offset
, count
, t
);
543 static inline int ext4_handle_dirty_dx_node(handle_t
*handle
,
545 struct buffer_head
*bh
)
547 ext4_dx_csum_set(inode
, (struct ext4_dir_entry
*)bh
->b_data
);
548 return ext4_handle_dirty_metadata(handle
, inode
, bh
);
552 * p is at least 6 bytes before the end of page
554 static inline struct ext4_dir_entry_2
*
555 ext4_next_entry(struct ext4_dir_entry_2
*p
, unsigned long blocksize
)
557 return (struct ext4_dir_entry_2
*)((char *)p
+
558 ext4_rec_len_from_disk(p
->rec_len
, blocksize
));
562 * Future: use high four bits of block for coalesce-on-delete flags
563 * Mask them off for now.
566 static inline ext4_lblk_t
dx_get_block(struct dx_entry
*entry
)
568 return le32_to_cpu(entry
->block
) & 0x0fffffff;
571 static inline void dx_set_block(struct dx_entry
*entry
, ext4_lblk_t value
)
573 entry
->block
= cpu_to_le32(value
);
576 static inline unsigned dx_get_hash(struct dx_entry
*entry
)
578 return le32_to_cpu(entry
->hash
);
581 static inline void dx_set_hash(struct dx_entry
*entry
, unsigned value
)
583 entry
->hash
= cpu_to_le32(value
);
586 static inline unsigned dx_get_count(struct dx_entry
*entries
)
588 return le16_to_cpu(((struct dx_countlimit
*) entries
)->count
);
591 static inline unsigned dx_get_limit(struct dx_entry
*entries
)
593 return le16_to_cpu(((struct dx_countlimit
*) entries
)->limit
);
596 static inline void dx_set_count(struct dx_entry
*entries
, unsigned value
)
598 ((struct dx_countlimit
*) entries
)->count
= cpu_to_le16(value
);
601 static inline void dx_set_limit(struct dx_entry
*entries
, unsigned value
)
603 ((struct dx_countlimit
*) entries
)->limit
= cpu_to_le16(value
);
606 static inline unsigned dx_root_limit(struct inode
*dir
, unsigned infosize
)
608 unsigned int entry_space
= dir
->i_sb
->s_blocksize
-
609 ext4_dir_rec_len(1, NULL
) -
610 ext4_dir_rec_len(2, NULL
) - infosize
;
612 if (ext4_has_metadata_csum(dir
->i_sb
))
613 entry_space
-= sizeof(struct dx_tail
);
614 return entry_space
/ sizeof(struct dx_entry
);
617 static inline unsigned dx_node_limit(struct inode
*dir
)
619 unsigned int entry_space
= dir
->i_sb
->s_blocksize
-
620 ext4_dir_rec_len(0, dir
);
622 if (ext4_has_metadata_csum(dir
->i_sb
))
623 entry_space
-= sizeof(struct dx_tail
);
624 return entry_space
/ sizeof(struct dx_entry
);
631 static void dx_show_index(char * label
, struct dx_entry
*entries
)
633 int i
, n
= dx_get_count (entries
);
634 printk(KERN_DEBUG
"%s index", label
);
635 for (i
= 0; i
< n
; i
++) {
636 printk(KERN_CONT
" %x->%lu",
637 i
? dx_get_hash(entries
+ i
) : 0,
638 (unsigned long)dx_get_block(entries
+ i
));
640 printk(KERN_CONT
"\n");
650 static struct stats
dx_show_leaf(struct inode
*dir
,
651 struct dx_hash_info
*hinfo
,
652 struct ext4_dir_entry_2
*de
,
653 int size
, int show_names
)
655 unsigned names
= 0, space
= 0;
656 char *base
= (char *) de
;
657 struct dx_hash_info h
= *hinfo
;
660 while ((char *) de
< base
+ size
)
666 #ifdef CONFIG_FS_ENCRYPTION
669 struct fscrypt_str fname_crypto_str
=
675 if (!IS_ENCRYPTED(dir
)) {
676 /* Directory is not encrypted */
677 ext4fs_dirhash(dir
, de
->name
,
679 printk("%*.s:(U)%x.%u ", len
,
681 (unsigned) ((char *) de
684 struct fscrypt_str de_name
=
685 FSTR_INIT(name
, len
);
687 /* Directory is encrypted */
688 res
= fscrypt_fname_alloc_buffer(
689 len
, &fname_crypto_str
);
691 printk(KERN_WARNING
"Error "
695 res
= fscrypt_fname_disk_to_usr(dir
,
699 printk(KERN_WARNING
"Error "
700 "converting filename "
706 name
= fname_crypto_str
.name
;
707 len
= fname_crypto_str
.len
;
709 if (IS_CASEFOLDED(dir
))
710 h
.hash
= EXT4_DIRENT_HASH(de
);
712 ext4fs_dirhash(dir
, de
->name
,
714 printk("%*.s:(E)%x.%u ", len
, name
,
715 h
.hash
, (unsigned) ((char *) de
717 fscrypt_fname_free_buffer(
721 int len
= de
->name_len
;
722 char *name
= de
->name
;
723 ext4fs_dirhash(dir
, de
->name
, de
->name_len
, &h
);
724 printk("%*.s:%x.%u ", len
, name
, h
.hash
,
725 (unsigned) ((char *) de
- base
));
728 space
+= ext4_dir_rec_len(de
->name_len
, dir
);
731 de
= ext4_next_entry(de
, size
);
733 printk(KERN_CONT
"(%i)\n", names
);
734 return (struct stats
) { names
, space
, 1 };
737 struct stats
dx_show_entries(struct dx_hash_info
*hinfo
, struct inode
*dir
,
738 struct dx_entry
*entries
, int levels
)
740 unsigned blocksize
= dir
->i_sb
->s_blocksize
;
741 unsigned count
= dx_get_count(entries
), names
= 0, space
= 0, i
;
743 struct buffer_head
*bh
;
744 printk("%i indexed blocks...\n", count
);
745 for (i
= 0; i
< count
; i
++, entries
++)
747 ext4_lblk_t block
= dx_get_block(entries
);
748 ext4_lblk_t hash
= i
? dx_get_hash(entries
): 0;
749 u32 range
= i
< count
- 1? (dx_get_hash(entries
+ 1) - hash
): ~hash
;
751 printk("%s%3u:%03u hash %8x/%8x ",levels
?"":" ", i
, block
, hash
, range
);
752 bh
= ext4_bread(NULL
,dir
, block
, 0);
753 if (!bh
|| IS_ERR(bh
))
756 dx_show_entries(hinfo
, dir
, ((struct dx_node
*) bh
->b_data
)->entries
, levels
- 1):
757 dx_show_leaf(dir
, hinfo
, (struct ext4_dir_entry_2
*)
758 bh
->b_data
, blocksize
, 0);
759 names
+= stats
.names
;
760 space
+= stats
.space
;
761 bcount
+= stats
.bcount
;
765 printk(KERN_DEBUG
"%snames %u, fullness %u (%u%%)\n",
766 levels
? "" : " ", names
, space
/bcount
,
767 (space
/bcount
)*100/blocksize
);
768 return (struct stats
) { names
, space
, bcount
};
772 * Linear search cross check
774 static inline void htree_rep_invariant_check(struct dx_entry
*at
,
775 struct dx_entry
*target
,
776 u32 hash
, unsigned int n
)
779 dxtrace(printk(KERN_CONT
","));
780 if (dx_get_hash(++at
) > hash
) {
785 ASSERT(at
== target
- 1);
788 static inline void htree_rep_invariant_check(struct dx_entry
*at
,
789 struct dx_entry
*target
,
790 u32 hash
, unsigned int n
)
793 #endif /* DX_DEBUG */
796 * Probe for a directory leaf block to search.
798 * dx_probe can return ERR_BAD_DX_DIR, which means there was a format
799 * error in the directory index, and the caller should fall back to
800 * searching the directory normally. The callers of dx_probe **MUST**
801 * check for this error code, and make sure it never gets reflected
804 static struct dx_frame
*
805 dx_probe(struct ext4_filename
*fname
, struct inode
*dir
,
806 struct dx_hash_info
*hinfo
, struct dx_frame
*frame_in
)
808 unsigned count
, indirect
, level
, i
;
809 struct dx_entry
*at
, *entries
, *p
, *q
, *m
;
810 struct dx_root
*root
;
811 struct dx_frame
*frame
= frame_in
;
812 struct dx_frame
*ret_err
= ERR_PTR(ERR_BAD_DX_DIR
);
815 ext4_lblk_t blocks
[EXT4_HTREE_LEVEL
];
817 memset(frame_in
, 0, EXT4_HTREE_LEVEL
* sizeof(frame_in
[0]));
818 frame
->bh
= ext4_read_dirblock(dir
, 0, INDEX
);
819 if (IS_ERR(frame
->bh
))
820 return (struct dx_frame
*) frame
->bh
;
822 root
= (struct dx_root
*) frame
->bh
->b_data
;
823 if (root
->info
.hash_version
!= DX_HASH_TEA
&&
824 root
->info
.hash_version
!= DX_HASH_HALF_MD4
&&
825 root
->info
.hash_version
!= DX_HASH_LEGACY
&&
826 root
->info
.hash_version
!= DX_HASH_SIPHASH
) {
827 ext4_warning_inode(dir
, "Unrecognised inode hash code %u",
828 root
->info
.hash_version
);
831 if (ext4_hash_in_dirent(dir
)) {
832 if (root
->info
.hash_version
!= DX_HASH_SIPHASH
) {
833 ext4_warning_inode(dir
,
834 "Hash in dirent, but hash is not SIPHASH");
838 if (root
->info
.hash_version
== DX_HASH_SIPHASH
) {
839 ext4_warning_inode(dir
,
840 "Hash code is SIPHASH, but hash not in dirent");
845 hinfo
= &fname
->hinfo
;
846 hinfo
->hash_version
= root
->info
.hash_version
;
847 if (hinfo
->hash_version
<= DX_HASH_TEA
)
848 hinfo
->hash_version
+= EXT4_SB(dir
->i_sb
)->s_hash_unsigned
;
849 hinfo
->seed
= EXT4_SB(dir
->i_sb
)->s_hash_seed
;
850 /* hash is already computed for encrypted casefolded directory */
851 if (fname
&& fname_name(fname
) &&
852 !(IS_ENCRYPTED(dir
) && IS_CASEFOLDED(dir
)))
853 ext4fs_dirhash(dir
, fname_name(fname
), fname_len(fname
), hinfo
);
856 if (root
->info
.unused_flags
& 1) {
857 ext4_warning_inode(dir
, "Unimplemented hash flags: %#06x",
858 root
->info
.unused_flags
);
862 indirect
= root
->info
.indirect_levels
;
863 if (indirect
>= ext4_dir_htree_level(dir
->i_sb
)) {
864 ext4_warning(dir
->i_sb
,
865 "Directory (ino: %lu) htree depth %#06x exceed"
866 "supported value", dir
->i_ino
,
867 ext4_dir_htree_level(dir
->i_sb
));
868 if (ext4_dir_htree_level(dir
->i_sb
) < EXT4_HTREE_LEVEL
) {
869 ext4_warning(dir
->i_sb
, "Enable large directory "
870 "feature to access it");
875 entries
= (struct dx_entry
*)(((char *)&root
->info
) +
876 root
->info
.info_length
);
878 if (dx_get_limit(entries
) != dx_root_limit(dir
,
879 root
->info
.info_length
)) {
880 ext4_warning_inode(dir
, "dx entry: limit %u != root limit %u",
881 dx_get_limit(entries
),
882 dx_root_limit(dir
, root
->info
.info_length
));
886 dxtrace(printk("Look up %x", hash
));
890 count
= dx_get_count(entries
);
891 if (!count
|| count
> dx_get_limit(entries
)) {
892 ext4_warning_inode(dir
,
893 "dx entry: count %u beyond limit %u",
894 count
, dx_get_limit(entries
));
899 q
= entries
+ count
- 1;
902 dxtrace(printk(KERN_CONT
"."));
903 if (dx_get_hash(m
) > hash
)
909 htree_rep_invariant_check(entries
, p
, hash
, count
- 1);
912 dxtrace(printk(KERN_CONT
" %x->%u\n",
913 at
== entries
? 0 : dx_get_hash(at
),
915 frame
->entries
= entries
;
918 block
= dx_get_block(at
);
919 for (i
= 0; i
<= level
; i
++) {
920 if (blocks
[i
] == block
) {
921 ext4_warning_inode(dir
,
922 "dx entry: tree cycle block %u points back to block %u",
923 blocks
[level
], block
);
927 if (++level
> indirect
)
929 blocks
[level
] = block
;
931 frame
->bh
= ext4_read_dirblock(dir
, block
, INDEX
);
932 if (IS_ERR(frame
->bh
)) {
933 ret_err
= (struct dx_frame
*) frame
->bh
;
938 entries
= ((struct dx_node
*) frame
->bh
->b_data
)->entries
;
940 if (dx_get_limit(entries
) != dx_node_limit(dir
)) {
941 ext4_warning_inode(dir
,
942 "dx entry: limit %u != node limit %u",
943 dx_get_limit(entries
), dx_node_limit(dir
));
948 while (frame
>= frame_in
) {
953 if (ret_err
== ERR_PTR(ERR_BAD_DX_DIR
))
954 ext4_warning_inode(dir
,
955 "Corrupt directory, running e2fsck is recommended");
959 static void dx_release(struct dx_frame
*frames
)
961 struct dx_root_info
*info
;
963 unsigned int indirect_levels
;
965 if (frames
[0].bh
== NULL
)
968 info
= &((struct dx_root
*)frames
[0].bh
->b_data
)->info
;
969 /* save local copy, "info" may be freed after brelse() */
970 indirect_levels
= info
->indirect_levels
;
971 for (i
= 0; i
<= indirect_levels
; i
++) {
972 if (frames
[i
].bh
== NULL
)
974 brelse(frames
[i
].bh
);
980 * This function increments the frame pointer to search the next leaf
981 * block, and reads in the necessary intervening nodes if the search
982 * should be necessary. Whether or not the search is necessary is
983 * controlled by the hash parameter. If the hash value is even, then
984 * the search is only continued if the next block starts with that
985 * hash value. This is used if we are searching for a specific file.
987 * If the hash value is HASH_NB_ALWAYS, then always go to the next block.
989 * This function returns 1 if the caller should continue to search,
990 * or 0 if it should not. If there is an error reading one of the
991 * index blocks, it will a negative error code.
993 * If start_hash is non-null, it will be filled in with the starting
994 * hash of the next page.
996 static int ext4_htree_next_block(struct inode
*dir
, __u32 hash
,
997 struct dx_frame
*frame
,
998 struct dx_frame
*frames
,
1002 struct buffer_head
*bh
;
1008 * Find the next leaf page by incrementing the frame pointer.
1009 * If we run out of entries in the interior node, loop around and
1010 * increment pointer in the parent node. When we break out of
1011 * this loop, num_frames indicates the number of interior
1012 * nodes need to be read.
1015 if (++(p
->at
) < p
->entries
+ dx_get_count(p
->entries
))
1024 * If the hash is 1, then continue only if the next page has a
1025 * continuation hash of any value. This is used for readdir
1026 * handling. Otherwise, check to see if the hash matches the
1027 * desired continuation hash. If it doesn't, return since
1028 * there's no point to read in the successive index pages.
1030 bhash
= dx_get_hash(p
->at
);
1032 *start_hash
= bhash
;
1033 if ((hash
& 1) == 0) {
1034 if ((bhash
& ~1) != hash
)
1038 * If the hash is HASH_NB_ALWAYS, we always go to the next
1039 * block so no check is necessary
1041 while (num_frames
--) {
1042 bh
= ext4_read_dirblock(dir
, dx_get_block(p
->at
), INDEX
);
1048 p
->at
= p
->entries
= ((struct dx_node
*) bh
->b_data
)->entries
;
1055 * This function fills a red-black tree with information from a
1056 * directory block. It returns the number directory entries loaded
1057 * into the tree. If there is an error it is returned in err.
1059 static int htree_dirblock_to_tree(struct file
*dir_file
,
1060 struct inode
*dir
, ext4_lblk_t block
,
1061 struct dx_hash_info
*hinfo
,
1062 __u32 start_hash
, __u32 start_minor_hash
)
1064 struct buffer_head
*bh
;
1065 struct ext4_dir_entry_2
*de
, *top
;
1066 int err
= 0, count
= 0;
1067 struct fscrypt_str fname_crypto_str
= FSTR_INIT(NULL
, 0), tmp_str
;
1068 int csum
= ext4_has_metadata_csum(dir
->i_sb
);
1070 dxtrace(printk(KERN_INFO
"In htree dirblock_to_tree: block %lu\n",
1071 (unsigned long)block
));
1072 bh
= ext4_read_dirblock(dir
, block
, DIRENT_HTREE
);
1076 de
= (struct ext4_dir_entry_2
*) bh
->b_data
;
1077 /* csum entries are not larger in the casefolded encrypted case */
1078 top
= (struct ext4_dir_entry_2
*) ((char *) de
+
1079 dir
->i_sb
->s_blocksize
-
1081 csum
? NULL
: dir
));
1082 /* Check if the directory is encrypted */
1083 if (IS_ENCRYPTED(dir
)) {
1084 err
= fscrypt_prepare_readdir(dir
);
1089 err
= fscrypt_fname_alloc_buffer(EXT4_NAME_LEN
,
1097 for (; de
< top
; de
= ext4_next_entry(de
, dir
->i_sb
->s_blocksize
)) {
1098 if (ext4_check_dir_entry(dir
, NULL
, de
, bh
,
1099 bh
->b_data
, bh
->b_size
,
1100 (block
<<EXT4_BLOCK_SIZE_BITS(dir
->i_sb
))
1101 + ((char *)de
- bh
->b_data
))) {
1102 /* silently ignore the rest of the block */
1105 if (ext4_hash_in_dirent(dir
)) {
1106 if (de
->name_len
&& de
->inode
) {
1107 hinfo
->hash
= EXT4_DIRENT_HASH(de
);
1108 hinfo
->minor_hash
= EXT4_DIRENT_MINOR_HASH(de
);
1111 hinfo
->minor_hash
= 0;
1114 ext4fs_dirhash(dir
, de
->name
, de
->name_len
, hinfo
);
1116 if ((hinfo
->hash
< start_hash
) ||
1117 ((hinfo
->hash
== start_hash
) &&
1118 (hinfo
->minor_hash
< start_minor_hash
)))
1122 if (!IS_ENCRYPTED(dir
)) {
1123 tmp_str
.name
= de
->name
;
1124 tmp_str
.len
= de
->name_len
;
1125 err
= ext4_htree_store_dirent(dir_file
,
1126 hinfo
->hash
, hinfo
->minor_hash
, de
,
1129 int save_len
= fname_crypto_str
.len
;
1130 struct fscrypt_str de_name
= FSTR_INIT(de
->name
,
1133 /* Directory is encrypted */
1134 err
= fscrypt_fname_disk_to_usr(dir
, hinfo
->hash
,
1135 hinfo
->minor_hash
, &de_name
,
1141 err
= ext4_htree_store_dirent(dir_file
,
1142 hinfo
->hash
, hinfo
->minor_hash
, de
,
1144 fname_crypto_str
.len
= save_len
;
1154 fscrypt_fname_free_buffer(&fname_crypto_str
);
1160 * This function fills a red-black tree with information from a
1161 * directory. We start scanning the directory in hash order, starting
1162 * at start_hash and start_minor_hash.
1164 * This function returns the number of entries inserted into the tree,
1165 * or a negative error code.
1167 int ext4_htree_fill_tree(struct file
*dir_file
, __u32 start_hash
,
1168 __u32 start_minor_hash
, __u32
*next_hash
)
1170 struct dx_hash_info hinfo
;
1171 struct ext4_dir_entry_2
*de
;
1172 struct dx_frame frames
[EXT4_HTREE_LEVEL
], *frame
;
1178 struct fscrypt_str tmp_str
;
1180 dxtrace(printk(KERN_DEBUG
"In htree_fill_tree, start hash: %x:%x\n",
1181 start_hash
, start_minor_hash
));
1182 dir
= file_inode(dir_file
);
1183 if (!(ext4_test_inode_flag(dir
, EXT4_INODE_INDEX
))) {
1184 if (ext4_hash_in_dirent(dir
))
1185 hinfo
.hash_version
= DX_HASH_SIPHASH
;
1187 hinfo
.hash_version
=
1188 EXT4_SB(dir
->i_sb
)->s_def_hash_version
;
1189 if (hinfo
.hash_version
<= DX_HASH_TEA
)
1190 hinfo
.hash_version
+=
1191 EXT4_SB(dir
->i_sb
)->s_hash_unsigned
;
1192 hinfo
.seed
= EXT4_SB(dir
->i_sb
)->s_hash_seed
;
1193 if (ext4_has_inline_data(dir
)) {
1194 int has_inline_data
= 1;
1195 count
= ext4_inlinedir_to_tree(dir_file
, dir
, 0,
1199 if (has_inline_data
) {
1204 count
= htree_dirblock_to_tree(dir_file
, dir
, 0, &hinfo
,
1205 start_hash
, start_minor_hash
);
1209 hinfo
.hash
= start_hash
;
1210 hinfo
.minor_hash
= 0;
1211 frame
= dx_probe(NULL
, dir
, &hinfo
, frames
);
1213 return PTR_ERR(frame
);
1215 /* Add '.' and '..' from the htree header */
1216 if (!start_hash
&& !start_minor_hash
) {
1217 de
= (struct ext4_dir_entry_2
*) frames
[0].bh
->b_data
;
1218 tmp_str
.name
= de
->name
;
1219 tmp_str
.len
= de
->name_len
;
1220 err
= ext4_htree_store_dirent(dir_file
, 0, 0,
1226 if (start_hash
< 2 || (start_hash
==2 && start_minor_hash
==0)) {
1227 de
= (struct ext4_dir_entry_2
*) frames
[0].bh
->b_data
;
1228 de
= ext4_next_entry(de
, dir
->i_sb
->s_blocksize
);
1229 tmp_str
.name
= de
->name
;
1230 tmp_str
.len
= de
->name_len
;
1231 err
= ext4_htree_store_dirent(dir_file
, 2, 0,
1239 if (fatal_signal_pending(current
)) {
1244 block
= dx_get_block(frame
->at
);
1245 ret
= htree_dirblock_to_tree(dir_file
, dir
, block
, &hinfo
,
1246 start_hash
, start_minor_hash
);
1253 ret
= ext4_htree_next_block(dir
, HASH_NB_ALWAYS
,
1254 frame
, frames
, &hashval
);
1255 *next_hash
= hashval
;
1261 * Stop if: (a) there are no more entries, or
1262 * (b) we have inserted at least one entry and the
1263 * next hash value is not a continuation
1266 (count
&& ((hashval
& 1) == 0)))
1270 dxtrace(printk(KERN_DEBUG
"Fill tree: returned %d entries, "
1271 "next hash: %x\n", count
, *next_hash
));
1278 static inline int search_dirblock(struct buffer_head
*bh
,
1280 struct ext4_filename
*fname
,
1281 unsigned int offset
,
1282 struct ext4_dir_entry_2
**res_dir
)
1284 return ext4_search_dir(bh
, bh
->b_data
, dir
->i_sb
->s_blocksize
, dir
,
1285 fname
, offset
, res_dir
);
1289 * Directory block splitting, compacting
1293 * Create map of hash values, offsets, and sizes, stored at end of block.
1294 * Returns number of entries mapped.
1296 static int dx_make_map(struct inode
*dir
, struct buffer_head
*bh
,
1297 struct dx_hash_info
*hinfo
,
1298 struct dx_map_entry
*map_tail
)
1301 struct ext4_dir_entry_2
*de
= (struct ext4_dir_entry_2
*)bh
->b_data
;
1302 unsigned int buflen
= bh
->b_size
;
1303 char *base
= bh
->b_data
;
1304 struct dx_hash_info h
= *hinfo
;
1306 if (ext4_has_metadata_csum(dir
->i_sb
))
1307 buflen
-= sizeof(struct ext4_dir_entry_tail
);
1309 while ((char *) de
< base
+ buflen
) {
1310 if (ext4_check_dir_entry(dir
, NULL
, de
, bh
, base
, buflen
,
1311 ((char *)de
) - base
))
1312 return -EFSCORRUPTED
;
1313 if (de
->name_len
&& de
->inode
) {
1314 if (ext4_hash_in_dirent(dir
))
1315 h
.hash
= EXT4_DIRENT_HASH(de
);
1317 ext4fs_dirhash(dir
, de
->name
, de
->name_len
, &h
);
1319 map_tail
->hash
= h
.hash
;
1320 map_tail
->offs
= ((char *) de
- base
)>>2;
1321 map_tail
->size
= le16_to_cpu(de
->rec_len
);
1325 de
= ext4_next_entry(de
, dir
->i_sb
->s_blocksize
);
1330 /* Sort map by hash value */
1331 static void dx_sort_map (struct dx_map_entry
*map
, unsigned count
)
1333 struct dx_map_entry
*p
, *q
, *top
= map
+ count
- 1;
1335 /* Combsort until bubble sort doesn't suck */
1337 count
= count
*10/13;
1338 if (count
- 9 < 2) /* 9, 10 -> 11 */
1340 for (p
= top
, q
= p
- count
; q
>= map
; p
--, q
--)
1341 if (p
->hash
< q
->hash
)
1344 /* Garden variety bubble sort */
1349 if (q
[1].hash
>= q
[0].hash
)
1357 static void dx_insert_block(struct dx_frame
*frame
, u32 hash
, ext4_lblk_t block
)
1359 struct dx_entry
*entries
= frame
->entries
;
1360 struct dx_entry
*old
= frame
->at
, *new = old
+ 1;
1361 int count
= dx_get_count(entries
);
1363 ASSERT(count
< dx_get_limit(entries
));
1364 ASSERT(old
< entries
+ count
);
1365 memmove(new + 1, new, (char *)(entries
+ count
) - (char *)(new));
1366 dx_set_hash(new, hash
);
1367 dx_set_block(new, block
);
1368 dx_set_count(entries
, count
+ 1);
1371 #if IS_ENABLED(CONFIG_UNICODE)
1373 * Test whether a case-insensitive directory entry matches the filename
1374 * being searched for. If quick is set, assume the name being looked up
1375 * is already in the casefolded form.
1377 * Returns: 0 if the directory entry matches, more than 0 if it
1378 * doesn't match or less than zero on error.
1380 static int ext4_ci_compare(const struct inode
*parent
, const struct qstr
*name
,
1381 u8
*de_name
, size_t de_name_len
, bool quick
)
1383 const struct super_block
*sb
= parent
->i_sb
;
1384 const struct unicode_map
*um
= sb
->s_encoding
;
1385 struct fscrypt_str decrypted_name
= FSTR_INIT(NULL
, de_name_len
);
1386 struct qstr entry
= QSTR_INIT(de_name
, de_name_len
);
1389 if (IS_ENCRYPTED(parent
)) {
1390 const struct fscrypt_str encrypted_name
=
1391 FSTR_INIT(de_name
, de_name_len
);
1393 decrypted_name
.name
= kmalloc(de_name_len
, GFP_KERNEL
);
1394 if (!decrypted_name
.name
)
1396 ret
= fscrypt_fname_disk_to_usr(parent
, 0, 0, &encrypted_name
,
1400 entry
.name
= decrypted_name
.name
;
1401 entry
.len
= decrypted_name
.len
;
1405 ret
= utf8_strncasecmp_folded(um
, name
, &entry
);
1407 ret
= utf8_strncasecmp(um
, name
, &entry
);
1409 /* Handle invalid character sequence as either an error
1410 * or as an opaque byte sequence.
1412 if (sb_has_strict_encoding(sb
))
1414 else if (name
->len
!= entry
.len
)
1417 ret
= !!memcmp(name
->name
, entry
.name
, entry
.len
);
1420 kfree(decrypted_name
.name
);
1424 int ext4_fname_setup_ci_filename(struct inode
*dir
, const struct qstr
*iname
,
1425 struct ext4_filename
*name
)
1427 struct fscrypt_str
*cf_name
= &name
->cf_name
;
1428 struct dx_hash_info
*hinfo
= &name
->hinfo
;
1431 if (!IS_CASEFOLDED(dir
) || !dir
->i_sb
->s_encoding
||
1432 (IS_ENCRYPTED(dir
) && !fscrypt_has_encryption_key(dir
))) {
1433 cf_name
->name
= NULL
;
1437 cf_name
->name
= kmalloc(EXT4_NAME_LEN
, GFP_NOFS
);
1441 len
= utf8_casefold(dir
->i_sb
->s_encoding
,
1442 iname
, cf_name
->name
,
1445 kfree(cf_name
->name
);
1446 cf_name
->name
= NULL
;
1448 cf_name
->len
= (unsigned) len
;
1449 if (!IS_ENCRYPTED(dir
))
1452 hinfo
->hash_version
= DX_HASH_SIPHASH
;
1455 ext4fs_dirhash(dir
, cf_name
->name
, cf_name
->len
, hinfo
);
1457 ext4fs_dirhash(dir
, iname
->name
, iname
->len
, hinfo
);
1463 * Test whether a directory entry matches the filename being searched for.
1465 * Return: %true if the directory entry matches, otherwise %false.
1467 static bool ext4_match(struct inode
*parent
,
1468 const struct ext4_filename
*fname
,
1469 struct ext4_dir_entry_2
*de
)
1471 struct fscrypt_name f
;
1476 f
.usr_fname
= fname
->usr_fname
;
1477 f
.disk_name
= fname
->disk_name
;
1478 #ifdef CONFIG_FS_ENCRYPTION
1479 f
.crypto_buf
= fname
->crypto_buf
;
1482 #if IS_ENABLED(CONFIG_UNICODE)
1483 if (parent
->i_sb
->s_encoding
&& IS_CASEFOLDED(parent
) &&
1484 (!IS_ENCRYPTED(parent
) || fscrypt_has_encryption_key(parent
))) {
1485 if (fname
->cf_name
.name
) {
1486 struct qstr cf
= {.name
= fname
->cf_name
.name
,
1487 .len
= fname
->cf_name
.len
};
1488 if (IS_ENCRYPTED(parent
)) {
1489 if (fname
->hinfo
.hash
!= EXT4_DIRENT_HASH(de
) ||
1490 fname
->hinfo
.minor_hash
!=
1491 EXT4_DIRENT_MINOR_HASH(de
)) {
1496 return !ext4_ci_compare(parent
, &cf
, de
->name
,
1497 de
->name_len
, true);
1499 return !ext4_ci_compare(parent
, fname
->usr_fname
, de
->name
,
1500 de
->name_len
, false);
1504 return fscrypt_match_name(&f
, de
->name
, de
->name_len
);
1508 * Returns 0 if not found, -1 on failure, and 1 on success
1510 int ext4_search_dir(struct buffer_head
*bh
, char *search_buf
, int buf_size
,
1511 struct inode
*dir
, struct ext4_filename
*fname
,
1512 unsigned int offset
, struct ext4_dir_entry_2
**res_dir
)
1514 struct ext4_dir_entry_2
* de
;
1518 de
= (struct ext4_dir_entry_2
*)search_buf
;
1519 dlimit
= search_buf
+ buf_size
;
1520 while ((char *) de
< dlimit
- EXT4_BASE_DIR_LEN
) {
1521 /* this code is executed quadratically often */
1522 /* do minimal checking `by hand' */
1523 if (de
->name
+ de
->name_len
<= dlimit
&&
1524 ext4_match(dir
, fname
, de
)) {
1525 /* found a match - just to be sure, do
1527 if (ext4_check_dir_entry(dir
, NULL
, de
, bh
, search_buf
,
1533 /* prevent looping on a bad block */
1534 de_len
= ext4_rec_len_from_disk(de
->rec_len
,
1535 dir
->i_sb
->s_blocksize
);
1539 de
= (struct ext4_dir_entry_2
*) ((char *) de
+ de_len
);
1544 static int is_dx_internal_node(struct inode
*dir
, ext4_lblk_t block
,
1545 struct ext4_dir_entry
*de
)
1547 struct super_block
*sb
= dir
->i_sb
;
1553 if (de
->inode
== 0 &&
1554 ext4_rec_len_from_disk(de
->rec_len
, sb
->s_blocksize
) ==
1561 * __ext4_find_entry()
1563 * finds an entry in the specified directory with the wanted name. It
1564 * returns the cache buffer in which the entry was found, and the entry
1565 * itself (as a parameter - res_dir). It does NOT read the inode of the
1566 * entry - you'll have to do that yourself if you want to.
1568 * The returned buffer_head has ->b_count elevated. The caller is expected
1569 * to brelse() it when appropriate.
1571 static struct buffer_head
*__ext4_find_entry(struct inode
*dir
,
1572 struct ext4_filename
*fname
,
1573 struct ext4_dir_entry_2
**res_dir
,
1576 struct super_block
*sb
;
1577 struct buffer_head
*bh_use
[NAMEI_RA_SIZE
];
1578 struct buffer_head
*bh
, *ret
= NULL
;
1579 ext4_lblk_t start
, block
;
1580 const u8
*name
= fname
->usr_fname
->name
;
1581 size_t ra_max
= 0; /* Number of bh's in the readahead
1583 size_t ra_ptr
= 0; /* Current index into readahead
1585 ext4_lblk_t nblocks
;
1586 int i
, namelen
, retval
;
1590 namelen
= fname
->usr_fname
->len
;
1591 if (namelen
> EXT4_NAME_LEN
)
1594 if (ext4_has_inline_data(dir
)) {
1595 int has_inline_data
= 1;
1596 ret
= ext4_find_inline_entry(dir
, fname
, res_dir
,
1599 *inlined
= has_inline_data
;
1600 if (has_inline_data
)
1601 goto cleanup_and_exit
;
1604 if ((namelen
<= 2) && (name
[0] == '.') &&
1605 (name
[1] == '.' || name
[1] == '\0')) {
1607 * "." or ".." will only be in the first block
1608 * NFS may look up ".."; "." should be handled by the VFS
1615 ret
= ext4_dx_find_entry(dir
, fname
, res_dir
);
1617 * On success, or if the error was file not found,
1618 * return. Otherwise, fall back to doing a search the
1619 * old fashioned way.
1621 if (!IS_ERR(ret
) || PTR_ERR(ret
) != ERR_BAD_DX_DIR
)
1622 goto cleanup_and_exit
;
1623 dxtrace(printk(KERN_DEBUG
"ext4_find_entry: dx failed, "
1627 nblocks
= dir
->i_size
>> EXT4_BLOCK_SIZE_BITS(sb
);
1630 goto cleanup_and_exit
;
1632 start
= EXT4_I(dir
)->i_dir_start_lookup
;
1633 if (start
>= nblocks
)
1639 * We deal with the read-ahead logic here.
1642 if (ra_ptr
>= ra_max
) {
1643 /* Refill the readahead buffer */
1646 ra_max
= start
- block
;
1648 ra_max
= nblocks
- block
;
1649 ra_max
= min(ra_max
, ARRAY_SIZE(bh_use
));
1650 retval
= ext4_bread_batch(dir
, block
, ra_max
,
1651 false /* wait */, bh_use
);
1653 ret
= ERR_PTR(retval
);
1655 goto cleanup_and_exit
;
1658 if ((bh
= bh_use
[ra_ptr
++]) == NULL
)
1661 if (!buffer_uptodate(bh
)) {
1662 EXT4_ERROR_INODE_ERR(dir
, EIO
,
1663 "reading directory lblock %lu",
1664 (unsigned long) block
);
1666 ret
= ERR_PTR(-EIO
);
1667 goto cleanup_and_exit
;
1669 if (!buffer_verified(bh
) &&
1670 !is_dx_internal_node(dir
, block
,
1671 (struct ext4_dir_entry
*)bh
->b_data
) &&
1672 !ext4_dirblock_csum_verify(dir
, bh
)) {
1673 EXT4_ERROR_INODE_ERR(dir
, EFSBADCRC
,
1674 "checksumming directory "
1675 "block %lu", (unsigned long)block
);
1677 ret
= ERR_PTR(-EFSBADCRC
);
1678 goto cleanup_and_exit
;
1680 set_buffer_verified(bh
);
1681 i
= search_dirblock(bh
, dir
, fname
,
1682 block
<< EXT4_BLOCK_SIZE_BITS(sb
), res_dir
);
1684 EXT4_I(dir
)->i_dir_start_lookup
= block
;
1686 goto cleanup_and_exit
;
1690 goto cleanup_and_exit
;
1693 if (++block
>= nblocks
)
1695 } while (block
!= start
);
1698 * If the directory has grown while we were searching, then
1699 * search the last part of the directory before giving up.
1702 nblocks
= dir
->i_size
>> EXT4_BLOCK_SIZE_BITS(sb
);
1703 if (block
< nblocks
) {
1709 /* Clean up the read-ahead blocks */
1710 for (; ra_ptr
< ra_max
; ra_ptr
++)
1711 brelse(bh_use
[ra_ptr
]);
1715 static struct buffer_head
*ext4_find_entry(struct inode
*dir
,
1716 const struct qstr
*d_name
,
1717 struct ext4_dir_entry_2
**res_dir
,
1721 struct ext4_filename fname
;
1722 struct buffer_head
*bh
;
1724 err
= ext4_fname_setup_filename(dir
, d_name
, 1, &fname
);
1728 return ERR_PTR(err
);
1730 bh
= __ext4_find_entry(dir
, &fname
, res_dir
, inlined
);
1732 ext4_fname_free_filename(&fname
);
1736 static struct buffer_head
*ext4_lookup_entry(struct inode
*dir
,
1737 struct dentry
*dentry
,
1738 struct ext4_dir_entry_2
**res_dir
)
1741 struct ext4_filename fname
;
1742 struct buffer_head
*bh
;
1744 err
= ext4_fname_prepare_lookup(dir
, dentry
, &fname
);
1745 generic_set_encrypted_ci_d_ops(dentry
);
1749 return ERR_PTR(err
);
1751 bh
= __ext4_find_entry(dir
, &fname
, res_dir
, NULL
);
1753 ext4_fname_free_filename(&fname
);
1757 static struct buffer_head
* ext4_dx_find_entry(struct inode
*dir
,
1758 struct ext4_filename
*fname
,
1759 struct ext4_dir_entry_2
**res_dir
)
1761 struct super_block
* sb
= dir
->i_sb
;
1762 struct dx_frame frames
[EXT4_HTREE_LEVEL
], *frame
;
1763 struct buffer_head
*bh
;
1767 #ifdef CONFIG_FS_ENCRYPTION
1770 frame
= dx_probe(fname
, dir
, NULL
, frames
);
1772 return (struct buffer_head
*) frame
;
1774 block
= dx_get_block(frame
->at
);
1775 bh
= ext4_read_dirblock(dir
, block
, DIRENT_HTREE
);
1779 retval
= search_dirblock(bh
, dir
, fname
,
1780 block
<< EXT4_BLOCK_SIZE_BITS(sb
),
1786 bh
= ERR_PTR(ERR_BAD_DX_DIR
);
1790 /* Check to see if we should continue to search */
1791 retval
= ext4_htree_next_block(dir
, fname
->hinfo
.hash
, frame
,
1794 ext4_warning_inode(dir
,
1795 "error %d reading directory index block",
1797 bh
= ERR_PTR(retval
);
1800 } while (retval
== 1);
1804 dxtrace(printk(KERN_DEBUG
"%s not found\n", fname
->usr_fname
->name
));
1810 static struct dentry
*ext4_lookup(struct inode
*dir
, struct dentry
*dentry
, unsigned int flags
)
1812 struct inode
*inode
;
1813 struct ext4_dir_entry_2
*de
;
1814 struct buffer_head
*bh
;
1816 if (dentry
->d_name
.len
> EXT4_NAME_LEN
)
1817 return ERR_PTR(-ENAMETOOLONG
);
1819 bh
= ext4_lookup_entry(dir
, dentry
, &de
);
1821 return ERR_CAST(bh
);
1824 __u32 ino
= le32_to_cpu(de
->inode
);
1826 if (!ext4_valid_inum(dir
->i_sb
, ino
)) {
1827 EXT4_ERROR_INODE(dir
, "bad inode number: %u", ino
);
1828 return ERR_PTR(-EFSCORRUPTED
);
1830 if (unlikely(ino
== dir
->i_ino
)) {
1831 EXT4_ERROR_INODE(dir
, "'%pd' linked to parent dir",
1833 return ERR_PTR(-EFSCORRUPTED
);
1835 inode
= ext4_iget(dir
->i_sb
, ino
, EXT4_IGET_NORMAL
);
1836 if (inode
== ERR_PTR(-ESTALE
)) {
1837 EXT4_ERROR_INODE(dir
,
1838 "deleted inode referenced: %u",
1840 return ERR_PTR(-EFSCORRUPTED
);
1842 if (!IS_ERR(inode
) && IS_ENCRYPTED(dir
) &&
1843 (S_ISDIR(inode
->i_mode
) || S_ISLNK(inode
->i_mode
)) &&
1844 !fscrypt_has_permitted_context(dir
, inode
)) {
1845 ext4_warning(inode
->i_sb
,
1846 "Inconsistent encryption contexts: %lu/%lu",
1847 dir
->i_ino
, inode
->i_ino
);
1849 return ERR_PTR(-EPERM
);
1853 #if IS_ENABLED(CONFIG_UNICODE)
1854 if (!inode
&& IS_CASEFOLDED(dir
)) {
1855 /* Eventually we want to call d_add_ci(dentry, NULL)
1856 * for negative dentries in the encoding case as
1857 * well. For now, prevent the negative dentry
1858 * from being cached.
1863 return d_splice_alias(inode
, dentry
);
1867 struct dentry
*ext4_get_parent(struct dentry
*child
)
1870 struct ext4_dir_entry_2
* de
;
1871 struct buffer_head
*bh
;
1873 bh
= ext4_find_entry(d_inode(child
), &dotdot_name
, &de
, NULL
);
1875 return ERR_CAST(bh
);
1877 return ERR_PTR(-ENOENT
);
1878 ino
= le32_to_cpu(de
->inode
);
1881 if (!ext4_valid_inum(child
->d_sb
, ino
)) {
1882 EXT4_ERROR_INODE(d_inode(child
),
1883 "bad parent inode number: %u", ino
);
1884 return ERR_PTR(-EFSCORRUPTED
);
1887 return d_obtain_alias(ext4_iget(child
->d_sb
, ino
, EXT4_IGET_NORMAL
));
1891 * Move count entries from end of map between two memory locations.
1892 * Returns pointer to last entry moved.
1894 static struct ext4_dir_entry_2
*
1895 dx_move_dirents(struct inode
*dir
, char *from
, char *to
,
1896 struct dx_map_entry
*map
, int count
,
1899 unsigned rec_len
= 0;
1902 struct ext4_dir_entry_2
*de
= (struct ext4_dir_entry_2
*)
1903 (from
+ (map
->offs
<<2));
1904 rec_len
= ext4_dir_rec_len(de
->name_len
, dir
);
1906 memcpy (to
, de
, rec_len
);
1907 ((struct ext4_dir_entry_2
*) to
)->rec_len
=
1908 ext4_rec_len_to_disk(rec_len
, blocksize
);
1910 /* wipe dir_entry excluding the rec_len field */
1912 memset(&de
->name_len
, 0, ext4_rec_len_from_disk(de
->rec_len
,
1914 offsetof(struct ext4_dir_entry_2
,
1920 return (struct ext4_dir_entry_2
*) (to
- rec_len
);
1924 * Compact each dir entry in the range to the minimal rec_len.
1925 * Returns pointer to last entry in range.
1927 static struct ext4_dir_entry_2
*dx_pack_dirents(struct inode
*dir
, char *base
,
1928 unsigned int blocksize
)
1930 struct ext4_dir_entry_2
*next
, *to
, *prev
, *de
= (struct ext4_dir_entry_2
*) base
;
1931 unsigned rec_len
= 0;
1934 while ((char*)de
< base
+ blocksize
) {
1935 next
= ext4_next_entry(de
, blocksize
);
1936 if (de
->inode
&& de
->name_len
) {
1937 rec_len
= ext4_dir_rec_len(de
->name_len
, dir
);
1939 memmove(to
, de
, rec_len
);
1940 to
->rec_len
= ext4_rec_len_to_disk(rec_len
, blocksize
);
1942 to
= (struct ext4_dir_entry_2
*) (((char *) to
) + rec_len
);
1950 * Split a full leaf block to make room for a new dir entry.
1951 * Allocate a new block, and move entries so that they are approx. equally full.
1952 * Returns pointer to de in block into which the new entry will be inserted.
1954 static struct ext4_dir_entry_2
*do_split(handle_t
*handle
, struct inode
*dir
,
1955 struct buffer_head
**bh
,struct dx_frame
*frame
,
1956 struct dx_hash_info
*hinfo
)
1958 unsigned blocksize
= dir
->i_sb
->s_blocksize
;
1961 struct buffer_head
*bh2
;
1962 ext4_lblk_t newblock
;
1964 struct dx_map_entry
*map
;
1965 char *data1
= (*bh
)->b_data
, *data2
;
1966 unsigned split
, move
, size
;
1967 struct ext4_dir_entry_2
*de
= NULL
, *de2
;
1971 if (ext4_has_metadata_csum(dir
->i_sb
))
1972 csum_size
= sizeof(struct ext4_dir_entry_tail
);
1974 bh2
= ext4_append(handle
, dir
, &newblock
);
1978 return (struct ext4_dir_entry_2
*) bh2
;
1981 BUFFER_TRACE(*bh
, "get_write_access");
1982 err
= ext4_journal_get_write_access(handle
, dir
->i_sb
, *bh
,
1987 BUFFER_TRACE(frame
->bh
, "get_write_access");
1988 err
= ext4_journal_get_write_access(handle
, dir
->i_sb
, frame
->bh
,
1993 data2
= bh2
->b_data
;
1995 /* create map in the end of data2 block */
1996 map
= (struct dx_map_entry
*) (data2
+ blocksize
);
1997 count
= dx_make_map(dir
, *bh
, hinfo
, map
);
2003 dx_sort_map(map
, count
);
2004 /* Ensure that neither split block is over half full */
2007 for (i
= count
-1; i
>= 0; i
--) {
2008 /* is more than half of this entry in 2nd half of the block? */
2009 if (size
+ map
[i
].size
/2 > blocksize
/2)
2011 size
+= map
[i
].size
;
2015 * map index at which we will split
2017 * If the sum of active entries didn't exceed half the block size, just
2018 * split it in half by count; each resulting block will have at least
2019 * half the space free.
2022 split
= count
- move
;
2026 hash2
= map
[split
].hash
;
2027 continued
= hash2
== map
[split
- 1].hash
;
2028 dxtrace(printk(KERN_INFO
"Split block %lu at %x, %i/%i\n",
2029 (unsigned long)dx_get_block(frame
->at
),
2030 hash2
, split
, count
-split
));
2032 /* Fancy dance to stay within two buffers */
2033 de2
= dx_move_dirents(dir
, data1
, data2
, map
+ split
, count
- split
,
2035 de
= dx_pack_dirents(dir
, data1
, blocksize
);
2036 de
->rec_len
= ext4_rec_len_to_disk(data1
+ (blocksize
- csum_size
) -
2039 de2
->rec_len
= ext4_rec_len_to_disk(data2
+ (blocksize
- csum_size
) -
2043 ext4_initialize_dirent_tail(*bh
, blocksize
);
2044 ext4_initialize_dirent_tail(bh2
, blocksize
);
2047 dxtrace(dx_show_leaf(dir
, hinfo
, (struct ext4_dir_entry_2
*) data1
,
2049 dxtrace(dx_show_leaf(dir
, hinfo
, (struct ext4_dir_entry_2
*) data2
,
2052 /* Which block gets the new entry? */
2053 if (hinfo
->hash
>= hash2
) {
2057 dx_insert_block(frame
, hash2
+ continued
, newblock
);
2058 err
= ext4_handle_dirty_dirblock(handle
, dir
, bh2
);
2061 err
= ext4_handle_dirty_dx_node(handle
, dir
, frame
->bh
);
2065 dxtrace(dx_show_index("frame", frame
->entries
));
2072 ext4_std_error(dir
->i_sb
, err
);
2073 return ERR_PTR(err
);
2076 int ext4_find_dest_de(struct inode
*dir
, struct inode
*inode
,
2077 struct buffer_head
*bh
,
2078 void *buf
, int buf_size
,
2079 struct ext4_filename
*fname
,
2080 struct ext4_dir_entry_2
**dest_de
)
2082 struct ext4_dir_entry_2
*de
;
2083 unsigned short reclen
= ext4_dir_rec_len(fname_len(fname
), dir
);
2085 unsigned int offset
= 0;
2089 top
= buf
+ buf_size
- reclen
;
2090 while ((char *) de
<= top
) {
2091 if (ext4_check_dir_entry(dir
, NULL
, de
, bh
,
2092 buf
, buf_size
, offset
))
2093 return -EFSCORRUPTED
;
2094 if (ext4_match(dir
, fname
, de
))
2096 nlen
= ext4_dir_rec_len(de
->name_len
, dir
);
2097 rlen
= ext4_rec_len_from_disk(de
->rec_len
, buf_size
);
2098 if ((de
->inode
? rlen
- nlen
: rlen
) >= reclen
)
2100 de
= (struct ext4_dir_entry_2
*)((char *)de
+ rlen
);
2103 if ((char *) de
> top
)
2110 void ext4_insert_dentry(struct inode
*dir
,
2111 struct inode
*inode
,
2112 struct ext4_dir_entry_2
*de
,
2114 struct ext4_filename
*fname
)
2119 nlen
= ext4_dir_rec_len(de
->name_len
, dir
);
2120 rlen
= ext4_rec_len_from_disk(de
->rec_len
, buf_size
);
2122 struct ext4_dir_entry_2
*de1
=
2123 (struct ext4_dir_entry_2
*)((char *)de
+ nlen
);
2124 de1
->rec_len
= ext4_rec_len_to_disk(rlen
- nlen
, buf_size
);
2125 de
->rec_len
= ext4_rec_len_to_disk(nlen
, buf_size
);
2128 de
->file_type
= EXT4_FT_UNKNOWN
;
2129 de
->inode
= cpu_to_le32(inode
->i_ino
);
2130 ext4_set_de_type(inode
->i_sb
, de
, inode
->i_mode
);
2131 de
->name_len
= fname_len(fname
);
2132 memcpy(de
->name
, fname_name(fname
), fname_len(fname
));
2133 if (ext4_hash_in_dirent(dir
)) {
2134 struct dx_hash_info
*hinfo
= &fname
->hinfo
;
2136 EXT4_DIRENT_HASHES(de
)->hash
= cpu_to_le32(hinfo
->hash
);
2137 EXT4_DIRENT_HASHES(de
)->minor_hash
=
2138 cpu_to_le32(hinfo
->minor_hash
);
2143 * Add a new entry into a directory (leaf) block. If de is non-NULL,
2144 * it points to a directory entry which is guaranteed to be large
2145 * enough for new directory entry. If de is NULL, then
2146 * add_dirent_to_buf will attempt search the directory block for
2147 * space. It will return -ENOSPC if no space is available, and -EIO
2148 * and -EEXIST if directory entry already exists.
2150 static int add_dirent_to_buf(handle_t
*handle
, struct ext4_filename
*fname
,
2152 struct inode
*inode
, struct ext4_dir_entry_2
*de
,
2153 struct buffer_head
*bh
)
2155 unsigned int blocksize
= dir
->i_sb
->s_blocksize
;
2159 if (ext4_has_metadata_csum(inode
->i_sb
))
2160 csum_size
= sizeof(struct ext4_dir_entry_tail
);
2163 err
= ext4_find_dest_de(dir
, inode
, bh
, bh
->b_data
,
2164 blocksize
- csum_size
, fname
, &de
);
2168 BUFFER_TRACE(bh
, "get_write_access");
2169 err
= ext4_journal_get_write_access(handle
, dir
->i_sb
, bh
,
2172 ext4_std_error(dir
->i_sb
, err
);
2176 /* By now the buffer is marked for journaling */
2177 ext4_insert_dentry(dir
, inode
, de
, blocksize
, fname
);
2180 * XXX shouldn't update any times until successful
2181 * completion of syscall, but too many callers depend
2184 * XXX similarly, too many callers depend on
2185 * ext4_new_inode() setting the times, but error
2186 * recovery deletes the inode, so the worst that can
2187 * happen is that the times are slightly out of date
2188 * and/or different from the directory change time.
2190 dir
->i_mtime
= dir
->i_ctime
= current_time(dir
);
2191 ext4_update_dx_flag(dir
);
2192 inode_inc_iversion(dir
);
2193 err2
= ext4_mark_inode_dirty(handle
, dir
);
2194 BUFFER_TRACE(bh
, "call ext4_handle_dirty_metadata");
2195 err
= ext4_handle_dirty_dirblock(handle
, dir
, bh
);
2197 ext4_std_error(dir
->i_sb
, err
);
2198 return err
? err
: err2
;
2202 * This converts a one block unindexed directory to a 3 block indexed
2203 * directory, and adds the dentry to the indexed directory.
2205 static int make_indexed_dir(handle_t
*handle
, struct ext4_filename
*fname
,
2207 struct inode
*inode
, struct buffer_head
*bh
)
2209 struct buffer_head
*bh2
;
2210 struct dx_root
*root
;
2211 struct dx_frame frames
[EXT4_HTREE_LEVEL
], *frame
;
2212 struct dx_entry
*entries
;
2213 struct ext4_dir_entry_2
*de
, *de2
;
2219 struct fake_dirent
*fde
;
2222 if (ext4_has_metadata_csum(inode
->i_sb
))
2223 csum_size
= sizeof(struct ext4_dir_entry_tail
);
2225 blocksize
= dir
->i_sb
->s_blocksize
;
2226 dxtrace(printk(KERN_DEBUG
"Creating index: inode %lu\n", dir
->i_ino
));
2227 BUFFER_TRACE(bh
, "get_write_access");
2228 retval
= ext4_journal_get_write_access(handle
, dir
->i_sb
, bh
,
2231 ext4_std_error(dir
->i_sb
, retval
);
2235 root
= (struct dx_root
*) bh
->b_data
;
2237 /* The 0th block becomes the root, move the dirents out */
2238 fde
= &root
->dotdot
;
2239 de
= (struct ext4_dir_entry_2
*)((char *)fde
+
2240 ext4_rec_len_from_disk(fde
->rec_len
, blocksize
));
2241 if ((char *) de
>= (((char *) root
) + blocksize
)) {
2242 EXT4_ERROR_INODE(dir
, "invalid rec_len for '..'");
2244 return -EFSCORRUPTED
;
2246 len
= ((char *) root
) + (blocksize
- csum_size
) - (char *) de
;
2248 /* Allocate new block for the 0th block's dirents */
2249 bh2
= ext4_append(handle
, dir
, &block
);
2252 return PTR_ERR(bh2
);
2254 ext4_set_inode_flag(dir
, EXT4_INODE_INDEX
);
2255 data2
= bh2
->b_data
;
2257 memcpy(data2
, de
, len
);
2258 memset(de
, 0, len
); /* wipe old data */
2259 de
= (struct ext4_dir_entry_2
*) data2
;
2261 while ((char *)(de2
= ext4_next_entry(de
, blocksize
)) < top
) {
2262 if (ext4_check_dir_entry(dir
, NULL
, de
, bh2
, data2
, len
,
2263 (data2
+ (blocksize
- csum_size
) -
2267 return -EFSCORRUPTED
;
2271 de
->rec_len
= ext4_rec_len_to_disk(data2
+ (blocksize
- csum_size
) -
2272 (char *) de
, blocksize
);
2275 ext4_initialize_dirent_tail(bh2
, blocksize
);
2277 /* Initialize the root; the dot dirents already exist */
2278 de
= (struct ext4_dir_entry_2
*) (&root
->dotdot
);
2279 de
->rec_len
= ext4_rec_len_to_disk(
2280 blocksize
- ext4_dir_rec_len(2, NULL
), blocksize
);
2281 memset (&root
->info
, 0, sizeof(root
->info
));
2282 root
->info
.info_length
= sizeof(root
->info
);
2283 if (ext4_hash_in_dirent(dir
))
2284 root
->info
.hash_version
= DX_HASH_SIPHASH
;
2286 root
->info
.hash_version
=
2287 EXT4_SB(dir
->i_sb
)->s_def_hash_version
;
2289 entries
= root
->entries
;
2290 dx_set_block(entries
, 1);
2291 dx_set_count(entries
, 1);
2292 dx_set_limit(entries
, dx_root_limit(dir
, sizeof(root
->info
)));
2294 /* Initialize as for dx_probe */
2295 fname
->hinfo
.hash_version
= root
->info
.hash_version
;
2296 if (fname
->hinfo
.hash_version
<= DX_HASH_TEA
)
2297 fname
->hinfo
.hash_version
+= EXT4_SB(dir
->i_sb
)->s_hash_unsigned
;
2298 fname
->hinfo
.seed
= EXT4_SB(dir
->i_sb
)->s_hash_seed
;
2300 /* casefolded encrypted hashes are computed on fname setup */
2301 if (!ext4_hash_in_dirent(dir
))
2302 ext4fs_dirhash(dir
, fname_name(fname
),
2303 fname_len(fname
), &fname
->hinfo
);
2305 memset(frames
, 0, sizeof(frames
));
2307 frame
->entries
= entries
;
2308 frame
->at
= entries
;
2311 retval
= ext4_handle_dirty_dx_node(handle
, dir
, frame
->bh
);
2314 retval
= ext4_handle_dirty_dirblock(handle
, dir
, bh2
);
2318 de
= do_split(handle
,dir
, &bh2
, frame
, &fname
->hinfo
);
2320 retval
= PTR_ERR(de
);
2324 retval
= add_dirent_to_buf(handle
, fname
, dir
, inode
, de
, bh2
);
2327 * Even if the block split failed, we have to properly write
2328 * out all the changes we did so far. Otherwise we can end up
2329 * with corrupted filesystem.
2332 ext4_mark_inode_dirty(handle
, dir
);
2341 * adds a file entry to the specified directory, using the same
2342 * semantics as ext4_find_entry(). It returns NULL if it failed.
2344 * NOTE!! The inode part of 'de' is left at 0 - which means you
2345 * may not sleep between calling this and putting something into
2346 * the entry, as someone else might have used it while you slept.
2348 static int ext4_add_entry(handle_t
*handle
, struct dentry
*dentry
,
2349 struct inode
*inode
)
2351 struct inode
*dir
= d_inode(dentry
->d_parent
);
2352 struct buffer_head
*bh
= NULL
;
2353 struct ext4_dir_entry_2
*de
;
2354 struct super_block
*sb
;
2355 struct ext4_filename fname
;
2359 ext4_lblk_t block
, blocks
;
2362 if (ext4_has_metadata_csum(inode
->i_sb
))
2363 csum_size
= sizeof(struct ext4_dir_entry_tail
);
2366 blocksize
= sb
->s_blocksize
;
2367 if (!dentry
->d_name
.len
)
2370 if (fscrypt_is_nokey_name(dentry
))
2373 #if IS_ENABLED(CONFIG_UNICODE)
2374 if (sb_has_strict_encoding(sb
) && IS_CASEFOLDED(dir
) &&
2375 sb
->s_encoding
&& utf8_validate(sb
->s_encoding
, &dentry
->d_name
))
2379 retval
= ext4_fname_setup_filename(dir
, &dentry
->d_name
, 0, &fname
);
2383 if (ext4_has_inline_data(dir
)) {
2384 retval
= ext4_try_add_inline_entry(handle
, &fname
, dir
, inode
);
2394 retval
= ext4_dx_add_entry(handle
, &fname
, dir
, inode
);
2395 if (!retval
|| (retval
!= ERR_BAD_DX_DIR
))
2397 /* Can we just ignore htree data? */
2398 if (ext4_has_metadata_csum(sb
)) {
2399 EXT4_ERROR_INODE(dir
,
2400 "Directory has corrupted htree index.");
2401 retval
= -EFSCORRUPTED
;
2404 ext4_clear_inode_flag(dir
, EXT4_INODE_INDEX
);
2406 retval
= ext4_mark_inode_dirty(handle
, dir
);
2407 if (unlikely(retval
))
2410 blocks
= dir
->i_size
>> sb
->s_blocksize_bits
;
2411 for (block
= 0; block
< blocks
; block
++) {
2412 bh
= ext4_read_dirblock(dir
, block
, DIRENT
);
2414 bh
= ext4_bread(handle
, dir
, block
,
2415 EXT4_GET_BLOCKS_CREATE
);
2416 goto add_to_new_block
;
2419 retval
= PTR_ERR(bh
);
2423 retval
= add_dirent_to_buf(handle
, &fname
, dir
, inode
,
2425 if (retval
!= -ENOSPC
)
2428 if (blocks
== 1 && !dx_fallback
&&
2429 ext4_has_feature_dir_index(sb
)) {
2430 retval
= make_indexed_dir(handle
, &fname
, dir
,
2432 bh
= NULL
; /* make_indexed_dir releases bh */
2437 bh
= ext4_append(handle
, dir
, &block
);
2440 retval
= PTR_ERR(bh
);
2444 de
= (struct ext4_dir_entry_2
*) bh
->b_data
;
2446 de
->rec_len
= ext4_rec_len_to_disk(blocksize
- csum_size
, blocksize
);
2449 ext4_initialize_dirent_tail(bh
, blocksize
);
2451 retval
= add_dirent_to_buf(handle
, &fname
, dir
, inode
, de
, bh
);
2453 ext4_fname_free_filename(&fname
);
2456 ext4_set_inode_state(inode
, EXT4_STATE_NEWENTRY
);
2461 * Returns 0 for success, or a negative error value
2463 static int ext4_dx_add_entry(handle_t
*handle
, struct ext4_filename
*fname
,
2464 struct inode
*dir
, struct inode
*inode
)
2466 struct dx_frame frames
[EXT4_HTREE_LEVEL
], *frame
;
2467 struct dx_entry
*entries
, *at
;
2468 struct buffer_head
*bh
;
2469 struct super_block
*sb
= dir
->i_sb
;
2470 struct ext4_dir_entry_2
*de
;
2476 frame
= dx_probe(fname
, dir
, NULL
, frames
);
2478 return PTR_ERR(frame
);
2479 entries
= frame
->entries
;
2481 bh
= ext4_read_dirblock(dir
, dx_get_block(frame
->at
), DIRENT_HTREE
);
2488 BUFFER_TRACE(bh
, "get_write_access");
2489 err
= ext4_journal_get_write_access(handle
, sb
, bh
, EXT4_JTR_NONE
);
2493 err
= add_dirent_to_buf(handle
, fname
, dir
, inode
, NULL
, bh
);
2498 /* Block full, should compress but for now just split */
2499 dxtrace(printk(KERN_DEBUG
"using %u of %u node entries\n",
2500 dx_get_count(entries
), dx_get_limit(entries
)));
2501 /* Need to split index? */
2502 if (dx_get_count(entries
) == dx_get_limit(entries
)) {
2503 ext4_lblk_t newblock
;
2504 int levels
= frame
- frames
+ 1;
2505 unsigned int icount
;
2507 struct dx_entry
*entries2
;
2508 struct dx_node
*node2
;
2509 struct buffer_head
*bh2
;
2511 while (frame
> frames
) {
2512 if (dx_get_count((frame
- 1)->entries
) <
2513 dx_get_limit((frame
- 1)->entries
)) {
2517 frame
--; /* split higher index block */
2519 entries
= frame
->entries
;
2522 if (add_level
&& levels
== ext4_dir_htree_level(sb
)) {
2523 ext4_warning(sb
, "Directory (ino: %lu) index full, "
2524 "reach max htree level :%d",
2525 dir
->i_ino
, levels
);
2526 if (ext4_dir_htree_level(sb
) < EXT4_HTREE_LEVEL
) {
2527 ext4_warning(sb
, "Large directory feature is "
2528 "not enabled on this "
2534 icount
= dx_get_count(entries
);
2535 bh2
= ext4_append(handle
, dir
, &newblock
);
2540 node2
= (struct dx_node
*)(bh2
->b_data
);
2541 entries2
= node2
->entries
;
2542 memset(&node2
->fake
, 0, sizeof(struct fake_dirent
));
2543 node2
->fake
.rec_len
= ext4_rec_len_to_disk(sb
->s_blocksize
,
2545 BUFFER_TRACE(frame
->bh
, "get_write_access");
2546 err
= ext4_journal_get_write_access(handle
, sb
, frame
->bh
,
2551 unsigned icount1
= icount
/2, icount2
= icount
- icount1
;
2552 unsigned hash2
= dx_get_hash(entries
+ icount1
);
2553 dxtrace(printk(KERN_DEBUG
"Split index %i/%i\n",
2556 BUFFER_TRACE(frame
->bh
, "get_write_access"); /* index root */
2557 err
= ext4_journal_get_write_access(handle
, sb
,
2563 memcpy((char *) entries2
, (char *) (entries
+ icount1
),
2564 icount2
* sizeof(struct dx_entry
));
2565 dx_set_count(entries
, icount1
);
2566 dx_set_count(entries2
, icount2
);
2567 dx_set_limit(entries2
, dx_node_limit(dir
));
2569 /* Which index block gets the new entry? */
2570 if (at
- entries
>= icount1
) {
2571 frame
->at
= at
- entries
- icount1
+ entries2
;
2572 frame
->entries
= entries
= entries2
;
2573 swap(frame
->bh
, bh2
);
2575 dx_insert_block((frame
- 1), hash2
, newblock
);
2576 dxtrace(dx_show_index("node", frame
->entries
));
2577 dxtrace(dx_show_index("node",
2578 ((struct dx_node
*) bh2
->b_data
)->entries
));
2579 err
= ext4_handle_dirty_dx_node(handle
, dir
, bh2
);
2583 err
= ext4_handle_dirty_dx_node(handle
, dir
,
2587 err
= ext4_handle_dirty_dx_node(handle
, dir
,
2592 struct dx_root
*dxroot
;
2593 memcpy((char *) entries2
, (char *) entries
,
2594 icount
* sizeof(struct dx_entry
));
2595 dx_set_limit(entries2
, dx_node_limit(dir
));
2598 dx_set_count(entries
, 1);
2599 dx_set_block(entries
+ 0, newblock
);
2600 dxroot
= (struct dx_root
*)frames
[0].bh
->b_data
;
2601 dxroot
->info
.indirect_levels
+= 1;
2602 dxtrace(printk(KERN_DEBUG
2603 "Creating %d level index...\n",
2604 dxroot
->info
.indirect_levels
));
2605 err
= ext4_handle_dirty_dx_node(handle
, dir
, frame
->bh
);
2608 err
= ext4_handle_dirty_dx_node(handle
, dir
, bh2
);
2614 de
= do_split(handle
, dir
, &bh
, frame
, &fname
->hinfo
);
2619 err
= add_dirent_to_buf(handle
, fname
, dir
, inode
, de
, bh
);
2623 ext4_std_error(dir
->i_sb
, err
); /* this is a no-op if err == 0 */
2627 /* @restart is true means htree-path has been changed, we need to
2628 * repeat dx_probe() to find out valid htree-path
2630 if (restart
&& err
== 0)
2636 * ext4_generic_delete_entry deletes a directory entry by merging it
2637 * with the previous entry
2639 int ext4_generic_delete_entry(struct inode
*dir
,
2640 struct ext4_dir_entry_2
*de_del
,
2641 struct buffer_head
*bh
,
2646 struct ext4_dir_entry_2
*de
, *pde
;
2647 unsigned int blocksize
= dir
->i_sb
->s_blocksize
;
2653 while (i
< buf_size
- csum_size
) {
2654 if (ext4_check_dir_entry(dir
, NULL
, de
, bh
,
2655 entry_buf
, buf_size
, i
))
2656 return -EFSCORRUPTED
;
2659 pde
->rec_len
= ext4_rec_len_to_disk(
2660 ext4_rec_len_from_disk(pde
->rec_len
,
2662 ext4_rec_len_from_disk(de
->rec_len
,
2666 /* wipe entire dir_entry */
2667 memset(de
, 0, ext4_rec_len_from_disk(de
->rec_len
,
2670 /* wipe dir_entry excluding the rec_len field */
2672 memset(&de
->name_len
, 0,
2673 ext4_rec_len_from_disk(de
->rec_len
,
2675 offsetof(struct ext4_dir_entry_2
,
2679 inode_inc_iversion(dir
);
2682 i
+= ext4_rec_len_from_disk(de
->rec_len
, blocksize
);
2684 de
= ext4_next_entry(de
, blocksize
);
2689 static int ext4_delete_entry(handle_t
*handle
,
2691 struct ext4_dir_entry_2
*de_del
,
2692 struct buffer_head
*bh
)
2694 int err
, csum_size
= 0;
2696 if (ext4_has_inline_data(dir
)) {
2697 int has_inline_data
= 1;
2698 err
= ext4_delete_inline_entry(handle
, dir
, de_del
, bh
,
2700 if (has_inline_data
)
2704 if (ext4_has_metadata_csum(dir
->i_sb
))
2705 csum_size
= sizeof(struct ext4_dir_entry_tail
);
2707 BUFFER_TRACE(bh
, "get_write_access");
2708 err
= ext4_journal_get_write_access(handle
, dir
->i_sb
, bh
,
2713 err
= ext4_generic_delete_entry(dir
, de_del
, bh
, bh
->b_data
,
2714 dir
->i_sb
->s_blocksize
, csum_size
);
2718 BUFFER_TRACE(bh
, "call ext4_handle_dirty_metadata");
2719 err
= ext4_handle_dirty_dirblock(handle
, dir
, bh
);
2726 ext4_std_error(dir
->i_sb
, err
);
2731 * Set directory link count to 1 if nlinks > EXT4_LINK_MAX, or if nlinks == 2
2732 * since this indicates that nlinks count was previously 1 to avoid overflowing
2733 * the 16-bit i_links_count field on disk. Directories with i_nlink == 1 mean
2734 * that subdirectory link counts are not being maintained accurately.
2736 * The caller has already checked for i_nlink overflow in case the DIR_LINK
2737 * feature is not enabled and returned -EMLINK. The is_dx() check is a proxy
2738 * for checking S_ISDIR(inode) (since the INODE_INDEX feature will not be set
2739 * on regular files) and to avoid creating huge/slow non-HTREE directories.
2741 static void ext4_inc_count(struct inode
*inode
)
2745 (inode
->i_nlink
> EXT4_LINK_MAX
|| inode
->i_nlink
== 2))
2746 set_nlink(inode
, 1);
2750 * If a directory had nlink == 1, then we should let it be 1. This indicates
2751 * directory has >EXT4_LINK_MAX subdirs.
2753 static void ext4_dec_count(struct inode
*inode
)
2755 if (!S_ISDIR(inode
->i_mode
) || inode
->i_nlink
> 2)
2761 * Add non-directory inode to a directory. On success, the inode reference is
2762 * consumed by dentry is instantiation. This is also indicated by clearing of
2763 * *inodep pointer. On failure, the caller is responsible for dropping the
2764 * inode reference in the safe context.
2766 static int ext4_add_nondir(handle_t
*handle
,
2767 struct dentry
*dentry
, struct inode
**inodep
)
2769 struct inode
*dir
= d_inode(dentry
->d_parent
);
2770 struct inode
*inode
= *inodep
;
2771 int err
= ext4_add_entry(handle
, dentry
, inode
);
2773 err
= ext4_mark_inode_dirty(handle
, inode
);
2774 if (IS_DIRSYNC(dir
))
2775 ext4_handle_sync(handle
);
2776 d_instantiate_new(dentry
, inode
);
2781 ext4_orphan_add(handle
, inode
);
2782 unlock_new_inode(inode
);
2787 * By the time this is called, we already have created
2788 * the directory cache entry for the new file, but it
2789 * is so far negative - it has no inode.
2791 * If the create succeeds, we fill in the inode information
2792 * with d_instantiate().
2794 static int ext4_create(struct user_namespace
*mnt_userns
, struct inode
*dir
,
2795 struct dentry
*dentry
, umode_t mode
, bool excl
)
2798 struct inode
*inode
;
2799 int err
, credits
, retries
= 0;
2801 err
= dquot_initialize(dir
);
2805 credits
= (EXT4_DATA_TRANS_BLOCKS(dir
->i_sb
) +
2806 EXT4_INDEX_EXTRA_TRANS_BLOCKS
+ 3);
2808 inode
= ext4_new_inode_start_handle(mnt_userns
, dir
, mode
, &dentry
->d_name
,
2809 0, NULL
, EXT4_HT_DIR
, credits
);
2810 handle
= ext4_journal_current_handle();
2811 err
= PTR_ERR(inode
);
2812 if (!IS_ERR(inode
)) {
2813 inode
->i_op
= &ext4_file_inode_operations
;
2814 inode
->i_fop
= &ext4_file_operations
;
2815 ext4_set_aops(inode
);
2816 err
= ext4_add_nondir(handle
, dentry
, &inode
);
2818 ext4_fc_track_create(handle
, dentry
);
2821 ext4_journal_stop(handle
);
2822 if (!IS_ERR_OR_NULL(inode
))
2824 if (err
== -ENOSPC
&& ext4_should_retry_alloc(dir
->i_sb
, &retries
))
2829 static int ext4_mknod(struct user_namespace
*mnt_userns
, struct inode
*dir
,
2830 struct dentry
*dentry
, umode_t mode
, dev_t rdev
)
2833 struct inode
*inode
;
2834 int err
, credits
, retries
= 0;
2836 err
= dquot_initialize(dir
);
2840 credits
= (EXT4_DATA_TRANS_BLOCKS(dir
->i_sb
) +
2841 EXT4_INDEX_EXTRA_TRANS_BLOCKS
+ 3);
2843 inode
= ext4_new_inode_start_handle(mnt_userns
, dir
, mode
, &dentry
->d_name
,
2844 0, NULL
, EXT4_HT_DIR
, credits
);
2845 handle
= ext4_journal_current_handle();
2846 err
= PTR_ERR(inode
);
2847 if (!IS_ERR(inode
)) {
2848 init_special_inode(inode
, inode
->i_mode
, rdev
);
2849 inode
->i_op
= &ext4_special_inode_operations
;
2850 err
= ext4_add_nondir(handle
, dentry
, &inode
);
2852 ext4_fc_track_create(handle
, dentry
);
2855 ext4_journal_stop(handle
);
2856 if (!IS_ERR_OR_NULL(inode
))
2858 if (err
== -ENOSPC
&& ext4_should_retry_alloc(dir
->i_sb
, &retries
))
2863 static int ext4_tmpfile(struct user_namespace
*mnt_userns
, struct inode
*dir
,
2864 struct file
*file
, umode_t mode
)
2867 struct inode
*inode
;
2868 int err
, retries
= 0;
2870 err
= dquot_initialize(dir
);
2875 inode
= ext4_new_inode_start_handle(mnt_userns
, dir
, mode
,
2878 EXT4_MAXQUOTAS_INIT_BLOCKS(dir
->i_sb
) +
2879 4 + EXT4_XATTR_TRANS_BLOCKS
);
2880 handle
= ext4_journal_current_handle();
2881 err
= PTR_ERR(inode
);
2882 if (!IS_ERR(inode
)) {
2883 inode
->i_op
= &ext4_file_inode_operations
;
2884 inode
->i_fop
= &ext4_file_operations
;
2885 ext4_set_aops(inode
);
2886 d_tmpfile(file
, inode
);
2887 err
= ext4_orphan_add(handle
, inode
);
2889 goto err_unlock_inode
;
2890 mark_inode_dirty(inode
);
2891 unlock_new_inode(inode
);
2894 ext4_journal_stop(handle
);
2895 if (err
== -ENOSPC
&& ext4_should_retry_alloc(dir
->i_sb
, &retries
))
2897 return finish_open_simple(file
, err
);
2899 ext4_journal_stop(handle
);
2900 unlock_new_inode(inode
);
2904 struct ext4_dir_entry_2
*ext4_init_dot_dotdot(struct inode
*inode
,
2905 struct ext4_dir_entry_2
*de
,
2906 int blocksize
, int csum_size
,
2907 unsigned int parent_ino
, int dotdot_real_len
)
2909 de
->inode
= cpu_to_le32(inode
->i_ino
);
2911 de
->rec_len
= ext4_rec_len_to_disk(ext4_dir_rec_len(de
->name_len
, NULL
),
2913 strcpy(de
->name
, ".");
2914 ext4_set_de_type(inode
->i_sb
, de
, S_IFDIR
);
2916 de
= ext4_next_entry(de
, blocksize
);
2917 de
->inode
= cpu_to_le32(parent_ino
);
2919 if (!dotdot_real_len
)
2920 de
->rec_len
= ext4_rec_len_to_disk(blocksize
-
2921 (csum_size
+ ext4_dir_rec_len(1, NULL
)),
2924 de
->rec_len
= ext4_rec_len_to_disk(
2925 ext4_dir_rec_len(de
->name_len
, NULL
),
2927 strcpy(de
->name
, "..");
2928 ext4_set_de_type(inode
->i_sb
, de
, S_IFDIR
);
2930 return ext4_next_entry(de
, blocksize
);
2933 int ext4_init_new_dir(handle_t
*handle
, struct inode
*dir
,
2934 struct inode
*inode
)
2936 struct buffer_head
*dir_block
= NULL
;
2937 struct ext4_dir_entry_2
*de
;
2938 ext4_lblk_t block
= 0;
2939 unsigned int blocksize
= dir
->i_sb
->s_blocksize
;
2943 if (ext4_has_metadata_csum(dir
->i_sb
))
2944 csum_size
= sizeof(struct ext4_dir_entry_tail
);
2946 if (ext4_test_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
)) {
2947 err
= ext4_try_create_inline_dir(handle
, dir
, inode
);
2948 if (err
< 0 && err
!= -ENOSPC
)
2955 dir_block
= ext4_append(handle
, inode
, &block
);
2956 if (IS_ERR(dir_block
))
2957 return PTR_ERR(dir_block
);
2958 de
= (struct ext4_dir_entry_2
*)dir_block
->b_data
;
2959 ext4_init_dot_dotdot(inode
, de
, blocksize
, csum_size
, dir
->i_ino
, 0);
2960 set_nlink(inode
, 2);
2962 ext4_initialize_dirent_tail(dir_block
, blocksize
);
2964 BUFFER_TRACE(dir_block
, "call ext4_handle_dirty_metadata");
2965 err
= ext4_handle_dirty_dirblock(handle
, inode
, dir_block
);
2968 set_buffer_verified(dir_block
);
2974 static int ext4_mkdir(struct user_namespace
*mnt_userns
, struct inode
*dir
,
2975 struct dentry
*dentry
, umode_t mode
)
2978 struct inode
*inode
;
2979 int err
, err2
= 0, credits
, retries
= 0;
2981 if (EXT4_DIR_LINK_MAX(dir
))
2984 err
= dquot_initialize(dir
);
2988 credits
= (EXT4_DATA_TRANS_BLOCKS(dir
->i_sb
) +
2989 EXT4_INDEX_EXTRA_TRANS_BLOCKS
+ 3);
2991 inode
= ext4_new_inode_start_handle(mnt_userns
, dir
, S_IFDIR
| mode
,
2993 0, NULL
, EXT4_HT_DIR
, credits
);
2994 handle
= ext4_journal_current_handle();
2995 err
= PTR_ERR(inode
);
2999 inode
->i_op
= &ext4_dir_inode_operations
;
3000 inode
->i_fop
= &ext4_dir_operations
;
3001 err
= ext4_init_new_dir(handle
, dir
, inode
);
3003 goto out_clear_inode
;
3004 err
= ext4_mark_inode_dirty(handle
, inode
);
3006 err
= ext4_add_entry(handle
, dentry
, inode
);
3010 ext4_orphan_add(handle
, inode
);
3011 unlock_new_inode(inode
);
3012 err2
= ext4_mark_inode_dirty(handle
, inode
);
3015 ext4_journal_stop(handle
);
3019 ext4_inc_count(dir
);
3021 ext4_update_dx_flag(dir
);
3022 err
= ext4_mark_inode_dirty(handle
, dir
);
3024 goto out_clear_inode
;
3025 d_instantiate_new(dentry
, inode
);
3026 ext4_fc_track_create(handle
, dentry
);
3027 if (IS_DIRSYNC(dir
))
3028 ext4_handle_sync(handle
);
3032 ext4_journal_stop(handle
);
3034 if (err
== -ENOSPC
&& ext4_should_retry_alloc(dir
->i_sb
, &retries
))
3040 * routine to check that the specified directory is empty (for rmdir)
3042 bool ext4_empty_dir(struct inode
*inode
)
3044 unsigned int offset
;
3045 struct buffer_head
*bh
;
3046 struct ext4_dir_entry_2
*de
;
3047 struct super_block
*sb
;
3049 if (ext4_has_inline_data(inode
)) {
3050 int has_inline_data
= 1;
3053 ret
= empty_inline_dir(inode
, &has_inline_data
);
3054 if (has_inline_data
)
3059 if (inode
->i_size
< ext4_dir_rec_len(1, NULL
) +
3060 ext4_dir_rec_len(2, NULL
)) {
3061 EXT4_ERROR_INODE(inode
, "invalid size");
3064 /* The first directory block must not be a hole,
3065 * so treat it as DIRENT_HTREE
3067 bh
= ext4_read_dirblock(inode
, 0, DIRENT_HTREE
);
3071 de
= (struct ext4_dir_entry_2
*) bh
->b_data
;
3072 if (ext4_check_dir_entry(inode
, NULL
, de
, bh
, bh
->b_data
, bh
->b_size
,
3074 le32_to_cpu(de
->inode
) != inode
->i_ino
|| strcmp(".", de
->name
)) {
3075 ext4_warning_inode(inode
, "directory missing '.'");
3079 offset
= ext4_rec_len_from_disk(de
->rec_len
, sb
->s_blocksize
);
3080 de
= ext4_next_entry(de
, sb
->s_blocksize
);
3081 if (ext4_check_dir_entry(inode
, NULL
, de
, bh
, bh
->b_data
, bh
->b_size
,
3083 le32_to_cpu(de
->inode
) == 0 || strcmp("..", de
->name
)) {
3084 ext4_warning_inode(inode
, "directory missing '..'");
3088 offset
+= ext4_rec_len_from_disk(de
->rec_len
, sb
->s_blocksize
);
3089 while (offset
< inode
->i_size
) {
3090 if (!(offset
& (sb
->s_blocksize
- 1))) {
3091 unsigned int lblock
;
3093 lblock
= offset
>> EXT4_BLOCK_SIZE_BITS(sb
);
3094 bh
= ext4_read_dirblock(inode
, lblock
, EITHER
);
3096 offset
+= sb
->s_blocksize
;
3102 de
= (struct ext4_dir_entry_2
*) (bh
->b_data
+
3103 (offset
& (sb
->s_blocksize
- 1)));
3104 if (ext4_check_dir_entry(inode
, NULL
, de
, bh
,
3105 bh
->b_data
, bh
->b_size
, offset
) ||
3106 le32_to_cpu(de
->inode
)) {
3110 offset
+= ext4_rec_len_from_disk(de
->rec_len
, sb
->s_blocksize
);
3116 static int ext4_rmdir(struct inode
*dir
, struct dentry
*dentry
)
3119 struct inode
*inode
;
3120 struct buffer_head
*bh
;
3121 struct ext4_dir_entry_2
*de
;
3122 handle_t
*handle
= NULL
;
3124 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir
->i_sb
))))
3127 /* Initialize quotas before so that eventual writes go in
3128 * separate transaction */
3129 retval
= dquot_initialize(dir
);
3132 retval
= dquot_initialize(d_inode(dentry
));
3137 bh
= ext4_find_entry(dir
, &dentry
->d_name
, &de
, NULL
);
3143 inode
= d_inode(dentry
);
3145 retval
= -EFSCORRUPTED
;
3146 if (le32_to_cpu(de
->inode
) != inode
->i_ino
)
3149 retval
= -ENOTEMPTY
;
3150 if (!ext4_empty_dir(inode
))
3153 handle
= ext4_journal_start(dir
, EXT4_HT_DIR
,
3154 EXT4_DATA_TRANS_BLOCKS(dir
->i_sb
));
3155 if (IS_ERR(handle
)) {
3156 retval
= PTR_ERR(handle
);
3161 if (IS_DIRSYNC(dir
))
3162 ext4_handle_sync(handle
);
3164 retval
= ext4_delete_entry(handle
, dir
, de
, bh
);
3167 if (!EXT4_DIR_LINK_EMPTY(inode
))
3168 ext4_warning_inode(inode
,
3169 "empty directory '%.*s' has too many links (%u)",
3170 dentry
->d_name
.len
, dentry
->d_name
.name
,
3172 inode_inc_iversion(inode
);
3174 /* There's no need to set i_disksize: the fact that i_nlink is
3175 * zero will ensure that the right thing happens during any
3178 ext4_orphan_add(handle
, inode
);
3179 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= current_time(inode
);
3180 retval
= ext4_mark_inode_dirty(handle
, inode
);
3183 ext4_dec_count(dir
);
3184 ext4_update_dx_flag(dir
);
3185 ext4_fc_track_unlink(handle
, dentry
);
3186 retval
= ext4_mark_inode_dirty(handle
, dir
);
3188 #if IS_ENABLED(CONFIG_UNICODE)
3189 /* VFS negative dentries are incompatible with Encoding and
3190 * Case-insensitiveness. Eventually we'll want avoid
3191 * invalidating the dentries here, alongside with returning the
3192 * negative dentries at ext4_lookup(), when it is better
3193 * supported by the VFS for the CI case.
3195 if (IS_CASEFOLDED(dir
))
3196 d_invalidate(dentry
);
3202 ext4_journal_stop(handle
);
3206 int __ext4_unlink(struct inode
*dir
, const struct qstr
*d_name
,
3207 struct inode
*inode
,
3208 struct dentry
*dentry
/* NULL during fast_commit recovery */)
3210 int retval
= -ENOENT
;
3211 struct buffer_head
*bh
;
3212 struct ext4_dir_entry_2
*de
;
3214 int skip_remove_dentry
= 0;
3217 * Keep this outside the transaction; it may have to set up the
3218 * directory's encryption key, which isn't GFP_NOFS-safe.
3220 bh
= ext4_find_entry(dir
, d_name
, &de
, NULL
);
3227 if (le32_to_cpu(de
->inode
) != inode
->i_ino
) {
3229 * It's okay if we find dont find dentry which matches
3230 * the inode. That's because it might have gotten
3231 * renamed to a different inode number
3233 if (EXT4_SB(inode
->i_sb
)->s_mount_state
& EXT4_FC_REPLAY
)
3234 skip_remove_dentry
= 1;
3239 handle
= ext4_journal_start(dir
, EXT4_HT_DIR
,
3240 EXT4_DATA_TRANS_BLOCKS(dir
->i_sb
));
3241 if (IS_ERR(handle
)) {
3242 retval
= PTR_ERR(handle
);
3246 if (IS_DIRSYNC(dir
))
3247 ext4_handle_sync(handle
);
3249 if (!skip_remove_dentry
) {
3250 retval
= ext4_delete_entry(handle
, dir
, de
, bh
);
3253 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
3254 ext4_update_dx_flag(dir
);
3255 retval
= ext4_mark_inode_dirty(handle
, dir
);
3261 if (inode
->i_nlink
== 0)
3262 ext4_warning_inode(inode
, "Deleting file '%.*s' with no links",
3263 d_name
->len
, d_name
->name
);
3266 if (!inode
->i_nlink
)
3267 ext4_orphan_add(handle
, inode
);
3268 inode
->i_ctime
= current_time(inode
);
3269 retval
= ext4_mark_inode_dirty(handle
, inode
);
3270 if (dentry
&& !retval
)
3271 ext4_fc_track_unlink(handle
, dentry
);
3273 ext4_journal_stop(handle
);
3279 static int ext4_unlink(struct inode
*dir
, struct dentry
*dentry
)
3283 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir
->i_sb
))))
3286 trace_ext4_unlink_enter(dir
, dentry
);
3288 * Initialize quotas before so that eventual writes go
3289 * in separate transaction
3291 retval
= dquot_initialize(dir
);
3294 retval
= dquot_initialize(d_inode(dentry
));
3298 retval
= __ext4_unlink(dir
, &dentry
->d_name
, d_inode(dentry
), dentry
);
3299 #if IS_ENABLED(CONFIG_UNICODE)
3300 /* VFS negative dentries are incompatible with Encoding and
3301 * Case-insensitiveness. Eventually we'll want avoid
3302 * invalidating the dentries here, alongside with returning the
3303 * negative dentries at ext4_lookup(), when it is better
3304 * supported by the VFS for the CI case.
3306 if (IS_CASEFOLDED(dir
))
3307 d_invalidate(dentry
);
3311 trace_ext4_unlink_exit(dentry
, retval
);
3315 static int ext4_init_symlink_block(handle_t
*handle
, struct inode
*inode
,
3316 struct fscrypt_str
*disk_link
)
3318 struct buffer_head
*bh
;
3322 bh
= ext4_bread(handle
, inode
, 0, EXT4_GET_BLOCKS_CREATE
);
3326 BUFFER_TRACE(bh
, "get_write_access");
3327 err
= ext4_journal_get_write_access(handle
, inode
->i_sb
, bh
, EXT4_JTR_NONE
);
3331 kaddr
= (char *)bh
->b_data
;
3332 memcpy(kaddr
, disk_link
->name
, disk_link
->len
);
3333 inode
->i_size
= disk_link
->len
- 1;
3334 EXT4_I(inode
)->i_disksize
= inode
->i_size
;
3335 err
= ext4_handle_dirty_metadata(handle
, inode
, bh
);
3341 static int ext4_symlink(struct user_namespace
*mnt_userns
, struct inode
*dir
,
3342 struct dentry
*dentry
, const char *symname
)
3345 struct inode
*inode
;
3346 int err
, len
= strlen(symname
);
3348 struct fscrypt_str disk_link
;
3351 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir
->i_sb
))))
3354 err
= fscrypt_prepare_symlink(dir
, symname
, len
, dir
->i_sb
->s_blocksize
,
3359 err
= dquot_initialize(dir
);
3364 * EXT4_INDEX_EXTRA_TRANS_BLOCKS for addition of entry into the
3365 * directory. +3 for inode, inode bitmap, group descriptor allocation.
3366 * EXT4_DATA_TRANS_BLOCKS for the data block allocation and
3369 credits
= EXT4_DATA_TRANS_BLOCKS(dir
->i_sb
) +
3370 EXT4_INDEX_EXTRA_TRANS_BLOCKS
+ 3;
3372 inode
= ext4_new_inode_start_handle(mnt_userns
, dir
, S_IFLNK
|S_IRWXUGO
,
3373 &dentry
->d_name
, 0, NULL
,
3374 EXT4_HT_DIR
, credits
);
3375 handle
= ext4_journal_current_handle();
3376 if (IS_ERR(inode
)) {
3378 ext4_journal_stop(handle
);
3379 err
= PTR_ERR(inode
);
3383 if (IS_ENCRYPTED(inode
)) {
3384 err
= fscrypt_encrypt_symlink(inode
, symname
, len
, &disk_link
);
3386 goto err_drop_inode
;
3387 inode
->i_op
= &ext4_encrypted_symlink_inode_operations
;
3389 if ((disk_link
.len
> EXT4_N_BLOCKS
* 4)) {
3390 inode
->i_op
= &ext4_symlink_inode_operations
;
3392 inode
->i_op
= &ext4_fast_symlink_inode_operations
;
3393 inode
->i_link
= (char *)&EXT4_I(inode
)->i_data
;
3397 if ((disk_link
.len
> EXT4_N_BLOCKS
* 4)) {
3398 /* alloc symlink block and fill it */
3399 err
= ext4_init_symlink_block(handle
, inode
, &disk_link
);
3401 goto err_drop_inode
;
3403 /* clear the extent format for fast symlink */
3404 ext4_clear_inode_flag(inode
, EXT4_INODE_EXTENTS
);
3405 memcpy((char *)&EXT4_I(inode
)->i_data
, disk_link
.name
,
3407 inode
->i_size
= disk_link
.len
- 1;
3408 EXT4_I(inode
)->i_disksize
= inode
->i_size
;
3410 err
= ext4_add_nondir(handle
, dentry
, &inode
);
3412 ext4_journal_stop(handle
);
3418 ext4_orphan_add(handle
, inode
);
3419 unlock_new_inode(inode
);
3421 ext4_journal_stop(handle
);
3424 if (err
== -ENOSPC
&& ext4_should_retry_alloc(dir
->i_sb
, &retries
))
3426 if (disk_link
.name
!= (unsigned char *)symname
)
3427 kfree(disk_link
.name
);
3431 int __ext4_link(struct inode
*dir
, struct inode
*inode
, struct dentry
*dentry
)
3434 int err
, retries
= 0;
3436 handle
= ext4_journal_start(dir
, EXT4_HT_DIR
,
3437 (EXT4_DATA_TRANS_BLOCKS(dir
->i_sb
) +
3438 EXT4_INDEX_EXTRA_TRANS_BLOCKS
) + 1);
3440 return PTR_ERR(handle
);
3442 if (IS_DIRSYNC(dir
))
3443 ext4_handle_sync(handle
);
3445 inode
->i_ctime
= current_time(inode
);
3446 ext4_inc_count(inode
);
3449 err
= ext4_add_entry(handle
, dentry
, inode
);
3451 err
= ext4_mark_inode_dirty(handle
, inode
);
3452 /* this can happen only for tmpfile being
3453 * linked the first time
3455 if (inode
->i_nlink
== 1)
3456 ext4_orphan_del(handle
, inode
);
3457 d_instantiate(dentry
, inode
);
3458 ext4_fc_track_link(handle
, dentry
);
3463 ext4_journal_stop(handle
);
3464 if (err
== -ENOSPC
&& ext4_should_retry_alloc(dir
->i_sb
, &retries
))
3469 static int ext4_link(struct dentry
*old_dentry
,
3470 struct inode
*dir
, struct dentry
*dentry
)
3472 struct inode
*inode
= d_inode(old_dentry
);
3475 if (inode
->i_nlink
>= EXT4_LINK_MAX
)
3478 err
= fscrypt_prepare_link(old_dentry
, dir
, dentry
);
3482 if ((ext4_test_inode_flag(dir
, EXT4_INODE_PROJINHERIT
)) &&
3483 (!projid_eq(EXT4_I(dir
)->i_projid
,
3484 EXT4_I(old_dentry
->d_inode
)->i_projid
)))
3487 err
= dquot_initialize(dir
);
3490 return __ext4_link(dir
, inode
, dentry
);
3494 * Try to find buffer head where contains the parent block.
3495 * It should be the inode block if it is inlined or the 1st block
3496 * if it is a normal dir.
3498 static struct buffer_head
*ext4_get_first_dir_block(handle_t
*handle
,
3499 struct inode
*inode
,
3501 struct ext4_dir_entry_2
**parent_de
,
3504 struct buffer_head
*bh
;
3506 if (!ext4_has_inline_data(inode
)) {
3507 struct ext4_dir_entry_2
*de
;
3508 unsigned int offset
;
3510 /* The first directory block must not be a hole, so
3511 * treat it as DIRENT_HTREE
3513 bh
= ext4_read_dirblock(inode
, 0, DIRENT_HTREE
);
3515 *retval
= PTR_ERR(bh
);
3519 de
= (struct ext4_dir_entry_2
*) bh
->b_data
;
3520 if (ext4_check_dir_entry(inode
, NULL
, de
, bh
, bh
->b_data
,
3522 le32_to_cpu(de
->inode
) != inode
->i_ino
||
3523 strcmp(".", de
->name
)) {
3524 EXT4_ERROR_INODE(inode
, "directory missing '.'");
3526 *retval
= -EFSCORRUPTED
;
3529 offset
= ext4_rec_len_from_disk(de
->rec_len
,
3530 inode
->i_sb
->s_blocksize
);
3531 de
= ext4_next_entry(de
, inode
->i_sb
->s_blocksize
);
3532 if (ext4_check_dir_entry(inode
, NULL
, de
, bh
, bh
->b_data
,
3533 bh
->b_size
, offset
) ||
3534 le32_to_cpu(de
->inode
) == 0 || strcmp("..", de
->name
)) {
3535 EXT4_ERROR_INODE(inode
, "directory missing '..'");
3537 *retval
= -EFSCORRUPTED
;
3546 return ext4_get_first_inline_block(inode
, parent_de
, retval
);
3549 struct ext4_renament
{
3551 struct dentry
*dentry
;
3552 struct inode
*inode
;
3554 int dir_nlink_delta
;
3556 /* entry for "dentry" */
3557 struct buffer_head
*bh
;
3558 struct ext4_dir_entry_2
*de
;
3561 /* entry for ".." in inode if it's a directory */
3562 struct buffer_head
*dir_bh
;
3563 struct ext4_dir_entry_2
*parent_de
;
3567 static int ext4_rename_dir_prepare(handle_t
*handle
, struct ext4_renament
*ent
)
3571 ent
->dir_bh
= ext4_get_first_dir_block(handle
, ent
->inode
,
3572 &retval
, &ent
->parent_de
,
3576 if (le32_to_cpu(ent
->parent_de
->inode
) != ent
->dir
->i_ino
)
3577 return -EFSCORRUPTED
;
3578 BUFFER_TRACE(ent
->dir_bh
, "get_write_access");
3579 return ext4_journal_get_write_access(handle
, ent
->dir
->i_sb
,
3580 ent
->dir_bh
, EXT4_JTR_NONE
);
3583 static int ext4_rename_dir_finish(handle_t
*handle
, struct ext4_renament
*ent
,
3588 ent
->parent_de
->inode
= cpu_to_le32(dir_ino
);
3589 BUFFER_TRACE(ent
->dir_bh
, "call ext4_handle_dirty_metadata");
3590 if (!ent
->dir_inlined
) {
3591 if (is_dx(ent
->inode
)) {
3592 retval
= ext4_handle_dirty_dx_node(handle
,
3596 retval
= ext4_handle_dirty_dirblock(handle
, ent
->inode
,
3600 retval
= ext4_mark_inode_dirty(handle
, ent
->inode
);
3603 ext4_std_error(ent
->dir
->i_sb
, retval
);
3609 static int ext4_setent(handle_t
*handle
, struct ext4_renament
*ent
,
3610 unsigned ino
, unsigned file_type
)
3612 int retval
, retval2
;
3614 BUFFER_TRACE(ent
->bh
, "get write access");
3615 retval
= ext4_journal_get_write_access(handle
, ent
->dir
->i_sb
, ent
->bh
,
3619 ent
->de
->inode
= cpu_to_le32(ino
);
3620 if (ext4_has_feature_filetype(ent
->dir
->i_sb
))
3621 ent
->de
->file_type
= file_type
;
3622 inode_inc_iversion(ent
->dir
);
3623 ent
->dir
->i_ctime
= ent
->dir
->i_mtime
=
3624 current_time(ent
->dir
);
3625 retval
= ext4_mark_inode_dirty(handle
, ent
->dir
);
3626 BUFFER_TRACE(ent
->bh
, "call ext4_handle_dirty_metadata");
3627 if (!ent
->inlined
) {
3628 retval2
= ext4_handle_dirty_dirblock(handle
, ent
->dir
, ent
->bh
);
3629 if (unlikely(retval2
)) {
3630 ext4_std_error(ent
->dir
->i_sb
, retval2
);
3637 static void ext4_resetent(handle_t
*handle
, struct ext4_renament
*ent
,
3638 unsigned ino
, unsigned file_type
)
3640 struct ext4_renament old
= *ent
;
3644 * old->de could have moved from under us during make indexed dir,
3645 * so the old->de may no longer valid and need to find it again
3646 * before reset old inode info.
3648 old
.bh
= ext4_find_entry(old
.dir
, &old
.dentry
->d_name
, &old
.de
,
3651 retval
= PTR_ERR(old
.bh
);
3655 ext4_std_error(old
.dir
->i_sb
, retval
);
3659 ext4_setent(handle
, &old
, ino
, file_type
);
3663 static int ext4_find_delete_entry(handle_t
*handle
, struct inode
*dir
,
3664 const struct qstr
*d_name
)
3666 int retval
= -ENOENT
;
3667 struct buffer_head
*bh
;
3668 struct ext4_dir_entry_2
*de
;
3670 bh
= ext4_find_entry(dir
, d_name
, &de
, NULL
);
3674 retval
= ext4_delete_entry(handle
, dir
, de
, bh
);
3680 static void ext4_rename_delete(handle_t
*handle
, struct ext4_renament
*ent
,
3685 * ent->de could have moved from under us during htree split, so make
3686 * sure that we are deleting the right entry. We might also be pointing
3687 * to a stale entry in the unused part of ent->bh so just checking inum
3688 * and the name isn't enough.
3690 if (le32_to_cpu(ent
->de
->inode
) != ent
->inode
->i_ino
||
3691 ent
->de
->name_len
!= ent
->dentry
->d_name
.len
||
3692 strncmp(ent
->de
->name
, ent
->dentry
->d_name
.name
,
3693 ent
->de
->name_len
) ||
3695 retval
= ext4_find_delete_entry(handle
, ent
->dir
,
3696 &ent
->dentry
->d_name
);
3698 retval
= ext4_delete_entry(handle
, ent
->dir
, ent
->de
, ent
->bh
);
3699 if (retval
== -ENOENT
) {
3700 retval
= ext4_find_delete_entry(handle
, ent
->dir
,
3701 &ent
->dentry
->d_name
);
3706 ext4_warning_inode(ent
->dir
,
3707 "Deleting old file: nlink %d, error=%d",
3708 ent
->dir
->i_nlink
, retval
);
3712 static void ext4_update_dir_count(handle_t
*handle
, struct ext4_renament
*ent
)
3714 if (ent
->dir_nlink_delta
) {
3715 if (ent
->dir_nlink_delta
== -1)
3716 ext4_dec_count(ent
->dir
);
3718 ext4_inc_count(ent
->dir
);
3719 ext4_mark_inode_dirty(handle
, ent
->dir
);
3723 static struct inode
*ext4_whiteout_for_rename(struct user_namespace
*mnt_userns
,
3724 struct ext4_renament
*ent
,
3725 int credits
, handle_t
**h
)
3732 * for inode block, sb block, group summaries,
3735 credits
+= (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent
->dir
->i_sb
) +
3736 EXT4_XATTR_TRANS_BLOCKS
+ 4);
3738 wh
= ext4_new_inode_start_handle(mnt_userns
, ent
->dir
,
3739 S_IFCHR
| WHITEOUT_MODE
,
3740 &ent
->dentry
->d_name
, 0, NULL
,
3741 EXT4_HT_DIR
, credits
);
3743 handle
= ext4_journal_current_handle();
3746 ext4_journal_stop(handle
);
3747 if (PTR_ERR(wh
) == -ENOSPC
&&
3748 ext4_should_retry_alloc(ent
->dir
->i_sb
, &retries
))
3752 init_special_inode(wh
, wh
->i_mode
, WHITEOUT_DEV
);
3753 wh
->i_op
= &ext4_special_inode_operations
;
3759 * Anybody can rename anything with this: the permission checks are left to the
3760 * higher-level routines.
3762 * n.b. old_{dentry,inode) refers to the source dentry/inode
3763 * while new_{dentry,inode) refers to the destination dentry/inode
3764 * This comes from rename(const char *oldpath, const char *newpath)
3766 static int ext4_rename(struct user_namespace
*mnt_userns
, struct inode
*old_dir
,
3767 struct dentry
*old_dentry
, struct inode
*new_dir
,
3768 struct dentry
*new_dentry
, unsigned int flags
)
3770 handle_t
*handle
= NULL
;
3771 struct ext4_renament old
= {
3773 .dentry
= old_dentry
,
3774 .inode
= d_inode(old_dentry
),
3776 struct ext4_renament
new = {
3778 .dentry
= new_dentry
,
3779 .inode
= d_inode(new_dentry
),
3783 struct inode
*whiteout
= NULL
;
3787 if (new.inode
&& new.inode
->i_nlink
== 0) {
3788 EXT4_ERROR_INODE(new.inode
,
3789 "target of rename is already freed");
3790 return -EFSCORRUPTED
;
3793 if ((ext4_test_inode_flag(new_dir
, EXT4_INODE_PROJINHERIT
)) &&
3794 (!projid_eq(EXT4_I(new_dir
)->i_projid
,
3795 EXT4_I(old_dentry
->d_inode
)->i_projid
)))
3798 retval
= dquot_initialize(old
.dir
);
3801 retval
= dquot_initialize(old
.inode
);
3804 retval
= dquot_initialize(new.dir
);
3808 /* Initialize quotas before so that eventual writes go
3809 * in separate transaction */
3811 retval
= dquot_initialize(new.inode
);
3817 * We need to protect against old.inode directory getting converted
3818 * from inline directory format into a normal one.
3820 if (S_ISDIR(old
.inode
->i_mode
))
3821 inode_lock_nested(old
.inode
, I_MUTEX_NONDIR2
);
3823 old
.bh
= ext4_find_entry(old
.dir
, &old
.dentry
->d_name
, &old
.de
,
3825 if (IS_ERR(old
.bh
)) {
3826 retval
= PTR_ERR(old
.bh
);
3827 goto unlock_moved_dir
;
3831 * Check for inode number is _not_ due to possible IO errors.
3832 * We might rmdir the source, keep it as pwd of some process
3833 * and merrily kill the link to whatever was created under the
3834 * same name. Goodbye sticky bit ;-<
3837 if (!old
.bh
|| le32_to_cpu(old
.de
->inode
) != old
.inode
->i_ino
)
3840 new.bh
= ext4_find_entry(new.dir
, &new.dentry
->d_name
,
3841 &new.de
, &new.inlined
);
3842 if (IS_ERR(new.bh
)) {
3843 retval
= PTR_ERR(new.bh
);
3853 if (new.inode
&& !test_opt(new.dir
->i_sb
, NO_AUTO_DA_ALLOC
))
3854 ext4_alloc_da_blocks(old
.inode
);
3856 credits
= (2 * EXT4_DATA_TRANS_BLOCKS(old
.dir
->i_sb
) +
3857 EXT4_INDEX_EXTRA_TRANS_BLOCKS
+ 2);
3858 if (!(flags
& RENAME_WHITEOUT
)) {
3859 handle
= ext4_journal_start(old
.dir
, EXT4_HT_DIR
, credits
);
3860 if (IS_ERR(handle
)) {
3861 retval
= PTR_ERR(handle
);
3865 whiteout
= ext4_whiteout_for_rename(mnt_userns
, &old
, credits
, &handle
);
3866 if (IS_ERR(whiteout
)) {
3867 retval
= PTR_ERR(whiteout
);
3872 old_file_type
= old
.de
->file_type
;
3873 if (IS_DIRSYNC(old
.dir
) || IS_DIRSYNC(new.dir
))
3874 ext4_handle_sync(handle
);
3876 if (S_ISDIR(old
.inode
->i_mode
)) {
3878 retval
= -ENOTEMPTY
;
3879 if (!ext4_empty_dir(new.inode
))
3883 if (new.dir
!= old
.dir
&& EXT4_DIR_LINK_MAX(new.dir
))
3886 retval
= ext4_rename_dir_prepare(handle
, &old
);
3888 inode_unlock(old
.inode
);
3893 * If we're renaming a file within an inline_data dir and adding or
3894 * setting the new dirent causes a conversion from inline_data to
3895 * extents/blockmap, we need to force the dirent delete code to
3896 * re-read the directory, or else we end up trying to delete a dirent
3897 * from what is now the extent tree root (or a block map).
3899 force_reread
= (new.dir
->i_ino
== old
.dir
->i_ino
&&
3900 ext4_test_inode_flag(new.dir
, EXT4_INODE_INLINE_DATA
));
3904 * Do this before adding a new entry, so the old entry is sure
3905 * to be still pointing to the valid old entry.
3907 retval
= ext4_setent(handle
, &old
, whiteout
->i_ino
,
3911 retval
= ext4_mark_inode_dirty(handle
, whiteout
);
3912 if (unlikely(retval
))
3917 retval
= ext4_add_entry(handle
, new.dentry
, old
.inode
);
3921 retval
= ext4_setent(handle
, &new,
3922 old
.inode
->i_ino
, old_file_type
);
3927 force_reread
= !ext4_test_inode_flag(new.dir
,
3928 EXT4_INODE_INLINE_DATA
);
3931 * Like most other Unix systems, set the ctime for inodes on a
3934 old
.inode
->i_ctime
= current_time(old
.inode
);
3935 retval
= ext4_mark_inode_dirty(handle
, old
.inode
);
3936 if (unlikely(retval
))
3943 ext4_rename_delete(handle
, &old
, force_reread
);
3947 ext4_dec_count(new.inode
);
3948 new.inode
->i_ctime
= current_time(new.inode
);
3950 old
.dir
->i_ctime
= old
.dir
->i_mtime
= current_time(old
.dir
);
3951 ext4_update_dx_flag(old
.dir
);
3953 retval
= ext4_rename_dir_finish(handle
, &old
, new.dir
->i_ino
);
3957 ext4_dec_count(old
.dir
);
3959 /* checked ext4_empty_dir above, can't have another
3960 * parent, ext4_dec_count() won't work for many-linked
3962 clear_nlink(new.inode
);
3964 ext4_inc_count(new.dir
);
3965 ext4_update_dx_flag(new.dir
);
3966 retval
= ext4_mark_inode_dirty(handle
, new.dir
);
3967 if (unlikely(retval
))
3971 retval
= ext4_mark_inode_dirty(handle
, old
.dir
);
3972 if (unlikely(retval
))
3975 if (S_ISDIR(old
.inode
->i_mode
)) {
3977 * We disable fast commits here that's because the
3978 * replay code is not yet capable of changing dot dot
3979 * dirents in directories.
3981 ext4_fc_mark_ineligible(old
.inode
->i_sb
,
3982 EXT4_FC_REASON_RENAME_DIR
, handle
);
3984 struct super_block
*sb
= old
.inode
->i_sb
;
3987 ext4_fc_track_unlink(handle
, new.dentry
);
3988 if (test_opt2(sb
, JOURNAL_FAST_COMMIT
) &&
3989 !(EXT4_SB(sb
)->s_mount_state
& EXT4_FC_REPLAY
) &&
3990 !(ext4_test_mount_flag(sb
, EXT4_MF_FC_INELIGIBLE
))) {
3991 __ext4_fc_track_link(handle
, old
.inode
, new.dentry
);
3992 __ext4_fc_track_unlink(handle
, old
.inode
, old
.dentry
);
3994 __ext4_fc_track_create(handle
, whiteout
,
4000 retval
= ext4_mark_inode_dirty(handle
, new.inode
);
4001 if (unlikely(retval
))
4003 if (!new.inode
->i_nlink
)
4004 ext4_orphan_add(handle
, new.inode
);
4011 ext4_resetent(handle
, &old
,
4012 old
.inode
->i_ino
, old_file_type
);
4013 drop_nlink(whiteout
);
4014 ext4_orphan_add(handle
, whiteout
);
4016 unlock_new_inode(whiteout
);
4017 ext4_journal_stop(handle
);
4020 ext4_journal_stop(handle
);
4028 if (S_ISDIR(old
.inode
->i_mode
))
4029 inode_unlock(old
.inode
);
4034 static int ext4_cross_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
4035 struct inode
*new_dir
, struct dentry
*new_dentry
)
4037 handle_t
*handle
= NULL
;
4038 struct ext4_renament old
= {
4040 .dentry
= old_dentry
,
4041 .inode
= d_inode(old_dentry
),
4043 struct ext4_renament
new = {
4045 .dentry
= new_dentry
,
4046 .inode
= d_inode(new_dentry
),
4050 struct timespec64 ctime
;
4052 if ((ext4_test_inode_flag(new_dir
, EXT4_INODE_PROJINHERIT
) &&
4053 !projid_eq(EXT4_I(new_dir
)->i_projid
,
4054 EXT4_I(old_dentry
->d_inode
)->i_projid
)) ||
4055 (ext4_test_inode_flag(old_dir
, EXT4_INODE_PROJINHERIT
) &&
4056 !projid_eq(EXT4_I(old_dir
)->i_projid
,
4057 EXT4_I(new_dentry
->d_inode
)->i_projid
)))
4060 retval
= dquot_initialize(old
.dir
);
4063 retval
= dquot_initialize(new.dir
);
4067 old
.bh
= ext4_find_entry(old
.dir
, &old
.dentry
->d_name
,
4068 &old
.de
, &old
.inlined
);
4070 return PTR_ERR(old
.bh
);
4072 * Check for inode number is _not_ due to possible IO errors.
4073 * We might rmdir the source, keep it as pwd of some process
4074 * and merrily kill the link to whatever was created under the
4075 * same name. Goodbye sticky bit ;-<
4078 if (!old
.bh
|| le32_to_cpu(old
.de
->inode
) != old
.inode
->i_ino
)
4081 new.bh
= ext4_find_entry(new.dir
, &new.dentry
->d_name
,
4082 &new.de
, &new.inlined
);
4083 if (IS_ERR(new.bh
)) {
4084 retval
= PTR_ERR(new.bh
);
4089 /* RENAME_EXCHANGE case: old *and* new must both exist */
4090 if (!new.bh
|| le32_to_cpu(new.de
->inode
) != new.inode
->i_ino
)
4093 handle
= ext4_journal_start(old
.dir
, EXT4_HT_DIR
,
4094 (2 * EXT4_DATA_TRANS_BLOCKS(old
.dir
->i_sb
) +
4095 2 * EXT4_INDEX_EXTRA_TRANS_BLOCKS
+ 2));
4096 if (IS_ERR(handle
)) {
4097 retval
= PTR_ERR(handle
);
4102 if (IS_DIRSYNC(old
.dir
) || IS_DIRSYNC(new.dir
))
4103 ext4_handle_sync(handle
);
4105 if (S_ISDIR(old
.inode
->i_mode
)) {
4107 retval
= ext4_rename_dir_prepare(handle
, &old
);
4111 if (S_ISDIR(new.inode
->i_mode
)) {
4113 retval
= ext4_rename_dir_prepare(handle
, &new);
4119 * Other than the special case of overwriting a directory, parents'
4120 * nlink only needs to be modified if this is a cross directory rename.
4122 if (old
.dir
!= new.dir
&& old
.is_dir
!= new.is_dir
) {
4123 old
.dir_nlink_delta
= old
.is_dir
? -1 : 1;
4124 new.dir_nlink_delta
= -old
.dir_nlink_delta
;
4126 if ((old
.dir_nlink_delta
> 0 && EXT4_DIR_LINK_MAX(old
.dir
)) ||
4127 (new.dir_nlink_delta
> 0 && EXT4_DIR_LINK_MAX(new.dir
)))
4131 new_file_type
= new.de
->file_type
;
4132 retval
= ext4_setent(handle
, &new, old
.inode
->i_ino
, old
.de
->file_type
);
4136 retval
= ext4_setent(handle
, &old
, new.inode
->i_ino
, new_file_type
);
4141 * Like most other Unix systems, set the ctime for inodes on a
4144 ctime
= current_time(old
.inode
);
4145 old
.inode
->i_ctime
= ctime
;
4146 new.inode
->i_ctime
= ctime
;
4147 retval
= ext4_mark_inode_dirty(handle
, old
.inode
);
4148 if (unlikely(retval
))
4150 retval
= ext4_mark_inode_dirty(handle
, new.inode
);
4151 if (unlikely(retval
))
4153 ext4_fc_mark_ineligible(new.inode
->i_sb
,
4154 EXT4_FC_REASON_CROSS_RENAME
, handle
);
4156 retval
= ext4_rename_dir_finish(handle
, &old
, new.dir
->i_ino
);
4161 retval
= ext4_rename_dir_finish(handle
, &new, old
.dir
->i_ino
);
4165 ext4_update_dir_count(handle
, &old
);
4166 ext4_update_dir_count(handle
, &new);
4175 ext4_journal_stop(handle
);
4179 static int ext4_rename2(struct user_namespace
*mnt_userns
,
4180 struct inode
*old_dir
, struct dentry
*old_dentry
,
4181 struct inode
*new_dir
, struct dentry
*new_dentry
,
4186 if (unlikely(ext4_forced_shutdown(EXT4_SB(old_dir
->i_sb
))))
4189 if (flags
& ~(RENAME_NOREPLACE
| RENAME_EXCHANGE
| RENAME_WHITEOUT
))
4192 err
= fscrypt_prepare_rename(old_dir
, old_dentry
, new_dir
, new_dentry
,
4197 if (flags
& RENAME_EXCHANGE
) {
4198 return ext4_cross_rename(old_dir
, old_dentry
,
4199 new_dir
, new_dentry
);
4202 return ext4_rename(mnt_userns
, old_dir
, old_dentry
, new_dir
, new_dentry
, flags
);
4206 * directories can handle most operations...
4208 const struct inode_operations ext4_dir_inode_operations
= {
4209 .create
= ext4_create
,
4210 .lookup
= ext4_lookup
,
4212 .unlink
= ext4_unlink
,
4213 .symlink
= ext4_symlink
,
4214 .mkdir
= ext4_mkdir
,
4215 .rmdir
= ext4_rmdir
,
4216 .mknod
= ext4_mknod
,
4217 .tmpfile
= ext4_tmpfile
,
4218 .rename
= ext4_rename2
,
4219 .setattr
= ext4_setattr
,
4220 .getattr
= ext4_getattr
,
4221 .listxattr
= ext4_listxattr
,
4222 .get_inode_acl
= ext4_get_acl
,
4223 .set_acl
= ext4_set_acl
,
4224 .fiemap
= ext4_fiemap
,
4225 .fileattr_get
= ext4_fileattr_get
,
4226 .fileattr_set
= ext4_fileattr_set
,
4229 const struct inode_operations ext4_special_inode_operations
= {
4230 .setattr
= ext4_setattr
,
4231 .getattr
= ext4_getattr
,
4232 .listxattr
= ext4_listxattr
,
4233 .get_inode_acl
= ext4_get_acl
,
4234 .set_acl
= ext4_set_acl
,