nilfs2: fix block comments
authorRyusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>
Mon, 23 May 2016 23:23:48 +0000 (16:23 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 24 May 2016 00:04:14 +0000 (17:04 -0700)
This fixes block comments with proper formatting to eliminate the
following checkpatch.pl warnings:

  "WARNING: Block comments use * on subsequent lines"
  "WARNING: Block comments use a trailing */ on a separate line"

Link: http://lkml.kernel.org/r/1462886671-3521-8-git-send-email-konishi.ryusuke@lab.ntt.co.jp
Signed-off-by: Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
fs/nilfs2/alloc.c
fs/nilfs2/bmap.h
fs/nilfs2/cpfile.c
fs/nilfs2/ifile.c
fs/nilfs2/inode.c
fs/nilfs2/nilfs.h
fs/nilfs2/recovery.c
fs/nilfs2/segment.c
fs/nilfs2/segment.h
fs/nilfs2/the_nilfs.c
include/linux/nilfs2_fs.h

index 698f582d69afa28360aad32584e3fe87a03de2d5..1a85d94f5b25f161fdcdef907d506d1c157a78bd 100644 (file)
@@ -68,13 +68,17 @@ int nilfs_palloc_init_blockgroup(struct inode *inode, unsigned int entry_size)
        mi->mi_blocks_per_group =
                DIV_ROUND_UP(nilfs_palloc_entries_per_group(inode),
                             mi->mi_entries_per_block) + 1;
-               /* Number of blocks in a group including entry blocks and
-                  a bitmap block */
+               /*
+                * Number of blocks in a group including entry blocks
+                * and a bitmap block
+                */
        mi->mi_blocks_per_desc_block =
                nilfs_palloc_groups_per_desc_block(inode) *
                mi->mi_blocks_per_group + 1;
-               /* Number of blocks per descriptor including the
-                  descriptor block */
+               /*
+                * Number of blocks per descriptor including the
+                * descriptor block
+                */
        return 0;
 }
 
index a6852807b22c73d017efe4f4d9c89a28a8c8acc9..b6a4c8f93ac8e0d092ffe7ac0a6461004b331fec 100644 (file)
@@ -122,10 +122,14 @@ struct nilfs_bmap {
 
 /* pointer type */
 #define NILFS_BMAP_PTR_P       0       /* physical block number (i.e. LBN) */
-#define NILFS_BMAP_PTR_VS      1       /* virtual block number (single
-                                          version) */
-#define NILFS_BMAP_PTR_VM      2       /* virtual block number (has multiple
-                                          versions) */
+#define NILFS_BMAP_PTR_VS      1       /*
+                                        * virtual block number (single
+                                        * version)
+                                        */
+#define NILFS_BMAP_PTR_VM      2       /*
+                                        * virtual block number (has multiple
+                                        * versions)
+                                        */
 #define NILFS_BMAP_PTR_U       (-1)    /* never perform pointer operations */
 
 #define NILFS_BMAP_USE_VBN(bmap)       ((bmap)->b_ptr_type > 0)
index b61c3e0eb342c6ff7ed846240b4571094433f2c9..8a3d3b65af3f4cee510486f33556ed8bf950d134 100644 (file)
@@ -870,8 +870,10 @@ int nilfs_cpfile_is_snapshot(struct inode *cpfile, __u64 cno)
        void *kaddr;
        int ret;
 
-       /* CP number is invalid if it's zero or larger than the
-       largest exist one.*/
+       /*
+        * CP number is invalid if it's zero or larger than the
+        * largest existing one.
+        */
        if (cno == 0 || cno >= nilfs_mdt_cno(cpfile))
                return -ENOENT;
        down_read(&NILFS_MDT(cpfile)->mi_sem);
