@@ -958,26 +958,16 @@ struct defrag_target_range {
* any adjacent ones), but we may still want to defrag them, to free up
* some space if possible.
*/
-static bool should_defrag_under_utilized(struct extent_map *em)
+static bool should_defrag_under_utilized(struct extent_map *em,
+ u32 usage_ratio, u32 wasted_bytes)
{
- /*
- * Ratio based check.
- *
- * If the current extent is only utilizing 1/16 of its on-disk size,
- * it's definitely under-utilized, and defragging it may free up
- * the whole extent.
- */
- if (em->len < em->orig_block_len / 16)
+ /* Ratio based check. */
+ if (em->len < div_u64(em->orig_block_len * usage_ratio, 100))
return true;
- /*
- * Wasted space based check.
- *
- * If we can free up at least 16MiB, then it may be a good idea
- * to defrag.
- */
+ /* Wasted space based check. */
if (em->len < em->orig_block_len &&
- em->orig_block_len - em->len > SZ_16M)
+ em->orig_block_len - em->len > wasted_bytes)
return true;
return false;
}
@@ -999,6 +989,7 @@ static bool should_defrag_under_utilized(struct extent_map *em)
static int defrag_collect_targets(struct btrfs_inode *inode,
u64 start, u64 len, u32 extent_thresh,
u64 newer_than, bool do_compress,
+ u32 usage_ratio, u32 wasted_bytes,
bool locked, struct list_head *target_list,
u64 *last_scanned_ret)
{
@@ -1109,7 +1100,8 @@ static int defrag_collect_targets(struct btrfs_inode *inode,
* But if we may free up some space, it is still worth
* defragging.
*/
- if (should_defrag_under_utilized(em))
+ if (should_defrag_under_utilized(em, usage_ratio,
+ wasted_bytes))
goto add;
/* Empty target list, no way to merge with last entry */
@@ -1241,6 +1233,7 @@ static int defrag_one_locked_target(struct btrfs_inode *inode,
static int defrag_one_range(struct btrfs_inode *inode, u64 start, u32 len,
u32 extent_thresh, u64 newer_than, bool do_compress,
+ u32 usage_ratio, u32 wasted_bytes,
u64 *last_scanned_ret)
{
struct extent_state *cached_state = NULL;
@@ -1286,7 +1279,8 @@ static int defrag_one_range(struct btrfs_inode *inode, u64 start, u32 len,
* so that we won't relock the extent range and cause deadlock.
*/
ret = defrag_collect_targets(inode, start, len, extent_thresh,
- newer_than, do_compress, true,
+ newer_than, do_compress, usage_ratio,
+ wasted_bytes, true,
&target_list, last_scanned_ret);
if (ret < 0)
goto unlock_extent;
@@ -1319,6 +1313,7 @@ static int defrag_one_cluster(struct btrfs_inode *inode,
struct file_ra_state *ra,
u64 start, u32 len, u32 extent_thresh,
u64 newer_than, bool do_compress,
+ u32 usage_ratio, u32 wasted_bytes,
unsigned long *sectors_defragged,
unsigned long max_sectors,
u64 *last_scanned_ret)
@@ -1330,7 +1325,8 @@ static int defrag_one_cluster(struct btrfs_inode *inode,
int ret;
ret = defrag_collect_targets(inode, start, len, extent_thresh,
- newer_than, do_compress, false,
+ newer_than, do_compress, usage_ratio,
+ wasted_bytes, false,
&target_list, NULL);
if (ret < 0)
goto out;
@@ -1370,6 +1366,7 @@ static int defrag_one_cluster(struct btrfs_inode *inode,
*/
ret = defrag_one_range(inode, entry->start, range_len,
extent_thresh, newer_than, do_compress,
+ usage_ratio, wasted_bytes,
last_scanned_ret);
if (ret < 0)
break;
@@ -1495,7 +1492,8 @@ int btrfs_defrag_file(struct inode *inode, struct file_ra_state *ra,
BTRFS_I(inode)->defrag_compress = compress_type;
ret = defrag_one_cluster(BTRFS_I(inode), ra, cur,
cluster_end + 1 - cur, extent_thresh,
- newer_than, do_compress, §ors_defragged,
+ newer_than, do_compress, range->usage_ratio,
+ range->wasted_bytes, §ors_defragged,
max_to_defrag, &last_scanned);
if (sectors_defragged > prev_sectors_defragged)
@@ -2635,10 +2635,23 @@ static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
range.flags |= BTRFS_DEFRAG_RANGE_START_IO;
range.extent_thresh = (u32)-1;
}
+
+ if (range.flags & BTRFS_DEFRAG_RANGE_USAGE_RATIO &&
+ range.usage_ratio > 100) {
+ ret = -EINVAL;
+ goto out;
+ }
} else {
/* the rest are all set to zero by kzalloc */
range.len = (u64)-1;
}
+
+ /* Disable the extra options if not enabled through flags. */
+ if (!(range.flags & BTRFS_DEFRAG_RANGE_USAGE_RATIO))
+ range.usage_ratio = 0;
+ if (!(range.flags & BTRFS_DEFRAG_RANGE_WASTED_BYTES))
+ range.wasted_bytes = U32_MAX;
+
ret = btrfs_defrag_file(file_inode(file), &file->f_ra,
&range, BTRFS_OLDEST_GENERATION, 0);
if (ret > 0)
@@ -613,10 +613,14 @@ struct btrfs_ioctl_clone_range_args {
* Used by:
* struct btrfs_ioctl_defrag_range_args.flags
*/
-#define BTRFS_DEFRAG_RANGE_COMPRESS 1
-#define BTRFS_DEFRAG_RANGE_START_IO 2
-#define BTRFS_DEFRAG_RANGE_FLAGS_SUPP (BTRFS_DEFRAG_RANGE_COMPRESS | \
- BTRFS_DEFRAG_RANGE_START_IO)
+#define BTRFS_DEFRAG_RANGE_COMPRESS (1ULL << 0)
+#define BTRFS_DEFRAG_RANGE_START_IO (1ULL << 1)
+#define BTRFS_DEFRAG_RANGE_USAGE_RATIO (1ULL << 2)
+#define BTRFS_DEFRAG_RANGE_WASTED_BYTES (1ULL << 3)
+#define BTRFS_DEFRAG_RANGE_FLAGS_SUPP (BTRFS_DEFRAG_RANGE_COMPRESS | \
+ BTRFS_DEFRAG_RANGE_START_IO | \
+ BTRFS_DEFRAG_RANGE_USAGE_RATIO |\
+ BTRFS_DEFRAG_RANGE_WASTED_BYTES)
struct btrfs_ioctl_defrag_range_args {
/* start of the defrag operation */
@@ -645,8 +649,34 @@ struct btrfs_ioctl_defrag_range_args {
*/
__u32 compress_type;
+ /*
+ * File extents which has lower usage ratio than this would be defragged.
+ *
+ * Valid values are [0, 100].
+ *
+ * 0 means no check based on usage ratio.
+ * 1 means one file extent would be defragged if its referred size
+ * (file extent num bytes) is smaller than 1% of its on-disk extent size.
+ * 100 means one file extent would be defragged if its referred size
+ * (file extent num bytes) is smaller than 100% of its on-disk extent size.
+ */
+ __u32 usage_ratio;
+
+ /*
+ * File extents which has more "wasted" bytes than this would be
+ * defragged.
+ *
+ * "Wasted" bytes just means the difference between the file extent size
+ * (file extent num bytes) against the on-disk extent size
+ * (file extent disk num bytes).
+ *
+ * Valid values are [0, U32_MAX], but values larger than
+ * BTRFS_MAX_EXTENT_SIZE would not make much sense.
+ */
+ __u32 wasted_bytes;
+
/* spare for later */
- __u32 unused[4];
+ __u32 unused[2];
};
Previously we're using a fixed usage ratio and wasted bytes for file extents which can not be merged with any adjacent ones, but may still free up some space. This patch would enhance the behavior by allowing fine-tuning using some extra members inside btrfs_ioctl_defrag_range_args. This would introduce two flags and two new members: - BTRFS_DEFRAG_RANGE_USAGE_RATIO and BTRFS_DEFRAG_RANGE_WASTED_BYTES With these flags set, defrag would consider file extents with their usage ratio and wasted bytes as a defrag condition. - usage_ratio This is a u32 value, but only [0, 100] is allowed. 0 means disable usage ratio detection, aka no extra file extents would be defragged based on their usage ratio at all. 1 means file extents which refer less than 1% of the on-disk extent size would be defragged. - wasted_bytes This is a u32 value. The "wasted" bytes are just the difference between file extent size against on-disk extent size. (That's if the file extent size is smaller than the on-disk extent size). This "wasted" calculation doesn't take other file extents into consideration, thus it's not ensured to free up space. Signed-off-by: Qu Wenruo <wqu@suse.com> --- fs/btrfs/defrag.c | 38 +++++++++++++++++------------------- fs/btrfs/ioctl.c | 13 +++++++++++++ include/uapi/linux/btrfs.h | 40 +++++++++++++++++++++++++++++++++----- 3 files changed, 66 insertions(+), 25 deletions(-)