AOSP: ANDROID: e2fsck: Handle casefolded encryption

Adds support for EXT2_HASH_SIPHASH, and reading the hash from disk in
that case. We cannot compute the siphash without the key, so we must
not modify the names of any encrypted and casefolded directories,
which limits some recovery options, and we must assume the hashes
stored in dirents are correct.
This is in preparation for upcoming kernel support for encryption and
casefolding at the same time.

Google-Bug-Id: 138322712
Test: Create fs with casefold and encryption enabled via mke2fs and
      tune2fs, run fsck after creating casefolded + encrypted folder

Change-Id: Icca32d7d9dd3c7f52da03d60e4d89273cbec0a7d
From AOSP commit: 67eae926bdac1a54dbb8335731c5e1581f93e4bb

8 files changed, 181 insertions, 30 deletions

diff --git a/e2fsck/e2fsck.c b/e2fsck/e2fsck.c
index 929bd78d8..6bf68197d 100644
--- a/e2fsck/e2fsck.c
+++ b/e2fsck/e2fsck.c
@@ -158,6 +158,10 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx)
 		ext2fs_u32_list_free(ctx->encrypted_dirs);
 		ctx->encrypted_dirs = 0;
 	}
+	if (ctx->casefolded_dirs) {
+		ext2fs_u32_list_free(ctx->casefolded_dirs);
+		ctx->casefolded_dirs = 0;
+	}
 	if (ctx->inode_count) {
 		ext2fs_free_icount(ctx->inode_count);
 		ctx->inode_count = 0;
diff --git a/e2fsck/e2fsck.h b/e2fsck/e2fsck.h
index 7e0895c23..166cc1f6c 100644
--- a/e2fsck/e2fsck.h
+++ b/e2fsck/e2fsck.h
@@ -390,6 +390,7 @@ struct e2fsck_struct {
 	profile_t	profile;
 	int blocks_per_page;
 	ext2_u32_list encrypted_dirs;
+	ext2_u32_list casefolded_dirs;
 
 	/* Reserve blocks for root and l+f re-creation */
 	blk64_t root_repair_block, lnf_repair_block;
diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index 38afda48d..bafbe8bf4 100644
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -79,6 +79,7 @@ static void alloc_bb_map(e2fsck_t ctx);
 static void alloc_imagic_map(e2fsck_t ctx);
 static void mark_inode_bad(e2fsck_t ctx, ino_t ino);
 static void add_encrypted_dir(e2fsck_t ctx, ino_t ino);
+static void add_casefolded_dir(e2fsck_t ctx, ino_t ino);
 static void handle_fs_bad_blocks(e2fsck_t ctx);
 static void process_inodes(e2fsck_t ctx, char *block_buf);
 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b);
@@ -1890,6 +1891,8 @@ void e2fsck_pass1(e2fsck_t ctx)
 			ctx->fs_directory_count++;
 			if (inode->i_flags & EXT4_ENCRYPT_FL)
 				add_encrypted_dir(ctx, ino);
+			if (inode->i_flags & EXT4_CASEFOLD_FL)
+				add_casefolded_dir(ctx, ino);
 		} else if (LINUX_S_ISREG (inode->i_mode)) {
 			ext2fs_mark_inode_bitmap2(ctx->inode_reg_map, ino);
 			ctx->fs_regular_count++;
@@ -2220,6 +2223,24 @@ error:
 	ctx->flags |= E2F_FLAG_ABORT;
 }
 
+static void add_casefolded_dir(e2fsck_t ctx, ino_t ino)
+{
+	struct		problem_context pctx;
+
+	if (!ctx->casefolded_dirs) {
+		pctx.errcode = ext2fs_u32_list_create(&ctx->casefolded_dirs, 0);
+		if (pctx.errcode)
+			goto error;
+	}
+	pctx.errcode = ext2fs_u32_list_add(ctx->casefolded_dirs, ino);
+	if (pctx.errcode == 0)
+		return;
+error:
+	fix_problem(ctx, PR_1_ALLOCATE_CASEFOLDED_DIRLIST, &pctx);
+	/* Should never get here */
+	ctx->flags |= E2F_FLAG_ABORT;
+}
+
 /*
  * This procedure will allocate the inode "bb" (badblock) map table
  */
