ext4_utils: format files

Format *.cpp according to the new .clang-format. The following command
was used to generate this change:

  $ find . \( -name \*.cpp -o -name \*.h \) -exec clang-format \
    --style=file -i {} \;

Test: mm
Bug: 171699326
Change-Id: I2514746ad3fe3d0c14f7efcf3868997a3a31be6f

12 files changed, 803 insertions, 789 deletions

diff --git a/ext4_utils/blk_alloc_to_base_fs.cpp b/ext4_utils/blk_alloc_to_base_fs.cpp
index 664648d1..65f60247 100644
--- a/ext4_utils/blk_alloc_to_base_fs.cpp
+++ b/ext4_utils/blk_alloc_to_base_fs.cpp
@@ -29,15 +29,13 @@
 #endif
 #define ___STRING(x) __STRING(x)
 
-static void usage(char *filename)
-{
+static void usage(char* filename) {
     fprintf(stderr, "Usage: %s input_blk_alloc_file output_base_fs_file \n", filename);
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char** argv) {
     FILE *blk_alloc_file = NULL, *base_fs_file = NULL;
-    char filename[MAX_PATH+1], file_version[MAX_FILE_VERSION+1], *spaced_allocs = NULL;
+    char filename[MAX_PATH + 1], file_version[MAX_FILE_VERSION + 1], *spaced_allocs = NULL;
     size_t spaced_allocs_len = 0;
 
     if (argc != 3) {
@@ -54,7 +52,8 @@ int main(int argc, char **argv)
         fprintf(stderr, "failed to open %s: %s\n", argv[2], strerror(errno));
         exit(EXIT_FAILURE);
     }
-    if (fscanf(blk_alloc_file, "Base EXT4 version %" ___STRING(MAX_FILE_VERSION) "s", file_version) > 0) {
+    if (fscanf(blk_alloc_file, "Base EXT4 version %" ___STRING(MAX_FILE_VERSION) "s",
+               file_version) > 0) {
         int c;
         printf("%s is already in *.base_fs format, just copying into %s...\n", argv[1], argv[2]);
         rewind(blk_alloc_file);
@@ -67,7 +66,7 @@ int main(int argc, char **argv)
         rewind(blk_alloc_file);
     }
     fprintf(base_fs_file, "Base EXT4 version 1.0\n");
-    while(fscanf(blk_alloc_file, "%" ___STRING(MAX_PATH) "s ", filename) != EOF) {
+    while (fscanf(blk_alloc_file, "%" ___STRING(MAX_PATH) "s ", filename) != EOF) {
         int i;
         fprintf(base_fs_file, "%s ", filename);
         if (getline(&spaced_allocs, &spaced_allocs_len, blk_alloc_file) == -1) {
@@ -77,7 +76,8 @@ int main(int argc, char **argv)
         for (i = 0; spaced_allocs[i]; i++) {
             if (spaced_allocs[i] == ' ') {
                 if (!isspace(spaced_allocs[i + 1])) fputc(',', base_fs_file);
-            } else fputc(spaced_allocs[i], base_fs_file);
+            } else
+                fputc(spaced_allocs[i], base_fs_file);
         }
     }
     free(spaced_allocs);
diff --git a/ext4_utils/ext4_sb.cpp b/ext4_utils/ext4_sb.cpp
index 4183b3aa..3d8f4c9e 100644
--- a/ext4_utils/ext4_sb.cpp
+++ b/ext4_utils/ext4_sb.cpp
@@ -18,30 +18,27 @@
 
 #include "ext4_utils/ext4_sb.h"
 
-int ext4_parse_sb(struct ext4_super_block *sb, struct fs_info *info)
-{
-	uint64_t len_blocks;
+int ext4_parse_sb(struct ext4_super_block* sb, struct fs_info* info) {
+    uint64_t len_blocks;
 
-        if (sb->s_magic != EXT4_SUPER_MAGIC)
-                return -EINVAL;
+    if (sb->s_magic != EXT4_SUPER_MAGIC) return -EINVAL;
 
-	info->block_size = 1024 << sb->s_log_block_size;
-	info->blocks_per_group = sb->s_blocks_per_group;
-	info->inodes_per_group = sb->s_inodes_per_group;
-	info->inode_size = sb->s_inode_size;
-	info->inodes = sb->s_inodes_count;
-	info->feat_ro_compat = sb->s_feature_ro_compat;
-	info->feat_compat = sb->s_feature_compat;
-	info->feat_incompat = sb->s_feature_incompat;
-	info->bg_desc_reserve_blocks = sb->s_reserved_gdt_blocks;
-	info->bg_desc_size =
-		(sb->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) ?
-		sb->s_desc_size : EXT4_MIN_DESC_SIZE;
-	info->label = sb->s_volume_name;
+    info->block_size = 1024 << sb->s_log_block_size;
+    info->blocks_per_group = sb->s_blocks_per_group;
+    info->inodes_per_group = sb->s_inodes_per_group;
+    info->inode_size = sb->s_inode_size;
+    info->inodes = sb->s_inodes_count;
+    info->feat_ro_compat = sb->s_feature_ro_compat;
+    info->feat_compat = sb->s_feature_compat;
+    info->feat_incompat = sb->s_feature_incompat;
+    info->bg_desc_reserve_blocks = sb->s_reserved_gdt_blocks;
+    info->bg_desc_size = (sb->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+                                 ? sb->s_desc_size
+                                 : EXT4_MIN_DESC_SIZE;
+    info->label = sb->s_volume_name;
 
-	len_blocks = ((uint64_t)sb->s_blocks_count_hi << 32) +
-                sb->s_blocks_count_lo;
-	info->len = (uint64_t)info->block_size * len_blocks;
+    len_blocks = ((uint64_t)sb->s_blocks_count_hi << 32) + sb->s_blocks_count_lo;
+    info->len = (uint64_t)info->block_size * len_blocks;
 
-	return 0;
+    return 0;
 }
diff --git a/ext4_utils/ext4_utils.cpp b/ext4_utils/ext4_utils.cpp
index 234ceeb6..632d8292 100644
--- a/ext4_utils/ext4_utils.cpp
+++ b/ext4_utils/ext4_utils.cpp
@@ -45,310 +45,270 @@ struct fs_aux_info aux_info;
 jmp_buf setjmp_env;
 
 /* returns 1 if a is a power of b */
-static int is_power_of(int a, int b)
-{
-	while (a > b) {
-		if (a % b)
-			return 0;
-		a /= b;
-	}
-
-	return (a == b) ? 1 : 0;
+static int is_power_of(int a, int b) {
+    while (a > b) {
+        if (a % b) return 0;
+        a /= b;
+    }
+
+    return (a == b) ? 1 : 0;
 }
 
-int bitmap_get_bit(u8 *bitmap, u32 bit)
-{
-	if (bitmap[bit / 8] & (1 << (bit % 8)))
-		return 1;
+int bitmap_get_bit(u8* bitmap, u32 bit) {
+    if (bitmap[bit / 8] & (1 << (bit % 8))) return 1;
 
-	return 0;
+    return 0;
 }
 
-void bitmap_clear_bit(u8 *bitmap, u32 bit)
-{
-	bitmap[bit / 8] &= ~(1 << (bit % 8));
+void bitmap_clear_bit(u8* bitmap, u32 bit) {
+    bitmap[bit / 8] &= ~(1 << (bit % 8));
 
-	return;
+    return;
 }
 
 /* Returns 1 if the bg contains a backup superblock.  On filesystems with
    the sparse_super feature, only block groups 0, 1, and powers of 3, 5,
    and 7 have backup superblocks.  Otherwise, all block groups have backup
    superblocks */
-int ext4_bg_has_super_block(int bg)
-{
-	/* Without sparse_super, every block group has a superblock */
-	if (!(info.feat_ro_compat & EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER))
-		return 1;
+int ext4_bg_has_super_block(int bg) {
+    /* Without sparse_super, every block group has a superblock */
+    if (!(info.feat_ro_compat & EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) return 1;
 
-	if (bg == 0 || bg == 1)
-		return 1;
+    if (bg == 0 || bg == 1) return 1;
 
-	if (is_power_of(bg, 3) || is_power_of(bg, 5) || is_power_of(bg, 7))
-		return 1;
+    if (is_power_of(bg, 3) || is_power_of(bg, 5) || is_power_of(bg, 7)) return 1;
 
-	return 0;
+    return 0;
 }
 
 /* Function to read the primary superblock */
-void read_sb(int fd, struct ext4_super_block *sb)
-{
-	off64_t ret;
-
-	ret = lseek64(fd, 1024, SEEK_SET);
-	if (ret < 0)
-		critical_error_errno("failed to seek to superblock");
-
-	ret = read(fd, sb, sizeof(*sb));
-	if (ret < 0)
-		critical_error_errno("failed to read superblock");
-	if (ret != sizeof(*sb))
-		critical_error("failed to read all of superblock");
+void read_sb(int fd, struct ext4_super_block* sb) {
+    off64_t ret;
+
+    ret = lseek64(fd, 1024, SEEK_SET);
+    if (ret < 0) critical_error_errno("failed to seek to superblock");
+
+    ret = read(fd, sb, sizeof(*sb));
+    if (ret < 0) critical_error_errno("failed to read superblock");
+    if (ret != sizeof(*sb)) critical_error("failed to read all of superblock");
 }
 
 /* Compute the rest of the parameters of the filesystem from the basic info */
-void ext4_create_fs_aux_info()
-{
-	aux_info.first_data_block = (info.block_size > 1024) ? 0 : 1;
-	aux_info.len_blocks = info.len / info.block_size;
-	aux_info.inode_table_blocks = DIV_ROUND_UP(info.inodes_per_group * info.inode_size,
-		info.block_size);
-	aux_info.groups = DIV_ROUND_UP(aux_info.len_blocks - aux_info.first_data_block,
-		info.blocks_per_group);
-	aux_info.blocks_per_ind = info.block_size / sizeof(u32);
-	aux_info.blocks_per_dind = aux_info.blocks_per_ind * aux_info.blocks_per_ind;
-	aux_info.blocks_per_tind = aux_info.blocks_per_dind * aux_info.blocks_per_dind;
-
-	aux_info.bg_desc_blocks =
-		DIV_ROUND_UP(aux_info.groups * (size_t)info.bg_desc_size, info.block_size);
-
-	aux_info.default_i_flags = EXT4_NOATIME_FL;
-
-	u32 last_group_size = aux_info.len_blocks == info.blocks_per_group
-		? aux_info.len_blocks : aux_info.len_blocks % info.blocks_per_group;
-	u32 last_header_size = 2 + aux_info.inode_table_blocks;
-	if (ext4_bg_has_super_block((int)aux_info.groups - 1))
-		last_header_size += 1 + aux_info.bg_desc_blocks +
-			info.bg_desc_reserve_blocks;
-	if (aux_info.groups <= 1 && last_group_size < last_header_size) {
-		critical_error("filesystem size too small");
-	}
-	if (last_group_size > 0 && last_group_size < last_header_size) {
-		aux_info.groups--;
-		aux_info.len_blocks -= last_group_size;
-	}
-
-	/* A zero-filled superblock to be written firstly to the block
-	 * device to mark the file-system as invalid
-	 */
-	aux_info.sb_zero = (struct ext4_super_block *)calloc(1, info.block_size);
-	if (!aux_info.sb_zero)
-		critical_error_errno("calloc");
-
-	/* The write_data* functions expect only block aligned calls.
-	 * This is not an issue, except when we write out the super
-	 * block on a system with a block size > 1K.  So, we need to
-	 * deal with that here.
-	 */
-	aux_info.sb_block = (struct ext4_super_block *)calloc(1, info.block_size);
-	if (!aux_info.sb_block)
-		critical_error_errno("calloc");
-
-	if (info.block_size > 1024)
-		aux_info.sb = (struct ext4_super_block *)((char *)aux_info.sb_block + 1024);
-	else
-		aux_info.sb = aux_info.sb_block;
-
-	/* Alloc an array to hold the pointers to the backup superblocks */
-	aux_info.backup_sb = (struct ext4_super_block **)calloc(aux_info.groups, sizeof(char *));
-
-	if (!aux_info.sb)
-		critical_error_errno("calloc");
-
-	aux_info.bg_desc =
-		(struct ext2_group_desc *)calloc(aux_info.groups, sizeof(struct ext2_group_desc));
-	if (!aux_info.bg_desc)
-		critical_error_errno("calloc");
-	aux_info.xattrs = NULL;
+void ext4_create_fs_aux_info() {
+    aux_info.first_data_block = (info.block_size > 1024) ? 0 : 1;
+    aux_info.len_blocks = info.len / info.block_size;
+    aux_info.inode_table_blocks =
+            DIV_ROUND_UP(info.inodes_per_group * info.inode_size, info.block_size);
+    aux_info.groups =
+            DIV_ROUND_UP(aux_info.len_blocks - aux_info.first_data_block, info.blocks_per_group);
+    aux_info.blocks_per_ind = info.block_size / sizeof(u32);
+    aux_info.blocks_per_dind = aux_info.blocks_per_ind * aux_info.blocks_per_ind;
+    aux_info.blocks_per_tind = aux_info.blocks_per_dind * aux_info.blocks_per_dind;
+
+    aux_info.bg_desc_blocks =
+            DIV_ROUND_UP(aux_info.groups * (size_t)info.bg_desc_size, info.block_size);
+
+    aux_info.default_i_flags = EXT4_NOATIME_FL;
+
+    u32 last_group_size = aux_info.len_blocks == info.blocks_per_group
+                                  ? aux_info.len_blocks
+                                  : aux_info.len_blocks % info.blocks_per_group;
+    u32 last_header_size = 2 + aux_info.inode_table_blocks;
+    if (ext4_bg_has_super_block((int)aux_info.groups - 1))
+        last_header_size += 1 + aux_info.bg_desc_blocks + info.bg_desc_reserve_blocks;
+    if (aux_info.groups <= 1 && last_group_size < last_header_size) {
+        critical_error("filesystem size too small");
+    }
+    if (last_group_size > 0 && last_group_size < last_header_size) {
+        aux_info.groups--;
+        aux_info.len_blocks -= last_group_size;
+    }
+
+    /* A zero-filled superblock to be written firstly to the block
+     * device to mark the file-system as invalid
+     */
+    aux_info.sb_zero = (struct ext4_super_block*)calloc(1, info.block_size);
+    if (!aux_info.sb_zero) critical_error_errno("calloc");
+
+    /* The write_data* functions expect only block aligned calls.
+     * This is not an issue, except when we write out the super
+     * block on a system with a block size > 1K.  So, we need to
+     * deal with that here.
+     */
+    aux_info.sb_block = (struct ext4_super_block*)calloc(1, info.block_size);
+    if (!aux_info.sb_block) critical_error_errno("calloc");
+
+    if (info.block_size > 1024)
+        aux_info.sb = (struct ext4_super_block*)((char*)aux_info.sb_block + 1024);
+    else
+        aux_info.sb = aux_info.sb_block;
+
+    /* Alloc an array to hold the pointers to the backup superblocks */
+    aux_info.backup_sb = (struct ext4_super_block**)calloc(aux_info.groups, sizeof(char*));
+
+    if (!aux_info.sb) critical_error_errno("calloc");
+
+    aux_info.bg_desc =
+            (struct ext2_group_desc*)calloc(aux_info.groups, sizeof(struct ext2_group_desc));
+    if (!aux_info.bg_desc) critical_error_errno("calloc");
+    aux_info.xattrs = NULL;
 }
 
-void ext4_free_fs_aux_info()
-{
-	unsigned int i;
-
-	for (i=0; i<aux_info.groups; i++) {
-		if (aux_info.backup_sb[i])
-			free(aux_info.backup_sb[i]);
-	}
-	free(aux_info.sb_block);
-	free(aux_info.sb_zero);
-	free(aux_info.bg_desc);
+void ext4_free_fs_aux_info() {
+    unsigned int i;
+
+    for (i = 0; i < aux_info.groups; i++) {
+        if (aux_info.backup_sb[i]) free(aux_info.backup_sb[i]);
+    }
+    free(aux_info.sb_block);
+    free(aux_info.sb_zero);
+    free(aux_info.bg_desc);
 }
 
-void ext4_parse_sb_info(struct ext4_super_block *sb)
-{
-	if (sb->s_magic != EXT4_SUPER_MAGIC)
-		error("superblock magic incorrect");
+void ext4_parse_sb_info(struct ext4_super_block* sb) {
+    if (sb->s_magic != EXT4_SUPER_MAGIC) error("superblock magic incorrect");
 
-	if ((sb->s_state & EXT4_VALID_FS) != EXT4_VALID_FS)
-		error("filesystem state not valid");
+    if ((sb->s_state & EXT4_VALID_FS) != EXT4_VALID_FS) error("filesystem state not valid");
 
-	ext4_parse_sb(sb, &info);
+    ext4_parse_sb(sb, &info);
 
-	ext4_create_fs_aux_info();
+    ext4_create_fs_aux_info();
 
-	memcpy(aux_info.sb, sb, sizeof(*sb));
+    memcpy(aux_info.sb, sb, sizeof(*sb));
 
-	if (aux_info.first_data_block != sb->s_first_data_block)
-		critical_error("first data block does not match");
+    if (aux_info.first_data_block != sb->s_first_data_block)
+        critical_error("first data block does not match");
 }
 
-u64 get_block_device_size(int fd)
-{
-	u64 size = 0;
-	int ret;
+u64 get_block_device_size(int fd) {
+    u64 size = 0;
+    int ret;
 
 #if defined(__linux__)
-	ret = ioctl(fd, BLKGETSIZE64, &size);
+    ret = ioctl(fd, BLKGETSIZE64, &size);
 #elif defined(__APPLE__) && defined(__MACH__)
-	ret = ioctl(fd, DKIOCGETBLOCKCOUNT, &size);
+    ret = ioctl(fd, DKIOCGETBLOCKCOUNT, &size);
 #else
-	close(fd);
-	return 0;
+    close(fd);
+    return 0;
 #endif
 
-	if (ret)
-		return 0;
+    if (ret) return 0;
 
-	return size;
+    return size;
 }
 
-int is_block_device_fd(int fd __attribute__((unused)))
-{
+int is_block_device_fd(int fd __attribute__((unused))) {
 #ifdef _WIN32
-	return 0;
+    return 0;
 #else
-	struct stat st;
-	int ret = fstat(fd, &st);
-	if (ret < 0)
-		return 0;
+    struct stat st;
+    int ret = fstat(fd, &st);
+    if (ret < 0) return 0;
 
-	return S_ISBLK(st.st_mode);
+    return S_ISBLK(st.st_mode);
 #endif
 }
 
-u64 get_file_size(int fd)
-{
-	struct stat buf;
-	int ret;
-	u64 reserve_len = 0;
-	s64 computed_size;
-
-	ret = fstat(fd, &buf);
-	if (ret)
-		return 0;
-
-	if (info.len < 0)
-		reserve_len = -info.len;
-
-	if (S_ISREG(buf.st_mode))
-		computed_size = buf.st_size - reserve_len;
-	else if (S_ISBLK(buf.st_mode))
-		computed_size = get_block_device_size(fd) - reserve_len;
-	else
-		computed_size = 0;
-
-	if (computed_size < 0) {
-		warn("Computed filesystem size less than 0");
-		computed_size = 0;
-	}
-
-	return computed_size;
-}
+u64 get_file_size(int fd) {
+    struct stat buf;
+    int ret;
+    u64 reserve_len = 0;
+    s64 computed_size;
 
-static void read_block_group_descriptors(int fd)
-{
-	size_t size = info.block_size * (size_t)aux_info.bg_desc_blocks;
-	void *buf = malloc(size);
-	ssize_t ret;
-
-	if (!buf)
-		critical_error("failed to alloc buffer");
-
-	ret = read(fd, buf, size);
-	if (ret < 0) {
-		free(buf);
-		critical_error_errno("failed to read block group descriptors");
-	}
-	if (ret != size) {
-		free(buf);
-		critical_error("failed to read all the block group descriptors");
-	}
-	const struct ext4_group_desc *gdp = (const struct ext4_group_desc *)buf;
-	bool extended = (info.bg_desc_size >= EXT4_MIN_DESC_SIZE_64BIT);
-	for (size_t i = 0; i < aux_info.groups; i++) {
-		aux_info.bg_desc[i].bg_block_bitmap =
-			(extended ? (u64)gdp->bg_block_bitmap_hi << 32 : 0) |
-			gdp->bg_block_bitmap_lo;
-		aux_info.bg_desc[i].bg_inode_bitmap =
-			(extended ? (u64)gdp->bg_inode_bitmap_hi << 32 : 0) |
-			gdp->bg_inode_bitmap_lo;
-		aux_info.bg_desc[i].bg_inode_table =
-			(extended ? (u64)gdp->bg_inode_table_hi << 32 : 0) |
-			gdp->bg_inode_table_lo;
-		aux_info.bg_desc[i].bg_free_blocks_count =
-			(extended ? (u32)gdp->bg_free_blocks_count_hi << 16 : 0) |
-			gdp->bg_free_blocks_count_lo;
-		aux_info.bg_desc[i].bg_free_inodes_count =
-			(extended ? (u32)gdp->bg_free_inodes_count_hi << 16 : 0) |
-			gdp->bg_free_inodes_count_lo;
-		aux_info.bg_desc[i].bg_used_dirs_count =
-			(extended ? (u32)gdp->bg_used_dirs_count_hi << 16 : 0) |
-			gdp->bg_used_dirs_count_lo;
-		aux_info.bg_desc[i].bg_flags = gdp->bg_flags;
-		gdp = (const struct ext4_group_desc *)((u8 *)gdp + info.bg_desc_size);
-	}
-	free(buf);
+    ret = fstat(fd, &buf);
+    if (ret) return 0;
+
+    if (info.len < 0) reserve_len = -info.len;
+
+    if (S_ISREG(buf.st_mode))
+        computed_size = buf.st_size - reserve_len;
+    else if (S_ISBLK(buf.st_mode))
+        computed_size = get_block_device_size(fd) - reserve_len;
+    else
+        computed_size = 0;
+
+    if (computed_size < 0) {
+        warn("Computed filesystem size less than 0");
+        computed_size = 0;
+    }
+
+    return computed_size;
 }
 
-int read_ext(int fd, int verbose)
-{
-	off64_t ret;
-	struct ext4_super_block sb;
-
-	read_sb(fd, &sb);
-
-	ext4_parse_sb_info(&sb);
-
-	ret = lseek64(fd, info.len, SEEK_SET);
-	if (ret < 0)
-		critical_error_errno("failed to seek to end of input image");
-
-	ret = lseek64(fd, info.block_size * (aux_info.first_data_block + 1), SEEK_SET);
-	if (ret < 0)
-		critical_error_errno("failed to seek to block group descriptors");
-
-	read_block_group_descriptors(fd);
-
-	if (verbose) {
-		printf("Found filesystem with parameters:\n");
-		printf("    Size: %" PRIu64 "\n", info.len);
-		printf("    Block size: %d\n", info.block_size);
-		printf("    Blocks per group: %d\n", info.blocks_per_group);
-		printf("    Inodes per group: %d\n", info.inodes_per_group);
-		printf("    Inode size: %d\n", info.inode_size);
-		printf("    Label: %s\n", info.label);
-		printf("    Blocks: %" PRIext4u64 "\n", aux_info.len_blocks);
-		printf("    Block groups: %d\n", aux_info.groups);
-		printf("    Reserved block group size: %d\n", info.bg_desc_reserve_blocks);
-		printf("    Block group descriptor size: %d\n", info.bg_desc_size);
-		printf("    Used %d/%d inodes and %d/%d blocks\n",
-			aux_info.sb->s_inodes_count - aux_info.sb->s_free_inodes_count,
-			aux_info.sb->s_inodes_count,
-			aux_info.sb->s_blocks_count_lo - aux_info.sb->s_free_blocks_count_lo,
-			aux_info.sb->s_blocks_count_lo);
-	}
-
-	return 0;
+static void read_block_group_descriptors(int fd) {
+    size_t size = info.block_size * (size_t)aux_info.bg_desc_blocks;
+    void* buf = malloc(size);
+    ssize_t ret;
+
+    if (!buf) critical_error("failed to alloc buffer");
+
+    ret = read(fd, buf, size);
+    if (ret < 0) {
+        free(buf);
+        critical_error_errno("failed to read block group descriptors");
+    }
+    if (ret != size) {
+        free(buf);
+        critical_error("failed to read all the block group descriptors");
+    }
+    const struct ext4_group_desc* gdp = (const struct ext4_group_desc*)buf;
+    bool extended = (info.bg_desc_size >= EXT4_MIN_DESC_SIZE_64BIT);
+    for (size_t i = 0; i < aux_info.groups; i++) {
+        aux_info.bg_desc[i].bg_block_bitmap =
+                (extended ? (u64)gdp->bg_block_bitmap_hi << 32 : 0) | gdp->bg_block_bitmap_lo;
+        aux_info.bg_desc[i].bg_inode_bitmap =
+                (extended ? (u64)gdp->bg_inode_bitmap_hi << 32 : 0) | gdp->bg_inode_bitmap_lo;
+        aux_info.bg_desc[i].bg_inode_table =
+                (extended ? (u64)gdp->bg_inode_table_hi << 32 : 0) | gdp->bg_inode_table_lo;
+        aux_info.bg_desc[i].bg_free_blocks_count =
+                (extended ? (u32)gdp->bg_free_blocks_count_hi << 16 : 0) |
+                gdp->bg_free_blocks_count_lo;
+        aux_info.bg_desc[i].bg_free_inodes_count =
+                (extended ? (u32)gdp->bg_free_inodes_count_hi << 16 : 0) |
+                gdp->bg_free_inodes_count_lo;
+        aux_info.bg_desc[i].bg_used_dirs_count =
+                (extended ? (u32)gdp->bg_used_dirs_count_hi << 16 : 0) | gdp->bg_used_dirs_count_lo;
+        aux_info.bg_desc[i].bg_flags = gdp->bg_flags;
+        gdp = (const struct ext4_group_desc*)((u8*)gdp + info.bg_desc_size);
+    }
+    free(buf);
 }
 
+int read_ext(int fd, int verbose) {
+    off64_t ret;
+    struct ext4_super_block sb;
+
+    read_sb(fd, &sb);
+
+    ext4_parse_sb_info(&sb);
+
+    ret = lseek64(fd, info.len, SEEK_SET);
+    if (ret < 0) critical_error_errno("failed to seek to end of input image");
+
+    ret = lseek64(fd, info.block_size * (aux_info.first_data_block + 1), SEEK_SET);
+    if (ret < 0) critical_error_errno("failed to seek to block group descriptors");
+
+    read_block_group_descriptors(fd);
+
+    if (verbose) {
+        printf("Found filesystem with parameters:\n");
+        printf("    Size: %" PRIu64 "\n", info.len);
+        printf("    Block size: %d\n", info.block_size);
+        printf("    Blocks per group: %d\n", info.blocks_per_group);
+        printf("    Inodes per group: %d\n", info.inodes_per_group);
+        printf("    Inode size: %d\n", info.inode_size);
+        printf("    Label: %s\n", info.label);
+        printf("    Blocks: %" PRIext4u64 "\n", aux_info.len_blocks);
+        printf("    Block groups: %d\n", aux_info.groups);
+        printf("    Reserved block group size: %d\n", info.bg_desc_reserve_blocks);
+        printf("    Block group descriptor size: %d\n", info.bg_desc_size);
+        printf("    Used %d/%d inodes and %d/%d blocks\n",
+               aux_info.sb->s_inodes_count - aux_info.sb->s_free_inodes_count,
+               aux_info.sb->s_inodes_count,
+               aux_info.sb->s_blocks_count_lo - aux_info.sb->s_free_blocks_count_lo,
+               aux_info.sb->s_blocks_count_lo);
+    }
+
+    return 0;
+}
diff --git a/ext4_utils/helpers.h b/ext4_utils/helpers.h
index 09b7b457..c7509ec6 100644
--- a/ext4_utils/helpers.h
+++ b/ext4_utils/helpers.h
@@ -18,8 +18,19 @@
 #include <stdio.h>
 #include <string.h>
 
-#define warn(fmt, args...) do { fprintf(stderr, "warning: %s: " fmt "\n", __func__, ## args); } while (0)
-#define error(fmt, args...) do { fprintf(stderr, "error: %s: " fmt "\n", __func__, ## args); if (!force) longjmp(setjmp_env, EXIT_FAILURE); } while (0)
+#define warn(fmt, args...)                                           \
+    do {                                                             \
+        fprintf(stderr, "warning: %s: " fmt "\n", __func__, ##args); \
+    } while (0)
+#define error(fmt, args...)                                        \
+    do {                                                           \
+        fprintf(stderr, "error: %s: " fmt "\n", __func__, ##args); \
+        if (!force) longjmp(setjmp_env, EXIT_FAILURE);             \
+    } while (0)
 #define error_errno(s, args...) error(s ": %s", ##args, strerror(errno))
-#define critical_error(fmt, args...) do { fprintf(stderr, "critical error: %s: " fmt "\n", __func__, ## args); longjmp(setjmp_env, EXIT_FAILURE); } while (0)
+#define critical_error(fmt, args...)                                        \
+    do {                                                                    \
+        fprintf(stderr, "critical error: %s: " fmt "\n", __func__, ##args); \
+        longjmp(setjmp_env, EXIT_FAILURE);                                  \
+    } while (0)
 #define critical_error_errno(s, args...) critical_error(s ": %s", ##args, strerror(errno))
diff --git a/ext4_utils/include/ext4_utils/ext4.h b/ext4_utils/include/ext4_utils/ext4.h
index 4bb1031f..54e5d86a 100644
--- a/ext4_utils/include/ext4_utils/ext4.h
+++ b/ext4_utils/include/ext4_utils/ext4.h
@@ -17,14 +17,20 @@
 #undef EXT4FS_DEBUG
 
 #ifdef EXT4FS_DEBUG
-#define ext4_debug(f, a...)   do {   printk(KERN_DEBUG "EXT4-fs DEBUG (%s, %d): %s:",   __FILE__, __LINE__, __func__);   printk(KERN_DEBUG f, ## a);   } while (0)
+#define ext4_debug(f, a...)                                                             \
+    do {                                                                                \
+        printk(KERN_DEBUG "EXT4-fs DEBUG (%s, %d): %s:", __FILE__, __LINE__, __func__); \
+        printk(KERN_DEBUG f, ##a);                                                      \
+    } while (0)
 #else
-#define ext4_debug(f, a...) do {} while (0)
+#define ext4_debug(f, a...) \
+    do {                    \
+    } while (0)
 #endif
 
-#define EXT4_ERROR_INODE(inode, fmt, a...)   ext4_error_inode(__func__, (inode), (fmt), ## a);
+#define EXT4_ERROR_INODE(inode, fmt, a...) ext4_error_inode(__func__, (inode), (fmt), ##a);
 
-#define EXT4_ERROR_FILE(file, fmt, a...)   ext4_error_file(__func__, (file), (fmt), ## a);
+#define EXT4_ERROR_FILE(file, fmt, a...) ext4_error_file(__func__, (file), (fmt), ##a);
 
 typedef int ext4_grpblk_t;
 
@@ -59,32 +65,31 @@ typedef unsigned int ext4_group_t;
 #define EXT4_MB_STREAM_ALLOC 0x0800
 
 struct ext4_allocation_request {
+    struct inode* inode;
 
- struct inode *inode;
+    unsigned int len;
 
- unsigned int len;
+    ext4_lblk_t logical;
 
- ext4_lblk_t logical;
+    ext4_lblk_t lleft;
 
- ext4_lblk_t lleft;
+    ext4_lblk_t lright;
 
- ext4_lblk_t lright;
+    ext4_fsblk_t goal;
 
- ext4_fsblk_t goal;
+    ext4_fsblk_t pleft;
 
- ext4_fsblk_t pleft;
+    ext4_fsblk_t pright;
 
- ext4_fsblk_t pright;
-
- unsigned int flags;
+    unsigned int flags;
 };
 
-#define EXT4_BAD_INO 1  
-#define EXT4_ROOT_INO 2  
-#define EXT4_BOOT_LOADER_INO 5  
-#define EXT4_UNDEL_DIR_INO 6  
-#define EXT4_RESIZE_INO 7  
-#define EXT4_JOURNAL_INO 8  
+#define EXT4_BAD_INO 1
+#define EXT4_ROOT_INO 2
+#define EXT4_BOOT_LOADER_INO 5
+#define EXT4_UNDEL_DIR_INO 6
+#define EXT4_RESIZE_INO 7
+#define EXT4_JOURNAL_INO 8
 
 #define EXT4_GOOD_OLD_FIRST_INO 11
 
@@ -96,35 +101,36 @@ struct ext4_allocation_request {
 #define EXT4_BLOCK_SIZE(s) (EXT4_MIN_BLOCK_SIZE << (s)->s_log_block_size)
 #define EXT4_ADDR_PER_BLOCK(s) (EXT4_BLOCK_SIZE(s) / sizeof(__u32))
 #define EXT4_BLOCK_SIZE_BITS(s) ((s)->s_log_block_size + 10)
-#define EXT4_INODE_SIZE(s) (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ?   EXT4_GOOD_OLD_INODE_SIZE :   (s)->s_inode_size)
-#define EXT4_FIRST_INO(s) (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ?   EXT4_GOOD_OLD_FIRST_INO :   (s)->s_first_ino)
+#define EXT4_INODE_SIZE(s) \
+    (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? EXT4_GOOD_OLD_INODE_SIZE : (s)->s_inode_size)
+#define EXT4_FIRST_INO(s) \
+    (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? EXT4_GOOD_OLD_FIRST_INO : (s)->s_first_ino)
 #define EXT4_BLOCK_ALIGN(size, blkbits) EXT4_ALIGN((size), (1 << (blkbits)))
 
-struct ext4_group_desc
-{
- __le32 bg_block_bitmap_lo;
- __le32 bg_inode_bitmap_lo;
- __le32 bg_inode_table_lo;
- __le16 bg_free_blocks_count_lo;
- __le16 bg_free_inodes_count_lo;
- __le16 bg_used_dirs_count_lo;
- __le16 bg_flags;
- __u32 bg_reserved[2];
- __le16 bg_itable_unused_lo;
- __le16 bg_checksum;
- __le32 bg_block_bitmap_hi;
- __le32 bg_inode_bitmap_hi;
- __le32 bg_inode_table_hi;
- __le16 bg_free_blocks_count_hi;
- __le16 bg_free_inodes_count_hi;
- __le16 bg_used_dirs_count_hi;
- __le16 bg_itable_unused_hi;
- __u32 bg_reserved2[3];
+struct ext4_group_desc {
+    __le32 bg_block_bitmap_lo;
+    __le32 bg_inode_bitmap_lo;
+    __le32 bg_inode_table_lo;
+    __le16 bg_free_blocks_count_lo;
+    __le16 bg_free_inodes_count_lo;
+    __le16 bg_used_dirs_count_lo;
+    __le16 bg_flags;
+    __u32 bg_reserved[2];
+    __le16 bg_itable_unused_lo;
+    __le16 bg_checksum;
+    __le32 bg_block_bitmap_hi;
+    __le32 bg_inode_bitmap_hi;
+    __le32 bg_inode_table_hi;
+    __le16 bg_free_blocks_count_hi;
+    __le16 bg_free_inodes_count_hi;
+    __le16 bg_used_dirs_count_hi;
+    __le16 bg_itable_unused_hi;
+    __u32 bg_reserved2[3];
 };
 
-#define EXT4_BG_INODE_UNINIT 0x0001  
-#define EXT4_BG_BLOCK_UNINIT 0x0002  
-#define EXT4_BG_INODE_ZEROED 0x0004  
+#define EXT4_BG_INODE_UNINIT 0x0001
+#define EXT4_BG_BLOCK_UNINIT 0x0002
+#define EXT4_BG_INODE_ZEROED 0x0004
 
 #define EXT4_MIN_DESC_SIZE 32
 #define EXT4_MIN_DESC_SIZE_64BIT 64
@@ -140,64 +146,67 @@ struct ext4_group_desc
 #define EXT4_TIND_BLOCK (EXT4_DIND_BLOCK + 1)
 #define EXT4_N_BLOCKS (EXT4_TIND_BLOCK + 1)
 
-#define EXT4_SECRM_FL 0x00000001  
-#define EXT4_UNRM_FL 0x00000002  
-#define EXT4_COMPR_FL 0x00000004  
-#define EXT4_SYNC_FL 0x00000008  
-#define EXT4_IMMUTABLE_FL 0x00000010  
-#define EXT4_APPEND_FL 0x00000020  
-#define EXT4_NODUMP_FL 0x00000040  
-#define EXT4_NOATIME_FL 0x00000080  
+#define EXT4_SECRM_FL 0x00000001
+#define EXT4_UNRM_FL 0x00000002
+#define EXT4_COMPR_FL 0x00000004
+#define EXT4_SYNC_FL 0x00000008
+#define EXT4_IMMUTABLE_FL 0x00000010
+#define EXT4_APPEND_FL 0x00000020
+#define EXT4_NODUMP_FL 0x00000040
+#define EXT4_NOATIME_FL 0x00000080
 
 #define EXT4_DIRTY_FL 0x00000100
-#define EXT4_COMPRBLK_FL 0x00000200  
-#define EXT4_NOCOMPR_FL 0x00000400  
-#define EXT4_ECOMPR_FL 0x00000800  
-
-#define EXT4_INDEX_FL 0x00001000  
-#define EXT4_IMAGIC_FL 0x00002000  
-#define EXT4_JOURNAL_DATA_FL 0x00004000  
-#define EXT4_NOTAIL_FL 0x00008000  
-#define EXT4_DIRSYNC_FL 0x00010000  
-#define EXT4_TOPDIR_FL 0x00020000  
-#define EXT4_HUGE_FILE_FL 0x00040000  
-#define EXT4_EXTENTS_FL 0x00080000  
-#define EXT4_EA_INODE_FL 0x00200000  
-#define EXT4_EOFBLOCKS_FL 0x00400000  
-#define EXT4_RESERVED_FL 0x80000000  
-
-#define EXT4_FL_USER_VISIBLE 0x004BDFFF  
-#define EXT4_FL_USER_MODIFIABLE 0x004B80FF  
-
-#define EXT4_FL_INHERITED (EXT4_SECRM_FL | EXT4_UNRM_FL | EXT4_COMPR_FL |  EXT4_SYNC_FL | EXT4_IMMUTABLE_FL | EXT4_APPEND_FL |  EXT4_NODUMP_FL | EXT4_NOATIME_FL |  EXT4_NOCOMPR_FL | EXT4_JOURNAL_DATA_FL |  EXT4_NOTAIL_FL | EXT4_DIRSYNC_FL)
+#define EXT4_COMPRBLK_FL 0x00000200
+#define EXT4_NOCOMPR_FL 0x00000400
+#define EXT4_ECOMPR_FL 0x00000800
+
+#define EXT4_INDEX_FL 0x00001000
+#define EXT4_IMAGIC_FL 0x00002000
+#define EXT4_JOURNAL_DATA_FL 0x00004000
+#define EXT4_NOTAIL_FL 0x00008000
+#define EXT4_DIRSYNC_FL 0x00010000
+#define EXT4_TOPDIR_FL 0x00020000
+#define EXT4_HUGE_FILE_FL 0x00040000
+#define EXT4_EXTENTS_FL 0x00080000
+#define EXT4_EA_INODE_FL 0x00200000
+#define EXT4_EOFBLOCKS_FL 0x00400000
+#define EXT4_RESERVED_FL 0x80000000
+
+#define EXT4_FL_USER_VISIBLE 0x004BDFFF
+#define EXT4_FL_USER_MODIFIABLE 0x004B80FF
+
+#define EXT4_FL_INHERITED                                                                         \
+    (EXT4_SECRM_FL | EXT4_UNRM_FL | EXT4_COMPR_FL | EXT4_SYNC_FL | EXT4_IMMUTABLE_FL |            \
+     EXT4_APPEND_FL | EXT4_NODUMP_FL | EXT4_NOATIME_FL | EXT4_NOCOMPR_FL | EXT4_JOURNAL_DATA_FL | \
+     EXT4_NOTAIL_FL | EXT4_DIRSYNC_FL)
 
 #define EXT4_REG_FLMASK (~(EXT4_DIRSYNC_FL | EXT4_TOPDIR_FL))
 
 #define EXT4_OTHER_FLMASK (EXT4_NODUMP_FL | EXT4_NOATIME_FL)
 
 struct ext4_new_group_data {
- __u32 group;
- __u64 block_bitmap;
- __u64 inode_bitmap;
- __u64 inode_table;
- __u32 blocks_count;
- __u16 reserved_blocks;
- __u16 unused;
- __u32 free_blocks_count;
+    __u32 group;
+    __u64 block_bitmap;
+    __u64 inode_bitmap;
+    __u64 inode_table;
+    __u32 blocks_count;
+    __u16 reserved_blocks;
+    __u16 unused;
+    __u32 free_blocks_count;
 };
 
 #define EXT4_GET_BLOCKS_CREATE 0x0001
 
 #define EXT4_GET_BLOCKS_UNINIT_EXT 0x0002
-#define EXT4_GET_BLOCKS_CREATE_UNINIT_EXT (EXT4_GET_BLOCKS_UNINIT_EXT|  EXT4_GET_BLOCKS_CREATE)
+#define EXT4_GET_BLOCKS_CREATE_UNINIT_EXT (EXT4_GET_BLOCKS_UNINIT_EXT | EXT4_GET_BLOCKS_CREATE)
 
 #define EXT4_GET_BLOCKS_DELALLOC_RESERVE 0x0004
 
 #define EXT4_GET_BLOCKS_PRE_IO 0x0008
 #define EXT4_GET_BLOCKS_CONVERT 0x0010
-#define EXT4_GET_BLOCKS_IO_CREATE_EXT (EXT4_GET_BLOCKS_PRE_IO|  EXT4_GET_BLOCKS_CREATE_UNINIT_EXT)
+#define EXT4_GET_BLOCKS_IO_CREATE_EXT (EXT4_GET_BLOCKS_PRE_IO | EXT4_GET_BLOCKS_CREATE_UNINIT_EXT)
 
-#define EXT4_GET_BLOCKS_IO_CONVERT_EXT (EXT4_GET_BLOCKS_CONVERT|  EXT4_GET_BLOCKS_CREATE_UNINIT_EXT)
+#define EXT4_GET_BLOCKS_IO_CONVERT_EXT (EXT4_GET_BLOCKS_CONVERT | EXT4_GET_BLOCKS_CREATE_UNINIT_EXT)
 
 #define EXT4_FREE_BLOCKS_METADATA 0x0001
 #define EXT4_FREE_BLOCKS_FORGET 0x0002
@@ -231,83 +240,107 @@ struct ext4_new_group_data {
 #define EXT4_MAX_BLOCK_FILE_PHYS 0xFFFFFFFF
 
 struct ext4_inode {
- __le16 i_mode;
- __le16 i_uid;
- __le32 i_size_lo;
- __le32 i_atime;
- __le32 i_ctime;
- __le32 i_mtime;
- __le32 i_dtime;
- __le16 i_gid;
- __le16 i_links_count;
- __le32 i_blocks_lo;
- __le32 i_flags;
- union {
- struct {
- __le32 l_i_version;
- } linux1;
- struct {
- __u32 h_i_translator;
- } hurd1;
- struct {
- __u32 m_i_reserved1;
- } masix1;
- } osd1;
- __le32 i_block[EXT4_N_BLOCKS];
- __le32 i_generation;
- __le32 i_file_acl_lo;
- __le32 i_size_high;
- __le32 i_obso_faddr;
- union {
- struct {
- __le16 l_i_blocks_high;
- __le16 l_i_file_acl_high;
- __le16 l_i_uid_high;
- __le16 l_i_gid_high;
- __u32 l_i_reserved2;
- } linux2;
- struct {
- __le16 h_i_reserved1;
- __u16 h_i_mode_high;
- __u16 h_i_uid_high;
- __u16 h_i_gid_high;
- __u32 h_i_author;
- } hurd2;
- struct {
- __le16 h_i_reserved1;
- __le16 m_i_file_acl_high;
- __u32 m_i_reserved2[2];
- } masix2;
- } osd2;
- __le16 i_extra_isize;
- __le16 i_pad1;
- __le32 i_ctime_extra;
- __le32 i_mtime_extra;
- __le32 i_atime_extra;
- __le32 i_crtime;
- __le32 i_crtime_extra;
- __le32 i_version_hi;
+    __le16 i_mode;
+    __le16 i_uid;
+    __le32 i_size_lo;
+    __le32 i_atime;
+    __le32 i_ctime;
+    __le32 i_mtime;
+    __le32 i_dtime;
+    __le16 i_gid;
+    __le16 i_links_count;
+    __le32 i_blocks_lo;
+    __le32 i_flags;
+    union {
+        struct {
+            __le32 l_i_version;
+        } linux1;
+        struct {
+            __u32 h_i_translator;
+        } hurd1;
+        struct {
+            __u32 m_i_reserved1;
+        } masix1;
+    } osd1;
+    __le32 i_block[EXT4_N_BLOCKS];
+    __le32 i_generation;
+    __le32 i_file_acl_lo;
+    __le32 i_size_high;
+    __le32 i_obso_faddr;
+    union {
+        struct {
+            __le16 l_i_blocks_high;
+            __le16 l_i_file_acl_high;
+            __le16 l_i_uid_high;
+            __le16 l_i_gid_high;
+            __u32 l_i_reserved2;
+        } linux2;
+        struct {
+            __le16 h_i_reserved1;
+            __u16 h_i_mode_high;
+            __u16 h_i_uid_high;
+            __u16 h_i_gid_high;
+            __u32 h_i_author;
+        } hurd2;
+        struct {
+            __le16 h_i_reserved1;
+            __le16 m_i_file_acl_high;
+            __u32 m_i_reserved2[2];
+        } masix2;
+    } osd2;
+    __le16 i_extra_isize;
+    __le16 i_pad1;
+    __le32 i_ctime_extra;
+    __le32 i_mtime_extra;
+    __le32 i_atime_extra;
+    __le32 i_crtime;
+    __le32 i_crtime_extra;
+    __le32 i_version_hi;
 };
 
 struct move_extent {
- __u32 reserved;
- __u32 donor_fd;
- __u64 orig_start;
- __u64 donor_start;
- __u64 len;
- __u64 moved_len;
+    __u32 reserved;
+    __u32 donor_fd;
+    __u64 orig_start;
+    __u64 donor_start;
+    __u64 len;
+    __u64 moved_len;
 };
 
 #define EXT4_EPOCH_BITS 2
 #define EXT4_EPOCH_MASK ((1 << EXT4_EPOCH_BITS) - 1)
 #define EXT4_NSEC_MASK (~0UL << EXT4_EPOCH_BITS)
 
-#define EXT4_FITS_IN_INODE(ext4_inode, einode, field) ((offsetof(typeof(*(ext4_inode)), field) +   sizeof((ext4_inode)->field))   <= (EXT4_GOOD_OLD_INODE_SIZE +   (einode)->i_extra_isize))
-#define EXT4_INODE_SET_XTIME(xtime, inode, raw_inode)  do {   (raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);   if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))   (raw_inode)->xtime ## _extra =   ext4_encode_extra_time(&(inode)->xtime);  } while (0)
-#define EXT4_EINODE_SET_XTIME(xtime, einode, raw_inode)  do {   if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))   (raw_inode)->xtime = cpu_to_le32((einode)->xtime.tv_sec);   if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime ## _extra))   (raw_inode)->xtime ## _extra =   ext4_encode_extra_time(&(einode)->xtime);  } while (0)
-#define EXT4_INODE_GET_XTIME(xtime, inode, raw_inode)  do {   (inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);   if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra)) ext4_decode_extra_time(&(inode)->xtime,   (raw_inode)->xtime ## _extra);  } while (0)
-
-#define EXT4_EINODE_GET_XTIME(xtime, einode, raw_inode)  do {   if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))   (einode)->xtime.tv_sec =   (signed)le32_to_cpu((raw_inode)->xtime);   if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime ## _extra))   ext4_decode_extra_time(&(einode)->xtime,   (raw_inode)->xtime ## _extra);  } while (0)
+#define EXT4_FITS_IN_INODE(ext4_inode, einode, field)                          \
+    ((offsetof(typeof(*(ext4_inode)), field) + sizeof((ext4_inode)->field)) <= \
+     (EXT4_GOOD_OLD_INODE_SIZE + (einode)->i_extra_isize))
+#define EXT4_INODE_SET_XTIME(xtime, inode, raw_inode)                             \
+    do {                                                                          \
+        (raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);                  \
+        if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime##_extra))          \
+            (raw_inode)->xtime##_extra = ext4_encode_extra_time(&(inode)->xtime); \
+    } while (0)
+#define EXT4_EINODE_SET_XTIME(xtime, einode, raw_inode)                            \
+    do {                                                                           \
+        if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))                          \
+            (raw_inode)->xtime = cpu_to_le32((einode)->xtime.tv_sec);              \
+        if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime##_extra))                  \
+            (raw_inode)->xtime##_extra = ext4_encode_extra_time(&(einode)->xtime); \
+    } while (0)
+#define EXT4_INODE_GET_XTIME(xtime, inode, raw_inode)                            \
+    do {                                                                         \
+        (inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);         \
+        if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime##_extra))         \
+            ext4_decode_extra_time(&(inode)->xtime, (raw_inode)->xtime##_extra); \
+    } while (0)
+
+#define EXT4_EINODE_GET_XTIME(xtime, einode, raw_inode)                           \
+    do {                                                                          \
+        if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))                         \
+            (einode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);     \
+        if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime##_extra))                 \
+            ext4_decode_extra_time(&(einode)->xtime, (raw_inode)->xtime##_extra); \
+    } while (0)
 #define i_disk_version osd1.linux1.l_i_version
 
 #define i_reserved1 osd1.linux1.l_i_reserved1
@@ -319,48 +352,48 @@ struct move_extent {
 #define i_gid_high osd2.linux2.l_i_gid_high
 #define i_reserved2 osd2.linux2.l_i_reserved2
 
-#define EXT4_VALID_FS 0x0001  
-#define EXT4_ERROR_FS 0x0002  
-#define EXT4_ORPHAN_FS 0x0004  
-
-#define EXT2_FLAGS_SIGNED_HASH 0x0001  
-#define EXT2_FLAGS_UNSIGNED_HASH 0x0002  
-#define EXT2_FLAGS_TEST_FILESYS 0x0004  
-
-#define EXT4_MOUNT_OLDALLOC 0x00002  
-#define EXT4_MOUNT_GRPID 0x00004  
-#define EXT4_MOUNT_DEBUG 0x00008  
-#define EXT4_MOUNT_ERRORS_CONT 0x00010  
-#define EXT4_MOUNT_ERRORS_RO 0x00020  
-#define EXT4_MOUNT_ERRORS_PANIC 0x00040  
-#define EXT4_MOUNT_MINIX_DF 0x00080  
-#define EXT4_MOUNT_NOLOAD 0x00100  
-#define EXT4_MOUNT_DATA_FLAGS 0x00C00  
-#define EXT4_MOUNT_JOURNAL_DATA 0x00400  
-#define EXT4_MOUNT_ORDERED_DATA 0x00800  
-#define EXT4_MOUNT_WRITEBACK_DATA 0x00C00  
-#define EXT4_MOUNT_UPDATE_JOURNAL 0x01000  
-#define EXT4_MOUNT_NO_UID32 0x02000  
-#define EXT4_MOUNT_XATTR_USER 0x04000  
-#define EXT4_MOUNT_POSIX_ACL 0x08000  
-#define EXT4_MOUNT_NO_AUTO_DA_ALLOC 0x10000  
-#define EXT4_MOUNT_BARRIER 0x20000  
-#define EXT4_MOUNT_NOBH 0x40000  
-#define EXT4_MOUNT_QUOTA 0x80000  
-#define EXT4_MOUNT_USRQUOTA 0x100000  
-#define EXT4_MOUNT_GRPQUOTA 0x200000  
-#define EXT4_MOUNT_DIOREAD_NOLOCK 0x400000  
-#define EXT4_MOUNT_JOURNAL_CHECKSUM 0x800000  
-#define EXT4_MOUNT_JOURNAL_ASYNC_COMMIT 0x1000000  
-#define EXT4_MOUNT_I_VERSION 0x2000000  
-#define EXT4_MOUNT_DELALLOC 0x8000000  
-#define EXT4_MOUNT_DATA_ERR_ABORT 0x10000000  
-#define EXT4_MOUNT_BLOCK_VALIDITY 0x20000000  
-#define EXT4_MOUNT_DISCARD 0x40000000  
+#define EXT4_VALID_FS 0x0001
+#define EXT4_ERROR_FS 0x0002
+#define EXT4_ORPHAN_FS 0x0004
+
+#define EXT2_FLAGS_SIGNED_HASH 0x0001
+#define EXT2_FLAGS_UNSIGNED_HASH 0x0002
+#define EXT2_FLAGS_TEST_FILESYS 0x0004
+
+#define EXT4_MOUNT_OLDALLOC 0x00002
+#define EXT4_MOUNT_GRPID 0x00004
+#define EXT4_MOUNT_DEBUG 0x00008
+#define EXT4_MOUNT_ERRORS_CONT 0x00010
+#define EXT4_MOUNT_ERRORS_RO 0x00020
+#define EXT4_MOUNT_ERRORS_PANIC 0x00040
+#define EXT4_MOUNT_MINIX_DF 0x00080
+#define EXT4_MOUNT_NOLOAD 0x00100
+#define EXT4_MOUNT_DATA_FLAGS 0x00C00
+#define EXT4_MOUNT_JOURNAL_DATA 0x00400
+#define EXT4_MOUNT_ORDERED_DATA 0x00800
+#define EXT4_MOUNT_WRITEBACK_DATA 0x00C00
+#define EXT4_MOUNT_UPDATE_JOURNAL 0x01000
+#define EXT4_MOUNT_NO_UID32 0x02000
+#define EXT4_MOUNT_XATTR_USER 0x04000
+#define EXT4_MOUNT_POSIX_ACL 0x08000
+#define EXT4_MOUNT_NO_AUTO_DA_ALLOC 0x10000
+#define EXT4_MOUNT_BARRIER 0x20000
+#define EXT4_MOUNT_NOBH 0x40000
+#define EXT4_MOUNT_QUOTA 0x80000
+#define EXT4_MOUNT_USRQUOTA 0x100000
+#define EXT4_MOUNT_GRPQUOTA 0x200000
+#define EXT4_MOUNT_DIOREAD_NOLOCK 0x400000
+#define EXT4_MOUNT_JOURNAL_CHECKSUM 0x800000
+#define EXT4_MOUNT_JOURNAL_ASYNC_COMMIT 0x1000000
+#define EXT4_MOUNT_I_VERSION 0x2000000
+#define EXT4_MOUNT_DELALLOC 0x8000000
+#define EXT4_MOUNT_DATA_ERR_ABORT 0x10000000
+#define EXT4_MOUNT_BLOCK_VALIDITY 0x20000000
+#define EXT4_MOUNT_DISCARD 0x40000000
 
 #define clear_opt(o, opt) o &= ~EXT4_MOUNT_##opt
 #define set_opt(o, opt) o |= EXT4_MOUNT_##opt
-#define test_opt(sb, opt) (EXT4_SB(sb)->s_mount_opt &   EXT4_MOUNT_##opt)
+#define test_opt(sb, opt) (EXT4_SB(sb)->s_mount_opt & EXT4_MOUNT_##opt)
 
 #define ext4_set_bit ext2_set_bit
 #define ext4_set_bit_atomic ext2_set_bit_atomic
@@ -371,84 +404,84 @@ struct move_extent {
 #define ext4_find_next_zero_bit ext2_find_next_zero_bit
 #define ext4_find_next_bit ext2_find_next_bit
 
-#define EXT4_DFL_MAX_MNT_COUNT 20  
-#define EXT4_DFL_CHECKINTERVAL 0  
+#define EXT4_DFL_MAX_MNT_COUNT 20
+#define EXT4_DFL_CHECKINTERVAL 0
 
-#define EXT4_ERRORS_CONTINUE 1  
-#define EXT4_ERRORS_RO 2  
-#define EXT4_ERRORS_PANIC 3  
+#define EXT4_ERRORS_CONTINUE 1
+#define EXT4_ERRORS_RO 2
+#define EXT4_ERRORS_PANIC 3
 #define EXT4_ERRORS_DEFAULT EXT4_ERRORS_CONTINUE
 
 struct ext4_super_block {
-  __le32 s_inodes_count;
- __le32 s_blocks_count_lo;
- __le32 s_r_blocks_count_lo;
- __le32 s_free_blocks_count_lo;
-  __le32 s_free_inodes_count;
- __le32 s_first_data_block;
- __le32 s_log_block_size;
- __le32 s_obso_log_frag_size;
-  __le32 s_blocks_per_group;
- __le32 s_obso_frags_per_group;
- __le32 s_inodes_per_group;
- __le32 s_mtime;
-  __le32 s_wtime;
- __le16 s_mnt_count;
- __le16 s_max_mnt_count;
- __le16 s_magic;
- __le16 s_state;
- __le16 s_errors;
- __le16 s_minor_rev_level;
-  __le32 s_lastcheck;
- __le32 s_checkinterval;
- __le32 s_creator_os;
- __le32 s_rev_level;
-  __le16 s_def_resuid;
- __le16 s_def_resgid;
-
- __le32 s_first_ino;
- __le16 s_inode_size;
- __le16 s_block_group_nr;
- __le32 s_feature_compat;
-  __le32 s_feature_incompat;
- __le32 s_feature_ro_compat;
-  __u8 s_uuid[16];
-  char s_volume_name[16];
-  char s_last_mounted[64];
-  __le32 s_algorithm_usage_bitmap;
-
- __u8 s_prealloc_blocks;
- __u8 s_prealloc_dir_blocks;
- __le16 s_reserved_gdt_blocks;
-
-  __u8 s_journal_uuid[16];
-  __le32 s_journal_inum;
- __le32 s_journal_dev;
- __le32 s_last_orphan;
- __le32 s_hash_seed[4];
- __u8 s_def_hash_version;
- __u8 s_reserved_char_pad;
- __le16 s_desc_size;
-  __le32 s_default_mount_opts;
- __le32 s_first_meta_bg;
- __le32 s_mkfs_time;
- __le32 s_jnl_blocks[17];
-
-  __le32 s_blocks_count_hi;
- __le32 s_r_blocks_count_hi;
- __le32 s_free_blocks_count_hi;
- __le16 s_min_extra_isize;
- __le16 s_want_extra_isize;
- __le32 s_flags;
- __le16 s_raid_stride;
- __le16 s_mmp_interval;
- __le64 s_mmp_block;
- __le32 s_raid_stripe_width;
- __u8 s_log_groups_per_flex;
- __u8 s_reserved_char_pad2;
- __le16 s_reserved_pad;
- __le64 s_kbytes_written;
- __u32 s_reserved[160];
+    __le32 s_inodes_count;
+    __le32 s_blocks_count_lo;
+    __le32 s_r_blocks_count_lo;
+    __le32 s_free_blocks_count_lo;
+    __le32 s_free_inodes_count;
+    __le32 s_first_data_block;
+    __le32 s_log_block_size;
+    __le32 s_obso_log_frag_size;
+    __le32 s_blocks_per_group;
+    __le32 s_obso_frags_per_group;
+    __le32 s_inodes_per_group;
+    __le32 s_mtime;
+    __le32 s_wtime;
+    __le16 s_mnt_count;
+    __le16 s_max_mnt_count;
+    __le16 s_magic;
+    __le16 s_state;
+    __le16 s_errors;
+    __le16 s_minor_rev_level;
+    __le32 s_lastcheck;
+    __le32 s_checkinterval;
+    __le32 s_creator_os;
+    __le32 s_rev_level;
+    __le16 s_def_resuid;
+    __le16 s_def_resgid;
+
+    __le32 s_first_ino;
+    __le16 s_inode_size;
+    __le16 s_block_group_nr;
+    __le32 s_feature_compat;
+    __le32 s_feature_incompat;
+    __le32 s_feature_ro_compat;
+    __u8 s_uuid[16];
+    char s_volume_name[16];
+    char s_last_mounted[64];
+    __le32 s_algorithm_usage_bitmap;
+
+    __u8 s_prealloc_blocks;
+    __u8 s_prealloc_dir_blocks;
+    __le16 s_reserved_gdt_blocks;
+
+    __u8 s_journal_uuid[16];
+    __le32 s_journal_inum;
+    __le32 s_journal_dev;
+    __le32 s_last_orphan;
+    __le32 s_hash_seed[4];
+    __u8 s_def_hash_version;
+    __u8 s_reserved_char_pad;
+    __le16 s_desc_size;
+    __le32 s_default_mount_opts;
+    __le32 s_first_meta_bg;
+    __le32 s_mkfs_time;
+    __le32 s_jnl_blocks[17];
+
+    __le32 s_blocks_count_hi;
+    __le32 s_r_blocks_count_hi;
+    __le32 s_free_blocks_count_hi;
+    __le16 s_min_extra_isize;
+    __le16 s_want_extra_isize;
+    __le32 s_flags;
+    __le16 s_raid_stride;
+    __le16 s_mmp_interval;
+    __le64 s_mmp_block;
+    __le32 s_raid_stripe_width;
+    __u8 s_log_groups_per_flex;
+    __u8 s_reserved_char_pad2;
+    __le16 s_reserved_pad;
+    __le64 s_kbytes_written;
+    __u32 s_reserved[160];
 };
 
 #define EXT4_SB(sb) (sb)
@@ -461,23 +494,31 @@ struct ext4_super_block {
 #define EXT4_OS_FREEBSD 3
 #define EXT4_OS_LITES 4
 
-#define EXT4_GOOD_OLD_REV 0  
-#define EXT4_DYNAMIC_REV 1  
+#define EXT4_GOOD_OLD_REV 0
+#define EXT4_DYNAMIC_REV 1
 
 #define EXT4_CURRENT_REV EXT4_GOOD_OLD_REV
 #define EXT4_MAX_SUPP_REV EXT4_DYNAMIC_REV
 
 #define EXT4_GOOD_OLD_INODE_SIZE 128
 
-#define EXT4_HAS_COMPAT_FEATURE(sb,mask)   ((EXT4_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask)) != 0)
-#define EXT4_HAS_RO_COMPAT_FEATURE(sb,mask)   ((EXT4_SB(sb)->s_es->s_feature_ro_compat & cpu_to_le32(mask)) != 0)
-#define EXT4_HAS_INCOMPAT_FEATURE(sb,mask)   ((EXT4_SB(sb)->s_es->s_feature_incompat & cpu_to_le32(mask)) != 0)
-#define EXT4_SET_COMPAT_FEATURE(sb,mask)   EXT4_SB(sb)->s_es->s_feature_compat |= cpu_to_le32(mask)
-#define EXT4_SET_RO_COMPAT_FEATURE(sb,mask)   EXT4_SB(sb)->s_es->s_feature_ro_compat |= cpu_to_le32(mask)
-#define EXT4_SET_INCOMPAT_FEATURE(sb,mask)   EXT4_SB(sb)->s_es->s_feature_incompat |= cpu_to_le32(mask)
-#define EXT4_CLEAR_COMPAT_FEATURE(sb,mask)   EXT4_SB(sb)->s_es->s_feature_compat &= ~cpu_to_le32(mask)
-#define EXT4_CLEAR_RO_COMPAT_FEATURE(sb,mask)   EXT4_SB(sb)->s_es->s_feature_ro_compat &= ~cpu_to_le32(mask)
-#define EXT4_CLEAR_INCOMPAT_FEATURE(sb,mask)   EXT4_SB(sb)->s_es->s_feature_incompat &= ~cpu_to_le32(mask)
+#define EXT4_HAS_COMPAT_FEATURE(sb, mask) \
+    ((EXT4_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask)) != 0)
+#define EXT4_HAS_RO_COMPAT_FEATURE(sb, mask) \
+    ((EXT4_SB(sb)->s_es->s_feature_ro_compat & cpu_to_le32(mask)) != 0)
+#define EXT4_HAS_INCOMPAT_FEATURE(sb, mask) \
+    ((EXT4_SB(sb)->s_es->s_feature_incompat & cpu_to_le32(mask)) != 0)
+#define EXT4_SET_COMPAT_FEATURE(sb, mask) EXT4_SB(sb)->s_es->s_feature_compat |= cpu_to_le32(mask)
+#define EXT4_SET_RO_COMPAT_FEATURE(sb, mask) \
+    EXT4_SB(sb)->s_es->s_feature_ro_compat |= cpu_to_le32(mask)
+#define EXT4_SET_INCOMPAT_FEATURE(sb, mask) \
+    EXT4_SB(sb)->s_es->s_feature_incompat |= cpu_to_le32(mask)
+#define EXT4_CLEAR_COMPAT_FEATURE(sb, mask) \
+    EXT4_SB(sb)->s_es->s_feature_compat &= ~cpu_to_le32(mask)
+#define EXT4_CLEAR_RO_COMPAT_FEATURE(sb, mask) \
+    EXT4_SB(sb)->s_es->s_feature_ro_compat &= ~cpu_to_le32(mask)
+#define EXT4_CLEAR_INCOMPAT_FEATURE(sb, mask) \
+    EXT4_SB(sb)->s_es->s_feature_incompat &= ~cpu_to_le32(mask)
 
 #define EXT4_FEATURE_COMPAT_DIR_PREALLOC 0x0001
 #define EXT4_FEATURE_COMPAT_IMAGIC_INODES 0x0002
@@ -502,21 +543,28 @@ struct ext4_super_block {
 
 #define EXT4_FEATURE_INCOMPAT_COMPRESSION 0x0001
 #define EXT4_FEATURE_INCOMPAT_FILETYPE 0x0002
-#define EXT4_FEATURE_INCOMPAT_RECOVER 0x0004  
-#define EXT4_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008  
+#define EXT4_FEATURE_INCOMPAT_RECOVER 0x0004
+#define EXT4_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008
 #define EXT4_FEATURE_INCOMPAT_META_BG 0x0010
-#define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040  
+#define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040
 #define EXT4_FEATURE_INCOMPAT_64BIT 0x0080
 #define EXT4_FEATURE_INCOMPAT_MMP 0x0100
 #define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200
-#define EXT4_FEATURE_INCOMPAT_EA_INODE 0x0400  
-#define EXT4_FEATURE_INCOMPAT_DIRDATA 0x1000  
+#define EXT4_FEATURE_INCOMPAT_EA_INODE 0x0400
+#define EXT4_FEATURE_INCOMPAT_DIRDATA 0x1000
 #define EXT4_FEATURE_INCOMPAT_ENCRYPT 0x10000
 #define EXT4_FEATURE_INCOMPAT_CASEFOLD 0x20000
 
 #define EXT4_FEATURE_COMPAT_SUPP EXT2_FEATURE_COMPAT_EXT_ATTR
-#define EXT4_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE|   EXT4_FEATURE_INCOMPAT_RECOVER|   EXT4_FEATURE_INCOMPAT_META_BG|   EXT4_FEATURE_INCOMPAT_EXTENTS|   EXT4_FEATURE_INCOMPAT_64BIT|   EXT4_FEATURE_INCOMPAT_FLEX_BG)
-#define EXT4_FEATURE_RO_COMPAT_SUPP (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER|   EXT4_FEATURE_RO_COMPAT_LARGE_FILE|   EXT4_FEATURE_RO_COMPAT_GDT_CSUM|   EXT4_FEATURE_RO_COMPAT_DIR_NLINK |   EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE |   EXT4_FEATURE_RO_COMPAT_BTREE_DIR |  EXT4_FEATURE_RO_COMPAT_HUGE_FILE)
+#define EXT4_FEATURE_INCOMPAT_SUPP                                                                 \
+    (EXT4_FEATURE_INCOMPAT_FILETYPE | EXT4_FEATURE_INCOMPAT_RECOVER |                              \
+     EXT4_FEATURE_INCOMPAT_META_BG | EXT4_FEATURE_INCOMPAT_EXTENTS | EXT4_FEATURE_INCOMPAT_64BIT | \
+     EXT4_FEATURE_INCOMPAT_FLEX_BG)
+#define EXT4_FEATURE_RO_COMPAT_SUPP                                            \
+    (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER | EXT4_FEATURE_RO_COMPAT_LARGE_FILE | \
+     EXT4_FEATURE_RO_COMPAT_GDT_CSUM | EXT4_FEATURE_RO_COMPAT_DIR_NLINK |      \
+     EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE | EXT4_FEATURE_RO_COMPAT_BTREE_DIR |   \
+     EXT4_FEATURE_RO_COMPAT_HUGE_FILE)
 
 #define EXT4_DEF_RESUID 0
 #define EXT4_DEF_RESGID 0
@@ -534,25 +582,25 @@ struct ext4_super_block {
 #define EXT4_DEFM_JMODE_WBACK 0x0060
 
 #define EXT4_DEF_MIN_BATCH_TIME 0
-#define EXT4_DEF_MAX_BATCH_TIME 15000  
+#define EXT4_DEF_MAX_BATCH_TIME 15000
 
 #define EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME 4
 
 #define EXT4_NAME_LEN 255
 
 struct ext4_dir_entry {
- __le32 inode;
- __le16 rec_len;
- __le16 name_len;
- char name[EXT4_NAME_LEN];
+    __le32 inode;
+    __le16 rec_len;
+    __le16 name_len;
+    char name[EXT4_NAME_LEN];
 };
 
 struct ext4_dir_entry_2 {
- __le32 inode;
- __le16 rec_len;
- __u8 name_len;
- __u8 file_type;
- char name[EXT4_NAME_LEN];
+    __le32 inode;
+    __le16 rec_len;
+    __u8 name_len;
+    __u8 file_type;
+    char name[EXT4_NAME_LEN];
 };
 
 #define EXT4_FT_UNKNOWN 0
@@ -568,10 +616,12 @@ struct ext4_dir_entry_2 {
 
 #define EXT4_DIR_PAD 4
 #define EXT4_DIR_ROUND (EXT4_DIR_PAD - 1)
-#define EXT4_DIR_REC_LEN(name_len) (((name_len) + 8 + EXT4_DIR_ROUND) &   ~EXT4_DIR_ROUND)
-#define EXT4_MAX_REC_LEN ((1<<16)-1)
+#define EXT4_DIR_REC_LEN(name_len) (((name_len) + 8 + EXT4_DIR_ROUND) & ~EXT4_DIR_ROUND)
+#define EXT4_MAX_REC_LEN ((1 << 16) - 1)
 
-#define is_dx(dir) (EXT4_HAS_COMPAT_FEATURE((dir)->i_sb,   EXT4_FEATURE_COMPAT_DIR_INDEX) &&   (EXT4_I(dir)->i_flags & EXT4_INDEX_FL))
+#define is_dx(dir)                                                          \
+    (EXT4_HAS_COMPAT_FEATURE((dir)->i_sb, EXT4_FEATURE_COMPAT_DIR_INDEX) && \
+     (EXT4_I(dir)->i_flags & EXT4_INDEX_FL))
 #define EXT4_DIR_LINK_MAX(dir) (!is_dx(dir) && (dir)->i_nlink >= EXT4_LINK_MAX)
 #define EXT4_DIR_LINK_EMPTY(dir) ((dir)->i_nlink == 2 || (dir)->i_nlink == 1)
 
@@ -583,4 +633,3 @@ struct ext4_dir_entry_2 {
 #define DX_HASH_TEA_UNSIGNED 5
 
 #endif
-
diff --git a/ext4_utils/include/ext4_utils/ext4_extents.h b/ext4_utils/include/ext4_utils/ext4_extents.h
index 68fc4a45..e69b017b 100644
--- a/ext4_utils/include/ext4_utils/ext4_extents.h
+++ b/ext4_utils/include/ext4_utils/ext4_extents.h
@@ -30,36 +30,36 @@
 #define EXT_STATS_
 
 struct ext4_extent {
- __le32 ee_block;
- __le16 ee_len;
- __le16 ee_start_hi;
- __le32 ee_start_lo;
+    __le32 ee_block;
+    __le16 ee_len;
+    __le16 ee_start_hi;
+    __le32 ee_start_lo;
 };
 
 struct ext4_extent_idx {
- __le32 ei_block;
- __le32 ei_leaf_lo;
- __le16 ei_leaf_hi;
- __u16 ei_unused;
+    __le32 ei_block;
+    __le32 ei_leaf_lo;
+    __le16 ei_leaf_hi;
+    __u16 ei_unused;
 };
 
 struct ext4_extent_header {
- __le16 eh_magic;
- __le16 eh_entries;
- __le16 eh_max;
- __le16 eh_depth;
- __le32 eh_generation;
+    __le16 eh_magic;
+    __le16 eh_entries;
+    __le16 eh_max;
+    __le16 eh_depth;
+    __le32 eh_generation;
 };
 
 #define EXT4_EXT_MAGIC 0xf30a
 
 struct ext4_ext_path {
- ext4_fsblk_t p_block;
- __u16 p_depth;
- struct ext4_extent *p_ext;
- struct ext4_extent_idx *p_idx;
- struct ext4_extent_header *p_hdr;
- struct buffer_head *p_bh;
+    ext4_fsblk_t p_block;
+    __u16 p_depth;
+    struct ext4_extent* p_ext;
+    struct ext4_extent_idx* p_idx;
+    struct ext4_extent_header* p_hdr;
+    struct buffer_head* p_bh;
 };
 
 #define EXT4_EXT_CACHE_NO 0
@@ -75,14 +75,17 @@ struct ext4_ext_path {
 #define EXT_INIT_MAX_LEN (1UL << 15)
 #define EXT_UNINIT_MAX_LEN (EXT_INIT_MAX_LEN - 1)
 
-#define EXT_FIRST_EXTENT(__hdr__)   ((struct ext4_extent *) (((char *) (__hdr__)) +   sizeof(struct ext4_extent_header)))
-#define EXT_FIRST_INDEX(__hdr__)   ((struct ext4_extent_idx *) (((char *) (__hdr__)) +   sizeof(struct ext4_extent_header)))
-#define EXT_HAS_FREE_INDEX(__path__)   (le16_to_cpu((__path__)->p_hdr->eh_entries)   < le16_to_cpu((__path__)->p_hdr->eh_max))
-#define EXT_LAST_EXTENT(__hdr__)   (EXT_FIRST_EXTENT((__hdr__)) + le16_to_cpu((__hdr__)->eh_entries) - 1)
-#define EXT_LAST_INDEX(__hdr__)   (EXT_FIRST_INDEX((__hdr__)) + le16_to_cpu((__hdr__)->eh_entries) - 1)
-#define EXT_MAX_EXTENT(__hdr__)   (EXT_FIRST_EXTENT((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1)
-#define EXT_MAX_INDEX(__hdr__)   (EXT_FIRST_INDEX((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1)
+#define EXT_FIRST_EXTENT(__hdr__) \
+    ((struct ext4_extent*)(((char*)(__hdr__)) + sizeof(struct ext4_extent_header)))
+#define EXT_FIRST_INDEX(__hdr__) \
+    ((struct ext4_extent_idx*)(((char*)(__hdr__)) + sizeof(struct ext4_extent_header)))
+#define EXT_HAS_FREE_INDEX(__path__) \
+    (le16_to_cpu((__path__)->p_hdr->eh_entries) < le16_to_cpu((__path__)->p_hdr->eh_max))
+#define EXT_LAST_EXTENT(__hdr__) \
+    (EXT_FIRST_EXTENT((__hdr__)) + le16_to_cpu((__hdr__)->eh_entries) - 1)
+#define EXT_LAST_INDEX(__hdr__) \
+    (EXT_FIRST_INDEX((__hdr__)) + le16_to_cpu((__hdr__)->eh_entries) - 1)
+#define EXT_MAX_EXTENT(__hdr__) (EXT_FIRST_EXTENT((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1)
+#define EXT_MAX_INDEX(__hdr__) (EXT_FIRST_INDEX((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1)
 
 #endif
-
-
diff --git a/ext4_utils/include/ext4_utils/ext4_sb.h b/ext4_utils/include/ext4_utils/ext4_sb.h
index 3b53dbe4..81d8e73a 100644
--- a/ext4_utils/include/ext4_utils/ext4_sb.h
+++ b/ext4_utils/include/ext4_utils/ext4_sb.h
@@ -28,28 +28,28 @@ extern "C" {
 #include <stdbool.h>
 
 struct fs_info {
-	int64_t len;	/* If set to 0, ask the block device for the size,
-			 * if less than 0, reserve that much space at the
-			 * end of the partition, else use the size given. */
-	uint32_t block_size;
-	uint32_t blocks_per_group;
-	uint32_t flash_erase_block_size;
-	uint32_t flash_logical_block_size;
-	uint32_t inodes_per_group;
-	uint32_t inode_size;
-	uint32_t inodes;
-	uint32_t journal_blocks;
-	uint32_t feat_ro_compat;
-	uint32_t feat_compat;
-	uint32_t feat_incompat;
-	uint32_t bg_desc_reserve_blocks;
-	uint16_t bg_desc_size;
-	const char *label;
-	uint8_t no_journal;
-	bool block_device;	/* target fd is a block device? */
+    int64_t len; /* If set to 0, ask the block device for the size,
+                  * if less than 0, reserve that much space at the
+                  * end of the partition, else use the size given. */
+    uint32_t block_size;
+    uint32_t blocks_per_group;
+    uint32_t flash_erase_block_size;
+    uint32_t flash_logical_block_size;
+    uint32_t inodes_per_group;
+    uint32_t inode_size;
+    uint32_t inodes;
+    uint32_t journal_blocks;
+    uint32_t feat_ro_compat;
+    uint32_t feat_compat;
+    uint32_t feat_incompat;
+    uint32_t bg_desc_reserve_blocks;
+    uint16_t bg_desc_size;
+    const char* label;
+    uint8_t no_journal;
+    bool block_device; /* target fd is a block device? */
 };
 
-int ext4_parse_sb(struct ext4_super_block *sb, struct fs_info *info);
+int ext4_parse_sb(struct ext4_super_block* sb, struct fs_info* info);
 
 #ifdef __cplusplus
 }
diff --git a/ext4_utils/include/ext4_utils/ext4_utils.h b/ext4_utils/include/ext4_utils/ext4_utils.h
index 2c2485f7..48f3ee78 100644
--- a/ext4_utils/include/ext4_utils/ext4_utils.h
+++ b/ext4_utils/include/ext4_utils/ext4_utils.h
@@ -29,14 +29,14 @@ extern "C" {
 #include <sys/types.h>
 #include <unistd.h>
 
-#include <sys/types.h>
 #include <errno.h>
+#include <setjmp.h>
 #include <stdarg.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <setjmp.h>
-#include <stdint.h>
+#include <sys/types.h>
 
 #if defined(__APPLE__) && defined(__MACH__)
 #define lseek64 lseek
@@ -57,8 +57,8 @@ extern int force;
 #endif
 #endif
 
-#define DIV_ROUND_UP(x, y) (((x) + (y) - 1)/(y))
-#define EXT4_ALIGN(x, y) ((y) * DIV_ROUND_UP((x), (y)))
+#define DIV_ROUND_UP(x, y) (((x) + (y)-1) / (y))
+#define EXT4_ALIGN(x, y) ((y)*DIV_ROUND_UP((x), (y)))
 
 /* XXX */
 #define cpu_to_le32(x) (x)
@@ -85,32 +85,32 @@ struct block_group_info;
 struct xattr_list_element;
 
 struct ext2_group_desc {
-	u64 bg_block_bitmap;
-	u64 bg_inode_bitmap;
-	u64 bg_inode_table;
-	u32 bg_free_blocks_count;
-	u32 bg_free_inodes_count;
-	u32 bg_used_dirs_count;
-	u16 bg_flags;
+    u64 bg_block_bitmap;
+    u64 bg_inode_bitmap;
+    u64 bg_inode_table;
+    u32 bg_free_blocks_count;
+    u32 bg_free_inodes_count;
+    u32 bg_used_dirs_count;
+    u16 bg_flags;
 };
 
 struct fs_aux_info {
-	struct ext4_super_block *sb;
-	struct ext4_super_block *sb_block;
-	struct ext4_super_block *sb_zero;
-	struct ext4_super_block **backup_sb;
-	struct ext2_group_desc *bg_desc;
-	struct block_group_info *bgs;
-	struct xattr_list_element *xattrs;
-	u32 first_data_block;
-	u64 len_blocks;
-	u32 inode_table_blocks;
-	u32 groups;
-	u32 bg_desc_blocks;
-	u32 default_i_flags;
-	u64 blocks_per_ind;
-	u64 blocks_per_dind;
-	u64 blocks_per_tind;
+    struct ext4_super_block* sb;
+    struct ext4_super_block* sb_block;
+    struct ext4_super_block* sb_zero;
+    struct ext4_super_block** backup_sb;
+    struct ext2_group_desc* bg_desc;
+    struct block_group_info* bgs;
+    struct xattr_list_element* xattrs;
+    u32 first_data_block;
+    u64 len_blocks;
+    u32 inode_table_blocks;
+    u32 groups;
+    u32 bg_desc_blocks;
+    u32 default_i_flags;
+    u64 blocks_per_ind;
+    u64 blocks_per_dind;
+    u64 blocks_per_tind;
 };
 
 extern struct fs_info info;
@@ -118,12 +118,12 @@ extern struct fs_aux_info aux_info;
 
 extern jmp_buf setjmp_env;
 
-int bitmap_get_bit(u8 *bitmap, u32 bit);	// vold
-u64 get_block_device_size(int fd);		// recovery
-int is_block_device_fd(int fd);			// wipe.c
-u64 get_file_size(int fd);			// fs_mgr
+int bitmap_get_bit(u8* bitmap, u32 bit);  // vold
+u64 get_block_device_size(int fd);        // recovery
+int is_block_device_fd(int fd);           // wipe.c
+u64 get_file_size(int fd);                // fs_mgr
 int ext4_bg_has_super_block(int bg);
-int read_ext(int fd, int verbose);		// vold
+int read_ext(int fd, int verbose);  // vold
 
 #ifdef __cplusplus
 }
diff --git a/ext4_utils/include/ext4_utils/jbd2.h b/ext4_utils/include/ext4_utils/jbd2.h
index bac58c2e..6b7b161c 100644
--- a/ext4_utils/include/ext4_utils/jbd2.h
+++ b/ext4_utils/include/ext4_utils/jbd2.h
@@ -21,11 +21,11 @@
 
 #define JBD2_DEFAULT_MAX_COMMIT_AGE 5
 
-#define jbd_debug(f, a...)  
+#define jbd_debug(f, a...)
 
 #define JBD2_MIN_JOURNAL_BLOCKS 1024
 
-#define JBD2_MAGIC_NUMBER 0xc03b3998U  
+#define JBD2_MAGIC_NUMBER 0xc03b3998U
 
 #define JBD2_DESCRIPTOR_BLOCK 1
 #define JBD2_COMMIT_BLOCK 2
@@ -33,11 +33,10 @@
 #define JBD2_SUPERBLOCK_V2 4
 #define JBD2_REVOKE_BLOCK 5
 
-typedef struct journal_header_s
-{
- __be32 h_magic;
- __be32 h_blocktype;
- __be32 h_sequence;
+typedef struct journal_header_s {
+    __be32 h_magic;
+    __be32 h_blocktype;
+    __be32 h_sequence;
 } journal_header_t;
 
 #define JBD2_CRC32_CHKSUM 1
@@ -49,74 +48,73 @@ typedef struct journal_header_s
 #define JBD2_CHECKSUM_BYTES (32 / sizeof(__u32))
 
 struct commit_header {
- __be32 h_magic;
- __be32 h_blocktype;
- __be32 h_sequence;
- unsigned char h_chksum_type;
- unsigned char h_chksum_size;
- unsigned char h_padding[2];
- __be32 h_chksum[JBD2_CHECKSUM_BYTES];
- __be64 h_commit_sec;
- __be32 h_commit_nsec;
+    __be32 h_magic;
+    __be32 h_blocktype;
+    __be32 h_sequence;
+    unsigned char h_chksum_type;
+    unsigned char h_chksum_size;
+    unsigned char h_padding[2];
+    __be32 h_chksum[JBD2_CHECKSUM_BYTES];
+    __be64 h_commit_sec;
+    __be32 h_commit_nsec;
 };
 
-typedef struct journal_block_tag_s
-{
- __be32 t_blocknr;
- __be32 t_flags;
- __be32 t_blocknr_high;
+typedef struct journal_block_tag_s {
+    __be32 t_blocknr;
+    __be32 t_flags;
+    __be32 t_blocknr_high;
 } journal_block_tag_t;
 
 #define JBD2_TAG_SIZE32 (offsetof(journal_block_tag_t, t_blocknr_high))
 #define JBD2_TAG_SIZE64 (sizeof(journal_block_tag_t))
 
-typedef struct jbd2_journal_revoke_header_s
-{
- journal_header_t r_header;
- __be32 r_count;
+typedef struct jbd2_journal_revoke_header_s {
+    journal_header_t r_header;
+    __be32 r_count;
 } jbd2_journal_revoke_header_t;
 
-#define JBD2_FLAG_ESCAPE 1  
-#define JBD2_FLAG_SAME_UUID 2  
-#define JBD2_FLAG_DELETED 4  
-#define JBD2_FLAG_LAST_TAG 8  
+#define JBD2_FLAG_ESCAPE 1
+#define JBD2_FLAG_SAME_UUID 2
+#define JBD2_FLAG_DELETED 4
+#define JBD2_FLAG_LAST_TAG 8
 
-typedef struct journal_superblock_s
-{
+typedef struct journal_superblock_s {
+    journal_header_t s_header;
 
- journal_header_t s_header;
+    __be32 s_blocksize;
+    __be32 s_maxlen;
+    __be32 s_first;
 
- __be32 s_blocksize;
- __be32 s_maxlen;
- __be32 s_first;
+    __be32 s_sequence;
+    __be32 s_start;
 
- __be32 s_sequence;
- __be32 s_start;
+    __be32 s_errno;
 
- __be32 s_errno;
+    __be32 s_feature_compat;
+    __be32 s_feature_incompat;
+    __be32 s_feature_ro_compat;
 
- __be32 s_feature_compat;
- __be32 s_feature_incompat;
- __be32 s_feature_ro_compat;
+    __u8 s_uuid[16];
 
- __u8 s_uuid[16];
+    __be32 s_nr_users;
 
- __be32 s_nr_users;
+    __be32 s_dynsuper;
 
- __be32 s_dynsuper;
+    __be32 s_max_transaction;
+    __be32 s_max_trans_data;
 
- __be32 s_max_transaction;
- __be32 s_max_trans_data;
+    __u32 s_padding[44];
 
- __u32 s_padding[44];
-
- __u8 s_users[16*48];
+    __u8 s_users[16 * 48];
 
 } journal_superblock_t;
 
-#define JBD2_HAS_COMPAT_FEATURE(j,mask)   ((j)->j_format_version >= 2 &&   ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
-#define JBD2_HAS_RO_COMPAT_FEATURE(j,mask)   ((j)->j_format_version >= 2 &&   ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
-#define JBD2_HAS_INCOMPAT_FEATURE(j,mask)   ((j)->j_format_version >= 2 &&   ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
+#define JBD2_HAS_COMPAT_FEATURE(j, mask) \
+    ((j)->j_format_version >= 2 && ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
+#define JBD2_HAS_RO_COMPAT_FEATURE(j, mask) \
+    ((j)->j_format_version >= 2 && ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
+#define JBD2_HAS_INCOMPAT_FEATURE(j, mask) \
+    ((j)->j_format_version >= 2 && ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
 
 #define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001
 
@@ -126,16 +124,17 @@ typedef struct journal_superblock_s
 
 #define JBD2_KNOWN_COMPAT_FEATURES JBD2_FEATURE_COMPAT_CHECKSUM
 #define JBD2_KNOWN_ROCOMPAT_FEATURES 0
-#define JBD2_KNOWN_INCOMPAT_FEATURES (JBD2_FEATURE_INCOMPAT_REVOKE |   JBD2_FEATURE_INCOMPAT_64BIT |   JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)
-
-#define BJ_None 0  
-#define BJ_Metadata 1  
-#define BJ_Forget 2  
-#define BJ_IO 3  
-#define BJ_Shadow 4  
-#define BJ_LogCtl 5  
-#define BJ_Reserved 6  
+#define JBD2_KNOWN_INCOMPAT_FEATURES                              \
+    (JBD2_FEATURE_INCOMPAT_REVOKE | JBD2_FEATURE_INCOMPAT_64BIT | \
+     JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)
+
+#define BJ_None 0
+#define BJ_Metadata 1
+#define BJ_Forget 2
+#define BJ_IO 3
+#define BJ_Shadow 4
+#define BJ_LogCtl 5
+#define BJ_Reserved 6
 #define BJ_Types 7
 
 #endif
-
diff --git a/ext4_utils/include/ext4_utils/wipe.h b/ext4_utils/include/ext4_utils/wipe.h
index d7d089e7..09c32955 100644
--- a/ext4_utils/include/ext4_utils/wipe.h
+++ b/ext4_utils/include/ext4_utils/wipe.h
@@ -27,9 +27,9 @@ extern "C" {
  * wiping of block devices. 0 otherwise. For now, only Linux does.
  */
 #ifdef __linux__
-#  define WIPE_IS_SUPPORTED 1
+#define WIPE_IS_SUPPORTED 1
 #else
-#  define WIPE_IS_SUPPORTED 0
+#define WIPE_IS_SUPPORTED 0
 #endif
 
 int wipe_block_device(int fd, s64 len);
diff --git a/ext4_utils/include/ext4_utils/xattr.h b/ext4_utils/include/ext4_utils/xattr.h
index 0f323fdc..4251c288 100644
--- a/ext4_utils/include/ext4_utils/xattr.h
+++ b/ext4_utils/include/ext4_utils/xattr.h
@@ -7,16 +7,16 @@
 #define EXT4_XATTR_INDEX_SECURITY 6
 
 struct ext4_xattr_header {
-    __le32  h_magic;
-    __le32  h_refcount;
-    __le32  h_blocks;
-    __le32  h_hash;
-    __le32  h_checksum;
-    __u32   h_reserved[3];
+    __le32 h_magic;
+    __le32 h_refcount;
+    __le32 h_blocks;
+    __le32 h_hash;
+    __le32 h_checksum;
+    __u32 h_reserved[3];
 };
 
 struct ext4_xattr_ibody_header {
-    __le32  h_magic;
+    __le32 h_magic;
 };
 
 struct ext4_xattr_entry {
@@ -30,16 +30,13 @@ struct ext4_xattr_entry {
 };
 
 #define EXT4_XATTR_PAD_BITS 2
-#define EXT4_XATTR_PAD (1<<EXT4_XATTR_PAD_BITS)
-#define EXT4_XATTR_ROUND (EXT4_XATTR_PAD-1)
+#define EXT4_XATTR_PAD (1 << EXT4_XATTR_PAD_BITS)
+#define EXT4_XATTR_ROUND (EXT4_XATTR_PAD - 1)
 #define EXT4_XATTR_LEN(name_len) \
-    (((name_len) + EXT4_XATTR_ROUND + \
-    sizeof(struct ext4_xattr_entry)) & ~EXT4_XATTR_ROUND)
+    (((name_len) + EXT4_XATTR_ROUND + sizeof(struct ext4_xattr_entry)) & ~EXT4_XATTR_ROUND)
 #define EXT4_XATTR_NEXT(entry) \
-    ((struct ext4_xattr_entry *)( \
-     (char *)(entry) + EXT4_XATTR_LEN((entry)->e_name_len)))
-#define EXT4_XATTR_SIZE(size) \
-    (((size) + EXT4_XATTR_ROUND) & ~EXT4_XATTR_ROUND)
-#define IS_LAST_ENTRY(entry) (*(uint32_t *)(entry) == 0)
+    ((struct ext4_xattr_entry*)((char*)(entry) + EXT4_XATTR_LEN((entry)->e_name_len)))
+#define EXT4_XATTR_SIZE(size) (((size) + EXT4_XATTR_ROUND) & ~EXT4_XATTR_ROUND)
+#define IS_LAST_ENTRY(entry) (*(uint32_t*)(entry) == 0)
 
 #endif /* !_SYSTEM_EXTRAS_EXT4_UTILS_XATTR_H */
diff --git a/ext4_utils/wipe.cpp b/ext4_utils/wipe.cpp
index 8b7a66bd..445c9739 100644
--- a/ext4_utils/wipe.cpp
+++ b/ext4_utils/wipe.cpp
@@ -30,59 +30,57 @@
 #include "helpers.h"
 
 #ifndef BLKDISCARD
-#define BLKDISCARD _IO(0x12,119)
+#define BLKDISCARD _IO(0x12, 119)
 #endif
 
 #ifndef BLKSECDISCARD
-#define BLKSECDISCARD _IO(0x12,125)
+#define BLKSECDISCARD _IO(0x12, 125)
 #endif
 
-int wipe_block_device(int fd, s64 len)
-{
-	u64 range[2];
-	int ret;
-
-	if (!is_block_device_fd(fd)) {
-		// Wiping only makes sense on a block device.
-		return 0;
-	}
-
-	range[0] = 0;
-	range[1] = len;
-	ret = ioctl(fd, BLKSECDISCARD, &range);
-	if (ret < 0) {
-		range[0] = 0;
-		range[1] = len;
-		ret = ioctl(fd, BLKDISCARD, &range);
-		if (ret < 0) {
-			warn("Discard failed\n");
-			return 1;
-		} else {
-			char buf[4096] = {0};
-
-			if (!android::base::WriteFully(fd, buf, 4096)) {
-				warn("Writing zeros failed\n");
-				return 1;
-			}
-			fsync(fd);
-			warn("Wipe via secure discard failed, used discard instead\n");
-			return 0;
-		}
-	}
-
-	return 0;
+int wipe_block_device(int fd, s64 len) {
+    u64 range[2];
+    int ret;
+
+    if (!is_block_device_fd(fd)) {
+        // Wiping only makes sense on a block device.
+        return 0;
+    }
+
+    range[0] = 0;
+    range[1] = len;
+    ret = ioctl(fd, BLKSECDISCARD, &range);
+    if (ret < 0) {
+        range[0] = 0;
+        range[1] = len;
+        ret = ioctl(fd, BLKDISCARD, &range);
+        if (ret < 0) {
+            warn("Discard failed\n");
+            return 1;
+        } else {
+            char buf[4096] = {0};
+
+            if (!android::base::WriteFully(fd, buf, 4096)) {
+                warn("Writing zeros failed\n");
+                return 1;
+            }
+            fsync(fd);
+            warn("Wipe via secure discard failed, used discard instead\n");
+            return 0;
+        }
+    }
+
+    return 0;
 }
 
-#else  /* __linux__ */
+#else /* __linux__ */
 #error "Missing block device wiping implementation for this platform!"
 #endif
 
-#else  /* WIPE_IS_SUPPORTED */
+#else /* WIPE_IS_SUPPORTED */
 
-int wipe_block_device(int fd __attribute__((unused)), s64 len __attribute__((unused)))
-{
-	/* Wiping is not supported on this platform. */
-	return 1;
+int wipe_block_device(int fd __attribute__((unused)), s64 len __attribute__((unused))) {
+    /* Wiping is not supported on this platform. */
+    return 1;
 }
 
-#endif  /* WIPE_IS_SUPPORTED */
+#endif /* WIPE_IS_SUPPORTED */