f2fs: clean checkpatch warnings

Fixed a variety of trivial checkpatch warnings.  The only delta should
be some minor formatting on log strings that were split / too long.

Signed-off-by: Chris Fries <cfries@motorola.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index bda889e2ca632765b8d195d89bdd9ec510f3a8e9..f5fac16bc6e71f72a6fe7a75769af481058410dd 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -792,7 +792,7 @@ static int f2fs_write_data_page(struct page *page,
        int err = 0;
        struct f2fs_io_info fio = {
                .type = DATA,
-               .rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC: WRITE,
+               .rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : WRITE,
        };
 
        if (page->index < end_index)

diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index 6e4ac9a25dfdfe3ef6d3daa2282357aad3f47162..63cb7e215e007b73f2342d53faa65b2888f436a2 100644 (file)
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -245,7 +245,7 @@ static int stat_show(struct seq_file *s, void *v)
                seq_printf(s, "  - node blocks : %d\n", si->node_blks);
                seq_printf(s, "\nExtent Hit Ratio: %d / %d\n",
                           si->hit_ext, si->total_ext);
-               seq_printf(s, "\nBalancing F2FS Async:\n");
+               seq_puts(s, "\nBalancing F2FS Async:\n");
                seq_printf(s, "  - nodes: %4d in %4d\n",
                           si->ndirty_node, si->node_pages);
                seq_printf(s, "  - dents: %4d in dirs:%4d\n",

diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index f815ca0c5819f51107fb41da6123f61331b69754..cd055b6fcffed40bd1209d9f95c8b6df7f4b6afd 100644 (file)
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -430,7 +430,8 @@ next:
  * Caller should grab and release a rwsem by calling f2fs_lock_op() and
  * f2fs_unlock_op().
  */
-int __f2fs_add_link(struct inode *dir, const struct qstr *name, struct inode *inode)
+int __f2fs_add_link(struct inode *dir, const struct qstr *name,
+                                               struct inode *inode)
 {
        unsigned int bit_pos;
        unsigned int level;
@@ -631,7 +632,7 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx)
 
        bit_pos = ((unsigned long)ctx->pos % NR_DENTRY_IN_BLOCK);
 
-       for ( ; n < npages; n++) {
+       for (; n < npages; n++) {
                dentry_page = get_lock_data_page(inode, n);
                if (IS_ERR(dentry_page))
                        continue;

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index ee304fb71e1f39fc2b69c12c2b26b2a8be8049b6..5ab3981938d41679bbf9ca43f699675a56140d88 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -607,9 +607,9 @@ static inline int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
 static inline int F2FS_HAS_BLOCKS(struct inode *inode)
 {
        if (F2FS_I(inode)->i_xattr_nid)
-               return (inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1);
+               return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1;
        else
-               return (inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS);
+               return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS;
 }
 
 static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi,
@@ -1231,7 +1231,7 @@ struct f2fs_stat_info {
 
 static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)
 {
-       return (struct f2fs_stat_info*)sbi->stat_info;
+       return (struct f2fs_stat_info *)sbi->stat_info;
 }
 
 #define stat_inc_call_count(si)                ((si)->call_count++)

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 14511b00fffa1aa5760f9e3c7133b7a675a3a6c7..85e91ca88d5791835d25dffe6fc0932f9640203b 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -202,7 +202,7 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
        raw_node = F2FS_NODE(dn->node_page);
        addr = blkaddr_in_node(raw_node) + ofs;
 
-       for ( ; count > 0; count--, addr++, dn->ofs_in_node++) {
+       for (; count > 0; count--, addr++, dn->ofs_in_node++) {
                block_t blkaddr = le32_to_cpu(*addr);
                if (blkaddr == NULL_ADDR)
                        continue;

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index ffa4c6d0fab407f1235adcc66d4d18619be418f2..4d67ed736dca41ddda18c439a1bb5efdc7fc2bd8 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -42,9 +42,11 @@ static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
        if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
                        S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
                if (ri->i_addr[0])
-                       inode->i_rdev = old_decode_dev(le32_to_cpu(ri->i_addr[0]));
+                       inode->i_rdev =
+                               old_decode_dev(le32_to_cpu(ri->i_addr[0]));
                else
-                       inode->i_rdev = new_decode_dev(le32_to_cpu(ri->i_addr[1]));
+                       inode->i_rdev =
+                               new_decode_dev(le32_to_cpu(ri->i_addr[1]));
        }
 }
 
@@ -52,11 +54,13 @@ static void __set_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
 {
        if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
                if (old_valid_dev(inode->i_rdev)) {
-                       ri->i_addr[0] = cpu_to_le32(old_encode_dev(inode->i_rdev));
+                       ri->i_addr[0] =
+                               cpu_to_le32(old_encode_dev(inode->i_rdev));
                        ri->i_addr[1] = 0;
                } else {
                        ri->i_addr[0] = 0;
-                       ri->i_addr[1] = cpu_to_le32(new_encode_dev(inode->i_rdev));
+                       ri->i_addr[1] =
+                               cpu_to_le32(new_encode_dev(inode->i_rdev));
                        ri->i_addr[2] = 0;
                }
        }

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index b8c9301db52ce66977644e4cbd54ed52cba582c5..226a05a27e3350292e70799c34acc21c5b41dba8 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1196,7 +1196,7 @@ static int f2fs_write_node_page(struct page *page,
        struct node_info ni;
        struct f2fs_io_info fio = {
                .type = NODE,
-               .rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC: WRITE,
+               .rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : WRITE,
        };
 
        if (unlikely(sbi->por_doing))

diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index 655791e518cf3c5facb1513472822a6e6e666d70..976a7a934db5ddf8ba7843f28cc8e1311c86a632 100644 (file)
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -95,9 +95,9 @@ out_unmap_put:
        kunmap(page);
        f2fs_put_page(page, 0);
 out:
-       f2fs_msg(inode->i_sb, KERN_NOTICE, "recover_inode and its dentry: "
-                       "ino = %x, name = %s, dir = %lx, err = %d",
-                       ino_of_node(ipage), raw_inode->i_name,
+       f2fs_msg(inode->i_sb, KERN_NOTICE,
+                       "%s: ino = %x, name = %s, dir = %lx, err = %d",
+                       __func__, ino_of_node(ipage), raw_inode->i_name,
                        IS_ERR(dir) ? 0 : dir->i_ino, err);
        return err;
 }
@@ -366,9 +366,9 @@ err:
        f2fs_put_dnode(&dn);
        f2fs_unlock_op(sbi);
 out:
-       f2fs_msg(sbi->sb, KERN_NOTICE, "recover_data: ino = %lx, "
-                       "recovered_data = %d blocks, err = %d",
-                       inode->i_ino, recovered, err);
+       f2fs_msg(sbi->sb, KERN_NOTICE,
+               "recover_data: ino = %lx, recovered = %d blocks, err = %d",
+               inode->i_ino, recovered, err);
        return err;
 }
 

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index a934e6f2738b67de7962f48535974a848396d9b3..e82423fbcb9d9d05594679e6c72f5eca2475720d 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -946,7 +946,8 @@ void write_data_page(struct page *page, struct dnode_of_data *dn,
        do_write_page(sbi, page, dn->data_blkaddr, new_blkaddr, &sum, fio);
 }
 
-void rewrite_data_page(struct page *page, block_t old_blkaddr, struct f2fs_io_info *fio)
+void rewrite_data_page(struct page *page, block_t old_blkaddr,
+                                       struct f2fs_io_info *fio)
 {
        struct inode *inode = page->mapping->host;
        struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
@@ -1647,7 +1648,8 @@ static void build_sit_entries(struct f2fs_sb_info *sbi)
 
                        mutex_lock(&curseg->curseg_mutex);
                        for (i = 0; i < sits_in_cursum(sum); i++) {
-                               if (le32_to_cpu(segno_in_journal(sum, i)) == start) {
+                               if (le32_to_cpu(segno_in_journal(sum, i))
+                                                               == start) {
                                        sit = sit_in_journal(sum, i);
                                        mutex_unlock(&curseg->curseg_mutex);
                                        goto got_it;

diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index e9a10bdd7fed7c4bdd46b01fb25ec6de1bb10041..5731682d7516aaefccefd96f0c70798f478d0c5c 100644 (file)
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -448,8 +448,8 @@ static inline int reserved_sections(struct f2fs_sb_info *sbi)
 
 static inline bool need_SSR(struct f2fs_sb_info *sbi)
 {
-       return ((prefree_segments(sbi) / sbi->segs_per_sec)
-                       + free_sections(sbi) < overprovision_sections(sbi));
+       return (prefree_segments(sbi) / sbi->segs_per_sec)
+                       + free_sections(sbi) < overprovision_sections(sbi);
 }
 
 static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi, int freed)
@@ -460,18 +460,19 @@ static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi, int freed)
        if (unlikely(sbi->por_doing))
                return false;
 
-       return ((free_sections(sbi) + freed) <= (node_secs + 2 * dent_secs +
-                                               reserved_sections(sbi)));
+       return (free_sections(sbi) + freed) <= (node_secs + 2 * dent_secs +
+                                               reserved_sections(sbi));
 }
 
 static inline bool excess_prefree_segs(struct f2fs_sb_info *sbi)
 {
-       return (prefree_segments(sbi) > SM_I(sbi)->rec_prefree_segments);
+       return prefree_segments(sbi) > SM_I(sbi)->rec_prefree_segments;
 }
 
 static inline int utilization(struct f2fs_sb_info *sbi)
 {
-       return div_u64((u64)valid_user_blocks(sbi) * 100, sbi->user_block_count);
+       return div_u64((u64)valid_user_blocks(sbi) * 100,
+                                       sbi->user_block_count);
 }
 
 /*

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index b070f3010ce9200fdf78c8d92710eeb5efcd6a2a..1a85f83abd53262f9f1e7c5b71cb38919e85ab22 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -535,7 +535,8 @@ static int segment_info_seq_show(struct seq_file *seq, void *offset)
 {
        struct super_block *sb = seq->private;
        struct f2fs_sb_info *sbi = F2FS_SB(sb);
-       unsigned int total_segs = le32_to_cpu(sbi->raw_super->segment_count_main);
+       unsigned int total_segs =
+                       le32_to_cpu(sbi->raw_super->segment_count_main);
        int i;
 
        for (i = 0; i < total_segs; i++) {
@@ -816,8 +817,9 @@ retry:
        /* sanity checking of raw super */
        if (sanity_check_raw_super(sb, *raw_super)) {
                brelse(*raw_super_buf);
-               f2fs_msg(sb, KERN_ERR, "Can't find a valid F2FS filesystem "
-                               "in %dth superblock", block + 1);
+               f2fs_msg(sb, KERN_ERR,
+                       "Can't find valid F2FS filesystem in %dth superblock",
+                                                               block + 1);
                if (block == 0) {
                        block++;
                        goto retry;