mirror of
https://github.com/torvalds/linux.git
synced 2025-01-01 07:42:07 +00:00
ext4: Fix up whitespace issues in fs/ext4/inode.c
This is a pure cleanup patch. Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
This commit is contained in:
Theodore Ts'o
parent
0610b6e999
commit
de9a55b841
200
fs/ext4/inode.c
200
fs/ext4/inode.c
@ -81,7 +81,7 @@ static int ext4_inode_is_fast_symlink(struct inode *inode)
|
||||
* If the handle isn't valid we're not journaling so there's nothing to do.
|
||||
*/
|
||||
int ext4_forget(handle_t *handle, int is_metadata, struct inode *inode,
|
||||
struct buffer_head *bh, ext4_fsblk_t blocknr)
|
||||
struct buffer_head *bh, ext4_fsblk_t blocknr)
|
||||
{
|
||||
int err;
|
||||
|
||||
@ -332,8 +332,8 @@ static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
|
||||
*/
|
||||
|
||||
static int ext4_block_to_path(struct inode *inode,
|
||||
ext4_lblk_t i_block,
|
||||
ext4_lblk_t offsets[4], int *boundary)
|
||||
ext4_lblk_t i_block,
|
||||
ext4_lblk_t offsets[4], int *boundary)
|
||||
{
|
||||
int ptrs = EXT4_ADDR_PER_BLOCK(inode->i_sb);
|
||||
int ptrs_bits = EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb);
|
||||
@ -365,9 +365,9 @@ static int ext4_block_to_path(struct inode *inode,
|
||||
final = ptrs;
|
||||
} else {
|
||||
ext4_warning(inode->i_sb, "ext4_block_to_path",
|
||||
"block %lu > max in inode %lu",
|
||||
i_block + direct_blocks +
|
||||
indirect_blocks + double_blocks, inode->i_ino);
|
||||
"block %lu > max in inode %lu",
|
||||
i_block + direct_blocks +
|
||||
indirect_blocks + double_blocks, inode->i_ino);
|
||||
}
|
||||
if (boundary)
|
||||
*boundary = final - 1 - (i_block & (ptrs - 1));
|
||||
@ -382,25 +382,25 @@ static int __ext4_check_blockref(const char *function, struct inode *inode,
|
||||
|
||||
while (bref < p+max) {
|
||||
blk = le32_to_cpu(*bref++);
|
||||
if (blk &&
|
||||
unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb),
|
||||
if (blk &&
|
||||
unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb),
|
||||
blk, 1))) {
|
||||
ext4_error(inode->i_sb, function,
|
||||
"invalid block reference %u "
|
||||
"in inode #%lu", blk, inode->i_ino);
|
||||
return -EIO;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
return -EIO;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#define ext4_check_indirect_blockref(inode, bh) \
|
||||
__ext4_check_blockref(__func__, inode, (__le32 *)(bh)->b_data, \
|
||||
__ext4_check_blockref(__func__, inode, (__le32 *)(bh)->b_data, \
|
||||
EXT4_ADDR_PER_BLOCK((inode)->i_sb))
|
||||
|
||||
#define ext4_check_inode_blockref(inode) \
|
||||
__ext4_check_blockref(__func__, inode, EXT4_I(inode)->i_data, \
|
||||
__ext4_check_blockref(__func__, inode, EXT4_I(inode)->i_data, \
|
||||
EXT4_NDIR_BLOCKS)
|
||||
|
||||
/**
|
||||
@ -450,7 +450,7 @@ static Indirect *ext4_get_branch(struct inode *inode, int depth,
|
||||
bh = sb_getblk(sb, le32_to_cpu(p->key));
|
||||
if (unlikely(!bh))
|
||||
goto failure;
|
||||
|
||||
|
||||
if (!bh_uptodate_or_lock(bh)) {
|
||||
if (bh_submit_read(bh) < 0) {
|
||||
put_bh(bh);
|
||||
@ -462,7 +462,7 @@ static Indirect *ext4_get_branch(struct inode *inode, int depth,
|
||||
goto failure;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
add_chain(++p, bh, (__le32 *)bh->b_data + *++offsets);
|
||||
/* Reader: end */
|
||||
if (!p->key)
|
||||
@ -555,7 +555,7 @@ static ext4_fsblk_t ext4_find_near(struct inode *inode, Indirect *ind)
|
||||
* returns it.
|
||||
*/
|
||||
static ext4_fsblk_t ext4_find_goal(struct inode *inode, ext4_lblk_t block,
|
||||
Indirect *partial)
|
||||
Indirect *partial)
|
||||
{
|
||||
/*
|
||||
* XXX need to get goal block from mballoc's data structures
|
||||
@ -577,7 +577,7 @@ static ext4_fsblk_t ext4_find_goal(struct inode *inode, ext4_lblk_t block,
|
||||
* direct and indirect blocks.
|
||||
*/
|
||||
static int ext4_blks_to_allocate(Indirect *branch, int k, unsigned int blks,
|
||||
int blocks_to_boundary)
|
||||
int blocks_to_boundary)
|
||||
{
|
||||
unsigned int count = 0;
|
||||
|
||||
@ -613,9 +613,9 @@ static int ext4_blks_to_allocate(Indirect *branch, int k, unsigned int blks,
|
||||
* direct blocks
|
||||
*/
|
||||
static int ext4_alloc_blocks(handle_t *handle, struct inode *inode,
|
||||
ext4_lblk_t iblock, ext4_fsblk_t goal,
|
||||
int indirect_blks, int blks,
|
||||
ext4_fsblk_t new_blocks[4], int *err)
|
||||
ext4_lblk_t iblock, ext4_fsblk_t goal,
|
||||
int indirect_blks, int blks,
|
||||
ext4_fsblk_t new_blocks[4], int *err)
|
||||
{
|
||||
struct ext4_allocation_request ar;
|
||||
int target, i;
|
||||
@ -686,10 +686,10 @@ static int ext4_alloc_blocks(handle_t *handle, struct inode *inode,
|
||||
}
|
||||
if (!*err) {
|
||||
if (target == blks) {
|
||||
/*
|
||||
* save the new block number
|
||||
* for the first direct block
|
||||
*/
|
||||
/*
|
||||
* save the new block number
|
||||
* for the first direct block
|
||||
*/
|
||||
new_blocks[index] = current_block;
|
||||
}
|
||||
blk_allocated += ar.len;
|
||||
@ -731,9 +731,9 @@ failed_out:
|
||||
* as described above and return 0.
|
||||
*/
|
||||
static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
|
||||
ext4_lblk_t iblock, int indirect_blks,
|
||||
int *blks, ext4_fsblk_t goal,
|
||||
ext4_lblk_t *offsets, Indirect *branch)
|
||||
ext4_lblk_t iblock, int indirect_blks,
|
||||
int *blks, ext4_fsblk_t goal,
|
||||
ext4_lblk_t *offsets, Indirect *branch)
|
||||
{
|
||||
int blocksize = inode->i_sb->s_blocksize;
|
||||
int i, n = 0;
|
||||
@ -780,7 +780,7 @@ static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
|
||||
* the chain to point to the new allocated
|
||||
* data blocks numbers
|
||||
*/
|
||||
for (i=1; i < num; i++)
|
||||
for (i = 1; i < num; i++)
|
||||
*(branch[n].p + i) = cpu_to_le32(++current_block);
|
||||
}
|
||||
BUFFER_TRACE(bh, "marking uptodate");
|
||||
@ -823,7 +823,8 @@ failed:
|
||||
* chain to new block and return 0.
|
||||
*/
|
||||
static int ext4_splice_branch(handle_t *handle, struct inode *inode,
|
||||
ext4_lblk_t block, Indirect *where, int num, int blks)
|
||||
ext4_lblk_t block, Indirect *where, int num,
|
||||
int blks)
|
||||
{
|
||||
int i;
|
||||
int err = 0;
|
||||
@ -924,9 +925,9 @@ err_out:
|
||||
* blocks.
|
||||
*/
|
||||
static int ext4_ind_get_blocks(handle_t *handle, struct inode *inode,
|
||||
ext4_lblk_t iblock, unsigned int maxblocks,
|
||||
struct buffer_head *bh_result,
|
||||
int flags)
|
||||
ext4_lblk_t iblock, unsigned int maxblocks,
|
||||
struct buffer_head *bh_result,
|
||||
int flags)
|
||||
{
|
||||
int err = -EIO;
|
||||
ext4_lblk_t offsets[4];
|
||||
@ -942,7 +943,7 @@ static int ext4_ind_get_blocks(handle_t *handle, struct inode *inode,
|
||||
J_ASSERT(!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL));
|
||||
J_ASSERT(handle != NULL || (flags & EXT4_GET_BLOCKS_CREATE) == 0);
|
||||
depth = ext4_block_to_path(inode, iblock, offsets,
|
||||
&blocks_to_boundary);
|
||||
&blocks_to_boundary);
|
||||
|
||||
if (depth == 0)
|
||||
goto out;
|
||||
@ -990,8 +991,8 @@ static int ext4_ind_get_blocks(handle_t *handle, struct inode *inode,
|
||||
* Block out ext4_truncate while we alter the tree
|
||||
*/
|
||||
err = ext4_alloc_branch(handle, inode, iblock, indirect_blks,
|
||||
&count, goal,
|
||||
offsets + (partial - chain), partial);
|
||||
&count, goal,
|
||||
offsets + (partial - chain), partial);
|
||||
|
||||
/*
|
||||
* The ext4_splice_branch call will free and forget any buffers
|
||||
@ -1002,8 +1003,8 @@ static int ext4_ind_get_blocks(handle_t *handle, struct inode *inode,
|
||||
*/
|
||||
if (!err)
|
||||
err = ext4_splice_branch(handle, inode, iblock,
|
||||
partial, indirect_blks, count);
|
||||
else
|
||||
partial, indirect_blks, count);
|
||||
else
|
||||
goto cleanup;
|
||||
|
||||
set_buffer_new(bh_result);
|
||||
@ -1175,7 +1176,7 @@ int ext4_get_blocks(handle_t *handle, struct inode *inode, sector_t block,
|
||||
up_read((&EXT4_I(inode)->i_data_sem));
|
||||
|
||||
if (retval > 0 && buffer_mapped(bh)) {
|
||||
int ret = check_block_validity(inode, block,
|
||||
int ret = check_block_validity(inode, block,
|
||||
bh->b_blocknr, retval);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
@ -1257,7 +1258,7 @@ int ext4_get_blocks(handle_t *handle, struct inode *inode, sector_t block,
|
||||
|
||||
up_write((&EXT4_I(inode)->i_data_sem));
|
||||
if (retval > 0 && buffer_mapped(bh)) {
|
||||
int ret = check_block_validity(inode, block,
|
||||
int ret = check_block_validity(inode, block,
|
||||
bh->b_blocknr, retval);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
@ -1408,8 +1409,7 @@ static int walk_page_buffers(handle_t *handle,
|
||||
|
||||
for (bh = head, block_start = 0;
|
||||
ret == 0 && (bh != head || !block_start);
|
||||
block_start = block_end, bh = next)
|
||||
{
|
||||
block_start = block_end, bh = next) {
|
||||
next = bh->b_this_page;
|
||||
block_end = block_start + blocksize;
|
||||
if (block_end <= from || block_start >= to) {
|
||||
@ -1450,7 +1450,7 @@ static int walk_page_buffers(handle_t *handle,
|
||||
* write.
|
||||
*/
|
||||
static int do_journal_get_write_access(handle_t *handle,
|
||||
struct buffer_head *bh)
|
||||
struct buffer_head *bh)
|
||||
{
|
||||
if (!buffer_mapped(bh) || buffer_freed(bh))
|
||||
return 0;
|
||||
@ -1458,15 +1458,15 @@ static int do_journal_get_write_access(handle_t *handle,
|
||||
}
|
||||
|
||||
static int ext4_write_begin(struct file *file, struct address_space *mapping,
|
||||
loff_t pos, unsigned len, unsigned flags,
|
||||
struct page **pagep, void **fsdata)
|
||||
loff_t pos, unsigned len, unsigned flags,
|
||||
struct page **pagep, void **fsdata)
|
||||
{
|
||||
struct inode *inode = mapping->host;
|
||||
int ret, needed_blocks;
|
||||
handle_t *handle;
|
||||
int retries = 0;
|
||||
struct page *page;
|
||||
pgoff_t index;
|
||||
pgoff_t index;
|
||||
unsigned from, to;
|
||||
|
||||
trace_ext4_write_begin(inode, pos, len, flags);
|
||||
@ -1475,7 +1475,7 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping,
|
||||
* we allocate blocks but write fails for some reason
|
||||
*/
|
||||
needed_blocks = ext4_writepage_trans_blocks(inode) + 1;
|
||||
index = pos >> PAGE_CACHE_SHIFT;
|
||||
index = pos >> PAGE_CACHE_SHIFT;
|
||||
from = pos & (PAGE_CACHE_SIZE - 1);
|
||||
to = from + len;
|
||||
|
||||
@ -1523,7 +1523,7 @@ retry:
|
||||
ext4_journal_stop(handle);
|
||||
if (pos + len > inode->i_size) {
|
||||
vmtruncate(inode, inode->i_size);
|
||||
/*
|
||||
/*
|
||||
* If vmtruncate failed early the inode might
|
||||
* still be on the orphan list; we need to
|
||||
* make sure the inode is removed from the
|
||||
@ -1550,9 +1550,9 @@ static int write_end_fn(handle_t *handle, struct buffer_head *bh)
|
||||
}
|
||||
|
||||
static int ext4_generic_write_end(struct file *file,
|
||||
struct address_space *mapping,
|
||||
loff_t pos, unsigned len, unsigned copied,
|
||||
struct page *page, void *fsdata)
|
||||
struct address_space *mapping,
|
||||
loff_t pos, unsigned len, unsigned copied,
|
||||
struct page *page, void *fsdata)
|
||||
{
|
||||
int i_size_changed = 0;
|
||||
struct inode *inode = mapping->host;
|
||||
@ -1603,9 +1603,9 @@ static int ext4_generic_write_end(struct file *file,
|
||||
* buffers are managed internally.
|
||||
*/
|
||||
static int ext4_ordered_write_end(struct file *file,
|
||||
struct address_space *mapping,
|
||||
loff_t pos, unsigned len, unsigned copied,
|
||||
struct page *page, void *fsdata)
|
||||
struct address_space *mapping,
|
||||
loff_t pos, unsigned len, unsigned copied,
|
||||
struct page *page, void *fsdata)
|
||||
{
|
||||
handle_t *handle = ext4_journal_current_handle();
|
||||
struct inode *inode = mapping->host;
|
||||
@ -1633,7 +1633,7 @@ static int ext4_ordered_write_end(struct file *file,
|
||||
|
||||
if (pos + len > inode->i_size) {
|
||||
vmtruncate(inode, inode->i_size);
|
||||
/*
|
||||
/*
|
||||
* If vmtruncate failed early the inode might still be
|
||||
* on the orphan list; we need to make sure the inode
|
||||
* is removed from the orphan list in that case.
|
||||
@ -1647,9 +1647,9 @@ static int ext4_ordered_write_end(struct file *file,
|
||||
}
|
||||
|
||||
static int ext4_writeback_write_end(struct file *file,
|
||||
struct address_space *mapping,
|
||||
loff_t pos, unsigned len, unsigned copied,
|
||||
struct page *page, void *fsdata)
|
||||
struct address_space *mapping,
|
||||
loff_t pos, unsigned len, unsigned copied,
|
||||
struct page *page, void *fsdata)
|
||||
{
|
||||
handle_t *handle = ext4_journal_current_handle();
|
||||
struct inode *inode = mapping->host;
|
||||
@ -1675,7 +1675,7 @@ static int ext4_writeback_write_end(struct file *file,
|
||||
|
||||
if (pos + len > inode->i_size) {
|
||||
vmtruncate(inode, inode->i_size);
|
||||
/*
|
||||
/*
|
||||
* If vmtruncate failed early the inode might still be
|
||||
* on the orphan list; we need to make sure the inode
|
||||
* is removed from the orphan list in that case.
|
||||
@ -1688,9 +1688,9 @@ static int ext4_writeback_write_end(struct file *file,
|
||||
}
|
||||
|
||||
static int ext4_journalled_write_end(struct file *file,
|
||||
struct address_space *mapping,
|
||||
loff_t pos, unsigned len, unsigned copied,
|
||||
struct page *page, void *fsdata)
|
||||
struct address_space *mapping,
|
||||
loff_t pos, unsigned len, unsigned copied,
|
||||
struct page *page, void *fsdata)
|
||||
{
|
||||
handle_t *handle = ext4_journal_current_handle();
|
||||
struct inode *inode = mapping->host;
|
||||
@ -1738,7 +1738,7 @@ static int ext4_journalled_write_end(struct file *file,
|
||||
ret = ret2;
|
||||
if (pos + len > inode->i_size) {
|
||||
vmtruncate(inode, inode->i_size);
|
||||
/*
|
||||
/*
|
||||
* If vmtruncate failed early the inode might still be
|
||||
* on the orphan list; we need to make sure the inode
|
||||
* is removed from the orphan list in that case.
|
||||
@ -1845,7 +1845,7 @@ static void ext4_da_release_space(struct inode *inode, int to_free)
|
||||
}
|
||||
|
||||
static void ext4_da_page_release_reservation(struct page *page,
|
||||
unsigned long offset)
|
||||
unsigned long offset)
|
||||
{
|
||||
int to_release = 0;
|
||||
struct buffer_head *head, *bh;
|
||||
@ -2854,8 +2854,8 @@ static int ext4_nonda_switch(struct super_block *sb)
|
||||
}
|
||||
|
||||
static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
|
||||
loff_t pos, unsigned len, unsigned flags,
|
||||
struct page **pagep, void **fsdata)
|
||||
loff_t pos, unsigned len, unsigned flags,
|
||||
struct page **pagep, void **fsdata)
|
||||
{
|
||||
int ret, retries = 0;
|
||||
struct page *page;
|
||||
@ -2925,7 +2925,7 @@ out:
|
||||
* when write to the end of file but not require block allocation
|
||||
*/
|
||||
static int ext4_da_should_update_i_disksize(struct page *page,
|
||||
unsigned long offset)
|
||||
unsigned long offset)
|
||||
{
|
||||
struct buffer_head *bh;
|
||||
struct inode *inode = page->mapping->host;
|
||||
@ -2944,9 +2944,9 @@ static int ext4_da_should_update_i_disksize(struct page *page,
|
||||
}
|
||||
|
||||
static int ext4_da_write_end(struct file *file,
|
||||
struct address_space *mapping,
|
||||
loff_t pos, unsigned len, unsigned copied,
|
||||
struct page *page, void *fsdata)
|
||||
struct address_space *mapping,
|
||||
loff_t pos, unsigned len, unsigned copied,
|
||||
struct page *page, void *fsdata)
|
||||
{
|
||||
struct inode *inode = mapping->host;
|
||||
int ret = 0, ret2;
|
||||
@ -3044,7 +3044,7 @@ int ext4_alloc_da_blocks(struct inode *inode)
|
||||
* not strictly speaking necessary (and for users of
|
||||
* laptop_mode, not even desirable). However, to do otherwise
|
||||
* would require replicating code paths in:
|
||||
*
|
||||
*
|
||||
* ext4_da_writepages() ->
|
||||
* write_cache_pages() ---> (via passed in callback function)
|
||||
* __mpage_da_writepage() -->
|
||||
@ -3064,7 +3064,7 @@ int ext4_alloc_da_blocks(struct inode *inode)
|
||||
* write out the pages, but rather only collect contiguous
|
||||
* logical block extents, call the multi-block allocator, and
|
||||
* then update the buffer heads with the block allocations.
|
||||
*
|
||||
*
|
||||
* For now, though, we'll cheat by calling filemap_flush(),
|
||||
* which will map the blocks, and start the I/O, but not
|
||||
* actually wait for the I/O to complete.
|
||||
@ -3200,7 +3200,7 @@ static int bput_one(handle_t *handle, struct buffer_head *bh)
|
||||
*
|
||||
*/
|
||||
static int __ext4_normal_writepage(struct page *page,
|
||||
struct writeback_control *wbc)
|
||||
struct writeback_control *wbc)
|
||||
{
|
||||
struct inode *inode = page->mapping->host;
|
||||
|
||||
@ -3212,7 +3212,7 @@ static int __ext4_normal_writepage(struct page *page,
|
||||
}
|
||||
|
||||
static int ext4_normal_writepage(struct page *page,
|
||||
struct writeback_control *wbc)
|
||||
struct writeback_control *wbc)
|
||||
{
|
||||
struct inode *inode = page->mapping->host;
|
||||
loff_t size = i_size_read(inode);
|
||||
@ -3248,7 +3248,7 @@ static int ext4_normal_writepage(struct page *page,
|
||||
}
|
||||
|
||||
static int __ext4_journalled_writepage(struct page *page,
|
||||
struct writeback_control *wbc)
|
||||
struct writeback_control *wbc)
|
||||
{
|
||||
struct address_space *mapping = page->mapping;
|
||||
struct inode *inode = mapping->host;
|
||||
@ -3298,7 +3298,7 @@ out:
|
||||
}
|
||||
|
||||
static int ext4_journalled_writepage(struct page *page,
|
||||
struct writeback_control *wbc)
|
||||
struct writeback_control *wbc)
|
||||
{
|
||||
struct inode *inode = page->mapping->host;
|
||||
loff_t size = i_size_read(inode);
|
||||
@ -3401,8 +3401,8 @@ static int ext4_releasepage(struct page *page, gfp_t wait)
|
||||
* VFS code falls back into buffered path in that case so we are safe.
|
||||
*/
|
||||
static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb,
|
||||
const struct iovec *iov, loff_t offset,
|
||||
unsigned long nr_segs)
|
||||
const struct iovec *iov, loff_t offset,
|
||||
unsigned long nr_segs)
|
||||
{
|
||||
struct file *file = iocb->ki_filp;
|
||||
struct inode *inode = file->f_mapping->host;
|
||||
@ -3722,7 +3722,8 @@ static inline int all_zeroes(__le32 *p, __le32 *q)
|
||||
* (no partially truncated stuff there). */
|
||||
|
||||
static Indirect *ext4_find_shared(struct inode *inode, int depth,
|
||||
ext4_lblk_t offsets[4], Indirect chain[4], __le32 *top)
|
||||
ext4_lblk_t offsets[4], Indirect chain[4],
|
||||
__le32 *top)
|
||||
{
|
||||
Indirect *partial, *p;
|
||||
int k, err;
|
||||
@ -3778,8 +3779,10 @@ no_top:
|
||||
* than `count' because there can be holes in there.
|
||||
*/
|
||||
static void ext4_clear_blocks(handle_t *handle, struct inode *inode,
|
||||
struct buffer_head *bh, ext4_fsblk_t block_to_free,
|
||||
unsigned long count, __le32 *first, __le32 *last)
|
||||
struct buffer_head *bh,
|
||||
ext4_fsblk_t block_to_free,
|
||||
unsigned long count, __le32 *first,
|
||||
__le32 *last)
|
||||
{
|
||||
__le32 *p;
|
||||
if (try_to_extend_transaction(handle, inode)) {
|
||||
@ -3796,10 +3799,11 @@ static void ext4_clear_blocks(handle_t *handle, struct inode *inode,
|
||||
}
|
||||
|
||||
/*
|
||||
* Any buffers which are on the journal will be in memory. We find
|
||||
* them on the hash table so jbd2_journal_revoke() will run jbd2_journal_forget()
|
||||
* on them. We've already detached each block from the file, so
|
||||
* bforget() in jbd2_journal_forget() should be safe.
|
||||
* Any buffers which are on the journal will be in memory. We
|
||||
* find them on the hash table so jbd2_journal_revoke() will
|
||||
* run jbd2_journal_forget() on them. We've already detached
|
||||
* each block from the file, so bforget() in
|
||||
* jbd2_journal_forget() should be safe.
|
||||
*
|
||||
* AKPM: turn on bforget in jbd2_journal_forget()!!!
|
||||
*/
|
||||
@ -4171,7 +4175,7 @@ void ext4_truncate(struct inode *inode)
|
||||
(__le32*)partial->bh->b_data+addr_per_block,
|
||||
(chain+n-1) - partial);
|
||||
BUFFER_TRACE(partial->bh, "call brelse");
|
||||
brelse (partial->bh);
|
||||
brelse(partial->bh);
|
||||
partial--;
|
||||
}
|
||||
do_indirects:
|
||||
@ -4412,8 +4416,9 @@ void ext4_get_inode_flags(struct ext4_inode_info *ei)
|
||||
if (flags & S_DIRSYNC)
|
||||
ei->i_flags |= EXT4_DIRSYNC_FL;
|
||||
}
|
||||
|
||||
static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
|
||||
struct ext4_inode_info *ei)
|
||||
struct ext4_inode_info *ei)
|
||||
{
|
||||
blkcnt_t i_blocks ;
|
||||
struct inode *inode = &(ei->vfs_inode);
|
||||
@ -4528,7 +4533,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
|
||||
EXT4_GOOD_OLD_INODE_SIZE +
|
||||
ei->i_extra_isize;
|
||||
if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC))
|
||||
ei->i_state |= EXT4_STATE_XATTR;
|
||||
ei->i_state |= EXT4_STATE_XATTR;
|
||||
}
|
||||
} else
|
||||
ei->i_extra_isize = 0;
|
||||
@ -4547,7 +4552,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
|
||||
|
||||
ret = 0;
|
||||
if (ei->i_file_acl &&
|
||||
((ei->i_file_acl <
|
||||
((ei->i_file_acl <
|
||||
(le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block) +
|
||||
EXT4_SB(sb)->s_gdb_count)) ||
|
||||
(ei->i_file_acl >= ext4_blocks_count(EXT4_SB(sb)->s_es)))) {
|
||||
@ -4562,15 +4567,15 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
|
||||
!ext4_inode_is_fast_symlink(inode)))
|
||||
/* Validate extent which is part of inode */
|
||||
ret = ext4_ext_check_inode(inode);
|
||||
} else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
|
||||
} else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
|
||||
(S_ISLNK(inode->i_mode) &&
|
||||
!ext4_inode_is_fast_symlink(inode))) {
|
||||
/* Validate block references which are part of inode */
|
||||
/* Validate block references which are part of inode */
|
||||
ret = ext4_check_inode_blockref(inode);
|
||||
}
|
||||
if (ret) {
|
||||
brelse(bh);
|
||||
goto bad_inode;
|
||||
brelse(bh);
|
||||
goto bad_inode;
|
||||
}
|
||||
|
||||
if (S_ISREG(inode->i_mode)) {
|
||||
@ -4601,7 +4606,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
|
||||
} else {
|
||||
brelse(bh);
|
||||
ret = -EIO;
|
||||
ext4_error(inode->i_sb, __func__,
|
||||
ext4_error(inode->i_sb, __func__,
|
||||
"bogus i_mode (%o) for inode=%lu",
|
||||
inode->i_mode, inode->i_ino);
|
||||
goto bad_inode;
|
||||
@ -4754,8 +4759,9 @@ static int ext4_do_update_inode(handle_t *handle,
|
||||
cpu_to_le32(new_encode_dev(inode->i_rdev));
|
||||
raw_inode->i_block[2] = 0;
|
||||
}
|
||||
} else for (block = 0; block < EXT4_N_BLOCKS; block++)
|
||||
raw_inode->i_block[block] = ei->i_data[block];
|
||||
} else
|
||||
for (block = 0; block < EXT4_N_BLOCKS; block++)
|
||||
raw_inode->i_block[block] = ei->i_data[block];
|
||||
|
||||
raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
|
||||
if (ei->i_extra_isize) {
|
||||
@ -5109,7 +5115,7 @@ int ext4_chunk_trans_blocks(struct inode *inode, int nrblocks)
|
||||
* Give this, we know that the caller already has write access to iloc->bh.
|
||||
*/
|
||||
int ext4_mark_iloc_dirty(handle_t *handle,
|
||||
struct inode *inode, struct ext4_iloc *iloc)
|
||||
struct inode *inode, struct ext4_iloc *iloc)
|
||||
{
|
||||
int err = 0;
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user