JFS: Whitespace cleanup and remove some dead code

Signed-off-by: Dave Kleikamp <shaggy@linux.vnet.ibm.com>

1 files changed, 212 insertions, 216 deletions

diff --git a/fs/jfs/jfs_xtree.c b/fs/jfs/jfs_xtree.c
index acc97c46d8a4..1543906a2e0d 100644
--- a/fs/jfs/jfs_xtree.c
+++ b/fs/jfs/jfs_xtree.c
@@ -16,7 +16,7 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 /*
- *      jfs_xtree.c: extent allocation descriptor B+-tree manager
+ *      jfs_xtree.c: extent allocation descriptor B+-tree manager
  */
 
 #include <linux/fs.h>
@@ -32,30 +32,30 @@
 /*
  * xtree local flag
  */
-#define XT_INSERT       0x00000001
+#define XT_INSERT       0x00000001
 
 /*
- *       xtree key/entry comparison: extent offset
+ *      xtree key/entry comparison: extent offset
  *
  * return:
- *      -1: k < start of extent
- *       0: start_of_extent <= k <= end_of_extent
- *       1: k > end_of_extent
+ *      -1: k < start of extent
+ *       0: start_of_extent <= k <= end_of_extent
+ *       1: k > end_of_extent
  */
 #define XT_CMP(CMP, K, X, OFFSET64)\
 {\
-        OFFSET64 = offsetXAD(X);\
-        (CMP) = ((K) >= OFFSET64 + lengthXAD(X)) ? 1 :\
-              ((K) < OFFSET64) ? -1 : 0;\
+        OFFSET64 = offsetXAD(X);\
+        (CMP) = ((K) >= OFFSET64 + lengthXAD(X)) ? 1 :\
+                ((K) < OFFSET64) ? -1 : 0;\
 }
 
 /* write a xad entry */
 #define XT_PUTENTRY(XAD, FLAG, OFF, LEN, ADDR)\
 {\
-        (XAD)->flag = (FLAG);\
-        XADoffset((XAD), (OFF));\
-        XADlength((XAD), (LEN));\
-        XADaddress((XAD), (ADDR));\
+        (XAD)->flag = (FLAG);\
+        XADoffset((XAD), (OFF));\
+        XADlength((XAD), (LEN));\
+        XADaddress((XAD), (ADDR));\
 }
 
 #define XT_PAGE(IP, MP) BT_PAGE(IP, MP, xtpage_t, i_xtroot)
@@ -76,13 +76,13 @@
                         MP = NULL;\
                         RC = -EIO;\
                 }\
-        }\
+        }\
 }
 
 /* for consistency */
 #define XT_PUTPAGE(MP) BT_PUTPAGE(MP)
 
