ext4: Make ext4_get_blocks_wrap take the truncate_mutex early.
When doing a migrate from ext3 to ext4 inode we need to make sure the test for inode type and walking inode data happens inside lock. To make this happen move truncate_mutex early before checking the i_flags. This actually should enable us to remove the verify_chain(). Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
This commit is contained in:
Aneesh Kumar K.V
Theodore Ts'o
parent
01f4adc044
commit
c278bfeceb
|
|
@ -2129,6 +2129,10 @@ out:
|
|||
return err ? err : allocated;
|
||||
}
|
||||
|
||||
/*
|
||||
* Need to be called with
|
||||
* mutex_lock(&EXT4_I(inode)->truncate_mutex);
|
||||
*/
|
||||
int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
|
||||
ext4_lblk_t iblock,
|
||||
unsigned long max_blocks, struct buffer_head *bh_result,
|
||||
|
|
@ -2144,7 +2148,6 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
|
|||
__clear_bit(BH_New, &bh_result->b_state);
|
||||
ext_debug("blocks %u/%lu requested for inode %u\n",
|
||||
iblock, max_blocks, inode->i_ino);
|
||||
mutex_lock(&EXT4_I(inode)->truncate_mutex);
|
||||
|
||||
/* check in cache */
|
||||
goal = ext4_ext_in_cache(inode, iblock, &newex);
|
||||
|
|
@ -2318,8 +2321,6 @@ out2:
|
|||
ext4_ext_drop_refs(path);
|
||||
kfree(path);
|
||||
}
|
||||
mutex_unlock(&EXT4_I(inode)->truncate_mutex);
|
||||
|
||||
return err ? err : allocated;
|
||||
}
|
||||
|
||||
|
|
@ -2449,6 +2450,7 @@ long ext4_fallocate(struct inode *inode, int mode, loff_t offset, loff_t len)
|
|||
* modify 1 super block, 1 block bitmap and 1 group descriptor.
|
||||
*/
|
||||
credits = EXT4_DATA_TRANS_BLOCKS(inode->i_sb) + 3;
|
||||
mutex_lock(&EXT4_I(inode)->truncate_mutex)
|
||||
retry:
|
||||
while (ret >= 0 && ret < max_blocks) {
|
||||
block = block + ret;
|
||||
|
|
@ -2505,6 +2507,7 @@ retry:
|
|||
if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
|
||||
goto retry;
|
||||
|
||||
mutex_unlock(&EXT4_I(inode)->truncate_mutex)
|
||||
/*
|
||||
* Time to update the file size.
|
||||
* Update only when preallocation was requested beyond the file size.
|
||||
|
|
|
|||
|
|
@ -243,13 +243,6 @@ static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
|
|||
p->bh = bh;
|
||||
}
|
||||
|
||||
static int verify_chain(Indirect *from, Indirect *to)
|
||||
{
|
||||
while (from <= to && from->key == *from->p)
|
||||
from++;
|
||||
return (from > to);
|
||||
}
|
||||
|
||||
/**
|
||||
* ext4_block_to_path - parse the block number into array of offsets
|
||||
* @inode: inode in question (we are only interested in its superblock)
|
||||
|
|
@ -348,10 +341,11 @@ static int ext4_block_to_path(struct inode *inode,
|
|||
* (pointer to last triple returned, *@err == 0)
|
||||
* or when it gets an IO error reading an indirect block
|
||||
* (ditto, *@err == -EIO)
|
||||
* or when it notices that chain had been changed while it was reading
|
||||
* (ditto, *@err == -EAGAIN)
|
||||
* or when it reads all @depth-1 indirect blocks successfully and finds
|
||||
* the whole chain, all way to the data (returns %NULL, *err == 0).
|
||||
*
|
||||
* Need to be called with
|
||||
* mutex_lock(&EXT4_I(inode)->truncate_mutex)
|
||||
*/
|
||||
static Indirect *ext4_get_branch(struct inode *inode, int depth,
|
||||
ext4_lblk_t *offsets,
|
||||
|
|
@ -370,9 +364,6 @@ static Indirect *ext4_get_branch(struct inode *inode, int depth,
|
|||
bh = sb_bread(sb, le32_to_cpu(p->key));
|
||||
if (!bh)
|
||||
goto failure;
|
||||
/* Reader: pointers */
|
||||
if (!verify_chain(chain, p))
|
||||
goto changed;
|
||||
add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
|
||||
/* Reader: end */
|
||||
if (!p->key)
|
||||
|
|
@ -380,10 +371,6 @@ static Indirect *ext4_get_branch(struct inode *inode, int depth,
|
|||
}
|
||||
return NULL;
|
||||
|
||||
changed:
|
||||
brelse(bh);
|
||||
*err = -EAGAIN;
|
||||
goto no_block;
|
||||
failure:
|
||||
*err = -EIO;
|
||||
no_block:
|
||||
|
|
@ -787,6 +774,10 @@ err_out:
|
|||
* return > 0, # of blocks mapped or allocated.
|
||||
* return = 0, if plain lookup failed.
|
||||
* return < 0, error case.
|
||||
*
|
||||
*
|
||||
* Need to be called with
|
||||
* mutex_lock(&EXT4_I(inode)->truncate_mutex)
|
||||
*/
|
||||
int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
|
||||
ext4_lblk_t iblock, unsigned long maxblocks,
|
||||
|
|
@ -825,18 +816,6 @@ int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
|
|||
while (count < maxblocks && count <= blocks_to_boundary) {
|
||||
ext4_fsblk_t blk;
|
||||
|
||||
if (!verify_chain(chain, partial)) {
|
||||
/*
|
||||
* Indirect block might be removed by
|
||||
* truncate while we were reading it.
|
||||
* Handling of that case: forget what we've
|
||||
* got now. Flag the err as EAGAIN, so it
|
||||
* will reread.
|
||||
*/
|
||||
err = -EAGAIN;
|
||||
count = 0;
|
||||
break;
|
||||
}
|
||||
blk = le32_to_cpu(*(chain[depth-1].p + count));
|
||||
|
||||
if (blk == first_block + count)
|
||||
|
|
@ -844,44 +823,13 @@ int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
|
|||
else
|
||||
break;
|
||||
}
|
||||
if (err != -EAGAIN)
|
||||
goto got_it;
|
||||
goto got_it;
|
||||
}
|
||||
|
||||
/* Next simple case - plain lookup or failed read of indirect block */
|
||||
if (!create || err == -EIO)
|
||||
goto cleanup;
|
||||
|
||||
mutex_lock(&ei->truncate_mutex);
|
||||
|
||||
/*
|
||||
* If the indirect block is missing while we are reading
|
||||
* the chain(ext4_get_branch() returns -EAGAIN err), or
|
||||
* if the chain has been changed after we grab the semaphore,
|
||||
* (either because another process truncated this branch, or
|
||||
* another get_block allocated this branch) re-grab the chain to see if
|
||||
* the request block has been allocated or not.
|
||||
*
|
||||
* Since we already block the truncate/other get_block
|
||||
* at this point, we will have the current copy of the chain when we
|
||||
* splice the branch into the tree.
|
||||
*/
|
||||
if (err == -EAGAIN || !verify_chain(chain, partial)) {
|
||||
while (partial > chain) {
|
||||
brelse(partial->bh);
|
||||
partial--;
|
||||
}
|
||||
partial = ext4_get_branch(inode, depth, offsets, chain, &err);
|
||||
if (!partial) {
|
||||
count++;
|
||||
mutex_unlock(&ei->truncate_mutex);
|
||||
if (err)
|
||||
goto cleanup;
|
||||
clear_buffer_new(bh_result);
|
||||
goto got_it;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Okay, we need to do block allocation. Lazily initialize the block
|
||||
* allocation info here if necessary
|
||||
|
|
@ -923,7 +871,6 @@ int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
|
|||
*/
|
||||
if (!err && extend_disksize && inode->i_size > ei->i_disksize)
|
||||
ei->i_disksize = inode->i_size;
|
||||
mutex_unlock(&ei->truncate_mutex);
|
||||
if (err)
|
||||
goto cleanup;
|
||||
|
||||
|
|
|
|||
|
|
@ -1113,6 +1113,7 @@ ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block,
|
|||
int create, int extend_disksize)
|
||||
{
|
||||
int retval;
|
||||
mutex_lock(&EXT4_I(inode)->truncate_mutex);
|
||||
if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
|
||||
retval = ext4_ext_get_blocks(handle, inode,
|
||||
(ext4_lblk_t)block, max_blocks,
|
||||
|
|
@ -1122,6 +1123,7 @@ ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block,
|
|||
(ext4_lblk_t)block, max_blocks,
|
||||
bh, create, extend_disksize);
|
||||
}
|
||||
mutex_unlock(&EXT4_I(inode)->truncate_mutex);
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue