f2fs_utils: format files

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

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

Test: mm
Bug: 171699326
Change-Id: I7b11cd2605b266a31cb10388a39f849711cf23c9

2 files changed, 116 insertions, 137 deletions

diff --git a/f2fs_utils/f2fs_sparseblock.c b/f2fs_utils/f2fs_sparseblock.c
index 0ec1f30c..e3292c98 100644
--- a/f2fs_utils/f2fs_sparseblock.c
+++ b/f2fs_utils/f2fs_sparseblock.c
@@ -16,24 +16,25 @@
 
 #include <log/log.h>
 
-#define D_DISP_u32(ptr, member)           \
-  do {                \
-    SLOGD("%-30s" "\t\t[0x%#08x : %u]\n",    \
-      #member, le32_to_cpu((ptr)->member), le32_to_cpu((ptr)->member) );  \
-  } while (0);
+#define D_DISP_u32(ptr, member)                                                 \
+    do {                                                                        \
+        SLOGD("%-30s"                                                           \
+              "\t\t[0x%#08x : %u]\n",                                           \
+              #member, le32_to_cpu((ptr)->member), le32_to_cpu((ptr)->member)); \
+    } while (0);
 
-#define D_DISP_u64(ptr, member)           \
-  do {                \
-    SLOGD("%-30s" "\t\t[0x%#016llx : %llu]\n",    \
-      #member, le64_to_cpu((ptr)->member), le64_to_cpu((ptr)->member) );  \
-  } while (0);
+#define D_DISP_u64(ptr, member)                                                 \
+    do {                                                                        \
+        SLOGD("%-30s"                                                           \
+              "\t\t[0x%#016llx : %llu]\n",                                      \
+              #member, le64_to_cpu((ptr)->member), le64_to_cpu((ptr)->member)); \
+    } while (0);
 
-#define segno_in_journal(jnl, i)    ((jnl)->sit_j.entries[i].segno)
+#define segno_in_journal(jnl, i) ((jnl)->sit_j.entries[i].segno)
 
-#define sit_in_journal(jnl, i)      ((jnl)->sit_j.entries[i].se)
+#define sit_in_journal(jnl, i) ((jnl)->sit_j.entries[i].se)
 
-static void dbg_print_raw_sb_info(struct f2fs_super_block *sb)
-{
+static void dbg_print_raw_sb_info(struct f2fs_super_block* sb) {
     SLOGD("\n");
     SLOGD("+--------------------------------------------------------+\n");
     SLOGD("| Super block                                            |\n");
@@ -74,8 +75,7 @@ static void dbg_print_raw_sb_info(struct f2fs_super_block *sb)
     D_DISP_u32(sb, cp_payload);
     SLOGD("\n");
 }
-static void dbg_print_raw_ckpt_struct(struct f2fs_checkpoint *cp)
-{
+static void dbg_print_raw_ckpt_struct(struct f2fs_checkpoint* cp) {
     SLOGD("\n");
     SLOGD("+--------------------------------------------------------+\n");
     SLOGD("| Checkpoint                                             |\n");
@@ -99,7 +99,6 @@ static void dbg_print_raw_ckpt_struct(struct f2fs_checkpoint *cp)
     D_DISP_u32(cp, cur_node_blkoff[1]);
     D_DISP_u32(cp, cur_node_blkoff[2]);
 
-
     D_DISP_u32(cp, alloc_type[CURSEG_HOT_DATA]);
     D_DISP_u32(cp, alloc_type[CURSEG_WARM_DATA]);
     D_DISP_u32(cp, alloc_type[CURSEG_COLD_DATA]);
@@ -126,8 +125,7 @@ static void dbg_print_raw_ckpt_struct(struct f2fs_checkpoint *cp)
     SLOGD("\n\n");
 }
 
-static void dbg_print_info_struct(struct f2fs_info *info)
-{
+static void dbg_print_info_struct(struct f2fs_info* info) {
     SLOGD("\n");
     SLOGD("+--------------------------------------------------------+\n");
     SLOGD("| F2FS_INFO                                              |\n");
@@ -141,7 +139,7 @@ static void dbg_print_info_struct(struct f2fs_info *info)
     SLOGD("sit_sums loc: %p", info->sit_sums);
     SLOGD("sit_sums num: %d", le16_to_cpu(info->sit_sums->journal.n_sits));
     unsigned int i;
-    for(i = 0; i < (le16_to_cpu(info->sit_sums->journal.n_sits)); i++) {
+    for (i = 0; i < (le16_to_cpu(info->sit_sums->journal.n_sits)); i++) {
         SLOGD("entry %d in journal entries is for segment %d", i,
               le32_to_cpu(segno_in_journal(&info->sit_sums->journal, i)));
     }
@@ -157,10 +155,8 @@ static void dbg_print_info_struct(struct f2fs_info *info)
     SLOGD("\n\n");
 }
 
-
 /* read blocks */
-static int read_structure(int fd, unsigned long long start, void *buf, ssize_t len)
-{
+static int read_structure(int fd, unsigned long long start, void* buf, ssize_t len) {
     off64_t ret;
 
     ret = lseek64(fd, start, SEEK_SET);
@@ -181,53 +177,46 @@ static int read_structure(int fd, unsigned long long start, void *buf, ssize_t l
     return 0;
 }
 
-static int read_structure_blk(int fd, unsigned long long start_blk, void *buf, size_t len)
-{
-    return read_structure(fd, F2FS_BLKSIZE*start_blk, buf, F2FS_BLKSIZE * len);
+static int read_structure_blk(int fd, unsigned long long start_blk, void* buf, size_t len) {
+    return read_structure(fd, F2FS_BLKSIZE * start_blk, buf, F2FS_BLKSIZE * len);
 }
 
-static int read_f2fs_sb(int fd, struct f2fs_super_block *sb)
-{
+static int read_f2fs_sb(int fd, struct f2fs_super_block* sb) {
     int rc;
     rc = read_structure(fd, F2FS_SUPER_OFFSET, sb, sizeof(*sb));
     if (le32_to_cpu(sb->magic) != F2FS_SUPER_MAGIC) {
-        SLOGE("Not a valid F2FS super block. Magic:%#08x != %#08x",
-                                  le32_to_cpu(sb->magic), F2FS_SUPER_MAGIC);
+        SLOGE("Not a valid F2FS super block. Magic:%#08x != %#08x", le32_to_cpu(sb->magic),
+              F2FS_SUPER_MAGIC);
         return -1;
     }
     return 0;
 }
 
-unsigned int get_f2fs_filesystem_size_sec(char *dev)
-{
+unsigned int get_f2fs_filesystem_size_sec(char* dev) {
     int fd;
     if ((fd = open(dev, O_RDONLY)) < 0) {
         SLOGE("Cannot open device to get filesystem size ");
         return 0;
     }
     struct f2fs_super_block sb;
-    if(read_f2fs_sb(fd, &sb))
-        return 0;
-    return (unsigned int)(le64_to_cpu(sb.block_count)*F2FS_BLKSIZE/DEFAULT_SECTOR_SIZE);
+    if (read_f2fs_sb(fd, &sb)) return 0;
+    return (unsigned int)(le64_to_cpu(sb.block_count) * F2FS_BLKSIZE / DEFAULT_SECTOR_SIZE);
 }
 
-static struct f2fs_checkpoint *validate_checkpoint(block_t cp_addr,
-                                                   unsigned long long *version, int fd)
-{
+static struct f2fs_checkpoint* validate_checkpoint(block_t cp_addr, unsigned long long* version,
+                                                   int fd) {
     unsigned char *cp_block_1, *cp_block_2;
-    struct f2fs_checkpoint *cp_block;
+    struct f2fs_checkpoint* cp_block;
     uint64_t cp1_version = 0, cp2_version = 0;
 
     cp_block_1 = malloc(F2FS_BLKSIZE);
-    if (!cp_block_1)
-        return NULL;
+    if (!cp_block_1) return NULL;
 
     /* Read the 1st cp block in this CP pack */
-    if (read_structure_blk(fd, cp_addr, cp_block_1, 1))
-        goto invalid_cp1;
+    if (read_structure_blk(fd, cp_addr, cp_block_1, 1)) goto invalid_cp1;
 
     /* get the version number */
-    cp_block = (struct f2fs_checkpoint *)cp_block_1;
+    cp_block = (struct f2fs_checkpoint*)cp_block_1;
 
     cp1_version = le64_to_cpu(cp_block->checkpoint_ver);
 
@@ -241,14 +230,14 @@ static struct f2fs_checkpoint *validate_checkpoint(block_t cp_addr,
         goto invalid_cp2;
     }
 
-    cp_block = (struct f2fs_checkpoint *)cp_block_2;
+    cp_block = (struct f2fs_checkpoint*)cp_block_2;
 
     cp2_version = le64_to_cpu(cp_block->checkpoint_ver);
 
     if (cp2_version == cp1_version) {
         *version = cp2_version;
         free(cp_block_2);
-        return (struct f2fs_checkpoint *)cp_block_1;
+        return (struct f2fs_checkpoint*)cp_block_1;
     }
 
     /* There must be something wrong with this checkpoint */
@@ -259,8 +248,8 @@ invalid_cp1:
     return NULL;
 }
 
-int get_valid_checkpoint_info(int fd, struct f2fs_super_block *sb, struct f2fs_checkpoint **cp,  struct f2fs_info *info)
-{
+int get_valid_checkpoint_info(int fd, struct f2fs_super_block* sb, struct f2fs_checkpoint** cp,
+                              struct f2fs_info* info) {
     struct f2fs_checkpoint *cp1, *cp2, *cur_cp;
     unsigned long blk_size;
     unsigned long long cp1_version = 0, cp2_version = 0;
@@ -308,26 +297,25 @@ fail_no_cp:
     return -EINVAL;
 }
 
-static int gather_sit_info(int fd, struct f2fs_info *info)
-{
-    uint64_t num_segments = (info->total_blocks - info->main_blkaddr
-            + info->blocks_per_segment - 1) / info->blocks_per_segment;
+static int gather_sit_info(int fd, struct f2fs_info* info) {
+    uint64_t num_segments =
+            (info->total_blocks - info->main_blkaddr + info->blocks_per_segment - 1) /
+            info->blocks_per_segment;
     uint64_t num_sit_blocks = (num_segments + SIT_ENTRY_PER_BLOCK - 1) / SIT_ENTRY_PER_BLOCK;
     uint64_t sit_block;
 
     info->sit_blocks = malloc(num_sit_blocks * sizeof(struct f2fs_sit_block));
-    if (!info->sit_blocks)
-        return -1;
+    if (!info->sit_blocks) return -1;
 
-    for(sit_block = 0; sit_block<num_sit_blocks; sit_block++) {
+    for (sit_block = 0; sit_block < num_sit_blocks; sit_block++) {
         off64_t address = info->sit_blkaddr + sit_block;
 
-        if (f2fs_test_bit(sit_block, info->sit_bmp))
-            address += info->blocks_per_sit;
+        if (f2fs_test_bit(sit_block, info->sit_bmp)) address += info->blocks_per_sit;
 
-        SLOGD("Reading cache block starting at block %"PRIu64, address);
-        if (read_structure(fd, address * F2FS_BLKSIZE, &info->sit_blocks[sit_block], sizeof(struct f2fs_sit_block))) {
-            SLOGE("Could not read sit block at block %"PRIu64, address);
+        SLOGD("Reading cache block starting at block %" PRIu64, address);
+        if (read_structure(fd, address * F2FS_BLKSIZE, &info->sit_blocks[sit_block],
+                           sizeof(struct f2fs_sit_block))) {
+            SLOGE("Could not read sit block at block %" PRIu64, address);
             free(info->sit_blocks);
             info->sit_blocks = NULL;
             return -1;
@@ -336,29 +324,27 @@ static int gather_sit_info(int fd, struct f2fs_info *info)
     return 0;
 }
 
-static inline int is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
-{
+static inline int is_set_ckpt_flags(struct f2fs_checkpoint* cp, unsigned int f) {
     unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
     return !!(ckpt_flags & f);
 }
 
-static inline uint64_t sum_blk_addr(struct f2fs_checkpoint *cp, struct f2fs_info *info, int base, int type)
-{
-    return info->cp_valid_cp_blkaddr + le32_to_cpu(cp->cp_pack_total_block_count)
-                - (base + 1) + type;
+static inline uint64_t sum_blk_addr(struct f2fs_checkpoint* cp, struct f2fs_info* info, int base,
+                                    int type) {
+    return info->cp_valid_cp_blkaddr + le32_to_cpu(cp->cp_pack_total_block_count) - (base + 1) +
+           type;
 }
 
-static int get_sit_summary(int fd, struct f2fs_info *info, struct f2fs_checkpoint *cp)
-{
+static int get_sit_summary(int fd, struct f2fs_info* info, struct f2fs_checkpoint* cp) {
     char buffer[F2FS_BLKSIZE];
 
     info->sit_sums = calloc(1, sizeof(struct f2fs_summary_block));
-    if (!info->sit_sums)
-        return -1;
+    if (!info->sit_sums) return -1;
 
     /* CURSEG_COLD_DATA where the journaled SIT entries are. */
     if (is_set_ckpt_flags(cp, CP_COMPACT_SUM_FLAG)) {
-        if (read_structure_blk(fd, info->cp_valid_cp_blkaddr + le32_to_cpu(cp->cp_pack_start_sum), buffer, 1))
+        if (read_structure_blk(fd, info->cp_valid_cp_blkaddr + le32_to_cpu(cp->cp_pack_start_sum),
+                               buffer, 1))
             return -1;
         memcpy(&info->sit_sums->journal.n_sits, &buffer[SUM_JOURNAL_SIZE], SUM_JOURNAL_SIZE);
     } else {
@@ -368,19 +354,17 @@ static int get_sit_summary(int fd, struct f2fs_info *info, struct f2fs_checkpoin
         else
             blk_addr = sum_blk_addr(cp, info, NR_CURSEG_DATA_TYPE, CURSEG_COLD_DATA);
 
-        if (read_structure_blk(fd, blk_addr, buffer, 1))
-            return -1;
+        if (read_structure_blk(fd, blk_addr, buffer, 1)) return -1;
 
         memcpy(info->sit_sums, buffer, sizeof(struct f2fs_summary_block));
     }
     return 0;
 }
 
-struct f2fs_info *generate_f2fs_info(int fd)
-{
-    struct f2fs_super_block *sb = NULL;
-    struct f2fs_checkpoint *cp = NULL;
-    struct f2fs_info *info;
+struct f2fs_info* generate_f2fs_info(int fd) {
+    struct f2fs_super_block* sb = NULL;
+    struct f2fs_checkpoint* cp = NULL;
+    struct f2fs_info* info;
 
     info = calloc(1, sizeof(*info));
     if (!info) {
@@ -389,7 +373,7 @@ struct f2fs_info *generate_f2fs_info(int fd)
     }
 
     sb = malloc(sizeof(*sb));
-    if(!sb) {
+    if (!sb) {
         SLOGE("Out of memory!");
         free(info);
         return NULL;
@@ -409,11 +393,11 @@ struct f2fs_info *generate_f2fs_info(int fd)
     info->main_blkaddr = le32_to_cpu(sb->main_blkaddr);
     info->block_size = F2FS_BLKSIZE;
     info->total_blocks = sb->block_count;
-    info->blocks_per_sit = (le32_to_cpu(sb->segment_count_sit) >> 1) << le32_to_cpu(sb->log_blocks_per_seg);
+    info->blocks_per_sit = (le32_to_cpu(sb->segment_count_sit) >> 1)
+                           << le32_to_cpu(sb->log_blocks_per_seg);
     info->blocks_per_segment = 1U << le32_to_cpu(sb->log_blocks_per_seg);
 
-    if (get_valid_checkpoint_info(fd, sb, &cp, info))
-        goto error;
+    if (get_valid_checkpoint_info(fd, sb, &cp, info)) goto error;
     dbg_print_raw_ckpt_struct(cp);
 
     info->total_user_used = le32_to_cpu(cp->valid_block_count);
@@ -422,20 +406,21 @@ struct f2fs_info *generate_f2fs_info(int fd)
 
     /* get sit validity bitmap */
     info->sit_bmp = malloc(bmp_size);
-    if(!info->sit_bmp) {
+    if (!info->sit_bmp) {
         SLOGE("Out of memory!");
         goto error;
     }
 
     info->sit_bmp_size = bmp_size;
-    if (read_structure(fd, info->cp_valid_cp_blkaddr * F2FS_BLKSIZE
-                   + offsetof(struct f2fs_checkpoint, sit_nat_version_bitmap),
-                   info->sit_bmp, bmp_size)) {
+    if (read_structure(fd,
+                       info->cp_valid_cp_blkaddr * F2FS_BLKSIZE +
+                               offsetof(struct f2fs_checkpoint, sit_nat_version_bitmap),
+                       info->sit_bmp, bmp_size)) {
         SLOGE("Error getting SIT validity bitmap");
         goto error;
     }
 
-    if (gather_sit_info(fd , info)) {
+    if (gather_sit_info(fd, info)) {
         SLOGE("Error getting SIT information");
         goto error;
     }
@@ -452,8 +437,7 @@ error:
     return NULL;
 }
 
-void free_f2fs_info(struct f2fs_info *info)
-{
+void free_f2fs_info(struct f2fs_info* info) {
     if (info) {
         free(info->sit_blocks);
         info->sit_blocks = NULL;
@@ -467,23 +451,22 @@ void free_f2fs_info(struct f2fs_info *info)
     free(info);
 }
 
-uint64_t get_num_blocks_used(struct f2fs_info *info)
-{
+uint64_t get_num_blocks_used(struct f2fs_info* info) {
     return info->main_blkaddr + info->total_user_used;
 }
 
-int f2fs_test_bit(unsigned int nr, const char *p)
-{
+int f2fs_test_bit(unsigned int nr, const char* p) {
     int mask;
-    char *addr = (char *)p;
+    char* addr = (char*)p;
 
     addr += (nr >> 3);
     mask = 1 << (7 - (nr & 0x07));
     return (mask & *addr) != 0;
 }
 
-int run_on_used_blocks(uint64_t startblock, struct f2fs_info *info, int (*func)(uint64_t pos, void *data), void *data) {
-    struct f2fs_sit_entry * sit_entry;
+int run_on_used_blocks(uint64_t startblock, struct f2fs_info* info,
+                       int (*func)(uint64_t pos, void* data), void* data) {
+    struct f2fs_sit_entry* sit_entry;
     uint64_t sit_block_num_cur = 0, segnum = 0, block_offset;
     uint64_t block;
     unsigned int used, found, i;
@@ -498,11 +481,11 @@ int run_on_used_blocks(uint64_t startblock, struct f2fs_info *info, int (*func)(
             }
         } else {
             /* Main Section */
-            segnum = (block - info->main_blkaddr)/info->blocks_per_segment;
+            segnum = (block - info->main_blkaddr) / info->blocks_per_segment;
 
             /* check the SIT entries in the journal */
             found = 0;
-            for(i = 0; i < le16_to_cpu(info->sit_sums->journal.n_sits); i++) {
+            for (i = 0; i < le16_to_cpu(info->sit_sums->journal.n_sits); i++) {
                 if (le32_to_cpu(segno_in_journal(&info->sit_sums->journal, i)) == segnum) {
                     sit_entry = &sit_in_journal(&info->sit_sums->journal, i);
                     found = 1;
@@ -513,7 +496,8 @@ int run_on_used_blocks(uint64_t startblock, struct f2fs_info *info, int (*func)(
             /* get SIT entry from SIT section */
             if (!found) {
                 sit_block_num_cur = segnum / SIT_ENTRY_PER_BLOCK;
-                sit_entry = &info->sit_blocks[sit_block_num_cur].entries[segnum % SIT_ENTRY_PER_BLOCK];
+                sit_entry =
+                        &info->sit_blocks[sit_block_num_cur].entries[segnum % SIT_ENTRY_PER_BLOCK];
             }
 
             block_offset = (block - info->main_blkaddr) % info->blocks_per_segment;
@@ -523,10 +507,9 @@ int run_on_used_blocks(uint64_t startblock, struct f2fs_info *info, int (*func)(
                 continue;
             }
 
-            used = f2fs_test_bit(block_offset, (char *)sit_entry->valid_map);
-            if(used)
-                if (func(block, data))
-                    return -1;
+            used = f2fs_test_bit(block_offset, (char*)sit_entry->valid_map);
+            if (used)
+                if (func(block, data)) return -1;
         }
 
         block++;
@@ -534,27 +517,24 @@ int run_on_used_blocks(uint64_t startblock, struct f2fs_info *info, int (*func)(
     return 0;
 }
 
-struct privdata
-{
+struct privdata {
     int count;
     int infd;
     int outfd;
     char* buf;
-    char *zbuf;
+    char* zbuf;
     int done;
-    struct f2fs_info *info;
+    struct f2fs_info* info;
 };
 
-
 /*
  * This is a simple test program. It performs a block to block copy of a
  * filesystem, replacing blocks identified as unused with 0's.
  */
 
-int copy_used(uint64_t pos, void *data)
-{
-    struct privdata *d = data;
-    char *buf;
+int copy_used(uint64_t pos, void* data) {
+    struct privdata* d = data;
+    char* buf;
     int pdone = (pos * 100) / d->info->total_blocks;
     if (pdone > d->done) {
         d->done = pdone;
@@ -563,7 +543,7 @@ int copy_used(uint64_t pos, void *data)
 
     d->count++;
     buf = d->buf;
-    if(read_structure_blk(d->infd, (unsigned long long)pos, d->buf, 1)) {
+    if (read_structure_blk(d->infd, (unsigned long long)pos, d->buf, 1)) {
         printf("Error reading!!!\n");
         return -1;
     }
@@ -587,19 +567,17 @@ int copy_used(uint64_t pos, void *data)
     return 0;
 }
 
-int main(int argc, char **argv)
-{
-    if (argc != 3)
-        printf("Usage: %s fs_file_in fs_file_out\n", argv[0]);
-    char *in = argv[1];
-    char *out = argv[2];
+int main(int argc, char** argv) {
+    if (argc != 3) printf("Usage: %s fs_file_in fs_file_out\n", argv[0]);
+    char* in = argv[1];
+    char* out = argv[2];
     int infd, outfd;
 
     if ((infd = open(in, O_RDONLY)) < 0) {
         SLOGE("Cannot open device");
         return 0;
     }
-    if ((outfd = open(out, O_WRONLY|O_CREAT, S_IRUSR | S_IWUSR)) < 0) {
+    if ((outfd = open(out, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR)) < 0) {
         SLOGE("Cannot open output");
         return 0;
     }
@@ -608,13 +586,13 @@ int main(int argc, char **argv)
     d.infd = infd;
     d.outfd = outfd;
     d.count = 0;
-    struct f2fs_info *info = generate_f2fs_info(infd);
+    struct f2fs_info* info = generate_f2fs_info(infd);
     if (!info) {
         printf("Failed to generate info!");
         return -1;
     }
-    char *buf = malloc(F2FS_BLKSIZE);
-    char *zbuf = calloc(1, F2FS_BLKSIZE);
+    char* buf = malloc(F2FS_BLKSIZE);
+    char* zbuf = calloc(1, F2FS_BLKSIZE);
     d.buf = buf;
     d.zbuf = zbuf;
     d.done = 0;
diff --git a/f2fs_utils/f2fs_sparseblock.h b/f2fs_utils/f2fs_sparseblock.h
index e5c5f846..e047ed28 100644
--- a/f2fs_utils/f2fs_sparseblock.h
+++ b/f2fs_utils/f2fs_sparseblock.h
@@ -23,13 +23,13 @@
 extern "C" {
 #endif
 
-#define ver_after(a, b) (typecheck(unsigned long long, a) &&            \
-    typecheck(unsigned long long, b) &&                     \
-    ((long long)((a) - (b)) > 0))
+#define ver_after(a, b)                                                      \
+    (typecheck(unsigned long long, a) && typecheck(unsigned long long, b) && \
+     ((long long)((a) - (b)) > 0))
 
-#define ver_equal(a, b) (typecheck(unsigned long long, a) &&            \
-    typecheck(unsigned long long, b) &&                     \
-    ((long long)((a) - (b)) == 0))
+#define ver_equal(a, b)                                                      \
+    (typecheck(unsigned long long, a) && typecheck(unsigned long long, b) && \
+     ((long long)((a) - (b)) == 0))
 
 struct f2fs_sit_block;
 struct f2fs_summary_block;
@@ -38,11 +38,11 @@ struct f2fs_info {
     uint64_t blocks_per_segment;
     uint32_t block_size;
 
-    char *sit_bmp;
+    char* sit_bmp;
     uint32_t sit_bmp_size;
     uint64_t blocks_per_sit;
-    struct f2fs_sit_block *sit_blocks;
-    struct f2fs_summary_block *sit_sums;
+    struct f2fs_sit_block* sit_blocks;
+    struct f2fs_summary_block* sit_sums;
 
     uint64_t cp_blkaddr;
     uint64_t cp_valid_cp_blkaddr;
@@ -59,11 +59,12 @@ struct f2fs_info {
     uint64_t total_blocks;
 };
 
-uint64_t get_num_blocks_used(struct f2fs_info *info);
-struct f2fs_info *generate_f2fs_info(int fd);
-void free_f2fs_info(struct f2fs_info *info);
-unsigned int get_f2fs_filesystem_size_sec(char *dev);
-int run_on_used_blocks(uint64_t startblock, struct f2fs_info *info, int (*func)(uint64_t pos, void *data), void *data);
+uint64_t get_num_blocks_used(struct f2fs_info* info);
+struct f2fs_info* generate_f2fs_info(int fd);
+void free_f2fs_info(struct f2fs_info* info);
+unsigned int get_f2fs_filesystem_size_sec(char* dev);
+int run_on_used_blocks(uint64_t startblock, struct f2fs_info* info,
+                       int (*func)(uint64_t pos, void* data), void* data);
 
 #ifdef __cplusplus
 }