From: Naohiro Aota <naohiro.aota@wdc.com>
To: linux-btrfs@vger.kernel.org, dsterba@suse.com
Cc: hare@suse.com, linux-fsdevel@vger.kernel.org,
Naohiro Aota <naohiro.aota@wdc.com>
Subject: [PATCH v8 17/41] btrfs: do sequential extent allocation in ZONED mode
Date: Fri, 2 Oct 2020 03:36:24 +0900 [thread overview]
Message-ID: <0fd14437a7a5e7d979611542475f5d294953565d.1601574234.git.naohiro.aota@wdc.com> (raw)
In-Reply-To: <dece91bca322ce44bed19f2b0f460fa5ded2e512.1601574234.git.naohiro.aota@wdc.com>
This commit implement sequential extent allocator for ZONED mode. The
allocator just need to check if there is enough space in the block group.
Since the allocator never manage bitmap or cluster. This commit also add
ASSERTs to the corresponding functions.
Actually, with zone append writing, it is unnecessary to track the
allocation offset. It only needs to check space availability. But, by
tracking the offset and returning the offset as an allocated region, we can
skip modification of ordered extents and checksum information when there is
no IO reordering.
Signed-off-by: Naohiro Aota <naohiro.aota@wdc.com>
---
fs/btrfs/block-group.c | 4 ++
fs/btrfs/extent-tree.c | 82 ++++++++++++++++++++++++++++++++++---
fs/btrfs/free-space-cache.c | 6 +++
3 files changed, 86 insertions(+), 6 deletions(-)
diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
index e68e477d9160..f07c03445390 100644
--- a/fs/btrfs/block-group.c
+++ b/fs/btrfs/block-group.c
@@ -683,6 +683,10 @@ int btrfs_cache_block_group(struct btrfs_block_group *cache, int load_cache_only
struct btrfs_caching_control *caching_ctl;
int ret = 0;
+ /* Allocator for ZONED btrfs do not use the cache at all */
+ if (btrfs_fs_incompat(fs_info, ZONED))
+ return 0;
+
caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_NOFS);
if (!caching_ctl)
return -ENOMEM;
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 051e61f16cbe..2be93d0f5978 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -3562,6 +3562,7 @@ btrfs_release_block_group(struct btrfs_block_group *cache,
enum btrfs_extent_allocation_policy {
BTRFS_EXTENT_ALLOC_CLUSTERED,
+ BTRFS_EXTENT_ALLOC_ZONED,
};
/*
@@ -3814,6 +3815,55 @@ static int do_allocation_clustered(struct btrfs_block_group *block_group,
return find_free_extent_unclustered(block_group, ffe_ctl);
}
+/*
+ * Simple allocator for sequential only block group. It only allows
+ * sequential allocation. No need to play with trees. This function
+ * also reserve the bytes as in btrfs_add_reserved_bytes.
+ */
+static int do_allocation_zoned(struct btrfs_block_group *block_group,
+ struct find_free_extent_ctl *ffe_ctl,
+ struct btrfs_block_group **bg_ret)
+{
+ struct btrfs_space_info *space_info = block_group->space_info;
+ struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;
+ u64 start = block_group->start;
+ u64 num_bytes = ffe_ctl->num_bytes;
+ u64 avail;
+ int ret = 0;
+
+ ASSERT(btrfs_fs_incompat(block_group->fs_info, ZONED));
+
+ spin_lock(&space_info->lock);
+ spin_lock(&block_group->lock);
+
+ if (block_group->ro) {
+ ret = 1;
+ goto out;
+ }
+
+ avail = block_group->length - block_group->alloc_offset;
+ if (avail < num_bytes) {
+ ffe_ctl->max_extent_size = avail;
+ ret = 1;
+ goto out;
+ }
+
+ ffe_ctl->found_offset = start + block_group->alloc_offset;
+ block_group->alloc_offset += num_bytes;
+ spin_lock(&ctl->tree_lock);
+ ctl->free_space -= num_bytes;
+ spin_unlock(&ctl->tree_lock);
+
+ ASSERT(IS_ALIGNED(ffe_ctl->found_offset,
+ block_group->fs_info->stripesize));
+ ffe_ctl->search_start = ffe_ctl->found_offset;
+
+out:
+ spin_unlock(&block_group->lock);
+ spin_unlock(&space_info->lock);
+ return ret;
+}
+
static int do_allocation(struct btrfs_block_group *block_group,
struct find_free_extent_ctl *ffe_ctl,
struct btrfs_block_group **bg_ret)
@@ -3821,6 +3871,8 @@ static int do_allocation(struct btrfs_block_group *block_group,
switch (ffe_ctl->policy) {
case BTRFS_EXTENT_ALLOC_CLUSTERED:
return do_allocation_clustered(block_group, ffe_ctl, bg_ret);
+ case BTRFS_EXTENT_ALLOC_ZONED:
+ return do_allocation_zoned(block_group, ffe_ctl, bg_ret);
default:
BUG();
}
@@ -3835,6 +3887,9 @@ static void release_block_group(struct btrfs_block_group *block_group,
ffe_ctl->retry_clustered = false;
ffe_ctl->retry_unclustered = false;
break;
+ case BTRFS_EXTENT_ALLOC_ZONED:
+ /* nothing to do */
+ break;
default:
BUG();
}
@@ -3863,6 +3918,9 @@ static void found_extent(struct find_free_extent_ctl *ffe_ctl,
case BTRFS_EXTENT_ALLOC_CLUSTERED:
found_extent_clustered(ffe_ctl, ins);
break;
+ case BTRFS_EXTENT_ALLOC_ZONED:
+ /* nothing to do */
+ break;
default:
BUG();
}
@@ -3878,6 +3936,9 @@ static int chunk_allocation_failed(struct find_free_extent_ctl *ffe_ctl)
*/
ffe_ctl->loop = LOOP_NO_EMPTY_SIZE;
return 0;
+ case BTRFS_EXTENT_ALLOC_ZONED:
+ /* give up here */
+ return -ENOSPC;
default:
BUG();
}
@@ -4046,6 +4107,9 @@ static int prepare_allocation(struct btrfs_fs_info *fs_info,
case BTRFS_EXTENT_ALLOC_CLUSTERED:
return prepare_allocation_clustered(fs_info, ffe_ctl,
space_info, ins);
+ case BTRFS_EXTENT_ALLOC_ZONED:
+ /* nothing to do */
+ return 0;
default:
BUG();
}
@@ -4109,6 +4173,9 @@ static noinline int find_free_extent(struct btrfs_root *root,
ffe_ctl.last_ptr = NULL;
ffe_ctl.use_cluster = true;
+ if (btrfs_fs_incompat(fs_info, ZONED))
+ ffe_ctl.policy = BTRFS_EXTENT_ALLOC_ZONED;
+
ins->type = BTRFS_EXTENT_ITEM_KEY;
ins->objectid = 0;
ins->offset = 0;
@@ -4251,20 +4318,23 @@ static noinline int find_free_extent(struct btrfs_root *root,
/* move on to the next group */
if (ffe_ctl.search_start + num_bytes >
block_group->start + block_group->length) {
- btrfs_add_free_space(block_group, ffe_ctl.found_offset,
- num_bytes);
+ btrfs_add_free_space_unused(block_group,
+ ffe_ctl.found_offset,
+ num_bytes);
goto loop;
}
if (ffe_ctl.found_offset < ffe_ctl.search_start)
- btrfs_add_free_space(block_group, ffe_ctl.found_offset,
- ffe_ctl.search_start - ffe_ctl.found_offset);
+ btrfs_add_free_space_unused(block_group,
+ ffe_ctl.found_offset,
+ ffe_ctl.search_start - ffe_ctl.found_offset);
ret = btrfs_add_reserved_bytes(block_group, ram_bytes,
num_bytes, delalloc);
if (ret == -EAGAIN) {
- btrfs_add_free_space(block_group, ffe_ctl.found_offset,
- num_bytes);
+ btrfs_add_free_space_unused(block_group,
+ ffe_ctl.found_offset,
+ num_bytes);
goto loop;
}
btrfs_inc_block_group_reservations(block_group);
diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 65dd1538692a..d6bc1f97cc78 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -2903,6 +2903,8 @@ u64 btrfs_find_space_for_alloc(struct btrfs_block_group *block_group,
u64 align_gap_len = 0;
enum btrfs_trim_state align_gap_trim_state = BTRFS_TRIM_STATE_UNTRIMMED;
+ ASSERT(!btrfs_fs_incompat(block_group->fs_info, ZONED));
+
spin_lock(&ctl->tree_lock);
entry = find_free_space(ctl, &offset, &bytes_search,
block_group->full_stripe_len, max_extent_size);
@@ -3034,6 +3036,8 @@ u64 btrfs_alloc_from_cluster(struct btrfs_block_group *block_group,
struct rb_node *node;
u64 ret = 0;
+ ASSERT(!btrfs_fs_incompat(block_group->fs_info, ZONED));
+
spin_lock(&cluster->lock);
if (bytes > cluster->max_size)
goto out;
@@ -3810,6 +3814,8 @@ int btrfs_trim_block_group(struct btrfs_block_group *block_group,
int ret;
u64 rem = 0;
+ ASSERT(!btrfs_fs_incompat(block_group->fs_info, ZONED));
+
*trimmed = 0;
spin_lock(&block_group->lock);
--
2.27.0
next prev parent reply other threads:[~2020-10-01 18:38 UTC|newest]
Thread overview: 61+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-10-01 18:36 [PATCH v8 00/41] btrfs: zoned block device support Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 01/41] block: add bio_add_zone_append_page Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 02/41] btrfs: introduce ZONED feature flag Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 03/41] btrfs: Get zone information of zoned block devices Naohiro Aota
2020-10-13 15:53 ` David Sterba
2020-10-15 7:45 ` Johannes Thumshirn
2020-10-01 18:36 ` [PATCH v8 04/41] btrfs: Check and enable ZONED mode Naohiro Aota
2020-10-13 15:56 ` David Sterba
2020-10-28 14:49 ` Johannes Thumshirn
2020-10-13 16:13 ` David Sterba
2020-10-01 18:36 ` [PATCH v8 05/41] btrfs: introduce max_zone_append_size Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 06/41] btrfs: disallow space_cache in ZONED mode Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 07/41] btrfs: disallow NODATACOW " Naohiro Aota
2020-10-13 15:39 ` David Sterba
2020-10-21 8:53 ` Johannes Thumshirn
2020-10-01 18:36 ` [PATCH v8 08/41] btrfs: disable fallocate " Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 09/41] btrfs: disallow mixed-bg " Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 10/41] btrfs: disallow inode_cache " Naohiro Aota
2020-10-13 15:41 ` David Sterba
2020-10-22 6:48 ` Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 11/41] btrfs: implement log-structured superblock for " Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 12/41] btrfs: implement zoned chunk allocator Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 13/41] btrfs: verify device extent is aligned to zone Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 14/41] btrfs: load zone's alloction offset Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 15/41] btrfs: emulate write pointer for conventional zones Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 16/41] btrfs: track unusable bytes for zones Naohiro Aota
2020-10-01 18:36 ` Naohiro Aota [this message]
2020-10-01 18:36 ` [PATCH v8 18/41] btrfs: reset zones of unused block groups Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 19/41] btrfs: redirty released extent buffers in ZONED mode Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 20/41] btrfs: extract page adding function Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 21/41] btrfs: use bio_add_zone_append_page for zoned btrfs Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 22/41] btrfs: handle REQ_OP_ZONE_APPEND as writing Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 23/41] btrfs: split ordered extent when bio is sent Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 24/41] btrfs: extend btrfs_rmap_block for specifying a device Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 25/41] btrfs: use ZONE_APPEND write for ZONED btrfs Naohiro Aota
2020-10-13 16:45 ` David Sterba
2020-10-01 18:36 ` [PATCH v8 26/41] btrfs: enable zone append writing for direct IO Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 27/41] btrfs: introduce dedicated data write path for ZONED mode Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 28/41] btrfs: serialize meta IOs on " Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 29/41] btrfs: wait existing extents before truncating Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 30/41] btrfs: avoid async metadata checksum on ZONED mode Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 31/41] btrfs: mark block groups to copy for device-replace Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 32/41] btrfs: implement cloning for ZONED device-replace Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 33/41] btrfs: implement copying " Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 34/41] btrfs: support dev-replace in ZONED mode Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 35/41] btrfs: enable relocation " Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 36/41] btrfs: relocate block group to repair IO failure in ZONED Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 37/41] btrfs: split alloc_log_tree() Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 38/41] btrfs: extend zoned allocator to use dedicated tree-log block group Naohiro Aota
2020-10-13 16:26 ` David Sterba
2020-10-15 7:21 ` Johannes Thumshirn
2020-10-01 18:36 ` [PATCH v8 39/41] btrfs: serialize log transaction on ZONED mode Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 40/41] btrfs: reorder log node allocation Naohiro Aota
2020-10-01 18:36 ` [PATCH v8 41/41] btrfs: enable to mount ZONED incompat flag Naohiro Aota
2020-10-02 13:39 ` [PATCH v8 01/41] block: add bio_add_zone_append_page Martin K. Petersen
2020-10-05 1:46 ` Damien Le Moal
2020-10-05 13:43 ` Christoph Hellwig
2020-10-06 1:26 ` Martin K. Petersen
2020-10-06 5:12 ` Damien Le Moal
2020-10-09 15:40 ` [PATCH v8 00/41] btrfs: zoned block device support Josef Bacik
2020-10-12 9:17 ` Naohiro Aota
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=0fd14437a7a5e7d979611542475f5d294953565d.1601574234.git.naohiro.aota@wdc.com \
--to=naohiro.aota@wdc.com \
--cc=dsterba@suse.com \
--cc=hare@suse.com \
--cc=linux-btrfs@vger.kernel.org \
--cc=linux-fsdevel@vger.kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).