@@ -2677,9 +2698,20 @@ static int handle_htree(e2fsck_t ctx, struct problem_context *pctx,
 	if ((root->hash_version != EXT2_HASH_LEGACY) &&
 	    (root->hash_version != EXT2_HASH_HALF_MD4) &&
 	    (root->hash_version != EXT2_HASH_TEA) &&
+	    (root->hash_version != EXT2_HASH_SIPHASH) &&
 	    fix_problem(ctx, PR_1_HTREE_HASHV, pctx))
 		return 1;
 
+	if (ext4_hash_in_dirent(inode)) {
+		if (root->hash_version != EXT2_HASH_SIPHASH &&
+		    fix_problem(ctx, PR_1_HTREE_NEEDS_SIPHASH, pctx))
+			return 1;
+	} else {
+		if (root->hash_version == EXT2_HASH_SIPHASH &&
+		   fix_problem(ctx, PR_1_HTREE_CANNOT_SIPHASH, pctx))
+			return 1;
+	}
+
 	if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) &&
 	    fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx))
 		return 1;
diff --git a/e2fsck/pass2.c b/e2fsck/pass2.c
index cb1e58756..c1db3a1a5 100644
--- a/e2fsck/pass2.c
+++ b/e2fsck/pass2.c
@@ -289,6 +289,10 @@ void e2fsck_pass2(e2fsck_t ctx)
 		ext2fs_u32_list_free(ctx->encrypted_dirs);
 		ctx->encrypted_dirs = 0;
 	}
