Refactor directory related names (shorter)

6 files changed, 247 insertions, 248 deletions

diff --git a/lwext4/ext4.c b/lwext4/ext4.c
index d81c242..78b5270 100644
--- a/lwext4/ext4.c
+++ b/lwext4/ext4.c
@@ -147,7 +147,7 @@ static int ext4_has_children(bool *has_children, struct ext4_inode_ref *enode)
 		return EOK;
 	}
 
-	struct ext4_directory_iterator it;
+	struct ext4_dir_iterator it;
 	int rc = ext4_dir_iterator_init(&it, enode, 0);
 	if (rc != EOK)
 		return rc;
@@ -243,7 +243,7 @@ static int ext4_link(struct ext4_mountpoint *mp, struct ext4_inode_ref *parent,
 			int has_flag_index =
 				ext4_inode_has_flag(child->inode,
 						    EXT4_INODE_FLAG_INDEX);
-			struct ext4_directory_search_result result;
+			struct ext4_dir_search_result result;
 			if (!has_flag_index) {
 				rc = ext4_dir_find_entry(&result,
 							 child, "..",
@@ -588,7 +588,7 @@ static int ext4_generic_open2(ext4_file *f, const char *path, int flags,
 
 	int r;
 	struct ext4_mountpoint *mp = ext4_get_mount(path);
-	struct ext4_directory_search_result result;
+	struct ext4_dir_search_result result;
 	struct ext4_inode_ref ref;
 
 	f->mp = 0;
@@ -770,7 +770,7 @@ static int __ext4_create_hardlink(const char *path,
 
 	int r;
 	struct ext4_mountpoint *mp = ext4_get_mount(path);
-	struct ext4_directory_search_result result;
+	struct ext4_dir_search_result result;
 	struct ext4_inode_ref ref;
 
 	if (!mp)
@@ -2196,7 +2196,7 @@ int ext4_dir_rm(const char *path)
 	struct ext4_mountpoint *mp = ext4_get_mount(path);
 	struct ext4_inode_ref current;
 	struct ext4_inode_ref child;
-	struct ext4_directory_iterator it;
+	struct ext4_dir_iterator it;
 
 	uint32_t name_off;
 	uint32_t inode_up;
@@ -2447,7 +2447,7 @@ const ext4_direntry *ext4_dir_entry_next(ext4_dir *d)
 	int r;
 	ext4_direntry *de = 0;
 	struct ext4_inode_ref dir;
-	struct ext4_directory_iterator it;
+	struct ext4_dir_iterator it;
 
 	EXT4_MP_LOCK(d->f.mp);
 
diff --git a/lwext4/ext4_dir.c b/lwext4/ext4_dir.c
index 3a8e9ac..55a4aa5 100644
--- a/lwext4/ext4_dir.c
+++ b/lwext4/ext4_dir.c
@@ -51,17 +51,17 @@
 /****************************************************************************/
 
 /* Walk through a dirent block to find a checksum "dirent" at the tail */
-static struct ext4_directory_entry_tail *
+static struct ext4_dir_entry_tail *
 ext4_dir_get_tail(struct ext4_inode_ref *inode_ref,
-		struct ext4_directory_entry_ll *de)
+		struct ext4_dir_entry_ll *de)
 {
-	struct ext4_directory_entry_tail *t;
+	struct ext4_dir_entry_tail *t;
 	struct ext4_sblock *sb = &inode_ref->fs->sb;
 
 	t = EXT4_DIRENT_TAIL(de, ext4_sb_get_block_size(sb));
 
 	if (t->reserved_zero1 ||
-	    to_le16(t->rec_len) != sizeof(struct ext4_directory_entry_tail) ||
+	    to_le16(t->rec_len) != sizeof(struct ext4_dir_entry_tail) ||
 	    t->reserved_zero2 ||
 	    t->reserved_ft != EXT4_DIRENTRY_DIR_CSUM)
 		return NULL;
@@ -71,7 +71,7 @@ ext4_dir_get_tail(struct ext4_inode_ref *inode_ref,
 
 #if CONFIG_META_CSUM_ENABLE
 static uint32_t ext4_dir_checksum(struct ext4_inode_ref *inode_ref,
-			       struct ext4_directory_entry_ll *dirent, int size)
+			       struct ext4_dir_entry_ll *dirent, int size)
 {
 	uint32_t checksum;
 	struct ext4_sblock *sb = &inode_ref->fs->sb;
@@ -97,10 +97,10 @@ static uint32_t ext4_dir_checksum(struct ext4_inode_ref *inode_ref,
 
 bool
 ext4_dir_checksum_verify(struct ext4_inode_ref *inode_ref,
-			 struct ext4_directory_entry_ll *dirent)
+			 struct ext4_dir_entry_ll *dirent)
 {
 #ifdef CONFIG_META_CSUM_ENABLE
-	struct ext4_directory_entry_tail *t;
+	struct ext4_dir_entry_tail *t;
 	struct ext4_sblock *sb = &inode_ref->fs->sb;
 
 	/* Compute the checksum only if the filesystem supports it */
@@ -121,17 +121,17 @@ ext4_dir_checksum_verify(struct ext4_inode_ref *inode_ref,
 }
 
 /* checksumming functions */
-void initialize_dir_tail(struct ext4_directory_entry_tail *t)
+void initialize_dir_tail(struct ext4_dir_entry_tail *t)
 {
-	memset(t, 0, sizeof(struct ext4_directory_entry_tail));
-	t->rec_len = to_le16(sizeof(struct ext4_directory_entry_tail));
+	memset(t, 0, sizeof(struct ext4_dir_entry_tail));
+	t->rec_len = to_le16(sizeof(struct ext4_dir_entry_tail));
 	t->reserved_ft = EXT4_DIRENTRY_DIR_CSUM;
 }
 
 void ext4_dir_set_checksum(struct ext4_inode_ref *inode_ref,
-			   struct ext4_directory_entry_ll *dirent)
+			   struct ext4_dir_entry_ll *dirent)
 {
-	struct ext4_directory_entry_tail *t;
+	struct ext4_dir_entry_tail *t;
 	struct ext4_sblock *sb = &inode_ref->fs->sb;
 
 	/* Compute the checksum only if the filesystem supports it */
@@ -152,7 +152,7 @@ void ext4_dir_set_checksum(struct ext4_inode_ref *inode_ref,
  * @param block_size Size of data block
  * @return Error code
  */
-static int ext4_dir_iterator_set(struct ext4_directory_iterator *it,
+static int ext4_dir_iterator_set(struct ext4_dir_iterator *it,
 				 uint32_t block_size)
 {
 	it->current = NULL;
@@ -167,7 +167,7 @@ static int ext4_dir_iterator_set(struct ext4_directory_iterator *it,
 	if (offset_in_block > block_size - 8)
 		return EIO;
 
-	struct ext4_directory_entry_ll *entry =
+	struct ext4_dir_entry_ll *entry =
 	    (void *)(it->current_block.data + offset_in_block);
 
 	/* Ensure that the whole entry does not overflow the block */
@@ -191,7 +191,7 @@ static int ext4_dir_iterator_set(struct ext4_directory_iterator *it,
  * @param pos Position of the next entry
  * @return Error code
  */
-static int ext4_dir_iterator_seek(struct ext4_directory_iterator *it,
+static int ext4_dir_iterator_seek(struct ext4_dir_iterator *it,
 				  uint64_t pos)
 {
 	uint64_t size =
@@ -257,7 +257,7 @@ static int ext4_dir_iterator_seek(struct ext4_directory_iterator *it,
 	return ext4_dir_iterator_set(it, block_size);
 }
 
-int ext4_dir_iterator_init(struct ext4_directory_iterator *it,
+int ext4_dir_iterator_init(struct ext4_dir_iterator *it,
 			   struct ext4_inode_ref *inode_ref, uint64_t pos)
 {
 	it->inode_ref = inode_ref;
@@ -268,7 +268,7 @@ int ext4_dir_iterator_init(struct ext4_directory_iterator *it,
 	return ext4_dir_iterator_seek(it, pos);
 }
 
-int ext4_dir_iterator_next(struct ext4_directory_iterator *it)
+int ext4_dir_iterator_next(struct ext4_dir_iterator *it)
 {
 	int r = EOK;
 	uint16_t skip;
@@ -287,7 +287,7 @@ int ext4_dir_iterator_next(struct ext4_directory_iterator *it)
 	return r;
 }
 
-int ext4_dir_iterator_fini(struct ext4_directory_iterator *it)
+int ext4_dir_iterator_fini(struct ext4_dir_iterator *it)
 {
 	it->current = 0;
 
@@ -299,7 +299,7 @@ int ext4_dir_iterator_fini(struct ext4_directory_iterator *it)
 }
 
 void ext4_dir_write_entry(struct ext4_sblock *sb,
-			  struct ext4_directory_entry_ll *entry,
+			  struct ext4_dir_entry_ll *entry,
 			  uint16_t entry_len, struct ext4_inode_ref *child,
 			  const char *name, size_t name_len)
 {
@@ -383,7 +383,7 @@ int ext4_dir_add_entry(struct ext4_inode_ref *parent, const char *name,
 
 		if (!ext4_dir_checksum_verify(
 				parent,
-				(struct ext4_directory_entry_ll *)
+				(struct ext4_dir_entry_ll *)
 					block.data)) {
 			ext4_dbg(DEBUG_DIR,
 				 DBG_WARN "Leaf block checksum failed."
@@ -424,12 +424,12 @@ int ext4_dir_add_entry(struct ext4_inode_ref *parent, const char *name,
 
 	/* Fill block with zeroes */
 	memset(new_block.data, 0, block_size);
-	struct ext4_directory_entry_ll *block_entry = (void *)new_block.data;
+	struct ext4_dir_entry_ll *block_entry = (void *)new_block.data;
 
 	/* Save new block */
 	if (ext4_sb_feature_ro_com(&fs->sb, EXT4_FRO_COM_METADATA_CSUM)) {
 		ext4_dir_write_entry(&fs->sb, block_entry,
-				block_size - sizeof(struct ext4_directory_entry_tail),
+				block_size - sizeof(struct ext4_dir_entry_tail),
 				child,
 				name, name_len);
 		initialize_dir_tail(EXT4_DIRENT_TAIL(new_block.data,
@@ -439,14 +439,14 @@ int ext4_dir_add_entry(struct ext4_inode_ref *parent, const char *name,
 				     name_len);
 
 	ext4_dir_set_checksum(parent,
-			(struct ext4_directory_entry_ll *)new_block.data);
+			(struct ext4_dir_entry_ll *)new_block.data);
 	new_block.dirty = true;
 	rc = ext4_block_set(fs->bdev, &new_block);
 
 	return rc;
 }
 
-int ext4_dir_find_entry(struct ext4_directory_search_result *result,
+int ext4_dir_find_entry(struct ext4_dir_search_result *result,
 			struct ext4_inode_ref *parent, const char *name,
 			uint32_t name_len)
 {
@@ -498,7 +498,7 @@ int ext4_dir_find_entry(struct ext4_directory_search_result *result,
 
 		if (!ext4_dir_checksum_verify(
 				parent,
-				(struct ext4_directory_entry_ll *)
+				(struct ext4_dir_entry_ll *)
 					block.data)) {
 			ext4_dbg(DEBUG_DIR,
 				 DBG_WARN "Leaf block checksum failed."
@@ -509,7 +509,7 @@ int ext4_dir_find_entry(struct ext4_directory_search_result *result,
 		}
 
 		/* Try to find entry in block */
-		struct ext4_directory_entry_ll *res_entry;
+		struct ext4_dir_entry_ll *res_entry;
 		rc = ext4_dir_find_in_block(&block, sb, name_len, name,
 					    &res_entry);
 		if (rc == EOK) {
@@ -542,7 +542,7 @@ int ext4_dir_remove_entry(struct ext4_inode_ref *parent, const char *name,
 		return ENOTDIR;
 
 	/* Try to find entry */
-	struct ext4_directory_search_result result;
+	struct ext4_dir_search_result result;
 	int rc = ext4_dir_find_entry(&result, parent, name, name_len);
 	if (rc != EOK)
 		return rc;
@@ -561,7 +561,7 @@ int ext4_dir_remove_entry(struct ext4_inode_ref *parent, const char *name,
 		uint32_t offset = 0;
 
 		/* Start from the first entry in block */
-		struct ext4_directory_entry_ll *tmp_dentry =
+		struct ext4_dir_entry_ll *tmp_dentry =
 		    (void *)result.block.data;
 		uint16_t tmp_dentry_length =
 		    ext4_dir_entry_ll_get_entry_length(tmp_dentry);
@@ -585,7 +585,7 @@ int ext4_dir_remove_entry(struct ext4_inode_ref *parent, const char *name,
 	}
 
 	ext4_dir_set_checksum(parent,
-			(struct ext4_directory_entry_ll *)result.block.data);
+			(struct ext4_dir_entry_ll *)result.block.data);
 	result.block.dirty = true;
 
 	return ext4_dir_destroy_result(parent, &result);
@@ -600,14 +600,14 @@ int ext4_dir_try_insert_entry(struct ext4_sblock *sb,
 	/* Compute required length entry and align it to 4 bytes */
 	uint32_t block_size = ext4_sb_get_block_size(sb);
 	uint16_t required_len =
-	    sizeof(struct ext4_fake_directory_entry) + name_len;
+	    sizeof(struct ext4_fake_dir_entry) + name_len;
 
 	if ((required_len % 4) != 0)
 		required_len += 4 - (required_len % 4);
 
 	/* Initialize pointers, stop means to upper bound */
-	struct ext4_directory_entry_ll *dentry = (void *)target_block->data;
-	struct ext4_directory_entry_ll *stop =
+	struct ext4_dir_entry_ll *dentry = (void *)target_block->data;
+	struct ext4_dir_entry_ll *stop =
 	    (void *)(target_block->data + block_size);
 
 	/*
@@ -626,7 +626,7 @@ int ext4_dir_try_insert_entry(struct ext4_sblock *sb,
 			ext4_dir_write_entry(sb, dentry, rec_len, child, name,
 					     name_len);
 			ext4_dir_set_checksum(inode_ref,
-						(struct ext4_directory_entry_ll *)
+						(struct ext4_dir_entry_ll *)
 						target_block->data);
 			target_block->dirty = true;
 
@@ -639,7 +639,7 @@ int ext4_dir_try_insert_entry(struct ext4_sblock *sb,
 			    ext4_dir_entry_ll_get_name_length(sb, dentry);
 
 			uint16_t used_space =
-			    sizeof(struct ext4_fake_directory_entry) +
+			    sizeof(struct ext4_fake_dir_entry) +
 			    used_name_len;
 
 			if ((used_name_len % 4) != 0)
@@ -652,13 +652,13 @@ int ext4_dir_try_insert_entry(struct ext4_sblock *sb,
 				/* Cut tail of current entry */
 				ext4_dir_entry_ll_set_entry_length(dentry,
 								   used_space);
-				struct ext4_directory_entry_ll *new_entry =
+				struct ext4_dir_entry_ll *new_entry =
 				    (void *)((uint8_t *)dentry + used_space);
 				ext4_dir_write_entry(sb, new_entry, free_space,
 						     child, name, name_len);
 
 				ext4_dir_set_checksum(inode_ref,
-						(struct ext4_directory_entry_ll *)
+						(struct ext4_dir_entry_ll *)
 						target_block->data);
 				target_block->dirty = true;
 				return EOK;
@@ -675,11 +675,11 @@ int ext4_dir_try_insert_entry(struct ext4_sblock *sb,
 
 int ext4_dir_find_in_block(struct ext4_block *block, struct ext4_sblock *sb,
 			   size_t name_len, const char *name,
-			   struct ext4_directory_entry_ll **res_entry)
+			   struct ext4_dir_entry_ll **res_entry)
 {
 	/* Start from the first entry in block */
-	struct ext4_directory_entry_ll *dentry =
-	    (struct ext4_directory_entry_ll *)block->data;
+	struct ext4_dir_entry_ll *dentry =
+	    (struct ext4_dir_entry_ll *)block->data;
 
 	/* Set upper bound for cycling */
 	uint8_t *addr_limit = block->data + ext4_sb_get_block_size(sb);
@@ -712,7 +712,7 @@ int ext4_dir_find_in_block(struct ext4_block *block, struct ext4_sblock *sb,
 			return EINVAL;
 
 		/* Jump to next entry */
-		dentry = (struct ext4_directory_entry_ll *)((uint8_t *)dentry +
+		dentry = (struct ext4_dir_entry_ll *)((uint8_t *)dentry +
 							    dentry_len);
 	}
 
@@ -721,7 +721,7 @@ int ext4_dir_find_in_block(struct ext4_block *block, struct ext4_sblock *sb,
 }
 
 int ext4_dir_destroy_result(struct ext4_inode_ref *parent,
-			    struct ext4_directory_search_result *result)
+			    struct ext4_dir_search_result *result)
 {
 	if (result->block.lb_id)
 		return ext4_block_set(parent->fs->bdev, &result->block);
diff --git a/lwext4/ext4_dir.h b/lwext4/ext4_dir.h
index b985080..bb1ffe0 100644
--- a/lwext4/ext4_dir.h
+++ b/lwext4/ext4_dir.h
@@ -54,7 +54,7 @@
  * @return I-node number
  */
 static inline uint32_t
-ext4_dir_entry_ll_get_inode(struct ext4_directory_entry_ll *de)
+ext4_dir_entry_ll_get_inode(struct ext4_dir_entry_ll *de)
 {
 	return to_le32(de->inode);
 }
@@ -64,7 +64,7 @@ ext4_dir_entry_ll_get_inode(struct ext4_directory_entry_ll *de)
  * @param inode I-node number
  */
 static inline void
-ext4_dir_entry_ll_set_inode(struct ext4_directory_entry_ll *de, uint32_t inode)
+ext4_dir_entry_ll_set_inode(struct ext4_dir_entry_ll *de, uint32_t inode)
 {
 	de->inode = to_le32(inode);
 }
@@ -74,7 +74,7 @@ ext4_dir_entry_ll_set_inode(struct ext4_directory_entry_ll *de, uint32_t inode)
  * @param inode I-node number
  */
 static inline void
-ext4_dx_dot_entry_set_inode(struct ext4_directory_dx_dot_entry *de, uint32_t inode)
+ext4_dx_dot_entry_set_inode(struct ext4_dir_idx_dot_entry *de, uint32_t inode)
 {
 	de->inode = to_le32(inode);
 }
@@ -84,7 +84,7 @@ ext4_dx_dot_entry_set_inode(struct ext4_directory_dx_dot_entry *de, uint32_t ino
  * @return Entry length
  */
 static inline uint16_t
-ext4_dir_entry_ll_get_entry_length(struct ext4_directory_entry_ll *de)
+ext4_dir_entry_ll_get_entry_length(struct ext4_dir_entry_ll *de)
 {
 	return to_le16(de->entry_length);
 }
@@ -94,7 +94,7 @@ ext4_dir_entry_ll_get_entry_length(struct ext4_directory_entry_ll *de)
  * @param length Entry length
  */
 static inline void
-ext4_dir_entry_ll_set_entry_length(struct ext4_directory_entry_ll *de,
+ext4_dir_entry_ll_set_entry_length(struct ext4_dir_entry_ll *de,
 				   uint16_t len)
 {
 	de->entry_length = to_le16(len);
@@ -107,7 +107,7 @@ ext4_dir_entry_ll_set_entry_length(struct ext4_directory_entry_ll *de,
  */
 static inline uint16_t
 ext4_dir_entry_ll_get_name_length(struct ext4_sblock *sb,
-				  struct ext4_directory_entry_ll *de)
+				  struct ext4_dir_entry_ll *de)
 {
 	uint16_t v = de->name_length;
 
@@ -124,7 +124,7 @@ ext4_dir_entry_ll_get_name_length(struct ext4_sblock *sb,
  * @param length Entry name length
  */
 static inline void ext4_dir_entry_ll_set_name_length(
-    struct ext4_sblock *sb, struct ext4_directory_entry_ll *de, uint16_t len)
+    struct ext4_sblock *sb, struct ext4_dir_entry_ll *de, uint16_t len)
 {
 	de->name_length = (len << 8) >> 8;
 
@@ -140,7 +140,7 @@ static inline void ext4_dir_entry_ll_set_name_length(
  */
 static inline uint8_t
 ext4_dir_entry_ll_get_inode_type(struct ext4_sblock *sb,
-				 struct ext4_directory_entry_ll *de)
+				 struct ext4_dir_entry_ll *de)
 {
 	if ((ext4_get32(sb, rev_level) > 0) ||
 	    (ext4_get32(sb, minor_rev_level) >= 5))
@@ -155,7 +155,7 @@ ext4_dir_entry_ll_get_inode_type(struct ext4_sblock *sb,
  */
 
 static inline void ext4_dir_entry_ll_set_inode_type(
-    struct ext4_sblock *sb, struct ext4_directory_entry_ll *de, uint8_t type)
+    struct ext4_sblock *sb, struct ext4_dir_entry_ll *de, uint8_t type)
 {
 	if ((ext4_get32(sb, rev_level) > 0) ||
 	    (ext4_get32(sb, minor_rev_level) >= 5))
@@ -169,7 +169,7 @@ static inline void ext4_dir_entry_ll_set_inode_type(
  */
 bool
 ext4_dir_checksum_verify(struct ext4_inode_ref *inode_ref,
-			 struct ext4_directory_entry_ll *dirent);
+			 struct ext4_dir_entry_ll *dirent);
 
 /**@brief Initialize directory iterator.
  * Set position to the first valid entry from the required position.
@@ -178,21 +178,21 @@ ext4_dir_checksum_verify(struct ext4_inode_ref *inode_ref,
  * @param pos       Position to start reading entries from
  * @return Error code
  */
-int ext4_dir_iterator_init(struct ext4_directory_iterator *it,
+int ext4_dir_iterator_init(struct ext4_dir_iterator *it,
 			   struct ext4_inode_ref *inode_ref, uint64_t pos);
 
 /**@brief Jump to the next valid entry
  * @param it Initialized iterator
  * @return Error code
  */
-int ext4_dir_iterator_next(struct ext4_directory_iterator *it);
+int ext4_dir_iterator_next(struct ext4_dir_iterator *it);
 
 /**@brief Uninitialize directory iterator.
  *        Release all allocated structures.
  * @param it Iterator to be finished
  * @return Error code
  */
-int ext4_dir_iterator_fini(struct ext4_directory_iterator *it);
+int ext4_dir_iterator_fini(struct ext4_dir_iterator *it);
 
 /**@brief Write directory entry to concrete data block.
  * @param sb        Superblock
@@ -203,7 +203,7 @@ int ext4_dir_iterator_fini(struct ext4_directory_iterator *it);
  * @param name_len  Length of entry name
  */
 void ext4_dir_write_entry(struct ext4_sblock *sb,
-			  struct ext4_directory_entry_ll *entry,
+			  struct ext4_dir_entry_ll *entry,
 			  uint16_t entry_len, struct ext4_inode_ref *child,
 			  const char *name, size_t name_len);
 
@@ -223,7 +223,7 @@ int ext4_dir_add_entry(struct ext4_inode_ref *parent, const char *name,
  * @param name_len  Name length
  * @return Error code
  */
-int ext4_dir_find_entry(struct ext4_directory_search_result *result,
+int ext4_dir_find_entry(struct ext4_dir_search_result *result,
 			struct ext4_inode_ref *parent, const char *name,
 			uint32_t name_len);
 
@@ -261,7 +261,7 @@ int ext4_dir_try_insert_entry(struct ext4_sblock *sb,
  */
 int ext4_dir_find_in_block(struct ext4_block *block, struct ext4_sblock *sb,
 			   size_t name_len, const char *name,
-			   struct ext4_directory_entry_ll **res_entry);
+			   struct ext4_dir_entry_ll **res_entry);
 
 /**@brief Simple function to release allocated data from result.
  * @param parent Parent inode
@@ -270,13 +270,13 @@ int ext4_dir_find_in_block(struct ext4_block *block, struct ext4_sblock *sb,
  *
  */
 int ext4_dir_destroy_result(struct ext4_inode_ref *parent,
-			    struct ext4_directory_search_result *result);
+			    struct ext4_dir_search_result *result);
 
 void ext4_dir_set_checksum(struct ext4_inode_ref *inode_ref,
-			   struct ext4_directory_entry_ll *dirent);
+			   struct ext4_dir_entry_ll *dirent);
 
 /* checksumming functions */
-void initialize_dir_tail(struct ext4_directory_entry_tail *t);
+void initialize_dir_tail(struct ext4_dir_entry_tail *t);
 
 #endif /* EXT4_DIR_H_ */
 
diff --git a/lwext4/ext4_dir_idx.c b/lwext4/ext4_dir_idx.c
index 2a53030..fcea020 100644
--- a/lwext4/ext4_dir_idx.c
+++ b/lwext4/ext4_dir_idx.c
@@ -52,7 +52,7 @@
  * @return Hash algorithm version
  */
 static inline uint8_t ext4_dir_dx_root_info_get_hash_version(
-    struct ext4_directory_dx_root_info *root_info)
+    struct ext4_dir_idx_root_info *root_info)
 {
 	return root_info->hash_version;
 }
@@ -62,7 +62,7 @@ static inline uint8_t ext4_dir_dx_root_info_get_hash_version(
  * @param v Hash algorithm version
  */
 static inline void ext4_dir_dx_root_info_set_hash_version(
-    struct ext4_directory_dx_root_info *root_info, uint8_t v)
+    struct ext4_dir_idx_root_info *root_info, uint8_t v)
 {
 	root_info->hash_version = v;
 }
@@ -72,7 +72,7 @@ static inline void ext4_dir_dx_root_info_set_hash_version(
  * @return Length of the structure
  */
 static inline uint8_t ext4_dir_dx_root_info_get_info_length(
-    struct ext4_directory_dx_root_info *root_info)
+    struct ext4_dir_idx_root_info *root_info)
 {
 	return root_info->info_length;
 }
@@ -82,7 +82,7 @@ static inline uint8_t ext4_dir_dx_root_info_get_info_length(
  * @param info_length Length of the structure
  */
 static inline void ext4_dir_dx_root_info_set_info_length(
-    struct ext4_directory_dx_root_info *root_info, uint8_t len)
+    struct ext4_dir_idx_root_info *root_info, uint8_t len)
 {
 	root_info->info_length = len;
 }
@@ -92,7 +92,7 @@ static inline void ext4_dir_dx_root_info_set_info_length(
  * @return Height of HTree (actually only 0 or 1)
  */
 static inline uint8_t ext4_dir_dx_root_info_get_indirect_levels(
-    struct ext4_directory_dx_root_info *root_info)
+    struct ext4_dir_idx_root_info *root_info)
 {
 	return root_info->indirect_levels;
 }
@@ -102,7 +102,7 @@ static inline uint8_t ext4_dir_dx_root_info_get_indirect_levels(
  * @param lvl Height of HTree (actually only 0 or 1)
  */
 static inline void ext4_dir_dx_root_info_set_indirect_levels(
-    struct ext4_directory_dx_root_info *root_info, uint8_t lvl)
+    struct ext4_dir_idx_root_info *root_info, uint8_t lvl)
 {
 	root_info->indirect_levels = lvl;
 }
@@ -112,7 +112,7 @@ static inline void ext4_dir_dx_root_info_set_indirect_levels(
  * @return Maximum of entries in node
  */
 static inline uint16_t
-ext4_dir_dx_countlimit_get_limit(struct ext4_directory_dx_countlimit *climit)
+ext4_dir_dx_countlimit_get_limit(struct ext4_dir_idx_countlimit *climit)
 {
 	return to_le16(climit->limit);
 }
@@ -122,7 +122,7 @@ ext4_dir_dx_countlimit_get_limit(struct ext4_directory_dx_countlimit *climit)
  * @param limit Maximum of entries in node
  */
 static inline void
-ext4_dir_dx_countlimit_set_limit(struct ext4_directory_dx_countlimit *climit,
+ext4_dir_dx_countlimit_set_limit(struct ext4_dir_idx_countlimit *climit,
 				 uint16_t limit)
 {
 	climit->limit = to_le16(limit);
@@ -133,7 +133,7 @@ ext4_dir_dx_countlimit_set_limit(struct ext4_directory_dx_countlimit *climit,
  * @return Number of entries in node
  */
 static inline uint16_t
-ext4_dir_dx_countlimit_get_count(struct ext4_directory_dx_countlimit *climit)
+ext4_dir_dx_countlimit_get_count(struct ext4_dir_idx_countlimit *climit)
 {
 	return to_le16(climit->count);
 }
@@ -143,7 +143,7 @@ ext4_dir_dx_countlimit_get_count(struct ext4_directory_dx_countlimit *climit)
  * @param count Number of entries in node
  */
 static inline void
-ext4_dir_dx_countlimit_set_count(struct ext4_directory_dx_countlimit *climit,
+ext4_dir_dx_countlimit_set_count(struct ext4_dir_idx_countlimit *climit,
 				 uint16_t count)
 {
 	climit->count = to_le16(count);
@@ -154,7 +154,7 @@ ext4_dir_dx_countlimit_set_count(struct ext4_directory_dx_countlimit *climit,
  * @return Hash value
  */
 static inline uint32_t
-ext4_dir_dx_entry_get_hash(struct ext4_directory_dx_entry *entry)
+ext4_dir_dx_entry_get_hash(struct ext4_dir_idx_entry *entry)
 {
 	return to_le32(entry->hash);
 }
@@ -164,7 +164,7 @@ ext4_dir_dx_entry_get_hash(struct ext4_directory_dx_entry *entry)
  * @param hash  Hash value
  */
 static inline void
-ext4_dir_dx_entry_set_hash(struct ext4_directory_dx_entry *entry, uint32_t hash)
+ext4_dir_dx_entry_set_hash(struct ext4_dir_idx_entry *entry, uint32_t hash)
 {
 	entry->hash = to_le32(hash);
 }
@@ -174,7 +174,7 @@ ext4_dir_dx_entry_set_hash(struct ext4_directory_dx_entry *entry, uint32_t hash)
  * @return Block address of child node
  */
 static inline uint32_t
-ext4_dir_dx_entry_get_block(struct ext4_directory_dx_entry *entry)
+ext4_dir_dx_entry_get_block(struct ext4_dir_idx_entry *entry)
 {
 	return to_le32(entry->block);
 }
@@ -184,7 +184,7 @@ ext4_dir_dx_entry_get_block(struct ext4_directory_dx_entry *entry)
  * @param block Block address of child node
  */
 static inline void
-ext4_dir_dx_entry_set_block(struct ext4_directory_dx_entry *entry,
+ext4_dir_dx_entry_set_block(struct ext4_dir_idx_entry *entry,
 			    uint32_t block)
 {
 	entry->block = to_le32(block);
@@ -208,7 +208,7 @@ static int ext4_dir_dx_hash_string(struct ext4_hash_info *hinfo, int len,
 static uint32_t
 ext4_dir_dx_checksum(struct ext4_inode_ref *inode_ref,
 		 void *dirent,
-		 int count_offset, int count, struct ext4_directory_dx_tail *t)
+		 int count_offset, int count, struct ext4_dir_idx_tail *t)
 {
 	uint32_t orig_checksum, checksum = 0;
 	struct ext4_sblock *sb = &inode_ref->fs->sb;
@@ -221,7 +221,7 @@ ext4_dir_dx_checksum(struct ext4_inode_ref *inode_ref,
 			to_le32(ext4_inode_get_generation(inode_ref->inode));
 
 		size = count_offset +
-			(count * sizeof(struct ext4_directory_dx_tail));
+			(count * sizeof(struct ext4_dir_idx_tail));
 		orig_checksum = t->checksum;
 		t->checksum = 0;
 		/* First calculate crc32 checksum against fs uuid */
@@ -237,19 +237,19 @@ ext4_dir_dx_checksum(struct ext4_inode_ref *inode_ref,
 		checksum = ext4_crc32c(checksum, dirent, size);
 		/* Finally calculate crc32 checksum for dx_tail */
 		checksum = ext4_crc32c(checksum, t,
-				sizeof(struct ext4_directory_dx_tail));
+				sizeof(struct ext4_dir_idx_tail));
 		t->checksum = orig_checksum;
 	}
 	return checksum;
 }
 
-static struct ext4_directory_dx_countlimit *
+static struct ext4_dir_idx_countlimit *
 ext4_dir_dx_get_countlimit(struct ext4_inode_ref *inode_ref,
-			struct ext4_directory_entry_ll *dirent,
+			struct ext4_dir_entry_ll *dirent,
 			int *offset)
 {
-	struct ext4_directory_entry_ll *dp;
-	struct ext4_directory_dx_root *root;
+	struct ext4_dir_entry_ll *dp;
+	struct ext4_dir_idx_root *root;
 	struct ext4_sblock *sb = &inode_ref->fs->sb;
 	int count_offset;
 
@@ -257,13 +257,13 @@ ext4_dir_dx_get_countlimit(struct ext4_inode_ref *inode_ref,
 			ext4_sb_get_block_size(sb))
 		count_offset = 8;
 	else if (ext4_dir_entry_ll_get_entry_length(dirent) == 12) {
-		root = (struct ext4_directory_dx_root *)dirent;
-		dp = (struct ext4_directory_entry_ll *)&root->dots[1];
+		root = (struct ext4_dir_idx_root *)dirent;
+		dp = (struct ext4_dir_entry_ll *)&root->dots[1];
 		if (ext4_dir_entry_ll_get_entry_length(dp) !=
 		    ext4_sb_get_block_size(sb) - 12)
 			return NULL;
 		if (root->info.reserved_zero ||
-		    root->info.info_length != sizeof(struct ext4_directory_dx_root_info))
+		    root->info.info_length != sizeof(struct ext4_dir_idx_root_info))
 			return NULL;
 		count_offset = 32;
 	} else
@@ -271,7 +271,7 @@ ext4_dir_dx_get_countlimit(struct ext4_inode_ref *inode_ref,
 
 	if (offset)
 		*offset = count_offset;
-	return (struct ext4_directory_dx_countlimit *)(((char *)dirent) + count_offset);
+	return (struct ext4_dir_idx_countlimit *)(((char *)dirent) + count_offset);
 }
 
 /*
@@ -280,29 +280,29 @@ ext4_dir_dx_get_countlimit(struct ext4_inode_ref *inode_ref,
  */
 static bool
 ext4_dir_dx_checksum_verify(struct ext4_inode_ref *inode_ref,
-				struct ext4_directory_entry_ll *dirent)
+				struct ext4_dir_entry_ll *dirent)
 {
 	struct ext4_sblock *sb = &inode_ref->fs->sb;
 	int count_offset, limit, count;
 
 	if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM)) {
-		struct ext4_directory_dx_countlimit *countlimit =
+		struct ext4_dir_idx_countlimit *countlimit =
 			ext4_dir_dx_get_countlimit(inode_ref, dirent, &count_offset);
 		if (!countlimit) {
 			/* Directory seems corrupted. */
 			return true;
 		}
-		struct ext4_directory_dx_tail *t;
+		struct ext4_dir_idx_tail *t;
 		limit = ext4_dir_dx_countlimit_get_limit(countlimit);
 		count = ext4_dir_dx_countlimit_get_count(countlimit);
-		if (count_offset + (limit * sizeof(struct ext4_directory_dx_entry)) >
+		if (count_offset + (limit * sizeof(struct ext4_dir_idx_entry)) >
 				ext4_sb_get_block_size(sb) -
-				sizeof(struct ext4_directory_dx_tail)) {
+				sizeof(struct ext4_dir_idx_tail)) {
 			/* There is no space to hold the checksum */
 			return true;
 		}
-		t = (struct ext4_directory_dx_tail *)
-			(((struct ext4_directory_dx_entry *)countlimit) + limit);
+		t = (struct ext4_dir_idx_tail *)
+			(((struct ext4_dir_idx_entry *)countlimit) + limit);
 
 		if (t->checksum != to_le32(ext4_dir_dx_checksum(inode_ref,
 								dirent,
@@ -316,29 +316,29 @@ ext4_dir_dx_checksum_verify(struct ext4_inode_ref *inode_ref,
 
 static void
 ext4_dir_set_dx_checksum(struct ext4_inode_ref *inode_ref,
-			struct ext4_directory_entry_ll *dirent)
+			struct ext4_dir_entry_ll *dirent)
 {
 	int count_offset, limit, count;
 	struct ext4_sblock *sb = &inode_ref->fs->sb;
 
 	if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM)) {
-		struct ext4_directory_dx_countlimit *countlimit =
+		struct ext4_dir_idx_countlimit *countlimit =
 			ext4_dir_dx_get_countlimit(inode_ref, dirent, &count_offset);
 		if (!countlimit) {
 			/* Directory seems corrupted. */
 			return;
 		}
-		struct ext4_directory_dx_tail *t;
+		struct ext4_dir_idx_tail *t;
 		limit = ext4_dir_dx_countlimit_get_limit(countlimit);
 		count = ext4_dir_dx_countlimit_get_count(countlimit);
-		if (count_offset + (limit * sizeof(struct ext4_directory_dx_entry)) >
+		if (count_offset + (limit * sizeof(struct ext4_dir_idx_entry)) >
 				ext4_sb_get_block_size(sb) -
-				sizeof(struct ext4_directory_dx_tail)) {
+				sizeof(struct ext4_dir_idx_tail)) {
 			/* There is no space to hold the checksum */
 			return;
 		}
-		t = (struct ext4_directory_dx_tail *)
-			(((struct ext4_directory_dx_entry *)countlimit) + limit);
+		t = (struct ext4_dir_idx_tail *)
+			(((struct ext4_dir_idx_entry *)countlimit) + limit);
 
 		t->checksum =
 			to_le32(ext4_dir_dx_checksum(inode_ref, dirent, count_offset, count, t));
@@ -367,19 +367,19 @@ int ext4_dir_dx_init(struct ext4_inode_ref *dir, struct ext4_inode_ref *parent)
 		return rc;
 
 	/* Initialize pointers to data structures */
-	struct ext4_directory_dx_root *root = (void *)block.data;
-	struct ext4_directory_dx_root_info *info = &(root->info);
+	struct ext4_dir_idx_root *root = (void *)block.data;
+	struct ext4_dir_idx_root_info *info = &(root->info);
 
 	/* Initialize dot entries */
 	ext4_dir_write_entry(&dir->fs->sb,
-			(struct ext4_directory_entry_ll *)root->dots,
+			(struct ext4_dir_entry_ll *)root->dots,
 			12,
 			dir,
 			".",
 			strlen("."));
 
 	ext4_dir_write_entry(&dir->fs->sb,
-			(struct ext4_directory_entry_ll *)(root->dots + 1),
+			(struct ext4_dir_entry_ll *)(root->dots + 1),
 			ext4_sb_get_block_size(sb) - 12,
 			parent,
 			"..",
@@ -393,20 +393,20 @@ int ext4_dir_dx_init(struct ext4_inode_ref *dir, struct ext4_inode_ref *parent)
 	ext4_dir_dx_root_info_set_info_length(info, 8);
 
 	/* Set limit and current number of entries */
-	struct ext4_directory_dx_countlimit *countlimit =
-	    (struct ext4_directory_dx_countlimit *)&root->entries;
+	struct ext4_dir_idx_countlimit *countlimit =
+	    (struct ext4_dir_idx_countlimit *)&root->entries;
 
 	ext4_dir_dx_countlimit_set_count(countlimit, 1);
 
 	uint32_t block_size = ext4_sb_get_block_size(&dir->fs->sb);
 	uint32_t entry_space = block_size -
-			       2 * sizeof(struct ext4_directory_dx_dot_entry) -
-			       sizeof(struct ext4_directory_dx_root_info);
+			       2 * sizeof(struct ext4_dir_idx_dot_entry) -
+			       sizeof(struct ext4_dir_idx_root_info);
 	if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM))
-		entry_space -= sizeof(struct ext4_directory_dx_tail);
+		entry_space -= sizeof(struct ext4_dir_idx_tail);
 
 	uint16_t root_limit =
-	    entry_space / sizeof(struct ext4_directory_dx_entry);
+	    entry_space / sizeof(struct ext4_dir_idx_entry);
 
 	ext4_dir_dx_countlimit_set_limit(countlimit, root_limit);
 
@@ -426,12 +426,12 @@ int ext4_dir_dx_init(struct ext4_inode_ref *dir, struct ext4_inode_ref *parent)
 	}
 
 	/* Fill the whole block with empty entry */
-	struct ext4_directory_entry_ll *block_entry = (void *)new_block.data;
+	struct ext4_dir_entry_ll *block_entry = (void *)new_block.data;
 
 	if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM)) {
 		ext4_dir_entry_ll_set_entry_length(block_entry,
 				block_size -
-				sizeof(struct ext4_directory_entry_tail));
+				sizeof(struct ext4_dir_entry_tail));
 		ext4_dir_entry_ll_set_name_length(sb,
 						  block_entry,
 						  0);
@@ -442,7 +442,7 @@ int ext4_dir_dx_init(struct ext4_inode_ref *dir, struct ext4_inode_ref *parent)
 		initialize_dir_tail(EXT4_DIRENT_TAIL(block_entry,
 					ext4_sb_get_block_size(sb)));
 		ext4_dir_set_checksum(dir,
-				(struct ext4_directory_entry_ll *)new_block.data);
+				(struct ext4_dir_entry_ll *)new_block.data);
 	} else {
 		ext4_dir_entry_ll_set_entry_length(block_entry, block_size);
 	}
@@ -457,11 +457,11 @@ int ext4_dir_dx_init(struct ext4_inode_ref *dir, struct ext4_inode_ref *parent)
 	}
 
 	/* Connect new block to the only entry in index */
-	struct ext4_directory_dx_entry *entry = root->entries;
+	struct ext4_dir_idx_entry *entry = root->entries;
 	ext4_dir_dx_entry_set_block(entry, iblock);
 
 	ext4_dir_set_dx_checksum(dir,
-			(struct ext4_directory_entry_ll *)block.data);
+			(struct ext4_dir_entry_ll *)block.data);
 	block.dirty = true;
 
 	return ext4_block_set(dir->fs->bdev, &block);
@@ -480,8 +480,8 @@ static int ext4_dir_hinfo_init(struct ext4_hash_info *hinfo,
 			       struct ext4_sblock *sb, size_t name_len,
 			       const char *name)
 {
-	struct ext4_directory_dx_root *root =
-	    (struct ext4_directory_dx_root *)root_block->data;
+	struct ext4_dir_idx_root *root =
+	    (struct ext4_dir_idx_root *)root_block->data;
 
 	if ((root->info.hash_version != EXT2_HTREE_LEGACY) &&
 	    (root->info.hash_version != EXT2_HTREE_HALF_MD4) &&
@@ -499,14 +499,14 @@ static int ext4_dir_hinfo_init(struct ext4_hash_info *hinfo,
 	/* Check if node limit is correct */
 	uint32_t block_size = ext4_sb_get_block_size(sb);
 	uint32_t entry_space = block_size;
-	entry_space -= 2 * sizeof(struct ext4_directory_dx_dot_entry);
-	entry_space -= sizeof(struct ext4_directory_dx_root_info);
+	entry_space -= 2 * sizeof(struct ext4_dir_idx_dot_entry);
+	entry_space -= sizeof(struct ext4_dir_idx_root_info);
 	if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM))
-		entry_space -= sizeof(struct ext4_directory_dx_tail);
-	entry_space = entry_space / sizeof(struct ext4_directory_dx_entry);
+		entry_space -= sizeof(struct ext4_dir_idx_tail);
+	entry_space = entry_space / sizeof(struct ext4_dir_idx_entry);
 
 	uint16_t limit = ext4_dir_dx_countlimit_get_limit(
-	    (struct ext4_directory_dx_countlimit *)&root->entries);
+	    (struct ext4_dir_idx_countlimit *)&root->entries);
 	if (limit != entry_space)
 		return EXT4_ERR_BAD_DX_DIR;
 
@@ -541,30 +541,30 @@ static int ext4_dir_hinfo_init(struct ext4_hash_info *hinfo,
 static int ext4_dir_dx_get_leaf(struct ext4_hash_info *hinfo,
 				struct ext4_inode_ref *inode_ref,
 				struct ext4_block *root_block,
-				struct ext4_directory_dx_block **dx_block,
-				struct ext4_directory_dx_block *dx_blocks)
+				struct ext4_dir_idx_block **dx_block,
+				struct ext4_dir_idx_block *dx_blocks)
 {
-	struct ext4_directory_dx_block *tmp_dx_block = dx_blocks;
-	struct ext4_directory_dx_root *root =
-	    (struct ext4_directory_dx_root *)root_block->data;
-	struct ext4_directory_dx_entry *entries =
-	    (struct ext4_directory_dx_entry *)&root->entries;
+	struct ext4_dir_idx_block *tmp_dx_block = dx_blocks;
+	struct ext4_dir_idx_root *root =
+	    (struct ext4_dir_idx_root *)root_block->data;
+	struct ext4_dir_idx_entry *entries =
+	    (struct ext4_dir_idx_entry *)&root->entries;
 
 	uint16_t limit = ext4_dir_dx_countlimit_get_limit(
-	    (struct ext4_directory_dx_countlimit *)entries);
+	    (struct ext4_dir_idx_countlimit *)entries);
 	uint8_t indirect_level =
 	    ext4_dir_dx_root_info_get_indirect_levels(&root->info);
 
 	struct ext4_block *tmp_block = root_block;
-	struct ext4_directory_dx_entry *p;
-	struct ext4_directory_dx_entry *q;
-	struct ext4_directory_dx_entry *m;
-	struct ext4_directory_dx_entry *at;
+	struct ext4_dir_idx_entry *p;
+	struct ext4_dir_idx_entry *q;
+	struct ext4_dir_idx_entry *m;
+	struct ext4_dir_idx_entry *at;
 
 	/* Walk through the index tree */
 	while (true) {
 		uint16_t count = ext4_dir_dx_countlimit_get_count(
-		    (struct ext4_directory_dx_countlimit *)entries);
+		    (struct ext4_dir_idx_countlimit *)entries);
 		if ((count == 0) || (count > limit))
 			return EXT4_ERR_BAD_DX_DIR;
 
@@ -611,20 +611,20 @@ static int ext4_dir_dx_get_leaf(struct ext4_hash_info *hinfo,
 			return rc;
 
 		entries =
-		    ((struct ext4_directory_dx_node *)tmp_block->data)->entries;
+		    ((struct ext4_dir_idx_node *)tmp_block->data)->entries;
 		limit = ext4_dir_dx_countlimit_get_limit(
-		    (struct ext4_directory_dx_countlimit *)entries);
+		    (struct ext4_dir_idx_countlimit *)entries);
 
 		uint16_t entry_space =
 		    ext4_sb_get_block_size(&inode_ref->fs->sb) -
-		    sizeof(struct ext4_fake_directory_entry);
+		    sizeof(struct ext4_fake_dir_entry);
 
 		if (ext4_sb_feature_ro_com(&inode_ref->fs->sb,
 				EXT4_FRO_COM_METADATA_CSUM))
-			entry_space -= sizeof(struct ext4_directory_dx_tail);
+			entry_space -= sizeof(struct ext4_dir_idx_tail);
 
 		entry_space =
-		    entry_space / sizeof(struct ext4_directory_dx_entry);
+		    entry_space / sizeof(struct ext4_dir_idx_entry);
 
 		if (limit != entry_space) {
 			ext4_block_set(inode_ref->fs->bdev, tmp_block);
@@ -632,7 +632,7 @@ static int ext4_dir_dx_get_leaf(struct ext4_hash_info *hinfo,
 		}
 
 		if (!ext4_dir_dx_checksum_verify(inode_ref,
-					(struct ext4_directory_entry_ll *)tmp_block->data)) {
+					(struct ext4_dir_entry_ll *)tmp_block->data)) {
 			ext4_dbg(DEBUG_DIR_IDX,
 					DBG_WARN "HTree checksum failed."
 					"Inode: %" PRIu32", "
@@ -657,17 +657,17 @@ static int ext4_dir_dx_get_leaf(struct ext4_hash_info *hinfo,
  */
 static int ext4_dir_dx_next_block(struct ext4_inode_ref *inode_ref,
 				  uint32_t hash,
-				  struct ext4_directory_dx_block *dx_block,
-				  struct ext4_directory_dx_block *dx_blocks)
+				  struct ext4_dir_idx_block *dx_block,
+				  struct ext4_dir_idx_block *dx_blocks)
 {
 	uint32_t num_handles = 0;
-	struct ext4_directory_dx_block *p = dx_block;
+	struct ext4_dir_idx_block *p = dx_block;
 
 	/* Try to find data block with next bunch of entries */
 	while (true) {
 		p->position++;
 		uint16_t count = ext4_dir_dx_countlimit_get_count(
-		    (struct ext4_directory_dx_countlimit *)p->entries);
+		    (struct ext4_dir_idx_countlimit *)p->entries);
 
 		if (p->position < p->entries + count)
 			break;
@@ -703,7 +703,7 @@ static int ext4_dir_dx_next_block(struct ext4_inode_ref *inode_ref,
 			return rc;
 
 		if (!ext4_dir_dx_checksum_verify(inode_ref,
-					(struct ext4_directory_entry_ll *)block.data)) {
+					(struct ext4_dir_entry_ll *)block.data)) {
 			ext4_dbg(DEBUG_DIR_IDX,
 					DBG_WARN "HTree checksum failed."
 					"Inode: %" PRIu32", "
@@ -721,14 +721,14 @@ static int ext4_dir_dx_next_block(struct ext4_inode_ref *inode_ref,
 
 		memcpy(&p->block, &block, sizeof(block));
 		p->entries =
-		    ((struct ext4_directory_dx_node *)block.data)->entries;
+		    ((struct ext4_dir_idx_node *)block.data)->entries;
 		p->position = p->entries;
 	}
 
 	return ENOENT;
 }
 
-int ext4_dir_dx_find_entry(struct ext4_directory_search_result *result,
+int ext4_dir_dx_find_entry(struct ext4_dir_search_result *result,
 			   struct ext4_inode_ref *inode_ref, size_t name_len,
 			   const char *name)
 {
@@ -749,7 +749,7 @@ int ext4_dir_dx_find_entry(struct ext4_directory_search_result *result,
 		return rc;
 
 	if (!ext4_dir_dx_checksum_verify(inode_ref,
-				(struct ext4_directory_entry_ll *)root_block.data)) {
+				(struct ext4_dir_entry_ll *)root_block.data)) {
 		ext4_dbg(DEBUG_DIR_IDX,
 			 DBG_WARN "HTree root checksum failed."
 			 "Inode: %" PRIu32", "
@@ -770,9 +770,9 @@ int ext4_dir_dx_find_entry(struct ext4_directory_search_result *result,
 	 * Hardcoded number 2 means maximum height of index tree,
 	 * specified in the Linux driver.
 	 */
-	struct ext4_directory_dx_block dx_blocks[2];
-	struct ext4_directory_dx_block *dx_block;
-	struct ext4_directory_dx_block *tmp;
+	struct ext4_dir_idx_block dx_blocks[2];
+	struct ext4_dir_idx_block *dx_block;
+	struct ext4_dir_idx_block *tmp;
 
 	rc = ext4_dir_dx_get_leaf(&hinfo, inode_ref, &root_block, &dx_block,
 				  dx_blocks);
@@ -799,7 +799,7 @@ int ext4_dir_dx_find_entry(struct ext4_directory_search_result *result,
 			goto cleanup;
 
 		if (!ext4_dir_checksum_verify(inode_ref,
-				(struct ext4_directory_entry_ll *)leaf_block.data)) {
+				(struct ext4_dir_entry_ll *)leaf_block.data)) {
 			ext4_dbg(DEBUG_DIR_IDX,
 				 DBG_WARN "HTree leaf block checksum failed."
 				 "Inode: %" PRIu32", "
@@ -809,7 +809,7 @@ int ext4_dir_dx_find_entry(struct ext4_directory_search_result *result,
 		}
 
 		/* Linear search inside block */
-		struct ext4_directory_entry_ll *res_dentry;
+		struct ext4_dir_entry_ll *res_dentry;
 		rc = ext4_dir_find_in_block(&leaf_block, &fs->sb, name_len,
 					    name, &res_dentry);
 
@@ -922,17 +922,17 @@ static int ext4_dir_dx_entry_comparator(const void *arg1, const void *arg2)
  */
 static void
 ext4_dir_dx_insert_entry(struct ext4_inode_ref *inode_ref __unused,
-			 struct ext4_directory_dx_block *index_block,
+			 struct ext4_dir_idx_block *index_block,
 			 uint32_t hash, uint32_t iblock)
 {
-	struct ext4_directory_dx_entry *old_index_entry = index_block->position;
-	struct ext4_directory_dx_entry *new_index_entry = old_index_entry + 1;
+	struct ext4_dir_idx_entry *old_index_entry = index_block->position;
+	struct ext4_dir_idx_entry *new_index_entry = old_index_entry + 1;
 
-	struct ext4_directory_dx_countlimit *countlimit =
-	    (struct ext4_directory_dx_countlimit *)index_block->entries;
+	struct ext4_dir_idx_countlimit *countlimit =
+	    (struct ext4_dir_idx_countlimit *)index_block->entries;
 	uint32_t count = ext4_dir_dx_countlimit_get_count(countlimit);
 
-	struct ext4_directory_dx_entry *start_index = index_block->entries;
+	struct ext4_dir_idx_entry *start_index = index_block->entries;
 	size_t bytes =
 	    (uint8_t *)(start_index + count) - (uint8_t *)(new_index_entry);
 
@@ -944,7 +944,7 @@ ext4_dir_dx_insert_entry(struct ext4_inode_ref *inode_ref __unused,
 	ext4_dir_dx_countlimit_set_count(countlimit, count + 1);
 
 	ext4_dir_set_dx_checksum(inode_ref,
-			(struct ext4_directory_entry_ll *)index_block->block.data);
+			(struct ext4_dir_entry_ll *)index_block->block.data);
 	index_block->block.dirty = true;
 }
 
@@ -958,7 +958,7 @@ ext4_dir_dx_insert_entry(struct ext4_inode_ref *inode_ref __unused,
 static int ext4_dir_dx_split_data(struct ext4_inode_ref *inode_ref,
 				  struct ext4_hash_info *hinfo,
 				  struct ext4_block *old_data_block,
-				  struct ext4_directory_dx_block *index_block,
+				  struct ext4_dir_idx_block *index_block,
 				  struct ext4_block *new_data_block)
 {
 	int rc = EOK;
@@ -972,7 +972,7 @@ static int ext4_dir_dx_split_data(struct ext4_inode_ref *inode_ref,
 
 	/* dot entry has the smallest size available */
 	uint32_t max_entry_count =
-	    block_size / sizeof(struct ext4_directory_dx_dot_entry);
+	    block_size / sizeof(struct ext4_dir_idx_dot_entry);
 
 	/* Allocate sort entry */
 	struct ext4_dx_sort_entry *sort_array =
@@ -991,7 +991,7 @@ static int ext4_dir_dx_split_data(struct ext4_inode_ref *inode_ref,
 	memcpy(&tmp_hinfo, hinfo, sizeof(struct ext4_hash_info));
 
 	/* Load all valid entries to the buffer */
-	struct ext4_directory_entry_ll *dentry = (void *)old_data_block->data;
+	struct ext4_dir_entry_ll *dentry = (void *)old_data_block->data;
 	uint8_t *entry_buffer_ptr = entry_buffer;
 	while ((void *)dentry < (void *)(old_data_block->data + block_size)) {
 		/* Read only valid entries */
@@ -1082,14 +1082,14 @@ static int ext4_dir_dx_split_data(struct ext4_inode_ref *inode_ref,
 	void *ptr;
 	struct ext4_sblock *sb = &inode_ref->fs->sb;
 	if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM))
-		block_size -= sizeof(struct ext4_directory_entry_tail);
+		block_size -= sizeof(struct ext4_dir_entry_tail);
 
 	/* First part - to the old block */
 	for (i = 0; i < mid; ++i) {
 		ptr = old_data_block->data + offset;
 		memcpy(ptr, sort_array[i].dentry, sort_array[i].rec_len);
 
-		struct ext4_directory_entry_ll *tmp = ptr;
+		struct ext4_dir_entry_ll *tmp = ptr;
 		if (i < (mid - 1))
 			ext4_dir_entry_ll_set_entry_length(
 			    tmp, sort_array[i].rec_len);
@@ -1106,7 +1106,7 @@ static int ext4_dir_dx_split_data(struct ext4_inode_ref *inode_ref,
 		ptr = new_data_block_tmp.data + offset;
 		memcpy(ptr, sort_array[i].dentry, sort_array[i].rec_len);
 
-		struct ext4_directory_entry_ll *tmp = ptr;
+		struct ext4_dir_entry_ll *tmp = ptr;
 		if (i < (idx - 1))
 			ext4_dir_entry_ll_set_entry_length(
 			    tmp, sort_array[i].rec_len);
@@ -1128,9 +1128,9 @@ static int ext4_dir_dx_split_data(struct ext4_inode_ref *inode_ref,
 					block_size));
 	}
 	ext4_dir_set_checksum(inode_ref,
-			(struct ext4_directory_entry_ll *)old_data_block->data);
+			(struct ext4_dir_entry_ll *)old_data_block->data);
 	ext4_dir_set_checksum(inode_ref,
-			(struct ext4_directory_entry_ll *)new_data_block_tmp.data);
+			(struct ext4_dir_entry_ll *)new_data_block_tmp.data);
 	old_data_block->dirty = true;
 	new_data_block_tmp.dirty = true;
 
@@ -1154,24 +1154,24 @@ static int ext4_dir_dx_split_data(struct ext4_inode_ref *inode_ref,
  */
 static int
 ext4_dir_dx_split_index(struct ext4_inode_ref *inode_ref,
-			struct ext4_directory_dx_block *dx_blocks,
-			struct ext4_directory_dx_block *dx_block,
-			struct ext4_directory_dx_block **new_dx_block)
+			struct ext4_dir_idx_block *dx_blocks,
+			struct ext4_dir_idx_block *dx_block,
+			struct ext4_dir_idx_block **new_dx_block)
 {
 	struct ext4_sblock *sb = &inode_ref->fs->sb;
-	struct ext4_directory_dx_entry *entries;
+	struct ext4_dir_idx_entry *entries;
 
 	if (dx_block == dx_blocks)
 		entries =
-		    ((struct ext4_directory_dx_root *)dx_block->block.data)
+		    ((struct ext4_dir_idx_root *)dx_block->block.data)
 			->entries;
 	else
 		entries =
-		    ((struct ext4_directory_dx_node *)dx_block->block.data)
+		    ((struct ext4_dir_idx_node *)dx_block->block.data)
 			->entries;
 
-	struct ext4_directory_dx_countlimit *countlimit =
-	    (struct ext4_directory_dx_countlimit *)entries;
+	struct ext4_dir_idx_countlimit *countlimit =
+	    (struct ext4_dir_idx_countlimit *)entries;
 
 	uint16_t leaf_limit = ext4_dir_dx_countlimit_get_limit(countlimit);
 	uint16_t leaf_count = ext4_dir_dx_countlimit_get_count(countlimit);
@@ -1180,12 +1180,12 @@ ext4_dir_dx_split_index(struct ext4_inode_ref *inode_ref,
 	if (leaf_limit == leaf_count) {
 		size_t levels = dx_block - dx_blocks;
 
-		struct ext4_directory_dx_entry *root_entries =
-		    ((struct ext4_directory_dx_root *)dx_blocks[0].block.data)
+		struct ext4_dir_idx_entry *root_entries =
+		    ((struct ext4_dir_idx_root *)dx_blocks[0].block.data)
 			->entries;
 
-		struct ext4_directory_dx_countlimit *root_countlimit =
-		    (struct ext4_directory_dx_countlimit *)root_entries;
+		struct ext4_dir_idx_countlimit *root_countlimit =
+		    (struct ext4_dir_idx_countlimit *)root_entries;
 		uint16_t root_limit =
 		    ext4_dir_dx_countlimit_get_limit(root_countlimit);
 		uint16_t root_count =
@@ -1210,12 +1210,12 @@ ext4_dir_dx_split_index(struct ext4_inode_ref *inode_ref,
 		if (rc != EOK)
 			return rc;
 
-		struct ext4_directory_dx_node *new_node =
+		struct ext4_dir_idx_node *new_node =
 		    (void *)new_block.data;
-		struct ext4_directory_dx_entry *new_entries = new_node->entries;
+		struct ext4_dir_idx_entry *new_entries = new_node->entries;
 
 		memset(&new_node->fake, 0,
-		       sizeof(struct ext4_fake_directory_entry));
+		       sizeof(struct ext4_fake_dir_entry));
 
 		uint32_t block_size =
 		    ext4_sb_get_block_size(&inode_ref->fs->sb);
@@ -1233,13 +1233,13 @@ ext4_dir_dx_split_index(struct ext4_inode_ref *inode_ref,
 			memcpy((void *)new_entries,
 			       (void *)(entries + count_left),
 			       count_right *
-				   sizeof(struct ext4_directory_dx_entry));
+				   sizeof(struct ext4_dir_idx_entry));
 
 			/* Initialize new node */
-			struct ext4_directory_dx_countlimit *left_countlimit =
-			    (struct ext4_directory_dx_countlimit *)entries;
-			struct ext4_directory_dx_countlimit *right_countlimit =
-			    (struct ext4_directory_dx_countlimit *)new_entries;
+			struct ext4_dir_idx_countlimit *left_countlimit =
+			    (struct ext4_dir_idx_countlimit *)entries;
+			struct ext4_dir_idx_countlimit *right_countlimit =
+			    (struct ext4_dir_idx_countlimit *)new_entries;
 
 			ext4_dir_dx_countlimit_set_count(left_countlimit,
 							 count_left);
@@ -1248,12 +1248,12 @@ ext4_dir_dx_split_index(struct ext4_inode_ref *inode_ref,
 
 			uint32_t entry_space =
 			    block_size -
-			    sizeof(struct ext4_fake_directory_entry);
+			    sizeof(struct ext4_fake_dir_entry);
 			if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM))
-				entry_space -= sizeof(struct ext4_directory_dx_tail);
+				entry_space -= sizeof(struct ext4_dir_idx_tail);
 
 			uint32_t node_limit =
-			    entry_space / sizeof(struct ext4_directory_dx_entry);
+			    entry_space / sizeof(struct ext4_dir_idx_entry);
 
 			ext4_dir_dx_countlimit_set_limit(right_countlimit,
 							 node_limit);
@@ -1264,7 +1264,7 @@ ext4_dir_dx_split_index(struct ext4_inode_ref *inode_ref,
 			if (position_index >= count_left) {
 				ext4_dir_set_dx_checksum(
 						inode_ref,
-						(struct ext4_directory_entry_ll *)
+						(struct ext4_dir_entry_ll *)
 						dx_block->block.data);
 				dx_block->block.dirty = true;
 
@@ -1284,16 +1284,16 @@ ext4_dir_dx_split_index(struct ext4_inode_ref *inode_ref,
 						 dx_blocks, hash_right,
 						 new_iblock);
 			ext4_dir_set_dx_checksum(inode_ref,
-						(struct ext4_directory_entry_ll *)
+						(struct ext4_dir_entry_ll *)
 							dx_blocks[0].block.data);
 			ext4_dir_set_dx_checksum(inode_ref,
-						(struct ext4_directory_entry_ll *)
+						(struct ext4_dir_entry_ll *)
 							dx_blocks[1].block.data);
 			dx_blocks[0].block.dirty = true;
 			dx_blocks[1].block.dirty = true;
 
 			ext4_dir_set_dx_checksum(inode_ref,
-						(struct ext4_directory_entry_ll *)
+						(struct ext4_dir_entry_ll *)
 							new_block.data);
 			new_block.dirty = true;
 			return ext4_block_set(inode_ref->fs->bdev, &new_block);
@@ -1303,32 +1303,32 @@ ext4_dir_dx_split_index(struct ext4_inode_ref *inode_ref,
 			/* Copy data from root to child block */
 			memcpy((void *)new_entries, (void *)entries,
 			       leaf_count *
-				   sizeof(struct ext4_directory_dx_entry));
+				   sizeof(struct ext4_dir_idx_entry));
 
-			struct ext4_directory_dx_countlimit *new_countlimit =
-			    (struct ext4_directory_dx_countlimit *)new_entries;
+			struct ext4_dir_idx_countlimit *new_countlimit =
+			    (struct ext4_dir_idx_countlimit *)new_entries;
 
 			uint32_t entry_space =
 			    block_size -
-			    sizeof(struct ext4_fake_directory_entry);
+			    sizeof(struct ext4_fake_dir_entry);
 			if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM))
-				entry_space -= sizeof(struct ext4_directory_dx_tail);
+				entry_space -= sizeof(struct ext4_dir_idx_tail);
 
 			uint32_t node_limit =
-			    entry_space / sizeof(struct ext4_directory_dx_entry);
+			    entry_space / sizeof(struct ext4_dir_idx_entry);
 			ext4_dir_dx_countlimit_set_limit(new_countlimit,
 							 node_limit);
 
 			/* Set values in root node */
-			struct ext4_directory_dx_countlimit
+			struct ext4_dir_idx_countlimit
 			    *new_root_countlimit =
-				(struct ext4_directory_dx_countlimit *)entries;
+				(struct ext4_dir_idx_countlimit *)entries;
 
 			ext4_dir_dx_countlimit_set_count(new_root_countlimit,
 							 1);
 			ext4_dir_dx_entry_set_block(entries, new_iblock);
 
-			((struct ext4_directory_dx_root *)dx_blocks[0]
+			((struct ext4_dir_idx_root *)dx_blocks[0]
 			     .block.data)
 			    ->info.indirect_levels = 1;
 
@@ -1342,10 +1342,10 @@ ext4_dir_dx_split_index(struct ext4_inode_ref *inode_ref,
 			*new_dx_block = dx_block;
 
 			ext4_dir_set_dx_checksum(inode_ref,
-						(struct ext4_directory_entry_ll *)
+						(struct ext4_dir_entry_ll *)
 							dx_blocks[0].block.data);
 			ext4_dir_set_dx_checksum(inode_ref,
-						(struct ext4_directory_entry_ll *)
+						(struct ext4_dir_entry_ll *)
 							dx_blocks[1].block.data);
 			dx_blocks[0].block.dirty = true;
 			dx_blocks[1].block.dirty = true;
@@ -1377,7 +1377,7 @@ int ext4_dir_dx_add_entry(struct ext4_inode_ref *parent,
 		return rc;
 
 	if (!ext4_dir_dx_checksum_verify(parent,
-			(struct ext4_directory_entry_ll *)root_block.data)) {
+			(struct ext4_dir_entry_ll *)root_block.data)) {
 		ext4_dbg(DEBUG_DIR_IDX,
 			 DBG_WARN "HTree root checksum failed."
 			 "Inode: %" PRIu32", "
@@ -1399,9 +1399,9 @@ int ext4_dir_dx_add_entry(struct ext4_inode_ref *parent,
 	 * Hardcoded number 2 means maximum height of index
 	 * tree defined in Linux.
 	 */
-	struct ext4_directory_dx_block dx_blocks[2];
-	struct ext4_directory_dx_block *dx_block;
-	struct ext4_directory_dx_block *dx_it;
+	struct ext4_dir_idx_block dx_blocks[2];
+	struct ext4_dir_idx_block *dx_block;
+	struct ext4_dir_idx_block *dx_it;
 
 	rc = ext4_dir_dx_get_leaf(&hinfo, parent, &root_block, &dx_block,
 				  dx_blocks);
@@ -1434,7 +1434,7 @@ int ext4_dir_dx_add_entry(struct ext4_inode_ref *parent,
 		goto release_index;
 
 	if (!ext4_dir_checksum_verify(parent,
-			(struct ext4_directory_entry_ll *)target_block.data)) {
+			(struct ext4_dir_entry_ll *)target_block.data)) {
 		ext4_dbg(DEBUG_DIR_IDX,
 				DBG_WARN "HTree leaf block checksum failed."
 				"Inode: %" PRIu32", "
@@ -1514,7 +1514,7 @@ int ext4_dir_dx_reset_parent_inode(struct ext4_inode_ref *dir,
 		return rc;
 
 	if (!ext4_dir_dx_checksum_verify(dir,
-			(struct ext4_directory_entry_ll *)block.data)) {
+			(struct ext4_dir_entry_ll *)block.data)) {
 		ext4_dbg(DEBUG_DIR_IDX,
 			 DBG_WARN "HTree root checksum failed."
 			 "Inode: %" PRIu32", "
@@ -1524,13 +1524,13 @@ int ext4_dir_dx_reset_parent_inode(struct ext4_inode_ref *dir,
 	}
 
 	/* Initialize pointers to data structures */
-	struct ext4_directory_dx_root *root = (void *)block.data;
+	struct ext4_dir_idx_root *root = (void *)block.data;
 
 	/* Fill the inode field with a new parent ino. */
 	ext4_dx_dot_entry_set_inode(&root->dots[1], parent_inode);
 
 	ext4_dir_set_dx_checksum(dir,
-				(struct ext4_directory_entry_ll *)
+				(struct ext4_dir_entry_ll *)
 					block.data);
 	block.dirty = true;
 
diff --git a/lwext4/ext4_dir_idx.h b/lwext4/ext4_dir_idx.h
index 74ddb07..5a864cc 100644
--- a/lwext4/ext4_dir_idx.h
+++ b/lwext4/ext4_dir_idx.h
@@ -64,7 +64,7 @@ int ext4_dir_dx_init(struct ext4_inode_ref *dir,
  * @param name      Name to be found
  * @return Error code
  */
-int ext4_dir_dx_find_entry(struct ext4_directory_search_result *result,
+int ext4_dir_dx_find_entry(struct ext4_dir_search_result *result,
 			   struct ext4_inode_ref *inode_ref, size_t name_len,
 			   const char *name);
 
diff --git a/lwext4/ext4_types.h b/lwext4/ext4_types.h
index 3cbdbad..93ab650 100644
--- a/lwext4/ext4_types.h
+++ b/lwext4/ext4_types.h
@@ -483,7 +483,7 @@ enum { EXT4_DIRENTRY_UNKNOWN = 0,
 
 #define EXT4_DIRENTRY_DIR_CSUM 0xDE
 
-union ext4_directory_entry_ll_internal {
+union ext4_dir_entry_ll_internal {
 	uint8_t name_length_high; /* Higher 8 bits of name length */
 	uint8_t inode_type;       /* Type of referenced inode (in rev >= 0.5) */
 } __attribute__((packed));
@@ -491,36 +491,36 @@ union ext4_directory_entry_ll_internal {
 /**
  * Linked list directory entry structure
  */
-struct ext4_directory_entry_ll {
+struct ext4_dir_entry_ll {
 	uint32_t inode;	/* I-node for the entry */
 	uint16_t entry_length; /* Distance to the next directory entry */
 	uint8_t name_length;   /* Lower 8 bits of name length */
 
-	union ext4_directory_entry_ll_internal in;
+	union ext4_dir_entry_ll_internal in;
 
 	uint8_t name[EXT4_DIRECTORY_FILENAME_LEN]; /* Entry name */
 } __attribute__((packed));
 
-struct ext4_directory_iterator {
+struct ext4_dir_iterator {
 	struct ext4_inode_ref *inode_ref;
 	struct ext4_block current_block;
 	uint64_t current_offset;
-	struct ext4_directory_entry_ll *current;
+	struct ext4_dir_entry_ll *current;
 };
 
-struct ext4_directory_search_result {
+struct ext4_dir_search_result {
 	struct ext4_block block;
-	struct ext4_directory_entry_ll *dentry;
+	struct ext4_dir_entry_ll *dentry;
 };
 
 /* Structures for indexed directory */
 
-struct ext4_directory_dx_countlimit {
+struct ext4_dir_idx_countlimit {
 	uint16_t limit;
 	uint16_t count;
 };
 
-struct ext4_directory_dx_dot_entry {
+struct ext4_dir_idx_dot_entry {
 	uint32_t inode;
 	uint16_t entry_length;
 	uint8_t name_length;
@@ -528,7 +528,7 @@ struct ext4_directory_dx_dot_entry {
 	uint8_t name[4];
 };
 
-struct ext4_directory_dx_root_info {
+struct ext4_dir_idx_root_info {
 	uint32_t reserved_zero;
 	uint8_t hash_version;
 	uint8_t info_length;
@@ -536,39 +536,39 @@ struct ext4_directory_dx_root_info {
 	uint8_t unused_flags;
 };
 
-struct ext4_directory_dx_entry {
+struct ext4_dir_idx_entry {
 	uint32_t hash;
 	uint32_t block;
 };
 
-struct ext4_directory_dx_root {
-	struct ext4_directory_dx_dot_entry dots[2];
-	struct ext4_directory_dx_root_info info;
-	struct ext4_directory_dx_entry entries[];
+struct ext4_dir_idx_root {
+	struct ext4_dir_idx_dot_entry dots[2];
+	struct ext4_dir_idx_root_info info;
+	struct ext4_dir_idx_entry entries[];
 };
 
-struct ext4_fake_directory_entry {
+struct ext4_fake_dir_entry {
 	uint32_t inode;
 	uint16_t entry_length;
 	uint8_t name_length;
 	uint8_t inode_type;
 };
 
-struct ext4_directory_dx_node {
-	struct ext4_fake_directory_entry fake;
-	struct ext4_directory_dx_entry entries[];
+struct ext4_dir_idx_node {
+	struct ext4_fake_dir_entry fake;
+	struct ext4_dir_idx_entry entries[];
 };
 
-struct ext4_directory_dx_block {
+struct ext4_dir_idx_block {
 	struct ext4_block block;
-	struct ext4_directory_dx_entry *entries;
-	struct ext4_directory_dx_entry *position;
+	struct ext4_dir_idx_entry *entries;
+	struct ext4_dir_idx_entry *position;
 };
 
 /*
  * This goes at the end of each htree block.
  */
-struct ext4_directory_dx_tail {
+struct ext4_dir_idx_tail {
 	uint32_t reserved;
 	uint32_t checksum;	/* crc32c(uuid+inum+dirblock) */
 };
@@ -577,7 +577,7 @@ struct ext4_directory_dx_tail {
  * This is a bogus directory entry at the end of each leaf block that
  * records checksums.
  */
-struct ext4_directory_entry_tail {
+struct ext4_dir_entry_tail {
 	uint32_t reserved_zero1;	/* Pretend to be unused */
 	uint16_t rec_len;		/* 12 */
 	uint8_t reserved_zero2;	/* Zero name length */
@@ -586,9 +586,8 @@ struct ext4_directory_entry_tail {
 };
 
 #define EXT4_DIRENT_TAIL(block, blocksize) \
-	((struct ext4_directory_entry_tail *)(((char *)(block)) + \
-					     ((blocksize) - \
-					     sizeof(struct ext4_directory_entry_tail))))
+	((struct ext4_dir_entry_tail *)(((char *)(block)) + ((blocksize) - \
+					sizeof(struct ext4_dir_entry_tail))))
 
 #define EXT4_ERR_BAD_DX_DIR (-25000)