reiserfs: cleanup, reformat comments to normal kernel style

This patch reformats comments in the reiserfs code to fit in 80 columns and
to follow the style rules.

There is no functional change but it helps make my eyes bleed less.

Signed-off-by: Jeff Mahoney <jeffm@suse.com>
Signed-off-by: Jan Kara <jack@suse.cz>

1 files changed, 55 insertions, 40 deletions

diff --git a/fs/reiserfs/objectid.c b/fs/reiserfs/objectid.c
index f732d6a5251d..99f66f885785 100644
--- a/fs/reiserfs/objectid.c
+++ b/fs/reiserfs/objectid.c
@@ -7,7 +7,7 @@
 #include <linux/time.h>
 #include "reiserfs.h"
 
-// find where objectid map starts
+/* find where objectid map starts */
 #define objectid_map(s,rs) (old_format_only (s) ? \
                          (__le32 *)((struct reiserfs_super_block_v1 *)(rs) + 1) :\
                          (__le32 *)((rs) + 1))
@@ -20,7 +20,7 @@ static void check_objectid_map(struct super_block *s, __le32 * map)
                 reiserfs_panic(s, "vs-15010", "map corrupted: %lx",
                                (long unsigned int)le32_to_cpu(map[0]));
 
-        // FIXME: add something else here
+        /* FIXME: add something else here */
 }
 
 #else
@@ -29,19 +29,21 @@ static void check_objectid_map(struct super_block *s, __le32 * map)
 }
 #endif
 
-/* When we allocate objectids we allocate the first unused objectid.
-   Each sequence of objectids in use (the odd sequences) is followed
-   by a sequence of objectids not in use (the even sequences).  We
-   only need to record the last objectid in each of these sequences
-   (both the odd and even sequences) in order to fully define the
-   boundaries of the sequences.  A consequence of allocating the first
-   objectid not in use is that under most conditions this scheme is
-   extremely compact.  The exception is immediately after a sequence
-   of operations which deletes a large number of objects of
-   non-sequential objectids, and even then it will become compact
-   again as soon as more objects are created.  Note that many
-   interesting optimizations of layout could result from complicating
-   objectid assignment, but we have deferred making them for now. */
+/*
+ * When we allocate objectids we allocate the first unused objectid.
+ * Each sequence of objectids in use (the odd sequences) is followed
+ * by a sequence of objectids not in use (the even sequences).  We
+ * only need to record the last objectid in each of these sequences
+ * (both the odd and even sequences) in order to fully define the
+ * boundaries of the sequences.  A consequence of allocating the first
+ * objectid not in use is that under most conditions this scheme is
+ * extremely compact.  The exception is immediately after a sequence
+ * of operations which deletes a large number of objects of
+ * non-sequential objectids, and even then it will become compact
+ * again as soon as more objects are created.  Note that many
+ * interesting optimizations of layout could result from complicating
+ * objectid assignment, but we have deferred making them for now.
+ */
 
 /* get unique object identifier */
 __u32 reiserfs_get_unused_objectid(struct reiserfs_transaction_handle *th)
@@ -64,19 +66,23 @@ __u32 reiserfs_get_unused_objectid(struct reiserfs_transaction_handle *th)
                 return 0;
         }
 
-        /* This incrementation allocates the first unused objectid. That
-           is to say, the first entry on the objectid map is the first
-           unused objectid, and by incrementing it we use it.  See below
-           where we check to see if we eliminated a sequence of unused
-           objectids.... */
+        /*
+         * This incrementation allocates the first unused objectid. That
+         * is to say, the first entry on the objectid map is the first
+         * unused objectid, and by incrementing it we use it.  See below
+         * where we check to see if we eliminated a sequence of unused
+         * objectids....
+         */
         map[1] = cpu_to_le32(unused_objectid + 1);
 