+	if (ctx->casefolded_dirs) {
+		ext2fs_u32_list_free(ctx->casefolded_dirs);
+		ctx->casefolded_dirs = 0;
+	}
 
 	clear_problem_context(&pctx);
 	if (ctx->large_files) {
@@ -706,7 +710,8 @@ static void salvage_directory(ext2_filsys fs,
 			      struct ext2_dir_entry *dirent,
 			      struct ext2_dir_entry *prev,
 			      unsigned int *offset,
-			      unsigned int block_len)
+			      unsigned int block_len,
+			      int hash_in_dirent)
 {
 	char	*cp = (char *) dirent;
 	int left;
@@ -731,7 +736,8 @@ static void salvage_directory(ext2_filsys fs,
 	 * Special case of directory entry of size 8: copy what's left
 	 * of the directory block up to cover up the invalid hole.
 	 */
-	if ((left >= 12) && (rec_len == EXT2_DIR_ENTRY_HEADER_LEN)) {
+	if ((left >= ext2fs_dir_rec_len(1, hash_in_dirent)) &&
+	     (rec_len == EXT2_DIR_ENTRY_HEADER_LEN)) {
 		memmove(cp, cp+EXT2_DIR_ENTRY_HEADER_LEN, left);
 		memset(cp + left, 0, EXT2_DIR_ENTRY_HEADER_LEN);
 		return;
@@ -743,7 +749,7 @@ static void salvage_directory(ext2_filsys fs,
 	 */
 	if ((left < 0) &&
 	    ((int) rec_len + left > EXT2_DIR_ENTRY_HEADER_LEN) &&
-	    ((int) name_len + EXT2_DIR_ENTRY_HEADER_LEN <= (int) rec_len + left) &&
+	    ((int) ext2fs_dir_rec_len(name_len, hash_in_dirent) <= (int) rec_len + left) &&
 	    dirent->inode <= fs->super->s_inodes_count &&
 	    strnlen(dirent->name, name_len) == name_len) {
 		(void) ext2fs_set_rec_len(fs, (int) rec_len + left, dirent);
@@ -933,6 +939,8 @@ static int check_dir_block(ext2_filsys fs,
 	size_t	inline_data_size = 0;
 	int	filetype = 0;
 	int	encrypted = 0;
+	int	hash_in_dirent = 0;
+	int	casefolded = 0;
 	size_t	max_block_size;
 	int	hash_flags = 0;
 	static char *eop_read_dirblock = NULL;
@@ -1156,6 +1164,9 @@ skip_checksum:
 
 	if (ctx->encrypted_dirs)
 		encrypted = ext2fs_u32_list_test(ctx->encrypted_dirs, ino);
+	if (ctx->casefolded_dirs)
+		casefolded = ext2fs_u32_list_test(ctx->casefolded_dirs, ino);
+	hash_in_dirent = encrypted && casefolded;
 
 	dict_init(&de_dict, DICTCOUNT_T_MAX, dict_de_cmp);
 	prev = 0;
@@ -1163,6 +1174,9 @@ skip_checksum:
 		dgrp_t group;
 		ext2_ino_t first_unused_inode;
 		unsigned int name_len;
+		/* csum entry is not checked here, so don't worry about it */
+		int extended = (dot_state > 1) && hash_in_dirent;
+		int min_dir_len = ext2fs_dir_rec_len(1, extended);
 
 		problem = 0;
 		if (!inline_data_size || dot_state > 1) {
@@ -1172,15 +1186,16 @@ skip_checksum:
 			 * force salvaging this dir.
 			 */
 			if (max_block_size - offset < EXT2_DIR_ENTRY_HEADER_LEN)
-				rec_len = EXT2_DIR_REC_LEN(1);
+				rec_len = ext2fs_dir_rec_len(1, extended);
 			else
 				(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
 			cd->pctx.dirent = dirent;
 			cd->pctx.num = offset;
 			if ((offset + rec_len > max_block_size) ||
-			    (rec_len < 12) ||
+			    (rec_len < min_dir_len) ||
 			    ((rec_len % 4) != 0) ||
-			    (((unsigned) ext2fs_dirent_name_len(dirent) + EXT2_DIR_ENTRY_HEADER_LEN) > rec_len)) {
+			    ((ext2fs_dir_rec_len(ext2fs_dirent_name_len(dirent),
+						 extended)) > rec_len)) {
 				if (fix_problem(ctx, PR_2_DIR_CORRUPTED,
 						&cd->pctx)) {
 #ifdef WORDS_BIGENDIAN
@@ -1213,7 +1228,8 @@ skip_checksum:
 #endif
 					salvage_directory(fs, dirent, prev,
 							  &offset,
-							  max_block_size);
+							  max_block_size,
+							  hash_in_dirent);
 #ifdef WORDS_BIGENDIAN
 					if (need_reswab) {
 						(void) ext2fs_get_rec_len(fs,
@@ -1435,10 +1451,17 @@ skip_checksum:
 			if (dx_dir->casefolded_hash)
 				hash_flags = EXT4_CASEFOLD_FL;
 
-			ext2fs_dirhash2(dx_dir->hashversion, dirent->name,
-					ext2fs_dirent_name_len(dirent),
-					fs->encoding, hash_flags,
-					fs->super->s_hash_seed, &hash, 0);
+			if (dx_dir->hashversion == EXT2_HASH_SIPHASH) {
+				if (dot_state > 1)
+					hash = EXT2_DIRENT_HASH(dirent);
+			} else {
+				ext2fs_dirhash2(dx_dir->hashversion,
+						dirent->name,
+						ext2fs_dirent_name_len(dirent),
+						fs->encoding, hash_flags,
+						fs->super->s_hash_seed,
+						&hash, 0);
+			}
 			if (hash < dx_db->min_hash)
 				dx_db->min_hash = hash;
 			if (hash > dx_db->max_hash)
diff --git a/e2fsck/problem.c b/e2fsck/problem.c
index f8882a592..da261fcea 100644
--- a/e2fsck/problem.c
+++ b/e2fsck/problem.c
@@ -1253,6 +1253,16 @@ static struct e2fsck_problem problem_table[] = {
 	  N_("@d %p has the casefold flag, but the\ncasefold feature is not enabled.  "),
 	  PROMPT_CLEAR_FLAG, 0, 0, 0, 0 },
 
+	/* Htree directory should use SipHash but does not */
+	{ PR_1_HTREE_NEEDS_SIPHASH,
+	  N_("@h %i uses hash version (%N), but should use SipHash (6) \n"),
+	  PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 },
+
+	/* Htree directory uses SipHash but should not */
+	{ PR_1_HTREE_CANNOT_SIPHASH,
+	  N_("@h %i uses SipHash, but should not.  "),
+	  PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 },
+
 	/* Pass 1b errors */
 
 	/* Pass 1B: Rescan for duplicate/bad blocks */
diff --git a/e2fsck/problem.h b/e2fsck/problem.h
index 7e144cac8..5e67b17a4 100644
--- a/e2fsck/problem.h
+++ b/e2fsck/problem.h
@@ -701,6 +701,15 @@ struct problem_context {
 /* Casefold flag set, but file system is missing the casefold feature */
 #define PR_1_CASEFOLD_FEATURE			0x010089
 
+/* Error allocating memory for casefolded directory list */
+#define PR_1_ALLOCATE_CASEFOLDED_DIRLIST	0x01008C
+
+/* Htree directory should use SipHash but does not */
+#define PR_1_HTREE_NEEDS_SIPHASH		0x01008D
+
+/* Htree directory uses SipHash but should not */
+#define PR_1_HTREE_CANNOT_SIPHASH		0x01008E
+
 
 /*
  * Pass 1b errors
diff --git a/e2fsck/rehash.c b/e2fsck/rehash.c
index 0d218e83f..57b5ad40b 100644
--- a/e2fsck/rehash.c
+++ b/e2fsck/rehash.c
@@ -101,6 +101,21 @@ struct out_dir {
 	ext2_dirhash_t	*hashes;
 };
 
+#define DOTDOT_OFFSET 12
+
+static int is_fake_entry(ext2_filsys fs, int lblk, unsigned int offset)
+{
+	/* Entries in the first block before this value refer to . or .. */
+	if (lblk == 0 && offset <= DOTDOT_OFFSET)
+		return 1;
+	/* Check if this is likely the csum entry */
+	if (ext2fs_has_feature_metadata_csum(fs->super) &&
+	    (offset & (fs->blocksize - 1)) ==
+			    fs->blocksize - sizeof(struct ext2_dir_entry_tail))
+		return 1;
+	return 0;
+}
+
 static int fill_dir_block(ext2_filsys fs,
 			  blk64_t *block_nr,
 			  e2_blkcnt_t blockcnt,
@@ -113,7 +128,7 @@ static int fill_dir_block(ext2_filsys fs,
 	struct ext2_dir_entry 	*dirent;
 	char			*dir;
 	unsigned int		offset, dir_offset, rec_len, name_len;
-	int			hash_alg, hash_flags;
+	int			hash_alg, hash_flags, hash_in_entry;
 
 	if (blockcnt < 0)
 		return 0;
@@ -140,6 +155,7 @@ static int fill_dir_block(ext2_filsys fs,
 			return BLOCK_ABORT;
 	}
 	hash_flags = fd->inode->i_flags & EXT4_CASEFOLD_FL;
+	hash_in_entry = ext4_hash_in_dirent(fd->inode);
 	hash_alg = fs->super->s_def_hash_version;
 	if ((hash_alg <= EXT2_HASH_TEA) &&
 	    (fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH))
@@ -147,13 +163,18 @@ static int fill_dir_block(ext2_filsys fs,
 	/* While the directory block is "hot", index it. */
 	dir_offset = 0;
 	while (dir_offset < fs->blocksize) {
+		int min_rec = EXT2_DIR_ENTRY_HEADER_LEN;
+		int extended = hash_in_entry && !is_fake_entry(fs, blockcnt, dir_offset);
+
+		if (extended)
+			min_rec += EXT2_DIR_ENTRY_HASH_LEN;
 		dirent = (struct ext2_dir_entry *) (dir + dir_offset);
 		(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
 		name_len = ext2fs_dirent_name_len(dirent);
 		if (((dir_offset + rec_len) > fs->blocksize) ||
-		    (rec_len < 8) ||
+		    (rec_len < min_rec) ||
 		    ((rec_len % 4) != 0) ||
-		    (name_len + 8 > rec_len)) {
+		    (name_len + min_rec > rec_len)) {
 			fd->err = EXT2_ET_DIR_CORRUPTED;
 			return BLOCK_ABORT;
 		}
@@ -187,11 +208,14 @@ static int fill_dir_block(ext2_filsys fs,
 		}
 		ent = fd->harray + fd->num_array++;
 		ent->dir = dirent;
-		fd->dir_size += EXT2_DIR_REC_LEN(name_len);
+		fd->dir_size += ext2fs_dir_rec_len(name_len, extended);
 		ent->ino = dirent->inode;
-		if (fd->compress)
+		if (extended) {
+			ent->hash = EXT2_DIRENT_HASH(dirent);
+			ent->minor_hash = EXT2_DIRENT_MINOR_HASH(dirent);
+		} else if (fd->compress) {
 			ent->hash = ent->minor_hash = 0;
-		else {
+		} else {
 			fd->err = ext2fs_dirhash2(hash_alg,
 						  dirent->name, name_len,
 						  fs->encoding, hash_flags,
@@ -473,6 +497,8 @@ static errcode_t copy_dir_entries(e2fsck_t ctx,
 	ext2_dirhash_t		prev_hash;
 	int			csum_size = 0;
 	struct			ext2_dir_entry_tail *t;
+	int hash_in_entry = ext4_hash_in_dirent(fd->inode);
+	int min_rec_len = ext2fs_dir_rec_len(1, hash_in_entry);
 
 	if (ctx->htree_slack_percentage == 255) {
 		profile_get_uint(ctx->profile, "options",
@@ -501,15 +527,16 @@ static errcode_t copy_dir_entries(e2fsck_t ctx,
 	prev_rec_len = 0;
 	rec_len = 0;
 	left = fs->blocksize - csum_size;
-	slack = fd->compress ? 12 :
+	slack = fd->compress ? min_rec_len :
 		((fs->blocksize - csum_size) * ctx->htree_slack_percentage)/100;
-	if (slack < 12)
-		slack = 12;
+	if (slack < min_rec_len)
+		slack = min_rec_len;
 	for (i = 0; i < fd->num_array; i++) {
 		ent = fd->harray + i;
 		if (ent->dir->inode == 0)
 			continue;
-		rec_len = EXT2_DIR_REC_LEN(ext2fs_dirent_name_len(ent->dir));
+		rec_len = ext2fs_dir_rec_len(ext2fs_dirent_name_len(ent->dir),
+					     hash_in_entry);
 		if (rec_len > left) {
 			if (left) {
 				left += prev_rec_len;
@@ -546,6 +573,11 @@ static errcode_t copy_dir_entries(e2fsck_t ctx,
 		prev_rec_len = rec_len;
 		memcpy(dirent->name, ent->dir->name,
 		       ext2fs_dirent_name_len(dirent));
+		if (hash_in_entry) {
+			EXT2_DIRENT_HASHES(dirent)->hash = ext2fs_cpu_to_le32(ent->hash);
+			EXT2_DIRENT_HASHES(dirent)->minor_hash =
+							ext2fs_cpu_to_le32(ent->minor_hash);
+		}
 		offset += rec_len;
 		left -= rec_len;
 		if (left < slack) {
@@ -570,7 +602,8 @@ static errcode_t copy_dir_entries(e2fsck_t ctx,
 
 
 static struct ext2_dx_root_info *set_root_node(ext2_filsys fs, char *buf,
-				    ext2_ino_t ino, ext2_ino_t parent)
+				    ext2_ino_t ino, ext2_ino_t parent,
+				    struct ext2_inode *inode)
 {
 	struct ext2_dir_entry 		*dir;
 	struct ext2_dx_root_info  	*root;
@@ -598,7 +631,10 @@ static struct ext2_dx_root_info *set_root_node(ext2_filsys fs, char *buf,
 
 	root = (struct ext2_dx_root_info *) (buf+24);
 	root->reserved_zero = 0;
-	root->hash_version = fs->super->s_def_hash_version;
+	if (ext4_hash_in_dirent(inode))
+		root->hash_version = EXT2_HASH_SIPHASH;
+	else
+		root->hash_version = fs->super->s_def_hash_version;
 	root->info_length = 8;
 	root->indirect_levels = 0;
 	root->unused_flags = 0;
@@ -684,7 +720,8 @@ static int alloc_blocks(ext2_filsys fs,
 static errcode_t calculate_tree(ext2_filsys fs,
 				struct out_dir *outdir,
 				ext2_ino_t ino,
-				ext2_ino_t parent)
+				ext2_ino_t parent,
+				struct ext2_inode *inode)
 {
 	struct ext2_dx_root_info	*root_info;
 	struct ext2_dx_entry		*root, *int_ent, *dx_ent = 0;
@@ -693,7 +730,7 @@ static errcode_t calculate_tree(ext2_filsys fs,
 	int				i, c1, c2, c3, nblks;
 	int				limit_offset, int_offset, root_offset;
 
-	root_info = set_root_node(fs, outdir->buf, ino, parent);
+	root_info = set_root_node(fs, outdir->buf, ino, parent, inode);
 	root_offset = limit_offset = ((char *) root_info - outdir->buf) +
 		root_info->info_length;
 	root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset);
@@ -992,7 +1029,7 @@ resort:
 
 	if (!fd.compress) {
 		/* Calculate the interior nodes */
-		retval = calculate_tree(fs, &outdir, ino, fd.parent);
+		retval = calculate_tree(fs, &outdir, ino, fd.parent, fd.inode);
 		if (retval)
 			goto errout;
 	}
diff --git a/lib/ext2fs/ext2_fs.h b/lib/ext2fs/ext2_fs.h
index 475ecf939..905eb323e 100644
--- a/lib/ext2fs/ext2_fs.h
+++ b/lib/ext2fs/ext2_fs.h
@@ -238,6 +238,7 @@ struct ext2_dx_root_info {
 #define EXT2_HASH_LEGACY_UNSIGNED	3 /* reserved for userspace lib */
 #define EXT2_HASH_HALF_MD4_UNSIGNED	4 /* reserved for userspace lib */
 #define EXT2_HASH_TEA_UNSIGNED		5 /* reserved for userspace lib */
+#define EXT2_HASH_SIPHASH		6
 
 #define EXT2_HASH_FLAG_INCOMPAT	0x1
 
@@ -983,6 +984,12 @@ EXT4_FEATURE_INCOMPAT_FUNCS(casefold,		4, CASEFOLD)
 #define EXT4_DEFM_DISCARD	0x0400
 #define EXT4_DEFM_NODELALLOC	0x0800
 
+static inline int ext4_hash_in_dirent(const struct ext2_inode *inode)
+{
+	return (inode->i_flags & EXT4_ENCRYPT_FL) &&
+		(inode->i_flags & EXT4_CASEFOLD_FL);
+}
+
 /*
  * Structure of a directory entry
  */
@@ -1018,6 +1025,25 @@ struct ext2_dir_entry_2 {
 };
 
 /*
+ * Hashes for ext4_dir_entry for casefolded and ecrypted directories.
+ * This is located at the first 4 bit aligned location after the name.
+ */
+
+struct ext2_dir_entry_hash {
+	__le32 hash;
+	__le32 minor_hash;
+};
+
+#define EXT2_DIRENT_HASHES(entry) \
+	((struct ext2_dir_entry_hash *) &entry->name[\
+		(ext2fs_dirent_name_len(entry) + \
+			EXT2_DIR_ROUND) & ~EXT2_DIR_ROUND])
+#define EXT2_DIRENT_HASH(entry) \
+		ext2fs_le32_to_cpu(EXT2_DIRENT_HASHES(entry)->hash)
+#define EXT2_DIRENT_MINOR_HASH(entry) \
+		ext2fs_le32_to_cpu(EXT2_DIRENT_HASHES(entry)->minor_hash)
+
+/*
  * This is a bogus directory entry at the end of each leaf block that
  * records checksums.
  */
@@ -1057,12 +1083,21 @@ struct ext2_dir_entry_tail {
  * NOTE: It must be a multiple of 4
  */
 #define EXT2_DIR_ENTRY_HEADER_LEN	8
+#define EXT2_DIR_ENTRY_HASH_LEN		8
 #define EXT2_DIR_PAD			4
 #define EXT2_DIR_ROUND			(EXT2_DIR_PAD - 1)
-#define EXT2_DIR_REC_LEN(name_len)	(((name_len) + \
-					  EXT2_DIR_ENTRY_HEADER_LEN + \
-					  EXT2_DIR_ROUND) & \
-					 ~EXT2_DIR_ROUND)
+#define EXT2_DIR_REC_LEN(name_len) ext2fs_dir_rec_len(name_len, 0)
+
+static inline unsigned int ext2fs_dir_rec_len(__u8 name_len,
+						int extended)
+{
+	int rec_len = (name_len + EXT2_DIR_ENTRY_HEADER_LEN + EXT2_DIR_ROUND);
+
+	rec_len &= ~EXT2_DIR_ROUND;
+	if (extended)
+		rec_len += EXT2_DIR_ENTRY_HASH_LEN;
+	return rec_len;
+}
 
 /*
  * Constants for ext4's extended time encoding