[1/2] btrfs: Make the chunk size limit on on-disk/logical more clean.
diff mbox

Message ID 1419386114-21703-1-git-send-email-quwenruo@cn.fujitsu.com
State New, archived
Headers show

Commit Message

Qu Wenruo Dec. 24, 2014, 1:55 a.m. UTC
Original __btrfs_alloc_chunk() use max_chunk_size to limit chunk size,
however it mixed the on-disk space with logical space.
When comes to 10% of writable space, max_chunk_size is used with on-disk
size, but it is also used as logical space size limit, so it is very
confusing and causing inconsistence in different profile.

For example:
on M single, D single 5G btrfs single device,
data chunk is limited to 512M due to 10% limit.

on M RAID1, D RAID1 10Gx2 btrfs 2 devices,
data chunk is limited to 2G due to 10% limit is mixed with on-disk
space, causing the logical chunk space to 1G, twice than single device.

This patch will make the logical and on-disk space limit independent and
clear and solve the above inconsistence.

Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
changelog:
v2:
   Newly introduced.
---
 fs/btrfs/volumes.c | 40 ++++++++++++++++++++++++++--------------
 1 file changed, 26 insertions(+), 14 deletions(-)

Comments

Qu Wenruo Feb. 26, 2015, 1:20 a.m. UTC | #1
Ping.

Any comment?

Thanks,
Qu
-------- Original Message --------
Subject: [PATCH 1/2] btrfs: Make the chunk size limit on on-disk/logical 
more clean.
From: Qu Wenruo <quwenruo@cn.fujitsu.com>
To: <linux-btrfs@vger.kernel.org>
Date: 2014?12?24? 09:55
> Original __btrfs_alloc_chunk() use max_chunk_size to limit chunk size,
> however it mixed the on-disk space with logical space.
> When comes to 10% of writable space, max_chunk_size is used with on-disk
> size, but it is also used as logical space size limit, so it is very
> confusing and causing inconsistence in different profile.
>
> For example:
> on M single, D single 5G btrfs single device,
> data chunk is limited to 512M due to 10% limit.
>
> on M RAID1, D RAID1 10Gx2 btrfs 2 devices,
> data chunk is limited to 2G due to 10% limit is mixed with on-disk
> space, causing the logical chunk space to 1G, twice than single device.
>
> This patch will make the logical and on-disk space limit independent and
> clear and solve the above inconsistence.
>
> Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
> ---
> changelog:
> v2:
>     Newly introduced.
> ---
>   fs/btrfs/volumes.c | 40 ++++++++++++++++++++++++++--------------
>   1 file changed, 26 insertions(+), 14 deletions(-)
>
> diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
> index 0144790..8e74b34 100644
> --- a/fs/btrfs/volumes.c
> +++ b/fs/btrfs/volumes.c
> @@ -4235,10 +4235,12 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
>   	int ncopies;		/* how many copies to data has */
>   	int ret;
>   	u64 max_stripe_size;
> -	u64 max_chunk_size;
> +	u64 max_logical_size;	/* Up limit on chunk's logical size */
> +	u64 max_physical_size;	/* Up limit on a chunk's on-disk size */
>   	u64 stripe_size;
>   	u64 num_bytes;
>   	u64 raid_stripe_len = BTRFS_STRIPE_LEN;
> +	int need_bump = 0;
>   	int ndevs;
>   	int i;
>   	int j;
> @@ -4260,7 +4262,7 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
>   
>   	if (type & BTRFS_BLOCK_GROUP_DATA) {
>   		max_stripe_size = 1024 * 1024 * 1024;
> -		max_chunk_size = 10 * max_stripe_size;
> +		max_logical_size = 10 * max_stripe_size;
>   		if (!devs_max)
>   			devs_max = BTRFS_MAX_DEVS(info->chunk_root);
>   	} else if (type & BTRFS_BLOCK_GROUP_METADATA) {
> @@ -4269,12 +4271,12 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
>   			max_stripe_size = 1024 * 1024 * 1024;
>   		else
>   			max_stripe_size = 256 * 1024 * 1024;
> -		max_chunk_size = max_stripe_size;
> +		max_logical_size = max_stripe_size;
>   		if (!devs_max)
>   			devs_max = BTRFS_MAX_DEVS(info->chunk_root);
>   	} else if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
>   		max_stripe_size = 32 * 1024 * 1024;
> -		max_chunk_size = 2 * max_stripe_size;
> +		max_logical_size = 2 * max_stripe_size;
>   		if (!devs_max)
>   			devs_max = BTRFS_MAX_DEVS_SYS_CHUNK;
>   	} else {
> @@ -4284,8 +4286,7 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
>   	}
>   
>   	/* we don't want a chunk larger than 10% of writeable space */
> -	max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1),
> -			     max_chunk_size);
> +	max_physical_size = div_factor(fs_devices->total_rw_bytes, 1);
>   
>   	devices_info = kzalloc(sizeof(*devices_info) * fs_devices->rw_devices,
>   			       GFP_NOFS);
> @@ -4391,15 +4392,21 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
>   		data_stripes = num_stripes - 2;
>   	}
>   
> -	/*
> -	 * Use the number of data stripes to figure out how big this chunk
> -	 * is really going to be in terms of logical address space,
> -	 * and compare that answer with the max chunk size
> -	 */
> -	if (stripe_size * data_stripes > max_chunk_size) {
> -		u64 mask = (1ULL << 24) - 1;
> -		stripe_size = max_chunk_size;
> +	/* Restrict on-disk chunk size */
> +	if (stripe_size * num_stripes > max_physical_size) {
> +		stripe_size = max_physical_size;
> +		do_div(stripe_size, num_stripes);
> +		need_bump = 1;
> +	}
> +	/* restrict logical chunk size  */
> +	if (stripe_size * data_stripes > max_logical_size) {
> +		stripe_size = max_logical_size;
>   		do_div(stripe_size, data_stripes);
> +		need_bump = 1;
> +	}
> +
> +	if (need_bump) {
> +		u64 mask = (1ULL << 24) - 1;
>   
>   		/* bump the answer up to a 16MB boundary */
>   		stripe_size = (stripe_size + mask) & ~mask;
> @@ -4411,6 +4418,11 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
>   			stripe_size = devices_info[ndevs-1].max_avail;
>   	}
>   
> +	/*
> +	 * Special handle for DUP, since stripe_size is the largest free extent
> +	 * we found, DUP can only use half of it. Other profile's dev_stripes
> +	 * is always 1.
> +	 */
>   	do_div(stripe_size, dev_stripes);
>   
>   	/* align to BTRFS_STRIPE_LEN */

--
To unsubscribe from this list: send the line "unsubscribe linux-btrfs" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Patch
diff mbox

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 0144790..8e74b34 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -4235,10 +4235,12 @@  static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 	int ncopies;		/* how many copies to data has */
 	int ret;
 	u64 max_stripe_size;
-	u64 max_chunk_size;
+	u64 max_logical_size;	/* Up limit on chunk's logical size */
+	u64 max_physical_size;	/* Up limit on a chunk's on-disk size */
 	u64 stripe_size;
 	u64 num_bytes;
 	u64 raid_stripe_len = BTRFS_STRIPE_LEN;
+	int need_bump = 0;
 	int ndevs;
 	int i;
 	int j;
@@ -4260,7 +4262,7 @@  static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 
 	if (type & BTRFS_BLOCK_GROUP_DATA) {
 		max_stripe_size = 1024 * 1024 * 1024;
-		max_chunk_size = 10 * max_stripe_size;
+		max_logical_size = 10 * max_stripe_size;
 		if (!devs_max)
 			devs_max = BTRFS_MAX_DEVS(info->chunk_root);
 	} else if (type & BTRFS_BLOCK_GROUP_METADATA) {
@@ -4269,12 +4271,12 @@  static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 			max_stripe_size = 1024 * 1024 * 1024;
 		else
 			max_stripe_size = 256 * 1024 * 1024;
-		max_chunk_size = max_stripe_size;
+		max_logical_size = max_stripe_size;
 		if (!devs_max)
 			devs_max = BTRFS_MAX_DEVS(info->chunk_root);
 	} else if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
 		max_stripe_size = 32 * 1024 * 1024;
-		max_chunk_size = 2 * max_stripe_size;
+		max_logical_size = 2 * max_stripe_size;
 		if (!devs_max)
 			devs_max = BTRFS_MAX_DEVS_SYS_CHUNK;
 	} else {
@@ -4284,8 +4286,7 @@  static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 	}
 
 	/* we don't want a chunk larger than 10% of writeable space */
