[PATCH] ext3 and jbd cleanup: remove whitespace

Remove whitespace from ext3 and jbd, before we clone ext4.

Signed-off-by: Mingming Cao<cmm@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 32 insertions, 32 deletions

diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 84be02e93652..473d206b1d7e 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -55,7 +55,7 @@ static int ext3_inode_is_fast_symlink(struct inode *inode)
 /*
  * The ext3 forget function must perform a revoke if we are freeing data
  * which has been journaled.  Metadata (eg. indirect blocks) must be
- * revoked in all cases. 
+ * revoked in all cases.
  *
  * "bh" may be NULL: a metadata block may have been freed from memory
  * but there may still be a record of it in the journal, and that record
@@ -105,7 +105,7 @@ int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,
  * Work out how many blocks we need to proceed with the next chunk of a
  * truncate transaction.
  */
-static unsigned long blocks_for_truncate(struct inode *inode) 
+static unsigned long blocks_for_truncate(struct inode *inode)
 {
         unsigned long needed;
 
@@ -122,13 +122,13 @@ static unsigned long blocks_for_truncate(struct inode *inode)
 
         /* But we need to bound the transaction so we don't overflow the
          * journal. */
-        if (needed > EXT3_MAX_TRANS_DATA) 
+        if (needed > EXT3_MAX_TRANS_DATA)
                 needed = EXT3_MAX_TRANS_DATA;
 
         return EXT3_DATA_TRANS_BLOCKS(inode->i_sb) + needed;
 }
 
-/* 
+/*
  * Truncate transactions can be complex and absolutely huge.  So we need to
  * be able to restart the transaction at a conventient checkpoint to make
  * sure we don't overflow the journal.
@@ -136,9 +136,9 @@ static unsigned long blocks_for_truncate(struct inode *inode)
  * start_transaction gets us a new handle for a truncate transaction,
  * and extend_transaction tries to extend the existing one a bit.  If
  * extend fails, we need to propagate the failure up and restart the
- * transaction in the top-level truncate loop. --sct 
+ * transaction in the top-level truncate loop. --sct
  */
