iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

btrfs: allow dedupe of same inode

Browse Source 
clone() supports cloning within an inode so extent-same can do
the same now. This patch fixes up the locking in extent-same to
know about the single-inode case. In addition to that, we add a
check for overlapping ranges, which clone does not allow.

Signed-off-by: Mark Fasheh <mfasheh@suse.de>
Reviewed-by: David Sterba <dsterba@suse.cz>
Signed-off-by: Chris Mason <clm@fb.com>
This commit is contained in:
Mark Fasheh 2015-06-30 14:42:07 -07:00 committed by Chris Mason
parent f441460202
commit 0efa9f48c7
1 changed files with 60 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
fs/btrfs/ioctl.c
View File

@ -2991,27 +2991,61 @@ static int btrfs_extent_same(struct inode *src, u64 loff, u64 olen,
int ret; int ret;
u64 len = olen; u64 len = olen;
struct cmp_pages cmp; struct cmp_pages cmp;
int same_inode = 0;
u64 same_lock_start = 0;
u64 same_lock_len = 0;
/*
* btrfs_clone() can't handle extents in the same file
* yet. Once that works, we can drop this check and replace it
* with a check for the same inode, but overlapping extents.
*/
if (src == dst) if (src == dst)
return -EINVAL; same_inode = 1;
if (len == 0) if (len == 0)
return 0; return 0;
btrfs_double_inode_lock(src, dst); if (same_inode) {
mutex_lock(&src->i_mutex);
ret = extent_same_check_offsets(src, loff, &len, olen); ret = extent_same_check_offsets(src, loff, &len, olen);
if (ret) if (ret)
goto out_unlock; goto out_unlock;
ret = extent_same_check_offsets(dst, dst_loff, &len, olen); /*
if (ret) * Single inode case wants the same checks, except we
goto out_unlock; * don't want our length pushed out past i_size as
* comparing that data range makes no sense.
*
* extent_same_check_offsets() will do this for an
* unaligned length at i_size, so catch it here and
* reject the request.
*
* This effectively means we require aligned extents
* for the single-inode case, whereas the other cases
* allow an unaligned length so long as it ends at
* i_size.
*/
if (len != olen) {
ret = -EINVAL;
goto out_unlock;
}
/* Check for overlapping ranges */
if (dst_loff + len > loff && dst_loff < loff + len) {
ret = -EINVAL;
goto out_unlock;
}
same_lock_start = min_t(u64, loff, dst_loff);
same_lock_len = max_t(u64, loff, dst_loff) + len - same_lock_start;
} else {
btrfs_double_inode_lock(src, dst);
ret = extent_same_check_offsets(src, loff, &len, olen);
if (ret)
goto out_unlock;
ret = extent_same_check_offsets(dst, dst_loff, &len, olen);
if (ret)
goto out_unlock;
}
/* don't make the dst file partly checksummed */ /* don't make the dst file partly checksummed */
if ((BTRFS_I(src)->flags & BTRFS_INODE_NODATASUM) != if ((BTRFS_I(src)->flags & BTRFS_INODE_NODATASUM) !=
@ -3024,18 +3058,28 @@ static int btrfs_extent_same(struct inode *src, u64 loff, u64 olen,
if (ret) if (ret)
goto out_unlock; goto out_unlock;
btrfs_double_extent_lock(src, loff, dst, dst_loff, len); if (same_inode)
lock_extent_range(src, same_lock_start, same_lock_len);
else
btrfs_double_extent_lock(src, loff, dst, dst_loff, len);
/* pass original length for comparison so we stay within i_size */ /* pass original length for comparison so we stay within i_size */
ret = btrfs_cmp_data(src, loff, dst, dst_loff, olen, &cmp); ret = btrfs_cmp_data(src, loff, dst, dst_loff, olen, &cmp);
if (ret == 0) if (ret == 0)
ret = btrfs_clone(src, dst, loff, olen, len, dst_loff); ret = btrfs_clone(src, dst, loff, olen, len, dst_loff);
btrfs_double_extent_unlock(src, loff, dst, dst_loff, len); if (same_inode)
unlock_extent(&BTRFS_I(src)->io_tree, same_lock_start,
same_lock_start + same_lock_len - 1);
else
btrfs_double_extent_unlock(src, loff, dst, dst_loff, len);
btrfs_cmp_data_free(&cmp); btrfs_cmp_data_free(&cmp);
out_unlock: out_unlock:
btrfs_double_inode_unlock(src, dst); if (same_inode)
mutex_unlock(&src->i_mutex);
else
btrfs_double_inode_unlock(src, dst);
return ret; return ret;
} }