-	max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1),
-			     max_chunk_size);
+	max_physical_size = div_factor(fs_devices->total_rw_bytes, 1);
 
 	devices_info = kzalloc(sizeof(*devices_info) * fs_devices->rw_devices,
 			       GFP_NOFS);
@@ -4391,15 +4392,21 @@  static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 		data_stripes = num_stripes - 2;
 	}
 
-	/*
-	 * Use the number of data stripes to figure out how big this chunk
-	 * is really going to be in terms of logical address space,
-	 * and compare that answer with the max chunk size
-	 */
-	if (stripe_size * data_stripes > max_chunk_size) {
-		u64 mask = (1ULL << 24) - 1;
-		stripe_size = max_chunk_size;
+	/* Restrict on-disk chunk size */
+	if (stripe_size * num_stripes > max_physical_size) {
+		stripe_size = max_physical_size;
+		do_div(stripe_size, num_stripes);
+		need_bump = 1;
+	}
+	/* restrict logical chunk size  */
+	if (stripe_size * data_stripes > max_logical_size) {
+		stripe_size = max_logical_size;
 		do_div(stripe_size, data_stripes);
+		need_bump = 1;
+	}
+
+	if (need_bump) {
+		u64 mask = (1ULL << 24) - 1;
 
 		/* bump the answer up to a 16MB boundary */
 		stripe_size = (stripe_size + mask) & ~mask;
@@ -4411,6 +4418,11 @@  static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 			stripe_size = devices_info[ndevs-1].max_avail;
 	}
 
+	/*
+	 * Special handle for DUP, since stripe_size is the largest free extent
+	 * we found, DUP can only use half of it. Other profile's dev_stripes
+	 * is always 1.
+	 */
 	do_div(stripe_size, dev_stripes);
 
 	/* align to BTRFS_STRIPE_LEN */