-static handle_t *start_transaction(struct inode *inode) 
+static handle_t *start_transaction(struct inode *inode)
 {
         handle_t *result;
 
@@ -215,12 +215,12 @@ void ext3_delete_inode (struct inode * inode)
         ext3_orphan_del(handle, inode);
         EXT3_I(inode)->i_dtime  = get_seconds();
 
-        /* 
+        /*
          * One subtle ordering requirement: if anything has gone wrong
          * (transaction abort, IO errors, whatever), then we can still
          * do these next steps (the fs will already have been marked as
          * having errors), but we can't free the inode if the mark_dirty
-         * fails.  
+         * fails.
          */
         if (ext3_mark_inode_dirty(handle, inode))
                 /* If that failed, just do the required in-core inode clear. */
@@ -398,7 +398,7 @@ no_block:
  *        + if there is a block to the left of our position - allocate near it.
  *        + if pointer will live in indirect block - allocate near that block.
  *        + if pointer will live in inode - allocate in the same
- *          cylinder group. 
+ *          cylinder group.
  *
  * In the latter case we colour the starting block by the callers PID to
  * prevent it from clashing with concurrent allocations for a different inode
@@ -744,7 +744,7 @@ static int ext3_splice_branch(handle_t *handle, struct inode *inode,
                 jbd_debug(5, "splicing indirect only\n");
                 BUFFER_TRACE(where->bh, "call ext3_journal_dirty_metadata");
                 err = ext3_journal_dirty_metadata(handle, where->bh);
-                if (err) 
+                if (err)
                         goto err_out;
         } else {
                 /*
@@ -1137,7 +1137,7 @@ static int walk_page_buffers(	handle_t *handle,
  * So what we do is to rely on the fact that journal_stop/journal_start
  * will _not_ run commit under these circumstances because handle->h_ref
  * is elevated.  We'll still have enough credits for the tiny quotafile
- * write.  
+ * write.
  */
 static int do_journal_get_write_access(handle_t *handle,
                                         struct buffer_head *bh)
@@ -1282,7 +1282,7 @@ static int ext3_journalled_commit_write(struct file *file,
         if (inode->i_size > EXT3_I(inode)->i_disksize) {
                 EXT3_I(inode)->i_disksize = inode->i_size;
                 ret2 = ext3_mark_inode_dirty(handle, inode);
-                if (!ret) 
+                if (!ret)
                         ret = ret2;
         }
         ret2 = ext3_journal_stop(handle);
@@ -1291,7 +1291,7 @@ static int ext3_journalled_commit_write(struct file *file,
         return ret;
 }
 
-/* 
+/*
  * bmap() is special.  It gets used by applications such as lilo and by
  * the swapper to find the on-disk block of a specific piece of data.
  *
@@ -1300,10 +1300,10 @@ static int ext3_journalled_commit_write(struct file *file,
  * filesystem and enables swap, then they may get a nasty shock when the
  * data getting swapped to that swapfile suddenly gets overwritten by
  * the original zero's written out previously to the journal and
- * awaiting writeback in the kernel's buffer cache. 
+ * awaiting writeback in the kernel's buffer cache.
  *
  * So, if we see any bmap calls here on a modified, data-journaled file,
- * take extra steps to flush any blocks which might be in the cache. 
+ * take extra steps to flush any blocks which might be in the cache.
  */
 static sector_t ext3_bmap(struct address_space *mapping, sector_t block)
 {
@@ -1312,16 +1312,16 @@ static sector_t ext3_bmap(struct address_space *mapping, sector_t block)
         int err;
 
         if (EXT3_I(inode)->i_state & EXT3_STATE_JDATA) {
-                /* 
+                /*
                  * This is a REALLY heavyweight approach, but the use of
                  * bmap on dirty files is expected to be extremely rare:
                  * only if we run lilo or swapon on a freshly made file
-                 * do we expect this to happen. 
+                 * do we expect this to happen.
                  *
                  * (bmap requires CAP_SYS_RAWIO so this does not
                  * represent an unprivileged user DOS attack --- we'd be
                  * in trouble if mortal users could trigger this path at
-                 * will.) 
+                 * will.)
                  *
                  * NB. EXT3_STATE_JDATA is not set on files other than
                  * regular files.  If somebody wants to bmap a directory
@@ -1457,7 +1457,7 @@ static int ext3_ordered_writepage(struct page *page,
          */
 
         /*
-         * And attach them to the current transaction.  But only if 
+         * And attach them to the current transaction.  But only if
          * block_write_full_page() succeeded.  Otherwise they are unmapped,
          * and generally junk.
          */
@@ -1644,7 +1644,7 @@ static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
                 }
         }
 
-        ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov, 
+        ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
                                  offset, nr_segs,
                                  ext3_get_block, NULL);
 
@@ -2025,7 +2025,7 @@ static void ext3_free_data(handle_t *handle, struct inode *inode,
                            __le32 *first, __le32 *last)
 {
         ext3_fsblk_t block_to_free = 0;    /* Starting block # of a run */
-        unsigned long count = 0;            /* Number of blocks in the run */ 
+        unsigned long count = 0;            /* Number of blocks in the run */
         __le32 *block_to_free_p = NULL;     /* Pointer into inode/ind
                                                corresponding to
                                                block_to_free */
@@ -2054,7 +2054,7 @@ static void ext3_free_data(handle_t *handle, struct inode *inode,
                         } else if (nr == block_to_free + count) {
                                 count++;
                         } else {
-                                ext3_clear_blocks(handle, inode, this_bh, 
+                                ext3_clear_blocks(handle, inode, this_bh,
                                                   block_to_free,
                                                   count, block_to_free_p, p);
                                 block_to_free = nr;
@@ -2184,7 +2184,7 @@ static void ext3_free_branches(handle_t *handle, struct inode *inode,
                                         *p = 0;
                                         BUFFER_TRACE(parent_bh,
                                         "call ext3_journal_dirty_metadata");
-                                        ext3_journal_dirty_metadata(handle, 
+                                        ext3_journal_dirty_metadata(handle,
                                                                     parent_bh);
                                 }
                         }
@@ -2704,7 +2704,7 @@ void ext3_read_inode(struct inode * inode)
                 if (raw_inode->i_block[0])
                         init_special_inode(inode, inode->i_mode,
                            old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
-                else 
+                else
                         init_special_inode(inode, inode->i_mode,
                            new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
         }
@@ -2724,8 +2724,8 @@ bad_inode:
  *
  * The caller must have write access to iloc->bh.
  */
-static int ext3_do_update_inode(handle_t *handle, 
-                                struct inode *inode, 
+static int ext3_do_update_inode(handle_t *handle,
+                                struct inode *inode,
                                 struct ext3_iloc *iloc)
 {
         struct ext3_inode *raw_inode = ext3_raw_inode(iloc);
@@ -2900,7 +2900,7 @@ int ext3_write_inode(struct inode *inode, int wait)
  * commit will leave the blocks being flushed in an unused state on
  * disk.  (On recovery, the inode will get truncated and the blocks will
  * be freed, so we have a strong guarantee that no future commit will
- * leave these blocks visible to the user.)  
+ * leave these blocks visible to the user.)
  *
  * Called with inode->sem down.
  */
@@ -3043,13 +3043,13 @@ int ext3_mark_iloc_dirty(handle_t *handle,
         return err;
 }
 
-/* 
+/*
  * On success, We end up with an outstanding reference count against
- * iloc->bh.  This _must_ be cleaned up later. 
+ * iloc->bh.  This _must_ be cleaned up later.
  */
 
 int
-ext3_reserve_inode_write(handle_t *handle, struct inode *inode, 
+ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
                          struct ext3_iloc *iloc)
 {
         int err = 0;
@@ -3139,7 +3139,7 @@ out:
 }
 
 #if 0
-/* 
+/*
  * Bind an inode's backing buffer_head into this transaction, to prevent
  * it from being flushed to disk early.  Unlike
  * ext3_reserve_inode_write, this leaves behind no bh reference and
@@ -3157,7 +3157,7 @@ static int ext3_pin_inode(handle_t *handle, struct inode *inode)
                         BUFFER_TRACE(iloc.bh, "get_write_access");
                         err = journal_get_write_access(handle, iloc.bh);
                         if (!err)
-                                err = ext3_journal_dirty_metadata(handle, 
+                                err = ext3_journal_dirty_metadata(handle,
                                                                   iloc.bh);
                         brelse(iloc.bh);
                 }