-#define XT_GETSEARCH(IP, LEAF, BN, MP,  P, INDEX) \
+#define XT_GETSEARCH(IP, LEAF, BN, MP, P, INDEX) \
         BT_GETSEARCH(IP, LEAF, BN, MP, xtpage_t, P, INDEX, i_xtroot)
 /* xtree entry parameter descriptor */
 struct xtsplit {
@@ -97,7 +97,7 @@ struct xtsplit {
 
 
 /*
- *      statistics
+ *      statistics
  */
 #ifdef CONFIG_JFS_STATISTICS
 static struct {
@@ -136,7 +136,7 @@ static int xtRelink(tid_t tid, struct inode *ip, xtpage_t * fp);
 #endif                          /*  _STILL_TO_PORT */
 
 /*
- *      xtLookup()
+ *      xtLookup()
  *
  * function: map a single page into a physical extent;
  */
@@ -179,7 +179,7 @@ int xtLookup(struct inode *ip, s64 lstart,
         }
 
         /*
-         *      compute the physical extent covering logical extent
+         *      compute the physical extent covering logical extent
          *
          * N.B. search may have failed (e.g., hole in sparse file),
          * and returned the index of the next entry.
@@ -220,27 +220,27 @@ int xtLookup(struct inode *ip, s64 lstart,
 
 
 /*
- *      xtLookupList()
+ *      xtLookupList()
  *
  * function: map a single logical extent into a list of physical extent;
  *
  * parameter:
- *      struct inode    *ip,
- *      struct lxdlist  *lxdlist,       lxd list (in)
- *      struct xadlist  *xadlist,       xad list (in/out)
- *      int             flag)
+ *      struct inode    *ip,
+ *      struct lxdlist  *lxdlist,       lxd list (in)
+ *      struct xadlist  *xadlist,       xad list (in/out)
+ *      int             flag)
  *
  * coverage of lxd by xad under assumption of
  * . lxd's are ordered and disjoint.
  * . xad's are ordered and disjoint.
  *
  * return:
- *      0:      success
+ *      0:      success
  *
  * note: a page being written (even a single byte) is backed fully,
- *      except the last page which is only backed with blocks
- *      required to cover the last byte;
- *      the extent backing a page is fully contained within an xad;
+ *      except the last page which is only backed with blocks
+ *      required to cover the last byte;
+ *      the extent backing a page is fully contained within an xad;
  */
 int xtLookupList(struct inode *ip, struct lxdlist * lxdlist,
                  struct xadlist * xadlist, int flag)
@@ -284,7 +284,7 @@ int xtLookupList(struct inode *ip, struct lxdlist * lxdlist,
                 return rc;
 
         /*
-         *      compute the physical extent covering logical extent
+         *      compute the physical extent covering logical extent
          *
          * N.B. search may have failed (e.g., hole in sparse file),
          * and returned the index of the next entry.
@@ -343,7 +343,7 @@ int xtLookupList(struct inode *ip, struct lxdlist * lxdlist,
                 if (lstart >= size)
                         goto mapend;
 
-                /* compare with the current xad  */
+                /* compare with the current xad */
                 goto compare1;
         }
         /* lxd is covered by xad */
@@ -430,7 +430,7 @@ int xtLookupList(struct inode *ip, struct lxdlist * lxdlist,
         /*
          * lxd is partially covered by xad
          */
-        else {                  /* (xend < lend)  */
+        else {                  /* (xend < lend) */
 
                 /*
                  * get next xad
@@ -477,22 +477,22 @@ int xtLookupList(struct inode *ip, struct lxdlist * lxdlist,
 
 
 /*
- *      xtSearch()
+ *      xtSearch()
  *
- * function:    search for the xad entry covering specified offset.
+ * function:    search for the xad entry covering specified offset.
  *
  * parameters:
- *      ip      - file object;
- *      xoff    - extent offset;
- *      nextp   - address of next extent (if any) for search miss
- *      cmpp    - comparison result:
- *      btstack - traverse stack;
- *      flag    - search process flag (XT_INSERT);
+ *      ip      - file object;
+ *      xoff    - extent offset;
+ *      nextp   - address of next extent (if any) for search miss
+ *      cmpp    - comparison result:
+ *      btstack - traverse stack;
+ *      flag    - search process flag (XT_INSERT);
  *
  * returns:
- *      btstack contains (bn, index) of search path traversed to the entry.
- *      *cmpp is set to result of comparison with the entry returned.
- *      the page containing the entry is pinned at exit.
+ *      btstack contains (bn, index) of search path traversed to the entry.
+ *      *cmpp is set to result of comparison with the entry returned.
+ *      the page containing the entry is pinned at exit.
  */
 static int xtSearch(struct inode *ip, s64 xoff, s64 *nextp,
                     int *cmpp, struct btstack * btstack, int flag)
@@ -517,7 +517,7 @@ static int xtSearch(struct inode *ip, s64 xoff,	s64 *nextp,
         btstack->nsplit = 0;
 
         /*
-         *      search down tree from root:
+         *      search down tree from root:
          *
          * between two consecutive entries of <Ki, Pi> and <Kj, Pj> of
          * internal page, child page Pi contains entry with k, Ki <= K < Kj.
@@ -642,7 +642,7 @@ static int xtSearch(struct inode *ip, s64 xoff,	s64 *nextp,
                         XT_CMP(cmp, xoff, &p->xad[index], t64);
                         if (cmp == 0) {
                                 /*
-                                 *      search hit
+                                 *      search hit
                                  */
                                 /* search hit - leaf page:
                                  * return the entry found
@@ -692,7 +692,7 @@ static int xtSearch(struct inode *ip, s64 xoff,	s64 *nextp,
                 }
 
                 /*
-                 *      search miss
+                 *      search miss
                  *
                  * base is the smallest index with key (Kj) greater than
                  * search key (K) and may be zero or maxentry index.
@@ -773,22 +773,22 @@ static int xtSearch(struct inode *ip, s64 xoff,	s64 *nextp,
 }
 
 /*
- *      xtInsert()
+ *      xtInsert()
  *
  * function:
  *
  * parameter:
- *      tid     - transaction id;
- *      ip      - file object;
- *      xflag   - extent flag (XAD_NOTRECORDED):
- *      xoff    - extent offset;
- *      xlen    - extent length;
- *      xaddrp  - extent address pointer (in/out):
- *              if (*xaddrp)
- *                      caller allocated data extent at *xaddrp;
- *              else
- *                      allocate data extent and return its xaddr;
- *      flag    -
+ *      tid     - transaction id;
+ *      ip      - file object;
+ *      xflag   - extent flag (XAD_NOTRECORDED):
+ *      xoff    - extent offset;
+ *      xlen    - extent length;
+ *      xaddrp  - extent address pointer (in/out):
+ *              if (*xaddrp)
+ *                      caller allocated data extent at *xaddrp;
+ *              else
+ *                      allocate data extent and return its xaddr;
+ *      flag    -
  *
  * return:
  */
@@ -813,7 +813,7 @@ int xtInsert(tid_t tid,		/* transaction id */
         jfs_info("xtInsert: nxoff:0x%lx nxlen:0x%x", (ulong) xoff, xlen);
 
         /*
-         *      search for the entry location at which to insert:
+         *      search for the entry location at which to insert:
          *
          * xtFastSearch() and xtSearch() both returns (leaf page
          * pinned, index at which to insert).
@@ -853,13 +853,13 @@ int xtInsert(tid_t tid,		/* transaction id */
         }
 
         /*
-         *      insert entry for new extent
+         *      insert entry for new extent
          */
         xflag |= XAD_NEW;
 
         /*
-         *      if the leaf page is full, split the page and
-         *      propagate up the router entry for the new page from split
+         *      if the leaf page is full, split the page and
+         *      propagate up the router entry for the new page from split
          *
          * The xtSplitUp() will insert the entry and unpin the leaf page.
          */
@@ -886,7 +886,7 @@ int xtInsert(tid_t tid,		/* transaction id */
         }
 
         /*
-         *      insert the new entry into the leaf page
+         *      insert the new entry into the leaf page
          */
         /*
          * acquire a transaction lock on the leaf page;
@@ -930,16 +930,16 @@ int xtInsert(tid_t tid,		/* transaction id */
 
 
 /*
- *      xtSplitUp()
+ *      xtSplitUp()
  *
  * function:
- *      split full pages as propagating insertion up the tree
+ *      split full pages as propagating insertion up the tree
  *
  * parameter:
- *      tid     - transaction id;
- *      ip      - file object;
- *      split   - entry parameter descriptor;
- *      btstack - traverse stack from xtSearch()
+ *      tid     - transaction id;
+ *      ip      - file object;
+ *      split   - entry parameter descriptor;
+ *      btstack - traverse stack from xtSearch()
  *
  * return:
  */
@@ -1199,22 +1199,22 @@ xtSplitUp(tid_t tid,
 
 
 /*
- *      xtSplitPage()
+ *      xtSplitPage()
  *
  * function:
- *      split a full non-root page into
- *      original/split/left page and new right page
- *      i.e., the original/split page remains as left page.
+ *      split a full non-root page into
+ *      original/split/left page and new right page
+ *      i.e., the original/split page remains as left page.
  *
  * parameter:
- *      int             tid,
- *      struct inode    *ip,
- *      struct xtsplit  *split,
- *      struct metapage **rmpp,
- *      u64             *rbnp,
+ *      int             tid,
+ *      struct inode    *ip,
+ *      struct xtsplit  *split,
+ *      struct metapage **rmpp,
+ *      u64             *rbnp,
  *
  * return:
- *      Pointer to page in which to insert or NULL on error.
+ *      Pointer to page in which to insert or NULL on error.
  */
 static int
 xtSplitPage(tid_t tid, struct inode *ip,
@@ -1248,9 +1248,9 @@ xtSplitPage(tid_t tid, struct inode *ip,
         rbn = addressPXD(pxd);
 
         /* Allocate blocks to quota. */
-       if (DQUOT_ALLOC_BLOCK(ip, lengthPXD(pxd))) {
-               rc = -EDQUOT;
-               goto clean_up;
+        if (DQUOT_ALLOC_BLOCK(ip, lengthPXD(pxd))) {
+                rc = -EDQUOT;
+                goto clean_up;
         }
 
         quota_allocation += lengthPXD(pxd);
@@ -1304,7 +1304,7 @@ xtSplitPage(tid_t tid, struct inode *ip,
         skip = split->index;
 
         /*
-         *      sequential append at tail (after last entry of last page)
+         *      sequential append at tail (after last entry of last page)
          *
          * if splitting the last page on a level because of appending
          * a entry to it (skip is maxentry), it's likely that the access is
@@ -1342,7 +1342,7 @@ xtSplitPage(tid_t tid, struct inode *ip,
         }
 
         /*
-         *      non-sequential insert (at possibly middle page)
+         *      non-sequential insert (at possibly middle page)
          */
 
         /*
@@ -1465,25 +1465,24 @@ xtSplitPage(tid_t tid, struct inode *ip,
 
 
 /*
- *      xtSplitRoot()
+ *      xtSplitRoot()
  *
  * function:
- *      split the full root page into
- *      original/root/split page and new right page
- *      i.e., root remains fixed in tree anchor (inode) and
- *      the root is copied to a single new right child page
- *      since root page << non-root page, and
- *      the split root page contains a single entry for the
- *      new right child page.
+ *      split the full root page into original/root/split page and new
+ *      right page
+ *      i.e., root remains fixed in tree anchor (inode) and the root is
+ *      copied to a single new right child page since root page <<
+ *      non-root page, and the split root page contains a single entry
+ *      for the new right child page.
  *
  * parameter:
- *      int             tid,
- *      struct inode    *ip,
- *      struct xtsplit  *split,
- *      struct metapage **rmpp)
+ *      int             tid,
+ *      struct inode    *ip,
+ *      struct xtsplit  *split,
+ *      struct metapage **rmpp)
  *
  * return:
- *      Pointer to page in which to insert or NULL on error.
+ *      Pointer to page in which to insert or NULL on error.
  */
 static int
 xtSplitRoot(tid_t tid,
@@ -1505,7 +1504,7 @@ xtSplitRoot(tid_t tid,
         INCREMENT(xtStat.split);
 
         /*
-         *      allocate a single (right) child page
+         *      allocate a single (right) child page
          */
         pxdlist = split->pxdlist;
         pxd = &pxdlist->pxd[pxdlist->npxd];
@@ -1573,7 +1572,7 @@ xtSplitRoot(tid_t tid,
         }
 
         /*
-         *      reset the root
+         *      reset the root
          *
          * init root with the single entry for the new right page
          * set the 1st entry offset to 0, which force the left-most key
@@ -1610,7 +1609,7 @@ xtSplitRoot(tid_t tid,
 
 
 /*
- *      xtExtend()
+ *      xtExtend()
  *
  * function: extend in-place;
  *
@@ -1677,7 +1676,7 @@ int xtExtend(tid_t tid,		/* transaction id */
                 goto extendOld;
 
         /*
-         *      extent overflow: insert entry for new extent
+         *      extent overflow: insert entry for new extent
          */
 //insertNew:
         xoff = offsetXAD(xad) + MAXXLEN;
@@ -1685,8 +1684,8 @@ int xtExtend(tid_t tid,		/* transaction id */
         nextindex = le16_to_cpu(p->header.nextindex);
 
         /*
-         *      if the leaf page is full, insert the new entry and
-         *      propagate up the router entry for the new page from split
+         *      if the leaf page is full, insert the new entry and
+         *      propagate up the router entry for the new page from split
          *
          * The xtSplitUp() will insert the entry and unpin the leaf page.
          */
@@ -1731,7 +1730,7 @@ int xtExtend(tid_t tid,		/* transaction id */
                 }
         }
         /*
-         *      insert the new entry into the leaf page
+         *      insert the new entry into the leaf page
          */
         else {
                 /* insert the new entry: mark the entry NEW */
@@ -1771,11 +1770,11 @@ int xtExtend(tid_t tid,		/* transaction id */
 
 #ifdef _NOTYET
 /*
- *      xtTailgate()
+ *      xtTailgate()
  *
  * function: split existing 'tail' extent
- *      (split offset >= start offset of tail extent), and
- *      relocate and extend the split tail half;
+ *      (split offset >= start offset of tail extent), and
+ *      relocate and extend the split tail half;
  *
  * note: existing extent may or may not have been committed.
  * caller is responsible for pager buffer cache update, and
@@ -1804,7 +1803,7 @@ int xtTailgate(tid_t tid,		/* transaction id */
 
 /*
 printf("xtTailgate: nxoff:0x%lx nxlen:0x%x nxaddr:0x%lx\n",
-        (ulong)xoff, xlen, (ulong)xaddr);
+        (ulong)xoff, xlen, (ulong)xaddr);
 */
 
         /* there must exist extent to be tailgated */
@@ -1842,18 +1841,18 @@ printf("xtTailgate: nxoff:0x%lx nxlen:0x%x nxaddr:0x%lx\n",
         xad = &p->xad[index];
 /*
 printf("xtTailgate: xoff:0x%lx xlen:0x%x xaddr:0x%lx\n",
-        (ulong)offsetXAD(xad), lengthXAD(xad), (ulong)addressXAD(xad));
+        (ulong)offsetXAD(xad), lengthXAD(xad), (ulong)addressXAD(xad));
 */
         if ((llen = xoff - offsetXAD(xad)) == 0)
                 goto updateOld;
 
         /*
-         *      partially replace extent: insert entry for new extent
+         *      partially replace extent: insert entry for new extent
          */
 //insertNew:
         /*
-         *      if the leaf page is full, insert the new entry and
-         *      propagate up the router entry for the new page from split
+         *      if the leaf page is full, insert the new entry and
+         *      propagate up the router entry for the new page from split
          *
          * The xtSplitUp() will insert the entry and unpin the leaf page.
          */
@@ -1898,7 +1897,7 @@ printf("xtTailgate: xoff:0x%lx xlen:0x%x xaddr:0x%lx\n",
                 }
         }
         /*
-         *      insert the new entry into the leaf page
+         *      insert the new entry into the leaf page
          */
         else {
                 /* insert the new entry: mark the entry NEW */
@@ -1955,17 +1954,17 @@ printf("xtTailgate: xoff:0x%lx xlen:0x%x xaddr:0x%lx\n",
 #endif /* _NOTYET */
 
 /*
- *      xtUpdate()
+ *      xtUpdate()
  *
  * function: update XAD;
  *
- *      update extent for allocated_but_not_recorded or
- *      compressed extent;
+ *      update extent for allocated_but_not_recorded or
+ *      compressed extent;
  *
  * parameter:
- *      nxad    - new XAD;
- *                logical extent of the specified XAD must be completely
- *                contained by an existing XAD;
+ *      nxad    - new XAD;
+ *              logical extent of the specified XAD must be completely
+ *              contained by an existing XAD;
  */
 int xtUpdate(tid_t tid, struct inode *ip, xad_t * nxad)
 {                               /* new XAD */
@@ -2416,19 +2415,19 @@ printf("xtUpdate.updateLeft.split p:0x%p\n", p);
 
 
 /*
- *      xtAppend()
+ *      xtAppend()
  *
  * function: grow in append mode from contiguous region specified ;
  *
  * parameter:
- *      tid             - transaction id;
- *      ip              - file object;
- *      xflag           - extent flag:
- *      xoff            - extent offset;
- *      maxblocks       - max extent length;
- *      xlen            - extent length (in/out);
- *      xaddrp          - extent address pointer (in/out):
- *      flag            -
+ *      tid             - transaction id;
+ *      ip              - file object;
+ *      xflag           - extent flag:
+ *      xoff            - extent offset;
+ *      maxblocks       - max extent length;
+ *      xlen            - extent length (in/out);
+ *      xaddrp          - extent address pointer (in/out):
+ *      flag            -
  *
  * return:
  */
@@ -2460,7 +2459,7 @@ int xtAppend(tid_t tid,		/* transaction id */
                  (ulong) xoff, maxblocks, xlen, (ulong) xaddr);
 
         /*
-         *      search for the entry location at which to insert:
+         *      search for the entry location at which to insert:
          *
          * xtFastSearch() and xtSearch() both returns (leaf page
          * pinned, index at which to insert).
@@ -2482,13 +2481,13 @@ int xtAppend(tid_t tid,		/* transaction id */
                 xlen = min(xlen, (int)(next - xoff));
 //insert:
         /*
-         *      insert entry for new extent
+         *      insert entry for new extent
          */
         xflag |= XAD_NEW;
 
         /*
-         *      if the leaf page is full, split the page and
-         *      propagate up the router entry for the new page from split
+         *      if the leaf page is full, split the page and
+         *      propagate up the router entry for the new page from split
          *
          * The xtSplitUp() will insert the entry and unpin the leaf page.
          */
@@ -2545,7 +2544,7 @@ int xtAppend(tid_t tid,		/* transaction id */
         return 0;
 
         /*
-         *      insert the new entry into the leaf page
+         *      insert the new entry into the leaf page
          */
       insertLeaf:
         /*
@@ -2589,17 +2588,17 @@ int xtAppend(tid_t tid,		/* transaction id */
 
 /* - TBD for defragmentaion/reorganization -
  *
- *      xtDelete()
+ *      xtDelete()
  *
  * function:
- *      delete the entry with the specified key.
+ *      delete the entry with the specified key.
  *
- *      N.B.: whole extent of the entry is assumed to be deleted.
+ *      N.B.: whole extent of the entry is assumed to be deleted.
  *
  * parameter:
  *
  * return:
- *       ENOENT: if the entry is not found.
+ *      ENOENT: if the entry is not found.
  *
  * exception:
  */
@@ -2665,10 +2664,10 @@ int xtDelete(tid_t tid, struct inode *ip, s64 xoff, s32 xlen, int flag)
 
 /* - TBD for defragmentaion/reorganization -
  *
- *      xtDeleteUp()
+ *      xtDeleteUp()
  *
  * function:
- *      free empty pages as propagating deletion up the tree
+ *      free empty pages as propagating deletion up the tree
  *
  * parameter:
  *
@@ -2815,15 +2814,15 @@ xtDeleteUp(tid_t tid, struct inode *ip,
 
 
 /*
- * NAME:        xtRelocate()
+ * NAME:        xtRelocate()
  *
- * FUNCTION:    relocate xtpage or data extent of regular file;
- *              This function is mainly used by defragfs utility.
+ * FUNCTION:    relocate xtpage or data extent of regular file;
+ *              This function is mainly used by defragfs utility.
  *
- * NOTE:        This routine does not have the logic to handle
- *              uncommitted allocated extent. The caller should call
- *              txCommit() to commit all the allocation before call
- *              this routine.
+ * NOTE:        This routine does not have the logic to handle
+ *              uncommitted allocated extent. The caller should call
+ *              txCommit() to commit all the allocation before call
+ *              this routine.
  */
 int
 xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad,  /* old XAD */
@@ -2865,8 +2864,8 @@ xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad,	/* old XAD */
                  xtype, (ulong) xoff, xlen, (ulong) oxaddr, (ulong) nxaddr);
 
         /*
-         *      1. get and validate the parent xtpage/xad entry
-         *      covering the source extent to be relocated;
+         *      1. get and validate the parent xtpage/xad entry
+         *      covering the source extent to be relocated;
          */
         if (xtype == DATAEXT) {
                 /* search in leaf entry */
@@ -2910,7 +2909,7 @@ xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad,	/* old XAD */
         jfs_info("xtRelocate: parent xad entry validated.");
 
         /*
-         *      2. relocate the extent
+         *      2. relocate the extent
          */
         if (xtype == DATAEXT) {
                 /* if the extent is allocated-but-not-recorded
@@ -2923,7 +2922,7 @@ xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad,	/* old XAD */
                         XT_PUTPAGE(pmp);
 
                 /*
-                 *      cmRelocate()
+                 *      cmRelocate()
                  *
                  * copy target data pages to be relocated;
                  *
@@ -2945,8 +2944,8 @@ xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad,	/* old XAD */
                 pno = offset >> CM_L2BSIZE;
                 npages = (nbytes + (CM_BSIZE - 1)) >> CM_L2BSIZE;
 /*
-                npages = ((offset + nbytes - 1) >> CM_L2BSIZE) -
-                         (offset >> CM_L2BSIZE) + 1;
+                npages = ((offset + nbytes - 1) >> CM_L2BSIZE) -
+                          (offset >> CM_L2BSIZE) + 1;
 */
                 sxaddr = oxaddr;
                 dxaddr = nxaddr;
@@ -2981,7 +2980,7 @@ xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad,	/* old XAD */
 
                 XT_GETSEARCH(ip, btstack.top, bn, pmp, pp, index);
                 jfs_info("xtRelocate: target data extent relocated.");
-        } else {                /* (xtype  == XTPAGE) */
+        } else {                /* (xtype == XTPAGE) */
 
                 /*
                  * read in the target xtpage from the source extent;
@@ -3026,16 +3025,14 @@ xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad,	/* old XAD */
                  */
                 if (lmp) {
                         BT_MARK_DIRTY(lmp, ip);
-                        tlck =
-                            txLock(tid, ip, lmp, tlckXTREE | tlckRELINK);
+                        tlck = txLock(tid, ip, lmp, tlckXTREE | tlckRELINK);
                         lp->header.next = cpu_to_le64(nxaddr);
                         XT_PUTPAGE(lmp);
                 }
 
                 if (rmp) {
                         BT_MARK_DIRTY(rmp, ip);
-                        tlck =
-                            txLock(tid, ip, rmp, tlckXTREE | tlckRELINK);
+                        tlck = txLock(tid, ip, rmp, tlckXTREE | tlckRELINK);
                         rp->header.prev = cpu_to_le64(nxaddr);
                         XT_PUTPAGE(rmp);
                 }
@@ -3062,7 +3059,7 @@ xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad,	/* old XAD */
                  * scan may be skipped by commit() and logredo();
                  */
                 BT_MARK_DIRTY(mp, ip);
-                /* tlckNEW init  xtlck->lwm.offset = XTENTRYSTART; */
+                /* tlckNEW init xtlck->lwm.offset = XTENTRYSTART; */
                 tlck = txLock(tid, ip, mp, tlckXTREE | tlckNEW);
                 xtlck = (struct xtlock *) & tlck->lock;
 
@@ -3084,7 +3081,7 @@ xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad,	/* old XAD */
         }
 
         /*
-         *      3. acquire maplock for the source extent to be freed;
+         *      3. acquire maplock for the source extent to be freed;
          *
          * acquire a maplock saving the src relocated extent address;
          * to free of the extent at commit time;
@@ -3105,7 +3102,7 @@ xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad,	/* old XAD */
          *      is no buffer associated with this lock since the buffer
          *      has been redirected to the target location.
          */
-        else                    /* (xtype  == XTPAGE) */
+        else                    /* (xtype == XTPAGE) */
                 tlck = txMaplock(tid, ip, tlckMAP | tlckRELOCATE);
 
         pxdlock = (struct pxd_lock *) & tlck->lock;
@@ -3115,7 +3112,7 @@ xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad,	/* old XAD */
         pxdlock->index = 1;
 
         /*
-         *      4. update the parent xad entry for relocation;
+         *      4. update the parent xad entry for relocation;
          *
          * acquire tlck for the parent entry with XAD_NEW as entry
          * update which will write LOG_REDOPAGE and update bmap for
@@ -3143,22 +3140,22 @@ xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad,	/* old XAD */
 
 
 /*
- *      xtSearchNode()
+ *      xtSearchNode()
  *
- * function:    search for the internal xad entry covering specified extent.
- *              This function is mainly used by defragfs utility.
+ * function:    search for the internal xad entry covering specified extent.
+ *              This function is mainly used by defragfs utility.
  *
  * parameters:
- *      ip      - file object;
- *      xad     - extent to find;
- *      cmpp    - comparison result:
- *      btstack - traverse stack;
- *      flag    - search process flag;
+ *      ip      - file object;
+ *      xad     - extent to find;
+ *      cmpp    - comparison result:
+ *      btstack - traverse stack;
+ *      flag    - search process flag;
  *
  * returns:
- *      btstack contains (bn, index) of search path traversed to the entry.
- *      *cmpp is set to result of comparison with the entry returned.
- *      the page containing the entry is pinned at exit.
+ *      btstack contains (bn, index) of search path traversed to the entry.
+ *      *cmpp is set to result of comparison with the entry returned.
+ *      the page containing the entry is pinned at exit.
  */
 static int xtSearchNode(struct inode *ip, xad_t * xad,  /* required XAD entry */
                         int *cmpp, struct btstack * btstack, int flag)
@@ -3181,7 +3178,7 @@ static int xtSearchNode(struct inode *ip, xad_t * xad,	/* required XAD entry */
         xaddr = addressXAD(xad);
 
         /*
-         *      search down tree from root:
+         *      search down tree from root:
          *
          * between two consecutive entries of <Ki, Pi> and <Kj, Pj> of
          * internal page, child page Pi contains entry with k, Ki <= K < Kj.
@@ -3217,7 +3214,7 @@ static int xtSearchNode(struct inode *ip, xad_t * xad,	/* required XAD entry */
                         XT_CMP(cmp, xoff, &p->xad[index], t64);
                         if (cmp == 0) {
                                 /*
-                                 *      search hit
+                                 *      search hit
                                  *
                                  * verify for exact match;
                                  */
@@ -3245,7 +3242,7 @@ static int xtSearchNode(struct inode *ip, xad_t * xad,	/* required XAD entry */
                 }
 
                 /*
-                 *      search miss - non-leaf page:
+                 *      search miss - non-leaf page:
                  *
                  * base is the smallest index with key (Kj) greater than
                  * search key (K) and may be zero or maxentry index.
@@ -3268,15 +3265,15 @@ static int xtSearchNode(struct inode *ip, xad_t * xad,	/* required XAD entry */
 
 
 /*
- *      xtRelink()
+ *      xtRelink()
  *
  * function:
- *      link around a freed page.
+ *      link around a freed page.
  *
  * Parameter:
- *      int           tid,
- *      struct inode    *ip,
- *      xtpage_t        *p)
+ *      int             tid,
+ *      struct inode    *ip,
+ *      xtpage_t        *p)
  *
  * returns:
  */
@@ -3338,7 +3335,7 @@ static int xtRelink(tid_t tid, struct inode *ip, xtpage_t * p)
 
 
 /*
- *      xtInitRoot()
+ *      xtInitRoot()
  *
  * initialize file root (inline in inode)
  */
@@ -3385,42 +3382,42 @@ void xtInitRoot(tid_t tid, struct inode *ip)
 #define MAX_TRUNCATE_LEAVES 50
 
 /*
- *      xtTruncate()
+ *      xtTruncate()
  *
  * function:
- *      traverse for truncation logging backward bottom up;
- *      terminate at the last extent entry at the current subtree
- *      root page covering new down size.
- *      truncation may occur within the last extent entry.
+ *      traverse for truncation logging backward bottom up;
+ *      terminate at the last extent entry at the current subtree
+ *      root page covering new down size.
+ *      truncation may occur within the last extent entry.
  *
  * parameter:
- *      int           tid,
- *      struct inode    *ip,
- *      s64           newsize,
- *      int           type)   {PWMAP, PMAP, WMAP; DELETE, TRUNCATE}
+ *      int             tid,
+ *      struct inode    *ip,
+ *      s64             newsize,
+ *      int             type)   {PWMAP, PMAP, WMAP; DELETE, TRUNCATE}
  *
  * return:
  *
  * note:
- *      PWMAP:
- *       1. truncate (non-COMMIT_NOLINK file)
- *          by jfs_truncate() or jfs_open(O_TRUNC):
- *          xtree is updated;
+ *      PWMAP:
+ *       1. truncate (non-COMMIT_NOLINK file)
+ *          by jfs_truncate() or jfs_open(O_TRUNC):
+ *          xtree is updated;
  *       2. truncate index table of directory when last entry removed
- *       map update via tlock at commit time;
- *      PMAP:
+ *      map update via tlock at commit time;
+ *      PMAP:
  *       Call xtTruncate_pmap instead
- *      WMAP:
- *       1. remove (free zero link count) on last reference release
- *          (pmap has been freed at commit zero link count);
- *       2. truncate (COMMIT_NOLINK file, i.e., tmp file):
- *          xtree is updated;
- *       map update directly at truncation time;
+ *      WMAP:
+ *       1. remove (free zero link count) on last reference release
+ *          (pmap has been freed at commit zero link count);
+ *       2. truncate (COMMIT_NOLINK file, i.e., tmp file):
+ *          xtree is updated;
+ *       map update directly at truncation time;
  *
- *      if (DELETE)
- *              no LOG_NOREDOPAGE is required (NOREDOFILE is sufficient);
- *      else if (TRUNCATE)
- *              must write LOG_NOREDOPAGE for deleted index page;
+ *      if (DELETE)
+ *              no LOG_NOREDOPAGE is required (NOREDOFILE is sufficient);
+ *      else if (TRUNCATE)
+ *              must write LOG_NOREDOPAGE for deleted index page;
  *
  * pages may already have been tlocked by anonymous transactions
  * during file growth (i.e., write) before truncation;
@@ -3493,7 +3490,7 @@ s64 xtTruncate(tid_t tid, struct inode *ip, s64 newsize, int flag)
          * retained in the new sized file.
          * if type is PMAP, the data and index pages are NOT
          * freed, and the data and index blocks are NOT freed
-         * from  working map.
+         * from working map.
          * (this will allow continued access of data/index of
          * temporary file (zerolink count file truncated to zero-length)).
          */
@@ -3542,7 +3539,7 @@ s64 xtTruncate(tid_t tid, struct inode *ip, s64 newsize, int flag)
                 goto getChild;
 
         /*
-         *      leaf page
+         *      leaf page
          */
         freed = 0;
 
@@ -3916,7 +3913,7 @@ s64 xtTruncate(tid_t tid, struct inode *ip, s64 newsize, int flag)
         }
 
         /*
-         *      internal page: go down to child page of current entry
+         *      internal page: go down to child page of current entry
          */
       getChild:
         /* save current parent entry for the child page */
@@ -3965,7 +3962,7 @@ s64 xtTruncate(tid_t tid, struct inode *ip, s64 newsize, int flag)
 
 
 /*
- *      xtTruncate_pmap()
+ *      xtTruncate_pmap()
  *
  * function:
  *      Perform truncate to zero lenghth for deleted file, leaving the
@@ -3974,9 +3971,9 @@ s64 xtTruncate(tid_t tid, struct inode *ip, s64 newsize, int flag)
  *      is committed to disk.
  *
  * parameter:
- *      tid_t           tid,
- *      struct inode    *ip,
- *      s64             committed_size)
+ *      tid_t           tid,
+ *      struct inode    *ip,
+ *      s64             committed_size)
  *
  * return: new committed size
  *
@@ -4050,7 +4047,7 @@ s64 xtTruncate_pmap(tid_t tid, struct inode *ip, s64 committed_size)
         }
 
         /*
-         *      leaf page
+         *      leaf page
          */
 
         if (++locked_leaves > MAX_TRUNCATE_LEAVES) {
@@ -4062,7 +4059,7 @@ s64 xtTruncate_pmap(tid_t tid, struct inode *ip, s64 committed_size)
                 xoff = offsetXAD(xad);
                 xlen = lengthXAD(xad);
                 XT_PUTPAGE(mp);
-                return  (xoff + xlen) << JFS_SBI(ip->i_sb)->l2bsize;
+                return (xoff + xlen) << JFS_SBI(ip->i_sb)->l2bsize;
         }
         tlck = txLock(tid, ip, mp, tlckXTREE);
         tlck->type = tlckXTREE | tlckFREE;
@@ -4099,8 +4096,7 @@ s64 xtTruncate_pmap(tid_t tid, struct inode *ip, s64 committed_size)
                  */
                 tlck = txLock(tid, ip, mp, tlckXTREE);
                 xtlck = (struct xtlock *) & tlck->lock;
-                xtlck->hwm.offset =
-                    le16_to_cpu(p->header.nextindex) - 1;
+                xtlck->hwm.offset = le16_to_cpu(p->header.nextindex) - 1;
                 tlck->type = tlckXTREE | tlckFREE;
 
                 XT_PUTPAGE(mp);
@@ -4118,7 +4114,7 @@ s64 xtTruncate_pmap(tid_t tid, struct inode *ip, s64 committed_size)
         else
                 index--;
         /*
-         *      internal page: go down to child page of current entry
+         *      internal page: go down to child page of current entry
          */
       getChild:
         /* save current parent entry for the child page */