Hi Ted,
Theodore Tso wrote:
> As a side note, the static functions in fs/ext4/move_extent.c really
> don't need the ext4_mext prefix, since static functions don't have
> namespace issues that require a consistent naming scheme. (Sometimes
> a shorter name can also be useful since it avoids needing to line wrap
> function calls with a long list of parameters.)
This patch is for "online-defrag" in the ext4 patch queue,
and changes are as follows:
- Remove unneeded function prefix (ext4_mext_ or ext4_)
in fs/ext4/move_extent.c to make function name shorter.
And change some name of functions.
- Fix error handling issue.
- Add some argument checks.
If this patch does not seem to have any problem,
could you add this change to the ext4 patch queue?
Best regards,
Akira Fujita
---
ext4: online defrag -- Change function prefix and some fixes
From: Akira Fujita <a-fujita@xxxxxxxxxxxxx>
- Remove unneeded function prefix to make function name shorter.
e.g ext4_mext_copy_extent_status() -> copy_extent_status()
And change some name of functions.
- Fix error handling issue.
- Add some argument checks.
Signed-off-by: Akira Fujita <a-fujita@xxxxxxxxxxxxx>
---
move_extent.c | 214 ++++++++++++++++++++++++++++++----------------------------
1 file changed, 113 insertions(+), 101 deletions(-)
--- linux-2.6.30-git4/fs/ext4/move_extent.c 2009-06-16 11:43:41.000000000 +0900
+++ linux-2.6.30-git4-fix/fs/ext4/move_extent.c 2009-06-16 13:45:14.000000000 +0900
@@ -19,7 +19,7 @@
#include "ext4_extents.h"
#include "ext4.h"
-#define ext4_mext_get_extpath(path, inode, block, ret) \
+#define get_ext_path(path, inode, block, ret) \
do { \
path = ext4_ext_find_extent(inode, block, path); \
if (IS_ERR(path)) { \
@@ -29,13 +29,13 @@
} while (0)
/**
- * ext4_mext_copy_extent_status - Copy the extent's initialization status
+ * copy_extent_status - Copy the extent's initialization status
*
* @src: an extent for getting initialize status
* @dest: an extent to be set the status
*/
static void
-ext4_mext_copy_extent_status(struct ext4_extent *src, struct ext4_extent *dest)
+copy_extent_status(struct ext4_extent *src, struct ext4_extent *dest)
{
if (ext4_ext_is_uninitialized(src))
ext4_ext_mark_uninitialized(dest);
@@ -44,7 +44,7 @@ ext4_mext_copy_extent_status(struct ext4
}
/**
- * ext4_mext_next_extent - Search for the next extent and set it to "extent"
+ * mext_next_extent - Search for the next extent and set it to "extent"
*
* @inode: inode which is searched
* @path: this will obtain data for the next extent
@@ -57,7 +57,7 @@ ext4_mext_copy_extent_status(struct ext4
* value on failure.
*/
static int
-ext4_mext_next_extent(struct inode *inode, struct ext4_ext_path *path,
+mext_next_extent(struct inode *inode, struct ext4_ext_path *path,
struct ext4_extent **extent)
{
int ppos, leaf_ppos = path->p_depth;
@@ -113,15 +113,14 @@ ext4_mext_next_extent(struct inode *inod
}
/**
- * ext4_mext_double_down_read - Acquire two inodes' read semaphore
+ * mext_double_down_read - Acquire two inodes' read semaphore
*
* @orig_inode: original inode structure
* @donor_inode: donor inode structure
* Acquire read semaphore of the two inodes (orig and donor) by i_ino order.
*/
static void
-ext4_mext_double_down_read(struct inode *orig_inode,
- struct inode *donor_inode)
+mext_double_down_read(struct inode *orig_inode, struct inode *donor_inode)
{
struct inode *first = orig_inode, *second = donor_inode;
@@ -142,15 +141,14 @@ ext4_mext_double_down_read(struct inode
}
/**
- * ext4_mext_double_down_write - Acquire two inodes' write semaphore
+ * mext_double_down_write - Acquire two inodes' write semaphore
*
* @orig_inode: original inode structure
* @donor_inode: donor inode structure
* Acquire write semaphore of the two inodes (orig and donor) by i_ino order.
*/
static void
-ext4_mext_double_down_write(struct inode *orig_inode,
- struct inode *donor_inode)
+mext_double_down_write(struct inode *orig_inode, struct inode *donor_inode)
{
struct inode *first = orig_inode, *second = donor_inode;
@@ -171,14 +169,14 @@ ext4_mext_double_down_write(struct inode
}
/**
- * ext4_mext_double_up_read - Release two inodes' read semaphore
+ * mext_double_up_read - Release two inodes' read semaphore
*
* @orig_inode: original inode structure to be released its lock first
* @donor_inode: donor inode structure to be released its lock second
* Release read semaphore of two inodes (orig and donor).
*/
static void
-ext4_mext_double_up_read(struct inode *orig_inode, struct inode *donor_inode)
+mext_double_up_read(struct inode *orig_inode, struct inode *donor_inode)
{
BUG_ON(orig_inode == NULL || donor_inode == NULL);
@@ -187,14 +185,14 @@ ext4_mext_double_up_read(struct inode *o
}
/**
- * ext4_mext_double_up_write - Release two inodes' write semaphore
+ * mext_double_up_write - Release two inodes' write semaphore
*
* @orig_inode: original inode structure to be released its lock first
* @donor_inode: donor inode structure to be released its lock second
* Release write semaphore of two inodes (orig and donor).
*/
static void
-ext4_mext_double_up_write(struct inode *orig_inode, struct inode *donor_inode)
+mext_double_up_write(struct inode *orig_inode, struct inode *donor_inode)
{
BUG_ON(orig_inode == NULL || donor_inode == NULL);
@@ -203,7 +201,7 @@ ext4_mext_double_up_write(struct inode *
}
/**
- * ext4_mext_insert_across_blocks - Insert extents across leaf block
+ * mext_insert_across_blocks - Insert extents across leaf block
*
* @handle: journal handle
* @orig_inode: original inode
@@ -217,7 +215,7 @@ ext4_mext_double_up_write(struct inode *
* or a negative error value on failure.
*/
static int
-ext4_mext_insert_across_blocks(handle_t *handle, struct inode *orig_inode,
+mext_insert_across_blocks(handle_t *handle, struct inode *orig_inode,
struct ext4_extent *o_start, struct ext4_extent *o_end,
struct ext4_extent *start_ext, struct ext4_extent *new_ext,
struct ext4_extent *end_ext)
@@ -285,7 +283,7 @@ ext4_mext_insert_across_blocks(handle_t
}
if (new_flag) {
- ext4_mext_get_extpath(orig_path, orig_inode, eblock, err);
+ get_ext_path(orig_path, orig_inode, eblock, err);
if (orig_path == NULL)
goto out;
@@ -295,7 +293,7 @@ ext4_mext_insert_across_blocks(handle_t
}
if (end_flag) {
- ext4_mext_get_extpath(orig_path, orig_inode,
+ get_ext_path(orig_path, orig_inode,
le32_to_cpu(end_ext->ee_block) - 1, err);
if (orig_path == NULL)
goto out;
@@ -315,7 +313,7 @@ out:
}
/**
- * ext4_mext_insert_inside_block - Insert new extent to the extent block
+ * mext_insert_inside_block - Insert new extent to the extent block
*
* @o_start: first original extent to be moved
* @o_end: last original extent to be moved
@@ -329,7 +327,7 @@ out:
* by inserted extents.
*/
static void
-ext4_mext_insert_inside_block(struct ext4_extent *o_start,
+mext_insert_inside_block(struct ext4_extent *o_start,
struct ext4_extent *o_end,
struct ext4_extent *start_ext,
struct ext4_extent *new_ext,
@@ -366,7 +364,7 @@ ext4_mext_insert_inside_block(struct ext
}
/**
- * ext4_mext_insert_extents - Insert new extent
+ * mext_insert_extents - Insert new extent
*
* @handle: journal handle
* @orig_inode: original inode
@@ -378,12 +376,12 @@ ext4_mext_insert_inside_block(struct ext
* @end_ext: last new extent to be inserted
*
* Call the function to insert extents. If we cannot add more extents into
- * the leaf block, we call ext4_mext_insert_across_blocks() to create a
- * new leaf block. Otherwise call ext4_mext_insert_inside_block(). Return 0
+ * the leaf block, we call mext_insert_across_blocks() to create a
+ * new leaf block. Otherwise call mext_insert_inside_block(). Return 0
* on success, or a negative error value on failure.
*/
static int
-ext4_mext_insert_extents(handle_t *handle, struct inode *orig_inode,
+mext_insert_extents(handle_t *handle, struct inode *orig_inode,
struct ext4_ext_path *orig_path,
struct ext4_extent *o_start,
struct ext4_extent *o_end,
@@ -424,15 +422,13 @@ ext4_mext_insert_extents(handle_t *handl
(range_to_move > le16_to_cpu(eh->eh_max)
- le16_to_cpu(eh->eh_entries))) {
- ret = ext4_mext_insert_across_blocks(handle, orig_inode,
- o_start, o_end, start_ext,
- new_ext, end_ext);
+ ret = mext_insert_across_blocks(handle, orig_inode, o_start,
+ o_end, start_ext, new_ext, end_ext);
if (ret < 0)
return ret;
} else
- ext4_mext_insert_inside_block(o_start, o_end, start_ext,
- new_ext, end_ext, eh,
- range_to_move);
+ mext_insert_inside_block(o_start, o_end, start_ext, new_ext,
+ end_ext, eh, range_to_move);
if (depth) {
ret = ext4_handle_dirty_metadata(handle, orig_inode,
@@ -449,7 +445,7 @@ ext4_mext_insert_extents(handle_t *handl
}
/**
- * ext4_mext_leaf_block - Move one leaf extent block into the inode.
+ * mext_leaf_block - Move one leaf extent block into the inode.
*
* @handle: journal handle
* @orig_inode: original inode
@@ -462,11 +458,11 @@ ext4_mext_insert_extents(handle_t *handl
* extents, and the others are located around it.
*
* Therefore, this function creates structures to save extents of the leaf
- * block, and inserts extents by calling ext4_mext_insert_extents() with
+ * block, and inserts extents by calling mext_insert_extents() with
* created extents. Return 0 on success, or a negative error value on failure.
*/
static int
-ext4_mext_leaf_block(handle_t *handle, struct inode *orig_inode,
+mext_leaf_block(handle_t *handle, struct inode *orig_inode,
struct ext4_ext_path *orig_path, struct ext4_extent *dext,
ext4_lblk_t *from)
{
@@ -500,7 +496,7 @@ ext4_mext_leaf_block(handle_t *handle, s
le32_to_cpu(oext->ee_block) + oext_alen) {
start_ext.ee_len = cpu_to_le16(le32_to_cpu(new_ext.ee_block) -
le32_to_cpu(oext->ee_block));
- ext4_mext_copy_extent_status(oext, &start_ext);
+ copy_extent_status(oext, &start_ext);
} else if (oext > EXT_FIRST_EXTENT(orig_path[depth].p_hdr)) {
prev_ext = oext - 1;
/*
@@ -513,7 +509,7 @@ ext4_mext_leaf_block(handle_t *handle, s
start_ext.ee_len = cpu_to_le16(
ext4_ext_get_actual_len(prev_ext) +
new_ext_alen);
- ext4_mext_copy_extent_status(prev_ext, &start_ext);
+ copy_extent_status(prev_ext, &start_ext);
new_ext.ee_len = 0;
}
}
@@ -536,7 +532,7 @@ ext4_mext_leaf_block(handle_t *handle, s
end_ext.ee_len =
cpu_to_le16(le32_to_cpu(oext->ee_block) +
oext_alen - 1 - new_ext_end);
- ext4_mext_copy_extent_status(oext, &end_ext);
+ copy_extent_status(oext, &end_ext);
end_ext_alen = ext4_ext_get_actual_len(&end_ext);
ext4_ext_store_pblock(&end_ext,
(ext_pblock(o_end) + oext_alen - end_ext_alen));
@@ -545,14 +541,13 @@ ext4_mext_leaf_block(handle_t *handle, s
oext_alen - end_ext_alen);
}
- ret = ext4_mext_insert_extents(handle, orig_inode,
- orig_path, o_start, o_end, &start_ext,
- &new_ext, &end_ext);
+ ret = mext_insert_extents(handle, orig_inode, orig_path, o_start,
+ o_end, &start_ext, &new_ext, &end_ext);
return ret;
}
/**
- * ext4_mext_get_replaced_extent - Compute extents for extent swapping.
+ * mext_calc_swap_extents - Calculate extents for extent swapping.
*
* @tmp_dext: the extent that will belong to the original inode
* @tmp_oext: the extent that will belong to the donor inode
@@ -561,7 +556,7 @@ ext4_mext_leaf_block(handle_t *handle, s
* @max_count: the maximun length of extents
*/
static void
-ext4_mext_get_replaced_extent(struct ext4_extent *tmp_dext,
+mext_calc_swap_extents(struct ext4_extent *tmp_dext,
struct ext4_extent *tmp_oext,
ext4_lblk_t orig_off, ext4_lblk_t donor_off,
ext4_lblk_t max_count)
@@ -594,12 +589,12 @@ ext4_mext_get_replaced_extent(struct ext
tmp_oext->ee_len = cpu_to_le16(ext4_ext_get_actual_len(tmp_dext));
- ext4_mext_copy_extent_status(&oext_old, tmp_dext);
- ext4_mext_copy_extent_status(&dext_old, tmp_oext);
+ copy_extent_status(&oext_old, tmp_dext);
+ copy_extent_status(&dext_old, tmp_oext);
}
/**
- * ext4_mext_replace_branches - Replace original extents with new extents
+ * mext_replace_branches - Replace original extents with new extents
*
* @handle: journal handle
* @orig_inode: original inode
@@ -619,7 +614,7 @@ ext4_mext_get_replaced_extent(struct ext
* Return 0 on success, or a negative error value on failure.
*/
static int
-ext4_mext_replace_branches(handle_t *handle, struct inode *orig_inode,
+mext_replace_branches(handle_t *handle, struct inode *orig_inode,
struct inode *donor_inode, ext4_lblk_t from,
ext4_lblk_t count)
{
@@ -633,15 +628,15 @@ ext4_mext_replace_branches(handle_t *han
int replaced_count = 0;
int dext_alen;
- ext4_mext_double_down_write(orig_inode, donor_inode);
+ mext_double_down_write(orig_inode, donor_inode);
/* Get the original extent for the block "orig_off" */
- ext4_mext_get_extpath(orig_path, orig_inode, orig_off, err);
+ get_ext_path(orig_path, orig_inode, orig_off, err);
if (orig_path == NULL)
goto out;
/* Get the donor extent for the head */
- ext4_mext_get_extpath(donor_path, donor_inode, donor_off, err);
+ get_ext_path(donor_path, donor_inode, donor_off, err);
if (donor_path == NULL)
goto out;
depth = ext_depth(orig_inode);
@@ -652,22 +647,22 @@ ext4_mext_replace_branches(handle_t *han
dext = donor_path[depth].p_ext;
tmp_dext = *dext;
- ext4_mext_get_replaced_extent(&tmp_dext, &tmp_oext, orig_off,
+ mext_calc_swap_extents(&tmp_dext, &tmp_oext, orig_off,
donor_off, count);
/* Loop for the donor extents */
while (1) {
/* The extent for donor must be found. */
- BUG_ON(!dext || donor_off != le32_to_cpu(dext->ee_block));
+ BUG_ON(!dext || donor_off != le32_to_cpu(tmp_dext.ee_block));
/* Set donor extent to orig extent */
- err = ext4_mext_leaf_block(handle, orig_inode,
+ err = mext_leaf_block(handle, orig_inode,
orig_path, &tmp_dext, &orig_off);
if (err < 0)
goto out;
/* Set orig extent to donor extent */
- err = ext4_mext_leaf_block(handle, donor_inode,
+ err = mext_leaf_block(handle, donor_inode,
donor_path, &tmp_oext, &donor_off);
if (err < 0)
goto out;
@@ -683,7 +678,7 @@ ext4_mext_replace_branches(handle_t *han
if (orig_path)
ext4_ext_drop_refs(orig_path);
- ext4_mext_get_extpath(orig_path, orig_inode, orig_off, err);
+ get_ext_path(orig_path, orig_inode, orig_off, err);
if (orig_path == NULL)
goto out;
depth = ext_depth(orig_inode);
@@ -697,7 +692,7 @@ ext4_mext_replace_branches(handle_t *han
if (donor_path)
ext4_ext_drop_refs(donor_path);
- ext4_mext_get_extpath(donor_path, donor_inode,
+ get_ext_path(donor_path, donor_inode,
donor_off, err);
if (donor_path == NULL)
goto out;
@@ -710,7 +705,7 @@ ext4_mext_replace_branches(handle_t *han
}
tmp_dext = *dext;
- ext4_mext_get_replaced_extent(&tmp_dext, &tmp_oext, orig_off,
+ mext_calc_swap_extents(&tmp_dext, &tmp_oext, orig_off,
donor_off,
count - replaced_count);
}
@@ -725,12 +720,12 @@ out:
kfree(donor_path);
}
- ext4_mext_double_up_write(orig_inode, donor_inode);
+ mext_double_up_write(orig_inode, donor_inode);
return err;
}
/**
- * ext4_mext_partial - Move extent data per page
+ * move_extent_per_page - Move extent data per page
*
* @o_filp: file structure of original file
* @donor_inode: donor inode
@@ -740,12 +735,12 @@ out:
* @uninit: orig extent is uninitialized or not
*
* Save the data in original inode blocks and replace original inode extents
- * with donor inode extents by calling ext4_mext_replace_branches().
+ * with donor inode extents by calling mext_replace_branches().
* Finally, write out the saved data in new original inode blocks. Return 0
* on success, or a negative error value on failure.
*/
static int
-ext4_mext_partial(struct file *o_filp, struct inode *donor_inode,
+move_extent_par_page(struct file *o_filp, struct inode *donor_inode,
pgoff_t orig_page_offset, int data_offset_in_page,
int block_len_in_page, int uninit)
{
@@ -788,7 +783,7 @@ ext4_mext_partial(struct file *o_filp, s
* Just swap data blocks between orig and donor.
*/
if (uninit) {
- ret = ext4_mext_replace_branches(handle, orig_inode,
+ ret = mext_replace_branches(handle, orig_inode,
donor_inode, orig_blk_offset,
block_len_in_page);
@@ -841,7 +836,7 @@ ext4_mext_partial(struct file *o_filp, s
/* Release old bh and drop refs */
try_to_release_page(page, 0);
- ret = ext4_mext_replace_branches(handle, orig_inode, donor_inode,
+ ret = mext_replace_branches(handle, orig_inode, donor_inode,
orig_blk_offset, block_len_in_page);
if (ret < 0)
goto out;
@@ -884,7 +879,7 @@ out2:
}
/**
- * ext4_mext_check_argumants - Check whether move extent can be done
+ * mext_check_argumants - Check whether move extent can be done
*
* @orig_inode: original inode
* @donor_inode: donor inode
@@ -898,9 +893,9 @@ out2:
* Return 0 on success, or a negative error value on failure.
*/
static int
-ext4_mext_check_arguments(struct inode *orig_inode,
+mext_check_arguments(struct inode *orig_inode,
struct inode *donor_inode, __u64 orig_start,
- __u64 donor_start, __u64 len, __u64 moved_len)
+ __u64 donor_start, __u64 *len, __u64 moved_len)
{
/* Regular file check */
if (!S_ISREG(orig_inode->i_mode) || !S_ISREG(donor_inode->i_mode)) {
@@ -945,6 +940,11 @@ ext4_mext_check_arguments(struct inode *
return -EOPNOTSUPP;
}
+ if ((!orig_inode->i_size) || (!donor_inode->i_size)) {
+ ext4_debug("ext4 move extent: File size is 0 byte\n");
+ return -EINVAL;
+ }
+
/* Start offset should be same */
if (orig_start != donor_start) {
ext4_debug("ext4 move extent: orig and donor's start "
@@ -962,8 +962,8 @@ ext4_mext_check_arguments(struct inode *
if ((orig_start > MAX_DEFRAG_SIZE) ||
(donor_start > MAX_DEFRAG_SIZE) ||
- (len > MAX_DEFRAG_SIZE) ||
- (orig_start + len > MAX_DEFRAG_SIZE)) {
+ (*len > MAX_DEFRAG_SIZE) ||
+ (orig_start + *len > MAX_DEFRAG_SIZE)) {
ext4_debug("ext4 move extent: Can't handle over [%lu] blocks "
"[ino:orig %lu, donor %lu]\n", MAX_DEFRAG_SIZE,
orig_inode->i_ino, donor_inode->i_ino);
@@ -980,15 +980,15 @@ ext4_mext_check_arguments(struct inode *
return -EINVAL;
}
- if (orig_start + len > donor_inode->i_size) {
+ if (orig_start + *len > donor_inode->i_size) {
ext4_debug("ext4 move extent: End offset [%llu] should "
"be less than donor file size [%lld]."
"So adjust length from %llu to %lld "
"[ino:orig %lu, donor %lu]\n",
- orig_start + len, donor_inode->i_size,
- len, donor_inode->i_size - orig_start,
+ orig_start + *len, donor_inode->i_size,
+ *len, donor_inode->i_size - orig_start,
orig_inode->i_ino, donor_inode->i_ino);
- len = donor_inode->i_size - orig_start;
+ *len = donor_inode->i_size - orig_start;
}
} else {
if (orig_start >= orig_inode->i_size) {
@@ -1000,22 +1000,29 @@ ext4_mext_check_arguments(struct inode *
return -EINVAL;
}
- if (orig_start + len > orig_inode->i_size) {
+ if (orig_start + *len > orig_inode->i_size) {
ext4_debug("ext4 move extent: Adjust length "
"from %llu to %lld. Because it should be "
"less than original file size "
"[ino:orig %lu, donor %lu]\n",
- len, orig_inode->i_size - orig_start,
+ *len, orig_inode->i_size - orig_start,
orig_inode->i_ino, donor_inode->i_ino);
- len = orig_inode->i_size - orig_start;
+ *len = orig_inode->i_size - orig_start;
}
}
+ if (!*len) {
+ ext4_debug("ext4 move extent: len shoudld not be 0 "
+ "[ino:orig %lu, donor %lu]\n", orig_inode->i_ino,
+ donor_inode->i_ino);
+ return -EINVAL;
+ }
+
return 0;
}
/**
- * ext4_mext_inode_double_lock - Lock i_mutex on both @inode1 and @inode2
+ * mext_inode_double_lock - Lock i_mutex on both @inode1 and @inode2
*
* @inode1: the inode structure
* @inode2: the inode structure
@@ -1023,7 +1030,8 @@ ext4_mext_check_arguments(struct inode *
* Lock two inodes' i_mutex by i_ino order. This function is moved from
* fs/inode.c.
*/
-void ext4_mext_inode_double_lock(struct inode *inode1, struct inode *inode2)
+static void
+mext_inode_double_lock(struct inode *inode1, struct inode *inode2)
{
if (inode1 == NULL || inode2 == NULL || inode1 == inode2) {
if (inode1)
@@ -1043,7 +1051,7 @@ void ext4_mext_inode_double_lock(struct
}
/**
- * ext4_mext_inode_double_unlock - Release i_mutex on both @inode1 and @inode2
+ * mext_inode_double_unlock - Release i_mutex on both @inode1 and @inode2
*
* @inode1: the inode that is released first
* @inode2: the inode that is released second
@@ -1051,7 +1059,8 @@ void ext4_mext_inode_double_lock(struct
* This function is moved from fs/inode.c.
*/
-void ext4_mext_inode_double_unlock(struct inode *inode1, struct inode *inode2)
+static void
+mext_inode_double_unlock(struct inode *inode1, struct inode *inode2)
{
if (inode1)
mutex_unlock(&inode1->i_mutex);
@@ -1082,7 +1091,7 @@ void ext4_mext_inode_double_unlock(struc
* after hole behind.
* 2:Continue step 3 to step 5, until the holecheck_path points to last_extent
* or the ext_cur exceeds the block_end which is last logical block number.
- * 3:To get the length of continues area, call ext4_mext_next_extent()
+ * 3:To get the length of continues area, call mext_next_extent()
* specified with the ext_cur (initial value is holecheck_path) re-cursive,
* until find un-continuous extent, the start logical block number exceeds
* the block_end or the extent points to the last extent.
@@ -1121,14 +1130,13 @@ ext4_move_extents(struct file *o_filp, s
int uninit;
/* protect orig and donor against a truncate */
- ext4_mext_inode_double_lock(orig_inode, donor_inode);
+ mext_inode_double_lock(orig_inode, donor_inode);
- ext4_mext_double_down_read(orig_inode, donor_inode);
+ mext_double_down_read(orig_inode, donor_inode);
/* Check the filesystem environment whether move_extent can be done */
- ret = ext4_mext_check_arguments(orig_inode, donor_inode,
- orig_start, donor_start, len,
- *moved_len);
- ext4_mext_double_up_read(orig_inode, donor_inode);
+ ret = mext_check_arguments(orig_inode, donor_inode, orig_start,
+ donor_start, &len, *moved_len);
+ mext_double_up_read(orig_inode, donor_inode);
if (ret)
goto out2;
@@ -1137,19 +1145,21 @@ ext4_move_extents(struct file *o_filp, s
if (file_end < block_end)
len -= block_end - file_end;
- ext4_mext_get_extpath(orig_path, orig_inode, block_start, ret);
+ get_ext_path(orig_path, orig_inode, block_start, ret);
if (orig_path == NULL)
goto out2;
/* Get path structure to check the hole */
- ext4_mext_get_extpath(holecheck_path, orig_inode, block_start, ret);
+ get_ext_path(holecheck_path, orig_inode, block_start, ret);
if (holecheck_path == NULL)
goto out;
depth = ext_depth(orig_inode);
ext_cur = holecheck_path[depth].p_ext;
- if (ext_cur == NULL)
+ if (ext_cur == NULL) {
+ ret = -EINVAL;
goto out;
+ }
/*
* Get proper extent whose ee_block is beyond block_start
@@ -1157,13 +1167,13 @@ ext4_move_extents(struct file *o_filp, s
*/
if (le32_to_cpu(ext_cur->ee_block) +
ext4_ext_get_actual_len(ext_cur) - 1 < block_start) {
- last_extent = ext4_mext_next_extent(orig_inode,
+ last_extent = mext_next_extent(orig_inode,
holecheck_path, &ext_cur);
if (last_extent < 0) {
ret = last_extent;
goto out;
}
- last_extent = ext4_mext_next_extent(orig_inode, orig_path,
+ last_extent = mext_next_extent(orig_inode, orig_path,
&ext_dummy);
if (last_extent < 0) {
ret = last_extent;
@@ -1176,6 +1186,7 @@ ext4_move_extents(struct file *o_filp, s
if (le32_to_cpu(ext_cur->ee_block) > block_end) {
ext4_debug("ext4 move extent: The specified range of file "
"may be the hole\n");
+ ret = -EINVAL;
goto out;
}
@@ -1192,8 +1203,8 @@ ext4_move_extents(struct file *o_filp, s
seq_blocks = block_end - seq_start + 1;
ext_prev = ext_cur;
- last_extent = ext4_mext_next_extent(orig_inode,
- holecheck_path, &ext_cur);
+ last_extent = mext_next_extent(orig_inode, holecheck_path,
+ &ext_cur);
if (last_extent < 0) {
ret = last_extent;
break;
@@ -1247,13 +1258,16 @@ ext4_move_extents(struct file *o_filp, s
while (orig_page_offset <= seq_end_page) {
/* Swap original branches with new branches */
- ret = ext4_mext_partial(o_filp, donor_inode,
+ ret = move_extent_par_page(o_filp, donor_inode,
orig_page_offset,
data_offset_in_page,
block_len_in_page, uninit);
if (ret < 0)
goto out;
orig_page_offset++;
+ /* Count how many blocks we have exchanged */
+ *moved_len += block_len_in_page;
+ BUG_ON(*moved_len > len);
data_offset_in_page = 0;
rest_blocks -= block_len_in_page;
@@ -1266,7 +1280,7 @@ ext4_move_extents(struct file *o_filp, s
/* Decrease buffer counter */
if (holecheck_path)
ext4_ext_drop_refs(holecheck_path);
- ext4_mext_get_extpath(holecheck_path, orig_inode,
+ get_ext_path(holecheck_path, orig_inode,
seq_start, ret);
if (holecheck_path == NULL)
break;
@@ -1275,7 +1289,7 @@ ext4_move_extents(struct file *o_filp, s
/* Decrease buffer counter */
if (orig_path)
ext4_ext_drop_refs(orig_path);
- ext4_mext_get_extpath(orig_path, orig_inode, seq_start, ret);
+ get_ext_path(orig_path, orig_inode, seq_start, ret);
if (orig_path == NULL)
break;
@@ -1294,15 +1308,13 @@ out:
kfree(holecheck_path);
}
out2:
- ext4_mext_inode_double_unlock(orig_inode, donor_inode);
+ mext_inode_double_unlock(orig_inode, donor_inode);
- if (ret) {
- *moved_len = orig_page_offset * blocks_per_page;
+ if (ret)
return ret;
- }
- /* Set moved block length */
- *moved_len = len;
+ /* All of the specified blocks must be exchanged in succeed */
+ BUG_ON(*moved_len != len);
return 0;
}
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
