[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>
This commit is contained in:
Mingming Cao
committed by
Linus Torvalds
Linus Torvalds
parent
e7ab8d6505
commit
ae6ddcc5f2
@@ -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);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user