-        /* Now we check to see if we eliminated the last remaining member of
-           the first even sequence (and can eliminate the sequence by
-           eliminating its last objectid from oids), and can collapse the
-           first two odd sequences into one sequence.  If so, then the net
-           result is to eliminate a pair of objectids from oids.  We do this
-           by shifting the entire map to the left. */
+        /*
+         * Now we check to see if we eliminated the last remaining member of
+         * the first even sequence (and can eliminate the sequence by
+         * eliminating its last objectid from oids), and can collapse the
+         * first two odd sequences into one sequence.  If so, then the net
+         * result is to eliminate a pair of objectids from oids.  We do this
+         * by shifting the entire map to the left.
+         */
         if (sb_oid_cursize(rs) > 2 && map[1] == map[2]) {
                 memmove(map + 1, map + 3,
                         (sb_oid_cursize(rs) - 3) * sizeof(__u32));
@@ -97,30 +103,33 @@ void reiserfs_release_objectid(struct reiserfs_transaction_handle *th,
         int i = 0;
 
         BUG_ON(!th->t_trans_id);
-        //return;
+        /*return; */
         check_objectid_map(s, map);
 
         reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
         journal_mark_dirty(th, s, SB_BUFFER_WITH_SB(s));
 
-        /* start at the beginning of the objectid map (i = 0) and go to
-           the end of it (i = disk_sb->s_oid_cursize).  Linear search is
-           what we use, though it is possible that binary search would be
-           more efficient after performing lots of deletions (which is
-           when oids is large.)  We only check even i's. */
+        /*
+         * start at the beginning of the objectid map (i = 0) and go to
+         * the end of it (i = disk_sb->s_oid_cursize).  Linear search is
+         * what we use, though it is possible that binary search would be
+         * more efficient after performing lots of deletions (which is
+         * when oids is large.)  We only check even i's.
+         */
         while (i < sb_oid_cursize(rs)) {
                 if (objectid_to_release == le32_to_cpu(map[i])) {
                         /* This incrementation unallocates the objectid. */
-                        //map[i]++;
                         le32_add_cpu(&map[i], 1);
 
-                        /* Did we unallocate the last member of an odd sequence, and can shrink oids? */
+                        /*
+                         * Did we unallocate the last member of an
+                         * odd sequence, and can shrink oids?
+                         */
                         if (map[i] == map[i + 1]) {
                                 /* shrink objectid map */
                                 memmove(map + i, map + i + 2,
                                         (sb_oid_cursize(rs) - i -
                                          2) * sizeof(__u32));
-                                //disk_sb->s_oid_cursize -= 2;
                                 set_sb_oid_cursize(rs, sb_oid_cursize(rs) - 2);
 
                                 RFALSE(sb_oid_cursize(rs) < 2 ||
@@ -135,14 +144,19 @@ void reiserfs_release_objectid(struct reiserfs_transaction_handle *th,
                     objectid_to_release < le32_to_cpu(map[i + 1])) {
                         /* size of objectid map is not changed */
                         if (objectid_to_release + 1 == le32_to_cpu(map[i + 1])) {
-                                //objectid_map[i+1]--;
                                 le32_add_cpu(&map[i + 1], -1);
                                 return;
                         }
 
-                        /* JDM comparing two little-endian values for equality -- safe */
+                        /*
+                         * JDM comparing two little-endian values for
+                         * equality -- safe
+                         */
+                        /*
+                         * objectid map must be expanded, but
+                         * there is no space
+                         */
                         if (sb_oid_cursize(rs) == sb_oid_maxsize(rs)) {
-                                /* objectid map must be expanded, but there is no space */
                                 PROC_INFO_INC(s, leaked_oid);
                                 return;
                         }
@@ -178,8 +192,9 @@ int reiserfs_convert_objectid_map_v1(struct super_block *s)
         new_objectid_map = (__le32 *) (disk_sb + 1);
 
         if (cur_size > new_size) {
-                /* mark everyone used that was listed as free at the end of the objectid
-                 ** map
+                /*
+                 * mark everyone used that was listed as free at
+                 * the end of the objectid map
                  */
                 objectid_map[new_size - 1] = objectid_map[cur_size - 1];
                 set_sb_oid_cursize(disk_sb, new_size);