index d9048f6a77805d8a6d7a845b77964c09fa767b47..1d2b1805327a0c8886927a16b00f69e8db8ef96c 100644 (file)
@@ -64,8 +64,10 @@ int nilfs_ifile_create_inode(struct inode *ifile, ino_t *out_ino,
        struct nilfs_palloc_req req;
        int ret;
 
-       req.pr_entry_nr = 0;  /* 0 says find free inode from beginning of
-                                a group. dull code!! */
+       req.pr_entry_nr = 0;  /*
+                              * 0 says find free inode from beginning
+                              * of a group. dull code!!
+                              */
        req.pr_entry_bh = NULL;
 
        ret = nilfs_palloc_prepare_alloc_entry(ifile, &req);
index 83d2c485efba17ca637707a0003dd4f1764248cf..a0ebdb17e9124c25520033b1f4137e6bcb3ddaaa 100644 (file)
@@ -129,11 +129,14 @@ int nilfs_get_block(struct inode *inode, sector_t blkoff,
                /* Error handling should be detailed */
                set_buffer_new(bh_result);
                set_buffer_delay(bh_result);
-               map_bh(bh_result, inode->i_sb, 0); /* dbn must be changed
-                                                     to proper value */
+               map_bh(bh_result, inode->i_sb, 0);
+               /* Disk block number must be changed to proper value */
+
        } else if (ret == -ENOENT) {
-               /* not found is not error (e.g. hole); must return without
-                  the mapped state flag. */
+               /*
+                * not found is not error (e.g. hole); must return without
+                * the mapped state flag.
+                */
                ;
        } else {
                err = ret;
@@ -395,23 +398,26 @@ struct inode *nilfs_new_inode(struct inode *dir, umode_t mode)
 
        err = nilfs_init_acl(inode, dir);
        if (unlikely(err))
-               goto failed_after_creation; /* never occur. When supporting
-                                   nilfs_init_acl(), proper cancellation of
-                                   above jobs should be considered */
+               /*
+                * Never occur.  When supporting nilfs_init_acl(),
+                * proper cancellation of above jobs should be considered.
+                */
+               goto failed_after_creation;
 
        return inode;
 
  failed_after_creation:
        clear_nlink(inode);
        unlock_new_inode(inode);
-       iput(inode);  /* raw_inode will be deleted through
-                        nilfs_evict_inode() */
+       iput(inode);  /*
+                      * raw_inode will be deleted through
+                      * nilfs_evict_inode().
+                      */
        goto failed;
 
  failed_ifile_create_inode:
        make_bad_inode(inode);
-       iput(inode);  /* if i_nlink == 1, generic_forget_inode() will be
-                        called */
+       iput(inode);
  failed:
        return ERR_PTR(err);
 }
@@ -662,8 +668,10 @@ void nilfs_write_inode_common(struct inode *inode,
        else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
                raw_inode->i_device_code =
                        cpu_to_le64(huge_encode_dev(inode->i_rdev));
-       /* When extending inode, nilfs->ns_inode_size should be checked
-          for substitutions of appended fields */
+       /*
+        * When extending inode, nilfs->ns_inode_size should be checked
+        * for substitutions of appended fields.
+        */
 }
 
 void nilfs_update_inode(struct inode *inode, struct buffer_head *ibh, int flags)
@@ -681,9 +689,12 @@ void nilfs_update_inode(struct inode *inode, struct buffer_head *ibh, int flags)
                set_bit(NILFS_I_INODE_SYNC, &ii->i_state);
 
        nilfs_write_inode_common(inode, raw_inode, 0);
-               /* XXX: call with has_bmap = 0 is a workaround to avoid
-                  deadlock of bmap. This delays update of i_bmap to just
-                  before writing */
+               /*
+                * XXX: call with has_bmap = 0 is a workaround to avoid
+                * deadlock of bmap.  This delays update of i_bmap to just
+                * before writing.
+                */
+
        nilfs_ifile_unmap_inode(ifile, ino, ibh);
 }
 
@@ -748,8 +759,10 @@ void nilfs_truncate(struct inode *inode)
        nilfs_mark_inode_dirty(inode);
        nilfs_set_file_dirty(inode, 0);
        nilfs_transaction_commit(sb);
-       /* May construct a logical segment and may fail in sync mode.
-          But truncate has no return value. */
+       /*
+        * May construct a logical segment and may fail in sync mode.
+        * But truncate has no return value.
+        */
 }
 
 static void nilfs_clear_inode(struct inode *inode)
@@ -806,8 +819,10 @@ void nilfs_evict_inode(struct inode *inode)
        if (IS_SYNC(inode))
                nilfs_set_transaction_flag(NILFS_TI_SYNC);
        nilfs_transaction_commit(sb);
-       /* May construct a logical segment and may fail in sync mode.
-          But delete_inode has no return value. */
+       /*
+        * May construct a logical segment and may fail in sync mode.
+        * But delete_inode has no return value.
+        */
 }
 
 int nilfs_setattr(struct dentry *dentry, struct iattr *iattr)
@@ -915,17 +930,23 @@ int nilfs_set_file_dirty(struct inode *inode, unsigned int nr_dirty)
        spin_lock(&nilfs->ns_inode_lock);
        if (!test_bit(NILFS_I_QUEUED, &ii->i_state) &&
            !test_bit(NILFS_I_BUSY, &ii->i_state)) {
-               /* Because this routine may race with nilfs_dispose_list(),
-                  we have to check NILFS_I_QUEUED here, too. */
+               /*
+                * Because this routine may race with nilfs_dispose_list(),
+                * we have to check NILFS_I_QUEUED here, too.
+                */
                if (list_empty(&ii->i_dirty) && igrab(inode) == NULL) {
-                       /* This will happen when somebody is freeing
-                          this inode. */
+                       /*
+                        * This will happen when somebody is freeing
+                        * this inode.
+                        */
                        nilfs_warning(inode->i_sb, __func__,
                                      "cannot get inode (ino=%lu)",
                                      inode->i_ino);
                        spin_unlock(&nilfs->ns_inode_lock);
-                       return -EINVAL; /* NILFS_I_DIRTY may remain for
-                                          freeing inode */
+                       return -EINVAL; /*
+                                        * NILFS_I_DIRTY may remain for
+                                        * freeing inode.
+                                        */
                }
                list_move_tail(&ii->i_dirty, &nilfs->ns_dirty_files);
                set_bit(NILFS_I_QUEUED, &ii->i_state);
index ea320315d557536b6da0245458aa4e7853c4f48e..b1d48bc0532d222bfd50ae62aaf2302f98b73bb5 100644 (file)
@@ -64,8 +64,10 @@ struct nilfs_inode_info {
         */
        struct rw_semaphore xattr_sem;
 #endif
-       struct buffer_head *i_bh;       /* i_bh contains a new or dirty
-                                          disk inode */
+       struct buffer_head *i_bh;       /*
+                                        * i_bh contains a new or dirty
+                                        * disk inode.
+                                        */
        struct nilfs_root *i_root;
        struct inode vfs_inode;
 };
@@ -95,8 +97,10 @@ enum {
        NILFS_I_NEW = 0,                /* Inode is newly created */
        NILFS_I_DIRTY,                  /* The file is dirty */
        NILFS_I_QUEUED,                 /* inode is in dirty_files list */
-       NILFS_I_BUSY,                   /* inode is grabbed by a segment
-                                          constructor */
+       NILFS_I_BUSY,                   /*
+                                        * Inode is grabbed by a segment
+                                        * constructor
+                                        */
        NILFS_I_COLLECTED,              /* All dirty blocks are collected */
        NILFS_I_UPDATED,                /* The file has been written back */
        NILFS_I_INODE_SYNC,             /* dsync is not allowed for inode */
@@ -140,8 +144,10 @@ enum {
 struct nilfs_transaction_info {
        u32                     ti_magic;
        void                   *ti_save;
-                               /* This should never used. If this happens,
-                                  one of other filesystems has a bug. */
+                               /*
+                                * This should never be used.  If it happens,
+                                * one of other filesystems has a bug.
+                                */
        unsigned short          ti_flags;
        unsigned short          ti_count;
 };
@@ -151,8 +157,10 @@ struct nilfs_transaction_info {
 
 /* ti_flags */
 #define NILFS_TI_DYNAMIC_ALLOC 0x0001  /* Allocated from slab */
-#define NILFS_TI_SYNC          0x0002  /* Force to construct segment at the
-                                          end of transaction. */
+#define NILFS_TI_SYNC          0x0002  /*
+                                        * Force to construct segment at the
+                                        * end of transaction.
+                                        */
 #define NILFS_TI_GC            0x0004  /* GC context */
 #define NILFS_TI_COMMIT                0x0008  /* Change happened or not */
 #define NILFS_TI_WRITER                0x0010  /* Constructor context */
index db156a199149b1c1e740b740376671092308e460..d893dc912b625440d4367985d9f77476d67805e0 100644 (file)
@@ -43,8 +43,10 @@ enum {
 
 /* work structure for recovery */
 struct nilfs_recovery_block {
-       ino_t ino;              /* Inode number of the file that this block
-                                  belongs to */
+       ino_t ino;              /*
+                                * Inode number of the file that this block
+                                * belongs to
+                                */
        sector_t blocknr;       /* block number */
        __u64 vblocknr;         /* virtual block number */
        unsigned long blkoff;   /* File offset of the data block (per block) */
@@ -869,9 +871,11 @@ int nilfs_search_super_root(struct the_nilfs *nilfs,
 
                flags = le16_to_cpu(sum->ss_flags);
                if (!(flags & NILFS_SS_SR) && !scan_newer) {
-                       /* This will never happen because a superblock
-                          (last_segment) always points to a pseg
-                          having a super root. */
+                       /*
+                        * This will never happen because a superblock
+                        * (last_segment) always points to a pseg with
+                        * a super root.
+                        */
                        ret = NILFS_SEG_FAIL_CONSISTENCY;
                        goto failed;
                }
index c9ee03c262ea0f9bf5a2cc1d2cc65428930f69fc..e78b68a81aec15824d0129528e7284f773fa19a4 100644 (file)
  */
 #define SC_N_INODEVEC  16   /* Size of locally allocated inode vector */
 
-#define SC_MAX_SEGDELTA 64   /* Upper limit of the number of segments
-                               appended in collection retry loop */
+#define SC_MAX_SEGDELTA 64   /*
+                             * Upper limit of the number of segments
+                             * appended in collection retry loop
+                             */
 
 /* Construction mode */
 enum {
        SC_LSEG_SR = 1, /* Make a logical segment having a super root */
-       SC_LSEG_DSYNC,  /* Flush data blocks of a given file and make
-                          a logical segment without a super root */
-       SC_FLUSH_FILE,  /* Flush data files, leads to segment writes without
-                          creating a checkpoint */
-       SC_FLUSH_DAT,   /* Flush DAT file. This also creates segments without
-                          a checkpoint */
+       SC_LSEG_DSYNC,  /*
+                        * Flush data blocks of a given file and make
+                        * a logical segment without a super root.
+                        */
+       SC_FLUSH_FILE,  /*
+                        * Flush data files, leads to segment writes without
+                        * creating a checkpoint.
+                        */
+       SC_FLUSH_DAT,   /*
+                        * Flush DAT file.  This also creates segments
+                        * without a checkpoint.
+                        */
 };
 
 /* Stage numbers of dirty block collection */
@@ -438,8 +446,10 @@ static int nilfs_segctor_feed_segment(struct nilfs_sc_info *sci)
 {
        sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks;
        if (NILFS_SEGBUF_IS_LAST(sci->sc_curseg, &sci->sc_segbufs))
-               return -E2BIG; /* The current segment is filled up
-                                 (internal code) */
+               return -E2BIG; /*
+                               * The current segment is filled up
+                               * (internal code)
+                               */
        sci->sc_curseg = NILFS_NEXT_SEGBUF(sci->sc_curseg);
        return nilfs_segctor_reset_segment_buffer(sci);
 }
@@ -869,9 +879,11 @@ static int nilfs_segctor_create_checkpoint(struct nilfs_sc_info *sci)
        err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, nilfs->ns_cno, 1,
                                          &raw_cp, &bh_cp);
        if (likely(!err)) {
-               /* The following code is duplicated with cpfile.  But, it is
-                  needed to collect the checkpoint even if it was not newly
-                  created */
+               /*
+                * The following code is duplicated with cpfile.  But, it is
+                * needed to collect the checkpoint even if it was not newly
+                * created.
+                */
                mark_buffer_dirty(bh_cp);
                nilfs_mdt_mark_dirty(nilfs->ns_cpfile);
                nilfs_cpfile_put_checkpoint(
@@ -1400,8 +1412,10 @@ static void nilfs_free_incomplete_logs(struct list_head *logs,
        if (atomic_read(&segbuf->sb_err)) {
                /* Case 1: The first segment failed */
                if (segbuf->sb_pseg_start != segbuf->sb_fseg_start)
-                       /* Case 1a:  Partial segment appended into an existing
-                          segment */
+                       /*
+                        * Case 1a:  Partial segment appended into an existing
+                        * segment
+                        */
                        nilfs_terminate_segment(nilfs, segbuf->sb_fseg_start,
                                                segbuf->sb_fseg_end);
                else /* Case 1b:  New full segment */
@@ -1625,8 +1639,10 @@ static int nilfs_segctor_assign(struct nilfs_sc_info *sci, int mode)
 static void nilfs_begin_page_io(struct page *page)
 {
        if (!page || PageWriteback(page))
-               /* For split b-tree node pages, this function may be called
-                  twice.  We ignore the 2nd or later calls by this check. */
+               /*
+                * For split b-tree node pages, this function may be called
+                * twice.  We ignore the 2nd or later calls by this check.
+                */
                return;
 
        lock_page(page);
@@ -2679,8 +2695,10 @@ static void nilfs_segctor_write_out(struct nilfs_sc_info *sci)
 {
        int ret, retrycount = NILFS_SC_CLEANUP_RETRY;
 
-       /* The segctord thread was stopped and its timer was removed.
-          But some tasks remain. */
+       /*
+        * The segctord thread was stopped and its timer was removed.
+        * But some tasks remain.
+        */
        do {
                struct nilfs_transaction_info ti;
 
index 27822e760d3f96d5756fea8bbbc84be5706730c5..6565c10b7b768a433b05fcf659936226dbfc91ba 100644 (file)
@@ -189,11 +189,15 @@ enum {
        NILFS_SC_DIRTY,         /* One or more dirty meta-data blocks exist */
        NILFS_SC_UNCLOSED,      /* Logical segment is not closed */
        NILFS_SC_SUPER_ROOT,    /* The latest segment has a super root */
-       NILFS_SC_PRIOR_FLUSH,   /* Requesting immediate flush without making a
-                                  checkpoint */
-       NILFS_SC_HAVE_DELTA,    /* Next checkpoint will have update of files
-                                  other than DAT, cpfile, sufile, or files
-                                  moved by GC */
+       NILFS_SC_PRIOR_FLUSH,   /*
+                                * Requesting immediate flush without making a
+                                * checkpoint
+                                */
+       NILFS_SC_HAVE_DELTA,    /*
+                                * Next checkpoint will have update of files
+                                * other than DAT, cpfile, sufile, or files
+                                * moved by GC.
+                                */
 };
 
 /* sc_state */
@@ -203,17 +207,23 @@ enum {
 /*
  * Constant parameters
  */
-#define NILFS_SC_CLEANUP_RETRY     3  /* Retry count of construction when
-                                         destroying segctord */
+#define NILFS_SC_CLEANUP_RETRY     3  /*
+                                       * Retry count of construction when
+                                       * destroying segctord
+                                       */
 
 /*
  * Default values of timeout, in seconds.
  */
-#define NILFS_SC_DEFAULT_TIMEOUT    5   /* Timeout value of dirty blocks.
-                                          It triggers construction of a
-                                          logical segment with a super root */
-#define NILFS_SC_DEFAULT_SR_FREQ    30  /* Maximum frequency of super root
-                                          creation */
+#define NILFS_SC_DEFAULT_TIMEOUT    5   /*
+                                        * Timeout value of dirty blocks.
+                                        * It triggers construction of a
+                                        * logical segment with a super root.
+                                        */
+#define NILFS_SC_DEFAULT_SR_FREQ    30  /*
+                                        * Maximum frequency of super root
+                                        * creation
+                                        */
 
 /*
  * The default threshold amount of data, in block counts.
index b9e19ca3c96e862bb902965031ca1573fe0d90cf..809bd2de7ad0602c638464e4ecd5a736c14fa878 100644 (file)
@@ -617,8 +617,10 @@ int init_nilfs(struct the_nilfs *nilfs, struct super_block *sb, char *data)
                err = nilfs_load_super_block(nilfs, sb, blocksize, &sbp);
                if (err)
                        goto out;
-                       /* not failed_sbh; sbh is released automatically
-                          when reloading fails. */
+                       /*
+                        * Not to failed_sbh; sbh is released automatically
+                        * when reloading fails.
+                        */
        }
        nilfs->ns_blocksize_bits = sb->s_blocksize_bits;
        nilfs->ns_blocksize = blocksize;
index 3b584925d0e8332dc4cf221e65bf134411064e19..5988dd57ba666ea71eb31910d2739ac235142bec 100644 (file)
@@ -127,10 +127,14 @@ struct nilfs_super_root {
 #define NILFS_MOUNT_ERRORS_RO          0x0020  /* Remount fs ro on errors */
 #define NILFS_MOUNT_ERRORS_PANIC       0x0040  /* Panic on errors */
 #define NILFS_MOUNT_BARRIER            0x1000  /* Use block barriers */
-#define NILFS_MOUNT_STRICT_ORDER       0x2000  /* Apply strict in-order
-                                                  semantics also for data */
-#define NILFS_MOUNT_NORECOVERY         0x4000  /* Disable write access during
-                                                  mount-time recovery */
+#define NILFS_MOUNT_STRICT_ORDER       0x2000  /*
+                                                * Apply strict in-order
+                                                * semantics also for data
+                                                */
+#define NILFS_MOUNT_NORECOVERY         0x4000  /*
+                                                * Disable write access during
+                                                * mount-time recovery
+                                                */
 #define NILFS_MOUNT_DISCARD            0x8000  /* Issue DISCARD requests */
 
 
@@ -142,16 +146,20 @@ struct nilfs_super_block {
        __le16  s_minor_rev_level;      /* minor revision level */
        __le16  s_magic;                /* Magic signature */
 
-       __le16  s_bytes;                /* Bytes count of CRC calculation
-                                          for this structure. s_reserved
-                                          is excluded. */
+       __le16  s_bytes;                /*
+                                        * Bytes count of CRC calculation
+                                        * for this structure. s_reserved
+                                        * is excluded.
+                                        */
        __le16  s_flags;                /* flags */
        __le32  s_crc_seed;             /* Seed value of CRC calculation */
 /*10*/ __le32  s_sum;                  /* Check sum of super block */
 
-       __le32  s_log_block_size;       /* Block size represented as follows
-                                          blocksize =
-                                              1 << (s_log_block_size + 10) */
+       __le32  s_log_block_size;       /*
+                                        * Block size represented as follows
+                                        * blocksize =
+                                        *     1 << (s_log_block_size + 10)
+                                        */
        __le64  s_nsegments;            /* Number of segments in filesystem */
 /*20*/ __le64  s_dev_size;             /* block device size in bytes */
        __le64  s_first_data_block;     /* 1st seg disk block number */
@@ -163,8 +171,10 @@ struct nilfs_super_block {
        __le64  s_last_seq;             /* seq. number of seg written last */
 /*50*/ __le64  s_free_blocks_count;    /* Free blocks count */
 
-       __le64  s_ctime;                /* Creation time (execution time of
-                                          newfs) */
+       __le64  s_ctime;                /*
+                                        * Creation time (execution time of
+                                        * newfs)
+                                        */
 /*60*/ __le64  s_mtime;                /* Mount time */
        __le64  s_wtime;                /* Write time */
 /*70*/ __le16  s_mnt_count;            /* Mount count */
@@ -188,8 +198,10 @@ struct nilfs_super_block {
 /*A8*/ char    s_volume_name[80];      /* volume name */
 
 /*F8*/ __le32  s_c_interval;           /* Commit interval of segment */
-       __le32  s_c_block_max;          /* Threshold of data amount for
-                                          the segment construction */
+       __le32  s_c_block_max;          /*
+                                        * Threshold of data amount for
+                                        * the segment construction
+                                        */
 /*100*/        __le64  s_feature_compat;       /* Compatible feature set */
        __le64  s_feature_compat_ro;    /* Read-only compatible feature set */
        __le64  s_feature_incompat;     /* Incompatible feature set */
@@ -242,12 +254,18 @@ struct nilfs_super_block {
 
 #define NILFS_SB_OFFSET_BYTES  1024    /* byte offset of nilfs superblock */
 
-#define NILFS_SEG_MIN_BLOCKS   16      /* Minimum number of blocks in
-                                          a full segment */
-#define NILFS_PSEG_MIN_BLOCKS  2       /* Minimum number of blocks in
-                                          a partial segment */
-#define NILFS_MIN_NRSVSEGS     8       /* Minimum number of reserved
-                                          segments */
+#define NILFS_SEG_MIN_BLOCKS   16      /*
+                                        * Minimum number of blocks in
+                                        * a full segment
+                                        */
+#define NILFS_PSEG_MIN_BLOCKS  2       /*
+                                        * Minimum number of blocks in
+                                        * a partial segment
+                                        */
+#define NILFS_MIN_NRSVSEGS     8       /*
+                                        * Minimum number of reserved
+                                        * segments
+                                        */
 
 /*
  * We call DAT, cpfile, and sufile root metadata files.  Inodes of
@@ -513,9 +531,11 @@ struct nilfs_checkpoint {
        __le64 cp_inodes_count;
        __le64 cp_blocks_count;
 
-       /* Do not change the byte offset of ifile inode.
-          To keep the compatibility of the disk format,
-          additional fields should be added behind cp_ifile_inode. */
+       /*
+        * Do not change the byte offset of ifile inode.
+        * To keep the compatibility of the disk format,
+        * additional fields should be added behind cp_ifile_inode.
+        */
        struct nilfs_inode cp_ifile_inode;
 };