btrfs: zoned block device support
Subsystems (3)
v8 cover btrfs: zoned block device support
This series adds zoned block device support to btrfs.
Changes from v7:
- Use bio_add_hw_page() to build up bio to honor hardware restrictions
- add bio_add_zone_append_page() as a wrapper of the function
- Split file extent on submitting bio
- If bio_add_zone_append_page() fails, split the file extent and send out bio
- so, we can ensure one bio == one file extent
- Fix build bot issues
- Rebased on misc-next
Userland series will follow.
This version of ZONED btrfs switched from normal write command to zone append write command. You do not need to specify LBA (at the write pointer) to write for zone append write command. Instead, you only select a zone to write with its start LBA. Then the device (NVMe ZNS), or the emulation of zone append command in the sd driver in the case of SAS or SATA HDDs, automatically writes the data at the write pointer position and return the written LBA as a command reply.
The benefit of using the zone append write command is that write command issuing order does not matter. So, we can eliminate block group lock and utilize asynchronous checksum, which can reorder the IOs.
Eliminating the lock improves performance. In particular, on a workload with massive competing to the same zone [1], we observed 36% performance improvement compared to normal write.
[1] Fio running 16 jobs with 4KB random writes for 5 minutes
However, there are some limitations. We cannot use the non-SINGLE profile. Supporting non-SINGLE profile with zone append writing is not trivial. For example, in the DUP profile, we send a zone append writing IO to two zones on a device. The device reply with written LBAs for the IOs. If the offsets of the returned addresses from the beginning of the zone are different, then it results in different logical addresses.
For the same reason, we cannot issue multiple IOs for one ordered extent. Thus, the size of an ordered extent is limited under max_zone_append_size. This limitation will cause fragmentation and increased usage of metadata. In the future, we can add optimization to merge ordered extents after end_bio.
* Patch series description
A zoned block device consists of a number of zones. Zones are either conventional and accepting random writes or sequential and requiring that writes be issued in LBA order from each zone write pointer position. This patch series ensures that the sequential write constraint of sequential zones is respected while fundamentally not changing BtrFS block and I/O management for block stored in conventional zones.
To achieve this, the default chunk size of btrfs is changed on zoned block devices so that chunks are always aligned to a zone. Allocation of blocks within a chunk is changed so that the allocation is always sequential from the beginning of the chunks. To do so, an allocation pointer is added to block groups and used as the allocation hint. The allocation changes also ensure that blocks freed below the allocation pointer are ignored, resulting in sequential block allocation regardless of the chunk usage.
The zone of a chunk is reset to allow reuse of the zone only when the block group is being freed, that is, when all the chunks of the block group are unused.
For btrfs volumes composed of multiple zoned disks, a restriction is added to ensure that all disks have the same zone size. This restriction matches the existing constraint that all chunks in a block group must have the same size.
* Enabling tree-log
The tree-log feature does not work on ZONED mode as is. Blocks for a tree-log tree are allocated mixed with other metadata blocks, and btrfs writes and syncs the tree-log blocks to devices at the time of fsync(), which is different timing than a global transaction commit. As a result, both writing tree-log blocks and writing other metadata blocks become non-sequential writes which ZONED mode must avoid.
This series introduces a dedicated block group for tree-log blocks to create two metadata writing streams, one for tree-log blocks and the other for metadata blocks. As a result, each write stream can now be written to devices separately and sequentially.
* Log-structured superblock
Superblock (and its copies) is the only data structure in btrfs which has a fixed location on a device. Since we cannot overwrite in a sequential write required zone, we cannot place superblock in the zone.
This series implements superblock log writing. It uses two zones as a circular buffer to write updated superblocks. Once the first zone is filled up, start writing into the second zone. The first zone will be reset once both zones are filled. We can determine the postion of the latest superblock by reading the write pointer information from a device.
* Patch series organization
Patch 1 add bio_add_zone_append_page() as a wrapper of bio_add_hw_page().
Patch 2 introduces the ZONED incompatible feature flag to indicate that the btrfs volume was formatted for use on zoned block devices.
Patches 3 to 5 implement functions to gather information on the zones of the device (zones type, write pointer position, and max_zone_append_size).
Patches 6 to 10 disable features which are not compatible with the sequential write constraints of zoned block devices. These includes space_cache, NODATACOW, fallocate, MIXED_BG and inode cache.
Patch 11 implements the log-structured superblock writing.
Patches 12 and 13 tweak the device extent allocation for ZONED mode and add verification to check if a device extent is properly aligned to zones.
Patches 14 to 17 implements sequential block allocator for ZONED mode.
Patch 18 implement a zone reset for unused block groups.
Patches 19 to 30 implement the writing path for several types of IO (non-compressed data, direct IO, and metadata). These include re-dirtying once-freed metadata blocks to prevent write holes.
Patches 31 to 40 tweak some btrfs features work with ZONED mode. These include device-replace, relocation, repairing IO error, and tree-log.
Finally, patch 41 adds the ZONED feature to the list of supported features.
* Patch testing note
This series is based on kdave/for-5.5.
** Zone-aware util-linux
Since the log-structured superblock feature changed the location of superblock magic, the current util-linux (libblkid) cannot detect ZONED btrfs anymore. You need to apply a to-be posted patch to util-linux to make it "zone aware".
** Testing device
You need devices with zone append writing command support to run ZONED btrfs.
Other than real devices, null_blk supports zone append write command. You can use memory backed null_blk to run the test on it. Following script creates 12800 MB /dev/nullb0.
sysfs=/sys/kernel/config/nullb/nullb0
size=12800 # MB
# drop nullb0
if [[ -d $sysfs ]]; then
echo 0 > "${sysfs}"/power
rmdir $sysfs
fi
lsmod | grep -q null_blk && rmmod null_blk
modprobe null_blk nr_devices=0
mkdir "${sysfs}"
echo "${size}" > "${sysfs}"/size
echo 1 > "${sysfs}"/zoned
echo 0 > "${sysfs}"/zone_nr_conv
echo 1 > "${sysfs}"/memory_backed
echo 1 > "${sysfs}"/power
udevadm settleZoned SCSI devices such as SMR HDDs or scsi_debug also support the zone append command as an emulated command within the SCSI sd driver. This emulation is completely transparent to the user and provides the same semantic as a NVMe ZNS native drive support.
Also, there is a qemu patch available to enable NVMe ZNS device.
** xfstests
We ran xfstests on ZONED btrfs, and, if we omit some cases that are known to fail currently, all test cases pass.
Cases that can be ignored:
1) failing also with the regular btrfs on regular devices,
2) trying to test fallocate feature without testing with "_require_xfs_io_command "falloc"",
3) trying to test incompatible features for ZONED btrfs (e.g. RAID5/6)
4) trying to use incompatible setup for ZONED btrfs (e.g. dm-linear not aligned to zone boundary, swap)
5) trying to create a file system with too small size, (we require at least 9 zones to initiate a ZONED btrfs)
6) dropping original MKFS_OPTIONS ("-O zoned"), so it cannot create ZONED btrfs (btrfs/003)
7) having ENOSPC which incurred by larger metadata block group size
I will send a patch series for xfstests to handle these cases (2-6) properly.
Also, you need to apply the following patch if you run xfstests with tcmu devices. xfstests btrfs/003 failed to "_devmgt_add" after "_devmgt_remove" without this patch.
https://marc.info/?l=linux-scsi&m=156498625421698&w=2
v7 https://lore.kernel.org/linux-btrfs/[email protected]/
v6 https://lore.kernel.org/linux-btrfs/[email protected]/
v5 https://lore.kernel.org/linux-btrfs/[email protected]/
v4 https://lwn.net/Articles/797061/
v3 https://lore.kernel.org/linux-btrfs/[email protected]/
v2 https://lore.kernel.org/linux-btrfs/[email protected]/
v1 https://lore.kernel.org/linux-btrfs/[email protected]/
Changelog
v7:
- Use zone append write command instead of normal write command
- Bio issuing order does not matter
- No need to use lock anymore
- Can use asynchronous checksum
- Removed RAID support for now
- Rename HMZONED to ZONED
- Split some patches
- Rebased on kdave/for-5.9-rc3 + iomap direct IO
v6:
- Use bitmap helpers (Johannes)
- Code cleanup (Johannes)
- Rebased on kdave/for-5.5
- Enable the tree-log feature.
- Treat conventional zones as sequential zones, so we can now allow mixed allocation of conventional zone and sequential write required zone to construct a block group.
- Implement log-structured superblock
- No need for one conventional zone at the beginning of a device.
- Fix deadlock of direct IO writing
- Fix building with !CONFIG_BLK_DEV_ZONED (Johannes)
- Fix leak of zone_info (Johannes)
v5:
- Rebased on kdave/for-5.5
- Enable the tree-log feature.
- Treat conventional zones as sequential zones, so we can now allow mixed allocation of conventional zone and sequential write required zone to construct a block group.
- Implement log-structured superblock
- No need for one conventional zone at the beginning of a device.
- Fix deadlock of direct IO writing
- Fix building with !CONFIG_BLK_DEV_ZONED (Johannes)
- Fix leak of zone_info (Johannes)
v4:
- Move memory allcation of zone informattion out of btrfs_get_dev_zones() (Anand)
- Add disabled features table in commit log (Anand)
- Ensure "max_chunk_size >= devs_min * data_stripes * zone_size"
v3:
- Serialize allocation and submit_bio instead of bio buffering in btrfs_map_bio().
-- Disable async checksum/submit in HMZONED mode
- Introduce helper functions and hmzoned.c/h (Josef, David)
- Add support for repairing IO failure
- Add support for NOCOW direct IO write (Josef)
- Disable preallocation entirely
-- Disable INODE_MAP_CACHE
-- relocation is reworked not to rely on preallocation in HMZONED mode
- Disable NODATACOW
-Disable MIXED_BG
- Device extent that cover super block position is banned (David)
v2:
- Add support for dev-replace
-- To support dev-replace, moved submit_buffer one layer up. It now
handles bio instead of btrfs_bio.
-- Mark unmirrored Block Group readonly only when there are writable
mirrored BGs. Necessary to handle degraded RAID.
- Expire worker use vanilla delayed_work instead of btrfs's async-thread
- Device extent allocator now ensure that region is on the same zone type.
- Add delayed allocation shrinking.
- Rename btrfs_drop_dev_zonetypes() to btrfs_destroy_dev_zonetypes
- Fix
-- Use SECTOR_SHIFT (Nikolay)
-- Use btrfs_err (Nikolay)
Johannes Thumshirn (1):
block: add bio_add_zone_append_page
Naohiro Aota (40):
btrfs: introduce ZONED feature flag
btrfs: Get zone information of zoned block devices
btrfs: Check and enable ZONED mode
btrfs: introduce max_zone_append_size
btrfs: disallow space_cache in ZONED mode
btrfs: disallow NODATACOW in ZONED mode
btrfs: disable fallocate in ZONED mode
btrfs: disallow mixed-bg in ZONED mode
btrfs: disallow inode_cache in ZONED mode
btrfs: implement log-structured superblock for ZONED mode
btrfs: implement zoned chunk allocator
btrfs: verify device extent is aligned to zone
btrfs: load zone's alloction offset
btrfs: emulate write pointer for conventional zones
btrfs: track unusable bytes for zones
btrfs: do sequential extent allocation in ZONED mode
btrfs: reset zones of unused block groups
btrfs: redirty released extent buffers in ZONED mode
btrfs: extract page adding function
btrfs: use bio_add_zone_append_page for zoned btrfs
btrfs: handle REQ_OP_ZONE_APPEND as writing
btrfs: split ordered extent when bio is sent
btrfs: extend btrfs_rmap_block for specifying a device
btrfs: use ZONE_APPEND write for ZONED btrfs
btrfs: enable zone append writing for direct IO
btrfs: introduce dedicated data write path for ZONED mode
btrfs: serialize meta IOs on ZONED mode
btrfs: wait existing extents before truncating
btrfs: avoid async metadata checksum on ZONED mode
btrfs: mark block groups to copy for device-replace
btrfs: implement cloning for ZONED device-replace
btrfs: implement copying for ZONED device-replace
btrfs: support dev-replace in ZONED mode
btrfs: enable relocation in ZONED mode
btrfs: relocate block group to repair IO failure in ZONED
btrfs: split alloc_log_tree()
btrfs: extend zoned allocator to use dedicated tree-log block group
btrfs: serialize log transaction on ZONED mode
btrfs: reorder log node allocation
btrfs: enable to mount ZONED incompat flag
block/bio.c | 36 + fs/btrfs/Makefile | 1 + fs/btrfs/block-group.c | 85 ++- fs/btrfs/block-group.h | 13 + fs/btrfs/ctree.h | 12 +- fs/btrfs/dev-replace.c | 187 ++++++ fs/btrfs/dev-replace.h | 3 + fs/btrfs/disk-io.c | 82 ++- fs/btrfs/disk-io.h | 2 + fs/btrfs/extent-tree.c | 203 +++++- fs/btrfs/extent_io.c | 136 +++- fs/btrfs/extent_io.h | 2 + fs/btrfs/file.c | 4 + fs/btrfs/free-space-cache.c | 58 ++ fs/btrfs/free-space-cache.h | 4 + fs/btrfs/inode.c | 153 ++++- fs/btrfs/ioctl.c | 3 + fs/btrfs/ordered-data.c | 76 +++ fs/btrfs/ordered-data.h | 6 + fs/btrfs/relocation.c | 35 +- fs/btrfs/scrub.c | 145 ++++ fs/btrfs/space-info.c | 13 +- fs/btrfs/space-info.h | 4 +- fs/btrfs/super.c | 13 +- fs/btrfs/sysfs.c | 4 + fs/btrfs/transaction.c | 10 + fs/btrfs/transaction.h | 3 + fs/btrfs/tree-log.c | 50 +- fs/btrfs/volumes.c | 307 ++++++++- fs/btrfs/volumes.h | 7 + fs/btrfs/zoned.c | 1266 +++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 279 ++++++++ include/linux/bio.h | 2 + include/uapi/linux/btrfs.h | 1 + 34 files changed, 3112 insertions(+), 93 deletions(-) create mode 100644 fs/btrfs/zoned.c create mode 100644 fs/btrfs/zoned.h
Signature · 1 line
2.27.0
PATCH v8 1/41 block: add bio_add_zone_append_page
From: Johannes Thumshirn <[email protected]>
Add bio_add_zone_append_page(), a wrapper around bio_add_hw_page() which is intended to be used by file systems that directly add pages to a bio instead of using bio_iov_iter_get_pages().
--- block/bio.c | 36 ++++++++++++++++++++++++++++++++++++ include/linux/bio.h | 2 ++ 2 files changed, 38 insertions(+)
block/bio.c +36 -0
@@ -853,6 +853,42 @@ int bio_add_pc_page(struct request_queue *q, struct bio *bio, }EXPORT_SYMBOL (bio_add_pc_page); +/** +* bio_add_zone_append_page - attempt to add page to zone-append bio +* @bio: destination bio +* @page: page to add +* @len: vec entry length +* @offset: vec entry offset +* +* Attempt to add a page to the bio_vec maplist of a bio that will be submitted +* for a zone-append request. This can fail for a number of reasons, such as the +* bio being full or the target block device is not a zoned block device or +* other limitations of the target block device. The target block device must +* allow bio's up to PAGE_SIZE, so it is always possible to add a single page +* to an empty bio. +*/ +int bio_add_zone_append_page (struct bio *bio,struct page *page, +unsigned int len,unsigned int offset) +{ +struct request_queue *q; +bool same_page = false; + +if (WARN_ON_ONCE (bio_op (bio) !=REQ_OP_ZONE_APPEND )) +return 0 ; + +if (WARN_ON_ONCE (!bio->bi_disk)) +return 0 ; + + q = bio->bi_disk->queue; + +if (WARN_ON_ONCE (!blk_queue_is_zoned (q))) +return 0 ; + +return bio_add_hw_page (q, bio, page, len, offset, +queue_max_zone_append_sectors (q), &same_page); +} +EXPORT_SYMBOL_GPL (bio_add_zone_append_page); +/** * __bio_try_merge_page - try appending data to an existing bvec. * @bio: destination bio
include/linux/bio.h +2 -0
@@ -442,6 +442,8 @@ void bio_chain(struct bio *, struct bio *);extern int bio_add_page (struct bio *,struct page *,unsigned int ,unsigned int );extern int bio_add_pc_page (struct request_queue *,struct bio *,struct page *,unsigned int ,unsigned int ); +int bio_add_zone_append_page (struct bio *bio,struct page *page, +unsigned int len,unsigned int offset);bool __bio_try_merge_page (struct bio *bio,struct page *page,unsigned int len,unsigned int off,bool *same_page); void __bio_add_page(struct bio *bio, struct page *page,
Signature · 1 line
2.27.0
PATCH v8 2/41 btrfs: introduce ZONED feature flag
This patch introduces the ZONED incompat flag. The flag indicates that the volume management will satisfy the constraints imposed by host-managed zoned block devices.
--- fs/btrfs/sysfs.c | 2 ++ include/uapi/linux/btrfs.h | 1 + 2 files changed, 3 insertions(+)
fs/btrfs/sysfs.c +2 -0
@@ -263,6 +263,7 @@ BTRFS_FEAT_ATTR_INCOMPAT(no_holes, NO_HOLES);BTRFS_FEAT_ATTR_INCOMPAT (metadata_uuid,METADATA_UUID );BTRFS_FEAT_ATTR_COMPAT_RO (free_space_tree,FREE_SPACE_TREE );BTRFS_FEAT_ATTR_INCOMPAT (raid1c34,RAID1C34 ); +BTRFS_FEAT_ATTR_INCOMPAT (zoned,ZONED );static struct attribute *btrfs_supported_feature_attrs[] = {BTRFS_FEAT_ATTR_PTR (mixed_backref),
@@ -278,6 +279,7 @@ static struct attribute *btrfs_supported_feature_attrs[] = {BTRFS_FEAT_ATTR_PTR (metadata_uuid),BTRFS_FEAT_ATTR_PTR (free_space_tree),BTRFS_FEAT_ATTR_PTR (raid1c34), +BTRFS_FEAT_ATTR_PTR (zoned), NULL };
include/uapi/linux/btrfs.h +1 -0
@@ -307,6 +307,7 @@ struct btrfs_ioctl_fs_info_args {#define BTRFS_FEATURE_INCOMPAT_NO_HOLES (1ULL << 9)#define BTRFS_FEATURE_INCOMPAT_METADATA_UUID (1ULL << 10)#define BTRFS_FEATURE_INCOMPAT_RAID1C34 (1ULL << 11) +#define BTRFS_FEATURE_INCOMPAT_ZONED (1ULL << 12)struct btrfs_ioctl_feature_flags {__u64 compat_flags;
Signature · 1 line
2.27.0
PATCH v8 3/41 btrfs: Get zone information of zoned block devices
In reply to Naohiro AotaIf a zoned block device is found, get its zone information (number of zones and zone size) using the new helper function btrfs_get_dev_zone_info(). To avoid costly run-time zone report commands to test the device zones type during block allocation, attach the seq_zones bitmap to the device structure to indicate if a zone is sequential or accept random writes. Also it attaches the empty_zones bitmap to indicate if a zone is empty or not.
This patch also introduces the helper function btrfs_dev_is_sequential() to test if the zone storing a block is a sequential write required zone and btrfs_dev_is_empty_zone() to test if the zone is a empty zone.
--- fs/btrfs/Makefile | 1 + fs/btrfs/dev-replace.c | 5 ++ fs/btrfs/volumes.c | 18 ++++- fs/btrfs/volumes.h | 4 + fs/btrfs/zoned.c | 179 +++++++++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 92 +++++++++++++++++++++ 6 files changed, 297 insertions(+), 2 deletions(-) create mode 100644 fs/btrfs/zoned.c create mode 100644 fs/btrfs/zoned.h
fs/btrfs/Makefile +1 -0
@@ -16,6 +16,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o btrfs-$(CONFIG_BTRFS_FS_REF_VERIFY) += ref-verify.o +btrfs-$(CONFIG_BLK_DEV_ZONED) += zoned.o btrfs-$(CONFIG_BTRFS_FS_RUN_SANITY_TESTS) += tests/free-space-tests.o \ tests/extent-buffer-tests.o tests/btrfs-tests.o \
fs/btrfs/dev-replace.c +5 -0
@@ -21,6 +21,7 @@#include "rcu-string.h" #include "dev-replace.h" #include "sysfs.h" +#include "zoned.h" /* * Device replace overview
@@ -291,6 +292,10 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,set_blocksize (device->bdev,BTRFS_BDEV_BLOCKSIZE ); device->fs_devices = fs_info->fs_devices; + ret =btrfs_get_dev_zone_info (device); +if (ret) + goto error; +mutex_lock (&fs_info->fs_devices->device_list_mutex);list_add (&device->dev_list, &fs_info->fs_devices->devices); fs_info->fs_devices->num_devices++;
fs/btrfs/volumes.c +16 -2
@@ -31,6 +31,7 @@#include "space-info.h" #include "block-group.h" #include "discard.h" +#include "zoned.h" const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES ] = { [BTRFS_RAID_RAID10 ] = {
@@ -374,6 +375,7 @@ void btrfs_free_device(struct btrfs_device *device)rcu_string_free (device->name);extent_io_tree_release (&device->alloc_state);bio_put (device->flush_bio); +btrfs_destroy_dev_zone_info (device);kfree (device); }
@@ -667,6 +669,11 @@ static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices,clear_bit (BTRFS_DEV_STATE_IN_FS_METADATA , &device->dev_state); device->mode = flags; +/* Get zone type information of zoned block devices */ + ret =btrfs_get_dev_zone_info (device); +if (ret !=0 ) + goto error_free_page; + fs_devices->open_devices++;if (test_bit (BTRFS_DEV_STATE_WRITEABLE , &device->dev_state) && device->devid !=BTRFS_DEV_REPLACE_DEVID ) {
@@ -2543,6 +2550,14 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path }rcu_assign_pointer (device->name, name); + device->fs_info = fs_info; + device->bdev = bdev; + +/* Get zone type information of zoned block devices */ + ret =btrfs_get_dev_zone_info (device); +if (ret) + goto error_free_device; + trans =btrfs_start_transaction (root,0 );if (IS_ERR (trans)) { ret =PTR_ERR (trans);
@@ -2559,8 +2574,6 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path fs_info->sectorsize); device->disk_total_bytes = device->total_bytes; device->commit_total_bytes = device->total_bytes; - device->fs_info = fs_info; - device->bdev = bdev;set_bit (BTRFS_DEV_STATE_IN_FS_METADATA , &device->dev_state);clear_bit (BTRFS_DEV_STATE_REPLACE_TGT , &device->dev_state); device->mode =FMODE_EXCL ;
@@ -2707,6 +2720,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path sb->s_flags |=SB_RDONLY ;if (trans)btrfs_end_transaction (trans); +btrfs_destroy_dev_zone_info (device); error_free_device:btrfs_free_device (device); error:
fs/btrfs/volumes.h +4 -0
@@ -51,6 +51,8 @@ struct btrfs_io_geometry {#define BTRFS_DEV_STATE_REPLACE_TGT (3)#define BTRFS_DEV_STATE_FLUSH_SENT (4) +struct btrfs_zoned_device_info ; +struct btrfs_device {struct list_head dev_list;/* device_list_mutex */ struct list_head dev_alloc_list;/* chunk mutex */
@@ -64,6 +66,8 @@ struct btrfs_device {struct block_device *bdev; +struct btrfs_zoned_device_info *zone_info; +/* the mode sent to blkdev_get */ fmode_t mode;
fs/btrfs/zoned.c new file +179 -0
179 lines not on this page · raw message
fs/btrfs/zoned.h new file +92 -0
92 lines not on this page · raw message
Signature · 1 line
2.27.0
Re: [PATCH v8 03/41] btrfs: Get zone information of zoned block devices
fs/btrfs/Makefile btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ · line 19
Quoted 7 lines · Naohiro Aota
fs/btrfs/Makefile +1
-0@@ -16,6 +16,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o btrfs-$(CONFIG_BTRFS_FS_REF_VERIFY) += ref-verify.o +btrfs-$(CONFIG_BLK_DEV_ZONED) += zoned.o
As this is conditionally built in, it should be also added to the string printed by btrfs_print_mod_info and we want the actual status so
#ifdef CONFIG_BLK_DEV_ZONED ", zoned=yes" #else ", zoned=no"
#endif
Re: [PATCH v8 03/41] btrfs: Get zone information of zoned block devices
Quoted 12 lines · David Sterba
fs/btrfs/Makefile btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ · line 19
Quoted 7 lines · Naohiro Aota
fs/btrfs/Makefile +1
-0@@ -16,6 +16,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o btrfs-$(CONFIG_BTRFS_FS_REF_VERIFY) += ref-verify.o +btrfs-$(CONFIG_BLK_DEV_ZONED) += zoned.oAs this is conditionally built in, it should be also added to the string printed by
btrfs_print_mod_infoand we want the actual status so
Quoted 6 lines
#ifdef CONFIG_BLK_DEV_ZONED ", zoned=yes" #else ", zoned=no"#endif
done
PATCH v8 4/41 btrfs: Check and enable ZONED mode
In reply to Naohiro AotaThis commit introduces the function btrfs_check_zoned_mode() to check if ZONED flag is enabled on the file system and if the file system consists of zoned devices with equal zone size.
--- fs/btrfs/ctree.h | 3 ++ fs/btrfs/dev-replace.c | 7 ++++ fs/btrfs/disk-io.c | 9 +++++ fs/btrfs/super.c | 1 + fs/btrfs/volumes.c | 5 +++ fs/btrfs/zoned.c | 78 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 26 ++++++++++++++ 7 files changed, 129 insertions(+)
fs/btrfs/ctree.h +3 -0
@@ -588,6 +588,9 @@ struct btrfs_fs_info {struct btrfs_root *free_space_root;struct btrfs_root *data_reloc_root; +/* Zone size when in ZONED mode */ +u64 zone_size; +/* the log root tree is a directory of all the other log roots */ struct btrfs_root *log_root_tree;
fs/btrfs/dev-replace.c +7 -0
@@ -238,6 +238,13 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,return PTR_ERR (bdev); } +if (!btrfs_check_device_zone_type (fs_info, bdev)) { +btrfs_err (fs_info, +"zone type of target device mismatch with the filesystem!" ); + ret = -EINVAL ; + goto error; + } +sync_blockdev (bdev);list_for_each_entry (device, &fs_info->fs_devices->devices, dev_list) {
fs/btrfs/disk-io.c +9 -0
@@ -42,6 +42,7 @@#include "block-group.h" #include "discard.h" #include "space-info.h" +#include "zoned.h" #define BTRFS_SUPER_FLAG_SUPP (BTRFS_HEADER_FLAG_WRITTEN |\ BTRFS_HEADER_FLAG_RELOC |\
@@ -3130,7 +3131,15 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_devicebtrfs_free_extra_devids (fs_devices,1 ); + ret =btrfs_check_zoned_mode (fs_info); +if (ret) { +btrfs_err (fs_info,"failed to init ZONED mode: %d" , + ret); + goto fail_block_groups; + } + ret =btrfs_sysfs_add_fsid (fs_devices); +if (ret) {btrfs_err (fs_info,"failed to init sysfs fsid interface: %d" , ret);
fs/btrfs/super.c +1 -0
@@ -44,6 +44,7 @@#include "backref.h" #include "space-info.h" #include "sysfs.h" +#include "zoned.h" #include "tests/btrfs-tests.h" #include "block-group.h" #include "discard.h"
fs/btrfs/volumes.c +5 -0
@@ -2517,6 +2517,11 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_pathif (IS_ERR (bdev))return PTR_ERR (bdev); +if (!btrfs_check_device_zone_type (fs_info, bdev)) { + ret = -EINVAL ; + goto error; + } +if (fs_devices->seeding) { seeding_dev =1 ;down_write (&sb->s_umount);
fs/btrfs/zoned.c +78 -0
81 lines not on this page · raw message
fs/btrfs/zoned.h +26 -0
@@ -9,6 +9,8 @@#ifndef BTRFS_ZONED_H #define BTRFS_ZONED_H +#include <linux/blkdev.h> + struct btrfs_zoned_device_info {/* * Number of zones, zone size and types of zones if bdev is a
@@ -26,6 +28,7 @@ int btrfs_get_dev_zone(struct btrfs_device *device, u64 pos, struct blk_zone *zone);int btrfs_get_dev_zone_info (struct btrfs_device *device);void btrfs_destroy_dev_zone_info (struct btrfs_device *device); +int btrfs_check_zoned_mode (struct btrfs_fs_info *fs_info);#else /* CONFIG_BLK_DEV_ZONED */ static inline int btrfs_get_dev_zone (struct btrfs_device *device,u64 pos,struct blk_zone *zone)
@@ -37,6 +40,14 @@ static inline int btrfs_get_dev_zone_info(struct btrfs_device *device) return 0; }static inline void btrfs_destroy_dev_zone_info (struct btrfs_device *device) { } +static inline int btrfs_check_zoned_mode (struct btrfs_fs_info *fs_info) +{ +if (!btrfs_fs_incompat (fs_info,ZONED )) +return 0 ; + +btrfs_err (fs_info,"Zoned block devices support is not enabled" ); +return -EOPNOTSUPP ; +}#endif static inline bool btrfs_dev_is_sequential (struct btrfs_device *device,u64 pos)
@@ -89,4 +100,19 @@ static inline void btrfs_dev_clear_zone_empty(struct btrfs_device *device, btrfs_dev_set_empty_zone_bit(device, pos, false); } +static inline bool btrfs_check_device_zone_type (struct btrfs_fs_info *fs_info, +struct block_device *bdev) +{ +u64 zone_size; + +if (btrfs_fs_incompat (fs_info,ZONED )) { + zone_size = (u64 )bdev_zone_sectors (bdev) <<SECTOR_SHIFT ; +/* Do not allow non-zoned device */ +return bdev_is_zoned (bdev) && fs_info->zone_size == zone_size; + } + +/* Do not allow Host Manged zoned device */ +return bdev_zoned_model (bdev) !=BLK_ZONED_HM ; +} +#endif
Signature · 1 line
2.27.0
Re: [PATCH v8 04/41] btrfs: Check and enable ZONED mode
fs/btrfs/ctree.h struct btrfs_fs_info { · line 592
Quoted 8 lines · Naohiro Aota
fs/btrfs/ctree.h +2
-0@@ -588,6 +588,9 @@ struct btrfs_fs_info {struct btrfs_root *free_space_root;struct btrfs_root *data_reloc_root; +/* Zone size when in ZONED mode */ +u64 zone_size;
I think this could be reused to avoid the lengthy
if (btrfs_fs_incompat(fs_info, ZONED))
to do
if (fs_info->zoned)
In order to keep the semantics of both an anonymouns union should work:
union {
u64 zone_size;
u64 zone;
};and the existing usage of zone_size can be kept intact.
Re: [PATCH v8 04/41] btrfs: Check and enable ZONED mode
Quoted 18 lines · David Sterba
fs/btrfs/ctree.h struct btrfs_fs_info { · line 592
Quoted 8 lines · Naohiro Aota
fs/btrfs/ctree.h +2
-0@@ -588,6 +588,9 @@ struct btrfs_fs_info {struct btrfs_root *free_space_root;struct btrfs_root *data_reloc_root; +/* Zone size when in ZONED mode */ +u64 zone_size;I think this could be reused to avoid the lengthy
if (
btrfs_fs_incompat(fs_info, ZONED))to do
if (fs_info->zoned)
Quoted 9 lines
In order to keep the semantics of both an anonymouns union should work:
union { u64 zone_size; u64 zone; };and the existing usage of
zone_sizecan be kept intact.
I've opted for a bool zoned in fs_info and a btrfs_is_zoned(fs_info) inline function, which we can get rid of again if you just want fs_info->zoned.
Re: [PATCH v8 04/41] btrfs: Check and enable ZONED mode
In reply to Naohiro Aotafs/btrfs/ctree.h struct btrfs_fs_info { · line 595
Quoted 11 lines · Naohiro Aota
fs/btrfs/ctree.h +3
-0@@ -588,6 +588,9 @@ struct btrfs_fs_info {struct btrfs_root *free_space_root;struct btrfs_root *data_reloc_root; +/* Zone size when in ZONED mode */ +u64 zone_size; +/* the log root tree is a directory of all the other log roots */ struct btrfs_root *log_root_tree;
This is misplaced, new members should be placed to an existing location if there is one or at the end of the structure. What's the logic behind putting zone_size and later max_zone_append_size into the tree root pointers?
PATCH v8 5/41 btrfs: introduce max_zone_append_size
In reply to Naohiro AotaZone append write command has a maximum IO size restriction it accepts. Introduce max_zone_append_size to zone_info and fs_into to track the value.
--- fs/btrfs/ctree.h | 2 ++ fs/btrfs/zoned.c | 17 +++++++++++++++-- fs/btrfs/zoned.h | 1 + 3 files changed, 18 insertions(+), 2 deletions(-)
fs/btrfs/ctree.h +2 -0
@@ -590,6 +590,8 @@ struct btrfs_fs_info {/* Zone size when in ZONED mode */ u64 zone_size; +/* max size to emit ZONE_APPEND write command */ +u64 max_zone_append_size;/* the log root tree is a directory of all the other log roots */ struct btrfs_root *log_root_tree;
fs/btrfs/zoned.c +15 -2
@@ -53,6 +53,7 @@ int btrfs_get_dev_zone_info(struct btrfs_device *device) {struct btrfs_zoned_device_info *zone_info =NULL ;struct block_device *bdev = device->bdev; +struct request_queue *q =bdev_get_queue (bdev);sector_t nr_sectors = bdev->bd_part->nr_sects;sector_t sector =0 ;struct blk_zone *zones =NULL ;
@@ -73,6 +74,8 @@ int btrfs_get_dev_zone_info(struct btrfs_device *device)ASSERT (is_power_of_2 (zone_sectors)); zone_info->zone_size = (u64 )zone_sectors <<SECTOR_SHIFT ; zone_info->zone_size_shift =ilog2 (zone_info->zone_size); + zone_info->max_zone_append_size = + (u64 )queue_max_zone_append_sectors (q) <<SECTOR_SHIFT ; zone_info->nr_zones = nr_sectors >>ilog2 (bdev_zone_sectors (bdev));if (!IS_ALIGNED (nr_sectors, zone_sectors)) zone_info->nr_zones++;
@@ -185,6 +188,7 @@ int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info)u64 hmzoned_devices =0 ;u64 nr_devices =0 ;u64 zone_size =0 ; +u64 max_zone_append_size =0 ;int incompat_zoned =btrfs_fs_incompat (fs_info,ZONED );int ret =0 ;
@@ -198,15 +202,23 @@ int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info) model =bdev_zoned_model (device->bdev);if (model ==BLK_ZONED_HM || (model ==BLK_ZONED_HA && incompat_zoned)) { +struct btrfs_zoned_device_info *zone_info = + device->zone_info; + hmzoned_devices++;if (!zone_size) { - zone_size = device->zone_info->zone_size; - }else if (device->zone_info->zone_size != zone_size) { + zone_size = zone_info->zone_size; + }else if (zone_info->zone_size != zone_size) {btrfs_err (fs_info,"Zoned block devices must have equal zone sizes" ); ret = -EINVAL ; goto out; } +if (!max_zone_append_size || + (zone_info->max_zone_append_size && + zone_info->max_zone_append_size < max_zone_append_size)) + max_zone_append_size = + zone_info->max_zone_append_size; } nr_devices++; }
@@ -249,6 +261,7 @@ int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info) } fs_info->zone_size = zone_size; + fs_info->max_zone_append_size = max_zone_append_size;btrfs_info (fs_info,"ZONED mode enabled, zone size %llu B" , fs_info->zone_size);
fs/btrfs/zoned.h +1 -0
@@ -18,6 +18,7 @@ struct btrfs_zoned_device_info {*/ u64 zone_size;u8 zone_size_shift; +u64 max_zone_append_size;u32 nr_zones;unsigned long *seq_zones;unsigned long *empty_zones;
Signature · 1 line
2.27.0
PATCH v8 6/41 btrfs: disallow space_cache in ZONED mode
In reply to Naohiro AotaAs updates to the space cache v1 are in-place, the space cache cannot be located over sequential zones and there is no guarantees that the device will have enough conventional zones to store this cache. Resolve this problem by disabling completely the space cache v1. This does not introduces any problems with sequential block groups: all the free space is located after the allocation pointer and no free space before the pointer. There is no need to have such cache.
Note: we can technically use free-space-tree (space cache v2) on ZONED mode. But, since ZONED mode now always allocate extents in a block group sequentially regardless of underlying device zone type, it's no use to enable and maintain the tree.
For the same reason, NODATACOW is also disabled.
Also INODE_MAP_CACHE is also disabled to avoid preallocation in the INODE_MAP_CACHE inode.
In summary, ZONED will disable:
| Disabled features | Reason | |-------------------+-----------------------------------------------------| | RAID/Dup | Cannot handle two zone append writes to different | | | zones | |-------------------+-----------------------------------------------------| | space_cache (v1) | In-place updating | | NODATACOW | In-place updating | |-------------------+-----------------------------------------------------| | fallocate | Reserved extent will be a write hole | | INODE_MAP_CACHE | Need pre-allocation. (and will be deprecated?) | |-------------------+-----------------------------------------------------| | MIXED_BG | Allocated metadata region will be write holes for | | | data writes |
--- fs/btrfs/super.c | 12 ++++++++++-- fs/btrfs/zoned.c | 18 ++++++++++++++++++ fs/btrfs/zoned.h | 5 +++++ 3 files changed, 33 insertions(+), 2 deletions(-)
fs/btrfs/super.c +10 -2
@@ -525,8 +525,14 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options, cache_gen =btrfs_super_cache_generation (info->super_copy);if (btrfs_fs_compat_ro (info,FREE_SPACE_TREE ))btrfs_set_opt (info->mount_opt,FREE_SPACE_TREE ); -else if (cache_gen) -btrfs_set_opt (info->mount_opt,SPACE_CACHE ); +else if (cache_gen) { +if (btrfs_fs_incompat (info,ZONED )) { +btrfs_info (info, +"clearring existing space cache in ZONED mode" ); +btrfs_set_super_cache_generation (info->super_copy,0 ); + }else +btrfs_set_opt (info->mount_opt,SPACE_CACHE ); + }/* * Even the options are empty, we still need to do extra check
@@ -985,6 +991,8 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options, ret = -EINVAL ; } +if (!ret) + ret =btrfs_check_mountopts_zoned (info);if (!ret &&btrfs_test_opt (info,SPACE_CACHE ))btrfs_info (info,"disk space caching is enabled" );if (!ret &&btrfs_test_opt (info,FREE_SPACE_TREE ))
fs/btrfs/zoned.c +18 -0
@@ -268,3 +268,21 @@ int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info) out:return ret; } + +int btrfs_check_mountopts_zoned (struct btrfs_fs_info *info) +{ +if (!btrfs_fs_incompat (info,ZONED )) +return 0 ; + +/* +* SPACE CACHE writing is not CoWed. Disable that to avoid write +* errors in sequential zones. +*/ +if (btrfs_test_opt (info,SPACE_CACHE )) { +btrfs_err (info, +"space cache v1 not supportted in ZONED mode" ); +return -EOPNOTSUPP ; + } + +return 0 ; +}
fs/btrfs/zoned.h +5 -0
@@ -30,6 +30,7 @@ int btrfs_get_dev_zone(struct btrfs_device *device, u64 pos,int btrfs_get_dev_zone_info (struct btrfs_device *device);void btrfs_destroy_dev_zone_info (struct btrfs_device *device);int btrfs_check_zoned_mode (struct btrfs_fs_info *fs_info); +int btrfs_check_mountopts_zoned (struct btrfs_fs_info *info);#else /* CONFIG_BLK_DEV_ZONED */ static inline int btrfs_get_dev_zone (struct btrfs_device *device,u64 pos,struct blk_zone *zone)
@@ -49,6 +50,10 @@ static inline int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info)btrfs_err (fs_info,"Zoned block devices support is not enabled" ); return -EOPNOTSUPP; } +static inline int btrfs_check_mountopts_zoned (struct btrfs_fs_info *info) +{ +return 0 ; +}#endif static inline bool btrfs_dev_is_sequential (struct btrfs_device *device,u64 pos)
Signature · 1 line
2.27.0
PATCH v8 7/41 btrfs: disallow NODATACOW in ZONED mode
In reply to Naohiro AotaNODATACOW implies overwriting the file data on a device, which is impossible in sequential required zones. Disable NODATACOW globally with mount option and per-file NODATACOW attribute by masking FS_NOCOW_FL.
--- fs/btrfs/ioctl.c | 3 +++ fs/btrfs/zoned.c | 6 ++++++ 2 files changed, 9 insertions(+)
fs/btrfs/ioctl.c +3 -0
@@ -91,6 +91,9 @@ struct btrfs_ioctl_send_args_32 {static unsigned int btrfs_mask_fsflags_for_type (struct inode *inode,unsigned int flags) { +if (btrfs_fs_incompat (btrfs_sb (inode->i_sb),ZONED )) + flags &= ~FS_NOCOW_FL ; +if (S_ISDIR (inode->i_mode))return flags;else if (S_ISREG (inode->i_mode))
fs/btrfs/zoned.c +6 -0
@@ -284,5 +284,11 @@ int btrfs_check_mountopts_zoned(struct btrfs_fs_info *info)return -EOPNOTSUPP ; } +if (btrfs_test_opt (info,NODATACOW )) { +btrfs_err (info, +"cannot enable nodatacow with ZONED mode" ); +return -EOPNOTSUPP ; + } +return 0 ; }
Signature · 1 line
2.27.0
Re: [PATCH v8 07/41] btrfs: disallow NODATACOW in ZONED mode
Quoted 17 lines · Naohiro Aota
NODATACOW implies overwriting the file data on a device, which is impossible in sequential required zones. Disable NODATACOW globally with mount option and per-file NODATACOW attribute by masking
FS_NOCOW_FL.Reviewed-by Johannes Thumshirn <[email protected]>Reviewed-by Josef Bacik <[email protected]>Signed-off-by Naohiro Aota <[email protected]>--- fs/btrfs/ioctl.c | 3 +++ fs/btrfs/zoned.c | 6 ++++++ 2 files changed, 9 insertions(+)fs/btrfs/ioctl.c +0
-0
fs/btrfs/ioctl.c struct btrfs_ioctl_send_args_32 { · line 96
Quoted 6 lines
fs/btrfs/ioctl.c +3
-0@@ -91,6 +91,9 @@ struct btrfs_ioctl_send_args_32 {static unsigned int btrfs_mask_fsflags_for_type (struct inode *inode,unsigned int flags) { +if (btrfs_fs_incompat (btrfs_sb (inode->i_sb),ZONED )) + flags &= ~FS_NOCOW_FL ; +
This can't be inside the function, the 'type' here is for inode that does not know anything about zoned mode. The right place is after check_fsflags in btrfs_ioctl_setflags in a helper like:
ret = check_fsflags_compatible(fs_info, flags)); if (ret) goto out_unlock;
and check_fsflags_compatible checks for zoned mode and NOCOW and returns -EPERM, not silently unmasking it.
Quoted 3 lines
fs/btrfs/ioctl.c +0
-0if (S_ISDIR (inode->i_mode))return flags;else if (S_ISREG (inode->i_mode))
Re: [PATCH v8 07/41] btrfs: disallow NODATACOW in ZONED mode
Quoted 10 lines · David Sterba
This can't be inside the function, the 'type' here is for inode that does not know anything about zoned mode. The right place is after
check_fsflagsinbtrfs_ioctl_setflagsin a helper like:ret = check_fsflags_compatible(fs_info, flags)); if (ret) goto out_unlock;and
check_fsflags_compatiblechecks for zoned mode and NOCOW and returns-EPERM, not silently unmasking it.
And done as well.
PATCH v8 8/41 btrfs: disable fallocate in ZONED mode
In reply to Naohiro Aotafallocate() is implemented by reserving actual extent instead of reservations. This can result in exposing the sequential write constraint of host-managed zoned block devices to the application, which would break the POSIX semantic for the fallocated file. To avoid this, report fallocate() as not supported when in ZONED mode for now.
In the future, we may be able to implement "in-memory" fallocate() in ZONED mode by utilizing space_info->bytes_may_use or so.
--- fs/btrfs/file.c | 4 ++++ 1 file changed, 4 insertions(+)
fs/btrfs/file.c +4 -0
@@ -3341,6 +3341,10 @@ static long btrfs_fallocate(struct file *file, int mode, alloc_end =round_up (offset + len, blocksize); cur_offset = alloc_start; +/* Do not allow fallocate in ZONED mode */ +if (btrfs_fs_incompat (btrfs_sb (inode->i_sb),ZONED )) +return -EOPNOTSUPP ; +/* Make sure we aren't being give some crap mode */ if (mode & ~(FALLOC_FL_KEEP_SIZE |FALLOC_FL_PUNCH_HOLE |FALLOC_FL_ZERO_RANGE ))
Signature · 1 line
2.27.0
PATCH v8 9/41 btrfs: disallow mixed-bg in ZONED mode
In reply to Naohiro AotaPlacing both data and metadata in a block group is impossible in ZONED mode. For data, we can allocate a space for it and write it immediately after the allocation. For metadata, however, we cannot do so, because the logical addresses are recorded in other metadata buffers to build up the trees. As a result, a data buffer can be placed after a metadata buffer, which is not written yet. Writing out the data buffer will break the sequential write rule.
This commit check and disallow MIXED_BG with ZONED mode.
--- fs/btrfs/zoned.c | 7 +++++++ 1 file changed, 7 insertions(+)
fs/btrfs/zoned.c +7 -0
@@ -260,6 +260,13 @@ int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info) goto out; } +if (btrfs_fs_incompat (fs_info,MIXED_GROUPS )) { +btrfs_err (fs_info, +"ZONED mode is not allowed for mixed block groups" ); + ret = -EINVAL ; + goto out; + } + fs_info->zone_size = zone_size; fs_info->max_zone_append_size = max_zone_append_size;
Signature · 1 line
2.27.0
PATCH v8 10/41 btrfs: disallow inode_cache in ZONED mode
In reply to Naohiro Aotainode_cache use pre-allocation to write its cache data. However, pre-allocation is completely disabled in ZONED mode.
We can technically enable inode_cache in the same way as relocation. However, inode_cache is rarely used and the man page discourage using it. So, let's just disable it for now.
--- fs/btrfs/zoned.c | 6 ++++++ 1 file changed, 6 insertions(+)
fs/btrfs/zoned.c +6 -0
@@ -297,5 +297,11 @@ int btrfs_check_mountopts_zoned(struct btrfs_fs_info *info)return -EOPNOTSUPP ; } +if (btrfs_test_pending (info,SET_INODE_MAP_CACHE )) { +btrfs_err (info, +"cannot enable inode map caching with ZONED mode" ); +return -EOPNOTSUPP ; + } +return 0 ; }
Signature · 1 line
2.27.0
Re: [PATCH v8 10/41] btrfs: disallow inode_cache in ZONED mode
Quoted 6 lines · Naohiro Aota
inode_cacheuse pre-allocation to write its cache data. However, pre-allocation is completely disabled in ZONED mode.We can technically enable
inode_cachein the same way as relocation. However,inode_cacheis rarely used and the man page discourage using it. So, let's just disable it for now.
Don't worry about the inode_cache mount option, it's been deprecated as of commit b547a88ea5776a8092f7 and will be removed in 5.11.
Re: [PATCH v8 10/41] btrfs: disallow inode_cache in ZONED mode
Quoted 10 lines · David Sterba
Quoted 6 lines · Naohiro Aota
inode_cacheuse pre-allocation to write its cache data. However, pre-allocation is completely disabled in ZONED mode.We can technically enable
inode_cachein the same way as relocation. However,inode_cacheis rarely used and the man page discourage using it. So, let's just disable it for now.Don't worry about the
inode_cachemount option, it's been deprecated as of commitb547a88ea5776a8092f7and will be removed in 5.11.
Thanks. I'll drop this one in the next version.
PATCH v8 11/41 btrfs: implement log-structured superblock for ZONED mode
In reply to Naohiro AotaSuperblock (and its copies) is the only data structure in btrfs which has a fixed location on a device. Since we cannot overwrite in a sequential write required zone, we cannot place superblock in the zone. One easy solution is limiting superblock and copies to be placed only in conventional zones. However, this method has two downsides: one is reduced number of superblock copies. The location of the second copy of superblock is 256GB, which is in a sequential write required zone on typical devices in the market today. So, the number of superblock and copies is limited to be two. Second downside is that we cannot support devices which have no conventional zones at all.
To solve these two problems, we employ superblock log writing. It uses two zones as a circular buffer to write updated superblocks. Once the first zone is filled up, start writing into the second buffer. Then, when the both zones are filled up and before start writing to the first zone again, it reset the first zone.
We can determine the position of the latest superblock by reading write pointer information from a device. One corner case is when the both zones are full. For this situation, we read out the last superblock of each zone, and compare them to determine which zone is older.
The following zones are reserved as the circular buffer on ZONED btrfs.
- The primary superblock: zones 0 and 1
- The first copy: zones 16 and 17
- The second copy: zones 1024 or zone at 256GB which is minimum, and next to it
If these reserved zones are conventional, superblock is written fixed at the start of the zone without logging.
--- fs/btrfs/block-group.c | 9 ++ fs/btrfs/disk-io.c | 41 +++++- fs/btrfs/scrub.c | 3 + fs/btrfs/volumes.c | 21 ++- fs/btrfs/zoned.c | 304 +++++++++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 40 ++++++ 6 files changed, 406 insertions(+), 12 deletions(-)
fs/btrfs/block-group.c +9 -0
@@ -1723,6 +1723,7 @@ int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,static int exclude_super_stripes (struct btrfs_block_group *cache) {struct btrfs_fs_info *fs_info = cache->fs_info; +bool zoned =btrfs_fs_incompat (fs_info,ZONED );u64 bytenr;u64 *logical;int stripe_len;
@@ -1744,6 +1745,14 @@ static int exclude_super_stripes(struct btrfs_block_group *cache)if (ret)return ret; +/* shouldn't have super stripes in sequential zones */ +if (zoned && nr) { +btrfs_err (fs_info, +"Zoned btrfs's block group %llu should not have super blocks" , + cache->start); +return -EUCLEAN ; + } +while (nr--) {u64 len =min_t (u64, stripe_len, cache->start + cache->length - logical[nr]);
fs/btrfs/disk-io.c +34 -7
89 lines not on this page · raw message
fs/btrfs/scrub.c +3 -0
@@ -20,6 +20,7 @@#include "rcu-string.h" #include "raid56.h" #include "block-group.h" +#include "zoned.h" /* * This is only the first step towards a full-features scrub. It reads all
@@ -3704,6 +3705,8 @@ static noinline_for_stack int scrub_supers(struct scrub_ctx *sctx,if (bytenr +BTRFS_SUPER_INFO_SIZE > scrub_dev->commit_total_bytes)break ; +if (!btrfs_check_super_location (scrub_dev, bytenr)) +continue ; ret = scrub_pages(sctx, bytenr, BTRFS_SUPER_INFO_SIZE, bytenr, scrub_dev, BTRFS_EXTENT_FLAG_SUPER, gen, i,
fs/btrfs/volumes.c +16 -5
@@ -1281,7 +1281,8 @@ void btrfs_release_disk_super(struct btrfs_super_block *super) }static struct btrfs_super_block *btrfs_read_disk_super (struct block_device *bdev, -u64 bytenr) +u64 bytenr, +u64 bytenr_orig) {struct btrfs_super_block *disk_super;struct page *page;
@@ -1312,7 +1313,7 @@ static struct btrfs_super_block *btrfs_read_disk_super(struct block_device *bdev/* align our pointer to the offset of the super block */ disk_super = p +offset_in_page (bytenr); -if (btrfs_super_bytenr (disk_super) != bytenr || +if (btrfs_super_bytenr (disk_super) != bytenr_orig ||btrfs_super_magic (disk_super) !=BTRFS_MAGIC ) {btrfs_release_disk_super (p);return ERR_PTR (-EINVAL );
@@ -1347,7 +1348,8 @@ struct btrfs_device *btrfs_scan_one_device(const char *path, fmode_t flags,bool new_device_added = false;struct btrfs_device *device =NULL ;struct block_device *bdev; -u64 bytenr; +u64 bytenr, bytenr_orig; +int ret;lockdep_assert_held (&uuid_mutex);
@@ -1357,14 +1359,18 @@ struct btrfs_device *btrfs_scan_one_device(const char *path, fmode_t flags,* So, we need to add a special mount option to scan for * later supers, using BTRFS_SUPER_MIRROR_MAX instead */ - bytenr =btrfs_sb_offset (0 ); flags |=FMODE_EXCL ; bdev =blkdev_get_by_path (path, flags, holder);if (IS_ERR (bdev))return ERR_CAST (bdev); - disk_super =btrfs_read_disk_super (bdev, bytenr); + bytenr_orig =btrfs_sb_offset (0 ); + ret =btrfs_sb_log_location_bdev (bdev,0 ,READ , &bytenr); +if (ret) +return ERR_PTR (ret); + + disk_super =btrfs_read_disk_super (bdev, bytenr, bytenr_orig);if (IS_ERR (disk_super)) { device =ERR_CAST (disk_super); goto error_bdev_put;
@@ -2028,6 +2034,11 @@ void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info,if (IS_ERR (disk_super))continue ; +if (bdev_is_zoned (bdev)) { +btrfs_reset_sb_log_zones (bdev, copy_num); +continue ; + } +memset (&disk_super->magic,0 ,sizeof (disk_super->magic)); page =virt_to_page (disk_super);
fs/btrfs/zoned.c +304 -0
319 lines not on this page · raw message
fs/btrfs/zoned.h +40 -0
@@ -10,6 +10,8 @@#define BTRFS_ZONED_H #include <linux/blkdev.h> +#include "volumes.h" +#include "disk-io.h" struct btrfs_zoned_device_info {/*
@@ -22,6 +24,7 @@ struct btrfs_zoned_device_info {u32 nr_zones;unsigned long *seq_zones;unsigned long *empty_zones; +struct blk_zone sb_zones[2 *BTRFS_SUPER_MIRROR_MAX ]; };#ifdef CONFIG_BLK_DEV_ZONED
@@ -31,6 +34,12 @@ int btrfs_get_dev_zone_info(struct btrfs_device *device);void btrfs_destroy_dev_zone_info (struct btrfs_device *device);int btrfs_check_zoned_mode (struct btrfs_fs_info *fs_info);int btrfs_check_mountopts_zoned (struct btrfs_fs_info *info); +int btrfs_sb_log_location_bdev (struct block_device *bdev,int mirror,int rw, +u64 *bytenr_ret); +int btrfs_sb_log_location (struct btrfs_device *device,int mirror,int rw, +u64 *bytenr_ret); +void btrfs_advance_sb_log (struct btrfs_device *device,int mirror); +int btrfs_reset_sb_log_zones (struct block_device *bdev,int mirror);#else /* CONFIG_BLK_DEV_ZONED */ static inline int btrfs_get_dev_zone (struct btrfs_device *device,u64 pos,struct blk_zone *zone)
@@ -54,6 +63,26 @@ static inline int btrfs_check_mountopts_zoned(struct btrfs_fs_info *info) {return 0 ; } +static inline int btrfs_sb_log_location_bdev (struct block_device *bdev, +int mirror,int rw, +u64 *bytenr_ret) +{ + *bytenr_ret =btrfs_sb_offset (mirror); +return 0 ; +} +static inline int btrfs_sb_log_location (struct btrfs_device *device,int mirror, +int rw,u64 *bytenr_ret) +{ + *bytenr_ret =btrfs_sb_offset (mirror); +return 0 ; +} +static inline void btrfs_advance_sb_log (struct btrfs_device *device, +int mirror) { } +static inline int btrfs_reset_sb_log_zones (struct block_device *bdev, +int mirror) +{ +return 0 ; +}#endif static inline bool btrfs_dev_is_sequential (struct btrfs_device *device,u64 pos)
@@ -121,4 +150,15 @@ static inline bool btrfs_check_device_zone_type(struct btrfs_fs_info *fs_info, return bdev_zoned_model(bdev) != BLK_ZONED_HM; } +static inline bool btrfs_check_super_location (struct btrfs_device *device, +u64 pos) +{ +/* +* On a non-zoned device, any address is OK. On a zoned device, +* non-SEQUENTIAL WRITE REQUIRED zones are capable. +*/ +return device->zone_info ==NULL || + !btrfs_dev_is_sequential (device, pos); +} +#endif
Signature · 1 line
2.27.0
PATCH v8 12/41 btrfs: implement zoned chunk allocator
In reply to Naohiro AotaThis commit implements zoned chunk/dev_extent allocator. The zoned allocator align the device extents to zone boundaries so that a zone reset affects only the device extent and does not change the state of blocks in the neighbor device extents.
Also, it checks that a region allocation is not over any locations of super block zones, and ensures the region is empty.
--- fs/btrfs/volumes.c | 133 +++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/volumes.h | 1 + fs/btrfs/zoned.c | 126 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 30 ++++++++++ 4 files changed, 290 insertions(+)
fs/btrfs/volumes.c +133 -0
@@ -1415,6 +1415,14 @@ static bool contains_pending_extent(struct btrfs_device *device, u64 *start,return false; } +static inline u64 dev_extent_search_start_zoned (struct btrfs_device *device, +u64 start) +{ + start =max_t (u64, start, +max_t (u64, device->zone_info->zone_size,SZ_1M )); +return btrfs_zone_align (device, start); +} +static u64 dev_extent_search_start (struct btrfs_device *device,u64 start) {switch (device->fs_devices->chunk_alloc_policy) {
@@ -1425,11 +1433,57 @@ static u64 dev_extent_search_start(struct btrfs_device *device, u64 start)* make sure to start at an offset of at least 1MB. */ return max_t (u64, start,SZ_1M ); +case BTRFS_CHUNK_ALLOC_ZONED : +return dev_extent_search_start_zoned (device, start);default :BUG (); } } +static bool dev_extent_hole_check_zoned (struct btrfs_device *device, +u64 *hole_start,u64 *hole_size, +u64 num_bytes) +{ +u64 zone_size = device->zone_info->zone_size; +u64 pos; +int ret; +int changed =0 ; + +ASSERT (IS_ALIGNED (*hole_start, zone_size)); + +while (*hole_size >0 ) { + pos =btrfs_find_allocatable_zones (device, *hole_start, + *hole_start + *hole_size, + num_bytes); +if (pos != *hole_start) { + *hole_size = *hole_start + *hole_size - pos; + *hole_start = pos; + changed =1 ; +if (*hole_size < num_bytes) +break ; + } + + ret =btrfs_ensure_empty_zones (device, pos, num_bytes); + +/* range is ensured to be empty */ +if (!ret) +return changed; + +/* given hole range was invalid (outside of device) */ +if (ret == -ERANGE ) { + *hole_start += *hole_size; + *hole_size =0 ; +return 1 ; + } + + *hole_start += zone_size; + *hole_size -= zone_size; + changed =1 ; + } + +return changed; +} +/** * dev_extent_hole_check - check if specified hole is suitable for allocation * @device: the device which we have the hole
@@ -1462,6 +1516,10 @@ static bool dev_extent_hole_check(struct btrfs_device *device, u64 *hole_start,case BTRFS_CHUNK_ALLOC_REGULAR :/* No extra check */ break ; +case BTRFS_CHUNK_ALLOC_ZONED : + changed |=dev_extent_hole_check_zoned (device, hole_start, + hole_size, num_bytes); +break ;default :BUG (); }
@@ -1516,6 +1574,9 @@ static int find_free_dev_extent_start(struct btrfs_device *device, search_start =dev_extent_search_start (device, search_start); +WARN_ON (device->zone_info && + !IS_ALIGNED (num_bytes, device->zone_info->zone_size)); + path =btrfs_alloc_path ();if (!path)return -ENOMEM ;
@@ -4906,6 +4967,39 @@ static void init_alloc_chunk_ctl_policy_regular( ctl->dev_extent_min =BTRFS_STRIPE_LEN * ctl->dev_stripes; } +static void +init_alloc_chunk_ctl_policy_zoned (struct btrfs_fs_devices *fs_devices, +struct alloc_chunk_ctl *ctl) +{ +u64 zone_size = fs_devices->fs_info->zone_size; +u64 limit; +int min_num_stripes = ctl->devs_min * ctl->dev_stripes; +int min_data_stripes = (min_num_stripes - ctl->nparity) / ctl->ncopies; +u64 min_chunk_size = min_data_stripes * zone_size; +u64 type = ctl->type; + + ctl->max_stripe_size = zone_size; +if (type &BTRFS_BLOCK_GROUP_DATA ) { + ctl->max_chunk_size =round_down (BTRFS_MAX_DATA_CHUNK_SIZE , + zone_size); + }else if (type &BTRFS_BLOCK_GROUP_METADATA ) { + ctl->max_chunk_size = ctl->max_stripe_size; + }else if (type &BTRFS_BLOCK_GROUP_SYSTEM ) { + ctl->max_chunk_size =2 * ctl->max_stripe_size; + ctl->devs_max =min_t (int, ctl->devs_max, +BTRFS_MAX_DEVS_SYS_CHUNK ); + }else { +BUG (); + } + +/* We don't want a chunk larger than 10% of writable space */ + limit =max (round_down (div_factor (fs_devices->total_rw_bytes,1 ), + zone_size), + min_chunk_size); + ctl->max_chunk_size =min (limit, ctl->max_chunk_size); + ctl->dev_extent_min = zone_size * ctl->dev_stripes; +} +static void init_alloc_chunk_ctl (struct btrfs_fs_devices *fs_devices,struct alloc_chunk_ctl *ctl) {
@@ -4926,6 +5020,9 @@ static void init_alloc_chunk_ctl(struct btrfs_fs_devices *fs_devices,case BTRFS_CHUNK_ALLOC_REGULAR :init_alloc_chunk_ctl_policy_regular (fs_devices, ctl);break ; +case BTRFS_CHUNK_ALLOC_ZONED : +init_alloc_chunk_ctl_policy_zoned (fs_devices, ctl); +break ;default :BUG (); }
@@ -5052,6 +5149,40 @@ static int decide_stripe_size_regular(struct alloc_chunk_ctl *ctl,return 0 ; } +static int decide_stripe_size_zoned (struct alloc_chunk_ctl *ctl, +struct btrfs_device_info *devices_info) +{ +u64 zone_size = devices_info[0 ].dev->zone_info->zone_size; +int data_stripes;/* number of stripes that count for +block group size */ + +/* +* It should hold because: +* dev_extent_min == dev_extent_want == zone_size * dev_stripes +*/ +ASSERT (devices_info[ctl->ndevs -1 ].max_avail == ctl->dev_extent_min); + + ctl->stripe_size = zone_size; + ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; + data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; + +/* +* stripe_size is fixed in ZONED. Reduce ndevs instead. +*/ +if (ctl->stripe_size * data_stripes > ctl->max_chunk_size) { + ctl->ndevs =div_u64 (div_u64 (ctl->max_chunk_size * ctl->ncopies, + ctl->stripe_size) + ctl->nparity, + ctl->dev_stripes); + ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; + data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; +ASSERT (ctl->stripe_size * data_stripes <= ctl->max_chunk_size); + } + + ctl->chunk_size = ctl->stripe_size * data_stripes; + +return 0 ; +} +static int decide_stripe_size (struct btrfs_fs_devices *fs_devices,struct alloc_chunk_ctl *ctl,struct btrfs_device_info *devices_info)
@@ -5079,6 +5210,8 @@ static int decide_stripe_size(struct btrfs_fs_devices *fs_devices,switch (fs_devices->chunk_alloc_policy) {case BTRFS_CHUNK_ALLOC_REGULAR :return decide_stripe_size_regular (ctl, devices_info); +case BTRFS_CHUNK_ALLOC_ZONED : +return decide_stripe_size_zoned (ctl, devices_info);default :BUG (); }
fs/btrfs/volumes.h +1 -0
@@ -213,6 +213,7 @@ BTRFS_DEVICE_GETSET_FUNCS(bytes_used);enum btrfs_chunk_allocation_policy {BTRFS_CHUNK_ALLOC_REGULAR , +BTRFS_CHUNK_ALLOC_ZONED , };struct btrfs_fs_devices {
fs/btrfs/zoned.c +126 -0
147 lines not on this page · raw message
fs/btrfs/zoned.h +30 -0
@@ -40,6 +40,11 @@ int btrfs_sb_log_location(struct btrfs_device *device, int mirror, int rw, u64 *bytenr_ret);void btrfs_advance_sb_log (struct btrfs_device *device,int mirror);int btrfs_reset_sb_log_zones (struct block_device *bdev,int mirror); +u64 btrfs_find_allocatable_zones (struct btrfs_device *device,u64 hole_start, +u64 hole_end,u64 num_bytes); +int btrfs_reset_device_zone (struct btrfs_device *device,u64 physical, +u64 length,u64 *bytes); +int btrfs_ensure_empty_zones (struct btrfs_device *device,u64 start,u64 size);#else /* CONFIG_BLK_DEV_ZONED */ static inline int btrfs_get_dev_zone (struct btrfs_device *device,u64 pos,struct blk_zone *zone)
@@ -83,6 +88,23 @@ static inline int btrfs_reset_sb_log_zones(struct block_device *bdev, {return 0 ; } +static inline u64 btrfs_find_allocatable_zones (struct btrfs_device *device, +u64 hole_start,u64 hole_end, +u64 num_bytes) +{ +return hole_start; +} +static inline int btrfs_reset_device_zone (struct btrfs_device *device, +u64 physical,u64 length,u64 *bytes) +{ + *bytes =0 ; +return 0 ; +} +static inline int btrfs_ensure_empty_zones (struct btrfs_device *device, +u64 start,u64 size) +{ +return 0 ; +}#endif static inline bool btrfs_dev_is_sequential (struct btrfs_device *device,u64 pos)
@@ -161,4 +183,12 @@ static inline bool btrfs_check_super_location(struct btrfs_device *device, !btrfs_dev_is_sequential(device, pos); } +static inline u64 btrfs_zone_align (struct btrfs_device *device,u64 pos) +{ +if (!device->zone_info) +return pos; + +return ALIGN (pos, device->zone_info->zone_size); +} +#endif
Signature · 1 line
2.27.0
PATCH v8 13/41 btrfs: verify device extent is aligned to zone
In reply to Naohiro AotaThis patch add a verification in verify_one_dev_extent() to check if the device extent is aligned to zone boundary.
--- fs/btrfs/volumes.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
fs/btrfs/volumes.c +14 -0
@@ -7779,6 +7779,20 @@ static int verify_one_dev_extent(struct btrfs_fs_info *fs_info, ret = -EUCLEAN ; goto out; } + +if (dev->zone_info) { +u64 zone_size = dev->zone_info->zone_size; + +if (!IS_ALIGNED (physical_offset, zone_size) || + !IS_ALIGNED (physical_len, zone_size)) { +btrfs_err (fs_info, +"dev extent devid %llu physical offset %llu len %llu is not aligned to device zone" , + devid, physical_offset, physical_len); + ret = -EUCLEAN ; + goto out; + } + } + out:free_extent_map (em);return ret;
Signature · 1 line
2.27.0
PATCH v8 14/41 btrfs: load zone's alloction offset
In reply to Naohiro AotaZoned btrfs must allocate blocks at the zones' write pointer. The device's write pointer position can be mapped to a logical address within a block group. This commit adds "alloc_offset" to track the logical address.
This logical address is populated in btrfs_load_block-group_zone_info() from write pointers of corresponding zones.
For now, zoned btrfs only support the SINGLE profile. Supporting non-SINGLE profile with zone append writing is not trivial. For example, in the DUP profile, we send a zone append writing IO to two zones on a device. The device reply with written LBAs for the IOs. If the offsets of the returned addresses from the beginning of the zone are different, then it results in different logical addresses.
We need fine-grained logical to physical mapping to support such separated physical address issue. Since it should require additional metadata type, disable non-SINGLE profiles for now.
--- fs/btrfs/block-group.c | 15 ++++ fs/btrfs/block-group.h | 6 ++ fs/btrfs/zoned.c | 153 +++++++++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 6 ++ 4 files changed, 180 insertions(+)
fs/btrfs/block-group.c +15 -0
@@ -15,6 +15,7 @@#include "delalloc-space.h" #include "discard.h" #include "raid56.h" +#include "zoned.h" /* * Return target flags in extended format or 0 if restripe for this chunk_type
@@ -1935,6 +1936,13 @@ static int read_one_block_group(struct btrfs_fs_info *info, goto error; } + ret =btrfs_load_block_group_zone_info (cache); +if (ret) { +btrfs_err (info,"failed to load zone info of bg %llu" , + cache->start); + goto error; + } +/* * We need to exclude the super stripes now so that the space info has * super bytes accounted for, otherwise we'll think we have more space
@@ -2161,6 +2169,13 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, u64 bytes_used, cache->last_byte_to_unpin = (u64)-1 ; cache->cached =BTRFS_CACHE_FINISHED ; cache->needs_free_space =1 ; + + ret =btrfs_load_block_group_zone_info (cache); +if (ret) { +btrfs_put_block_group (cache); +return ret; + } + ret =exclude_super_stripes (cache);if (ret) {/* We may have excluded something, so call this just in case */
fs/btrfs/block-group.h +6 -0
@@ -183,6 +183,12 @@ struct btrfs_block_group {/* Record locked full stripes for RAID5/6 block group */ struct btrfs_full_stripe_locks_tree full_stripe_locks_root; + +/* +* Allocation offset for the block group to implement sequential +* allocation. This is used only with ZONED mode enabled. +*/ +u64 alloc_offset; };static inline u64 btrfs_block_group_end (struct btrfs_block_group *block_group)
fs/btrfs/zoned.c +153 -0
170 lines not on this page · raw message
fs/btrfs/zoned.h +6 -0
@@ -45,6 +45,7 @@ u64 btrfs_find_allocatable_zones(struct btrfs_device *device, u64 hole_start,int btrfs_reset_device_zone (struct btrfs_device *device,u64 physical,u64 length,u64 *bytes);int btrfs_ensure_empty_zones (struct btrfs_device *device,u64 start,u64 size); +int btrfs_load_block_group_zone_info (struct btrfs_block_group *cache);#else /* CONFIG_BLK_DEV_ZONED */ static inline int btrfs_get_dev_zone (struct btrfs_device *device,u64 pos,struct blk_zone *zone)
@@ -105,6 +106,11 @@ static inline int btrfs_ensure_empty_zones(struct btrfs_device *device, {return 0 ; } +static inline int btrfs_load_block_group_zone_info ( +struct btrfs_block_group *cache) +{ +return 0 ; +}#endif static inline bool btrfs_dev_is_sequential (struct btrfs_device *device,u64 pos)
Signature · 1 line
2.27.0
PATCH v8 15/41 btrfs: emulate write pointer for conventional zones
In reply to Naohiro AotaConventional zones do not have a write pointer. So, we cannot use it to determine the allocation offset if a block group contains a conventional zone. Instead, we can consider the end of the last allocated extent int the block group as an allocation offset.
--- fs/btrfs/zoned.c | 119 ++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 113 insertions(+), 6 deletions(-)
fs/btrfs/zoned.c +113 -6
@@ -742,6 +742,104 @@ int btrfs_ensure_empty_zones(struct btrfs_device *device, u64 start, u64 size)return 0 ; } +static int emulate_write_pointer (struct btrfs_block_group *cache, +u64 *offset_ret) +{ +struct btrfs_fs_info *fs_info = cache->fs_info; +struct btrfs_root *root = fs_info->extent_root; +struct btrfs_path *path; +struct extent_buffer *leaf; +struct btrfs_key search_key; +struct btrfs_key found_key; +int slot; +int ret; +u64 length; + + path =btrfs_alloc_path (); +if (!path) +return -ENOMEM ; + + search_key.objectid = cache->start + cache->length; + search_key.type =0 ; + search_key.offset =0 ; + + ret =btrfs_search_slot (NULL , root, &search_key, path,0 ,0 ); +if (ret <0 ) + goto out; +ASSERT (ret !=0 ); + slot = path->slots[0 ]; + leaf = path->nodes[0 ]; +ASSERT (slot !=0 ); + slot--; +btrfs_item_key_to_cpu (leaf, &found_key, slot); + +if (found_key.objectid < cache->start) { + *offset_ret =0 ; + }else if (found_key.type ==BTRFS_BLOCK_GROUP_ITEM_KEY ) { +struct btrfs_key extent_item_key; + +if (found_key.objectid != cache->start) { + ret = -EUCLEAN ; + goto out; + } + + length =0 ; + +/* metadata may have METADATA_ITEM_KEY */ +if (slot ==0 ) { +btrfs_set_path_blocking (path); + ret =btrfs_prev_leaf (root, path); +if (ret <0 ) + goto out; +if (ret ==0 ) { + slot =btrfs_header_nritems (leaf) -1 ; +btrfs_item_key_to_cpu (leaf, &extent_item_key, + slot); + } + }else { +btrfs_item_key_to_cpu (leaf, &extent_item_key, slot -1 ); + ret =0 ; + } + +if (ret ==0 && + extent_item_key.objectid == cache->start) { +if (extent_item_key.type ==BTRFS_METADATA_ITEM_KEY ) + length = fs_info->nodesize; +else if (extent_item_key.type ==BTRFS_EXTENT_ITEM_KEY ) + length = extent_item_key.offset; +else { + ret = -EUCLEAN ; + goto out; + } + } + + *offset_ret = length; + }else if (found_key.type ==BTRFS_EXTENT_ITEM_KEY || + found_key.type ==BTRFS_METADATA_ITEM_KEY ) { + +if (found_key.type ==BTRFS_EXTENT_ITEM_KEY ) + length = found_key.offset; +else + length = fs_info->nodesize; + +if (!(found_key.objectid >= cache->start && + found_key.objectid + length <= + cache->start + cache->length)) { + ret = -EUCLEAN ; + goto out; + } + *offset_ret = found_key.objectid + length - cache->start; + }else { + ret = -EUCLEAN ; + goto out; + } + ret =0 ; + +out: +btrfs_free_path (path); +return ret; +} +int btrfs_load_block_group_zone_info (struct btrfs_block_group *cache) {struct btrfs_fs_info *fs_info = cache->fs_info;
@@ -756,6 +854,7 @@ int btrfs_load_block_group_zone_info(struct btrfs_block_group *cache)int i;unsigned int nofs_flag;u64 *alloc_offsets =NULL ; +u64 emulated_offset =0 ;u32 num_sequential =0 , num_conventional =0 ;if (!btrfs_fs_incompat (fs_info,ZONED ))
@@ -856,12 +955,12 @@ int btrfs_load_block_group_zone_info(struct btrfs_block_group *cache) }if (num_conventional >0 ) { -/* -* Since conventional zones does not have write pointer, we -* cannot determine alloc_offset from the pointer -*/ - ret = -EINVAL ; - goto out; + ret =emulate_write_pointer (cache, &emulated_offset); +if (ret || map->num_stripes == num_conventional) { +if (!ret) + cache->alloc_offset = emulated_offset; + goto out; + } }switch (map->type &BTRFS_BLOCK_GROUP_PROFILE_MASK ) {
@@ -883,6 +982,14 @@ int btrfs_load_block_group_zone_info(struct btrfs_block_group *cache) } out: +/* an extent is allocated after the write pointer */ +if (num_conventional && emulated_offset > cache->alloc_offset) { +btrfs_err (fs_info, +"got wrong write pointer in BG %llu: %llu > %llu" , + logical, emulated_offset, cache->alloc_offset); + ret = -EIO ; + } +kfree (alloc_offsets);free_extent_map (em);
Signature · 1 line
2.27.0
PATCH v8 16/41 btrfs: track unusable bytes for zones
In reply to Naohiro AotaIn zoned btrfs, once written, then freed region is never usable until resetting underlying zones. We need to distinguish such unusable space from usable free space. So, this commit introduces "zone_unusable" to block group, and "bytes_zone_unusable" to space_info to track the unusable space.
Pinned bytes are always reclaimed to the unsable space. But, when an allocated region is returned before using e.g., the block group becomes read-only between allocation time and reservation time, we can safely return the region to the block group. For the situation, this commit introduces "btrfs_add_free_space_unused". This behave as the same as btrfs_add_free_space() on regular btrfs. On zoned btrfs, it rewinds the allocation offset.
--- fs/btrfs/block-group.c | 19 +++++++++----- fs/btrfs/block-group.h | 1 + fs/btrfs/extent-tree.c | 15 ++++++++--- fs/btrfs/free-space-cache.c | 52 +++++++++++++++++++++++++++++++++++++ fs/btrfs/free-space-cache.h | 4 +++ fs/btrfs/space-info.c | 13 ++++++---- fs/btrfs/space-info.h | 4 ++- fs/btrfs/sysfs.c | 2 ++ fs/btrfs/zoned.c | 22 ++++++++++++++++ fs/btrfs/zoned.h | 2 ++ 10 files changed, 118 insertions(+), 16 deletions(-)
fs/btrfs/block-group.c +13 -6
@@ -1080,12 +1080,15 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,WARN_ON (block_group->space_info->total_bytes < block_group->length);WARN_ON (block_group->space_info->bytes_readonly - < block_group->length); + < block_group->length - block_group->zone_unusable); +WARN_ON (block_group->space_info->bytes_zone_unusable + < block_group->zone_unusable);WARN_ON (block_group->space_info->disk_total < block_group->length * factor); } block_group->space_info->total_bytes -= block_group->length; - block_group->space_info->bytes_readonly -= block_group->length; + block_group->space_info->bytes_readonly -= + (block_group->length - block_group->zone_unusable); block_group->space_info->disk_total -= block_group->length * factor;spin_unlock (&block_group->space_info->lock);
@@ -1229,7 +1232,7 @@ static int inc_block_group_ro(struct btrfs_block_group *cache, int force) } num_bytes = cache->length - cache->reserved - cache->pinned - - cache->bytes_super - cache->used; + cache->bytes_super - cache->zone_unusable - cache->used;/* * Data never overcommits, even in mixed mode, so do just the straight
@@ -1973,6 +1976,8 @@ static int read_one_block_group(struct btrfs_fs_info *info,btrfs_free_excluded_extents (cache); } +btrfs_calc_zone_unusable (cache); + ret =btrfs_add_block_group_cache (info, cache);if (ret) {btrfs_remove_free_space_cache (cache);
@@ -1980,7 +1985,8 @@ static int read_one_block_group(struct btrfs_fs_info *info, }trace_btrfs_add_block_group (info, cache,0 );btrfs_update_space_info (info, cache->flags, cache->length, - cache->used, cache->bytes_super, &space_info); + cache->used, cache->bytes_super, + cache->zone_unusable, &space_info); cache->space_info = space_info;
@@ -2217,7 +2223,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, u64 bytes_used,*/ trace_btrfs_add_block_group (fs_info, cache,1 );btrfs_update_space_info (fs_info, cache->flags, size, bytes_used, - cache->bytes_super, &cache->space_info); + cache->bytes_super,0 , &cache->space_info);btrfs_update_global_block_rsv (fs_info);link_block_group (cache);
@@ -2325,7 +2331,8 @@ void btrfs_dec_block_group_ro(struct btrfs_block_group *cache)spin_lock (&cache->lock);if (!--cache->ro) { num_bytes = cache->length - cache->reserved - - cache->pinned - cache->bytes_super - cache->used; + cache->pinned - cache->bytes_super - + cache->zone_unusable - cache->used; sinfo->bytes_readonly -= num_bytes;list_del_init (&cache->ro_list); }
fs/btrfs/block-group.h +1 -0
@@ -189,6 +189,7 @@ struct btrfs_block_group {* allocation. This is used only with ZONED mode enabled. */ u64 alloc_offset; +u64 zone_unusable; };static inline u64 btrfs_block_group_end (struct btrfs_block_group *block_group)
fs/btrfs/extent-tree.c +11 -4
@@ -34,6 +34,7 @@#include "block-group.h" #include "discard.h" #include "rcu-string.h" +#include "zoned.h" #undef SCRAMBLE_DELAYED_REFS
@@ -2807,9 +2808,11 @@ static int unpin_extent_range(struct btrfs_fs_info *fs_info, cache =btrfs_lookup_block_group (fs_info, start);BUG_ON (!cache);/* Logic error */ - cluster =fetch_cluster_info (fs_info, - cache->space_info, - &empty_cluster); +if (!btrfs_fs_incompat (fs_info,ZONED )) + cluster =fetch_cluster_info (fs_info, + cache->space_info, + &empty_cluster); + empty_cluster <<=1 ; }
@@ -2846,7 +2849,11 @@ static int unpin_extent_range(struct btrfs_fs_info *fs_info, space_info->max_extent_size =0 ;percpu_counter_add_batch (&space_info->total_bytes_pinned, -len,BTRFS_TOTAL_BYTES_PINNED_BATCH ); -if (cache->ro) { +if (btrfs_fs_incompat (fs_info,ZONED )) { +/* need reset before reusing in zoned Block Group */ + space_info->bytes_zone_unusable += len; + readonly = true; + }else if (cache->ro) { space_info->bytes_readonly += len; readonly = true; }
fs/btrfs/free-space-cache.c +52 -0
87 lines not on this page · raw message
fs/btrfs/free-space-cache.h +4 -0
@@ -114,8 +114,12 @@ int __btrfs_add_free_space(struct btrfs_fs_info *fs_info,struct btrfs_free_space_ctl *ctl, u64 bytenr, u64 size, enum btrfs_trim_state trim_state); +int __btrfs_add_free_space_zoned (struct btrfs_block_group *block_group, +u64 bytenr,u64 size,bool used);int btrfs_add_free_space (struct btrfs_block_group *block_group,u64 bytenr,u64 size); +int btrfs_add_free_space_unused (struct btrfs_block_group *block_group, +u64 bytenr,u64 size);int btrfs_add_free_space_async_trimmed (struct btrfs_block_group *block_group,u64 bytenr,u64 size); int btrfs_remove_free_space(struct btrfs_block_group *block_group,
fs/btrfs/space-info.c +8 -5
@@ -163,6 +163,7 @@ u64 __pure btrfs_space_info_used(struct btrfs_space_info *s_info,ASSERT (s_info);return s_info->bytes_used + s_info->bytes_reserved + s_info->bytes_pinned + s_info->bytes_readonly + + s_info->bytes_zone_unusable + (may_use_included ? s_info->bytes_may_use :0 ); }
@@ -257,7 +258,7 @@ int btrfs_init_space_info(struct btrfs_fs_info *fs_info)void btrfs_update_space_info (struct btrfs_fs_info *info,u64 flags,u64 total_bytes,u64 bytes_used, -u64 bytes_readonly, +u64 bytes_readonly,u64 bytes_zone_unusable,struct btrfs_space_info **space_info) {struct btrfs_space_info *found;
@@ -273,6 +274,7 @@ void btrfs_update_space_info(struct btrfs_fs_info *info, u64 flags, found->bytes_used += bytes_used; found->disk_used += bytes_used * factor; found->bytes_readonly += bytes_readonly; + found->bytes_zone_unusable += bytes_zone_unusable;if (total_bytes >0 ) found->full =0 ;btrfs_try_granting_tickets (info, found);
@@ -422,10 +424,10 @@ static void __btrfs_dump_space_info(struct btrfs_fs_info *fs_info, info->total_bytes -btrfs_space_info_used (info, true), info->full ? "" : "not ");btrfs_info (fs_info, -"space_info total=%llu, used=%llu, pinned=%llu, reserved=%llu, may_use=%llu, readonly=%llu" , +"space_info total=%llu, used=%llu, pinned=%llu, reserved=%llu, may_use=%llu, readonly=%llu zone_unusable=%llu" , info->total_bytes, info->bytes_used, info->bytes_pinned, info->bytes_reserved, info->bytes_may_use, - info->bytes_readonly); + info->bytes_readonly, info->bytes_zone_unusable);DUMP_BLOCK_RSV (fs_info, global_block_rsv);DUMP_BLOCK_RSV (fs_info, trans_block_rsv);
@@ -454,9 +456,10 @@ void btrfs_dump_space_info(struct btrfs_fs_info *fs_info,list_for_each_entry (cache, &info->block_groups[index], list) {spin_lock (&cache->lock);btrfs_info (fs_info, -"block group %llu has %llu bytes, %llu used %llu pinned %llu reserved %s" , +"block group %llu has %llu bytes, %llu used %llu pinned %llu reserved %llu zone_unusable %s" , cache->start, cache->length, cache->used, cache->pinned, - cache->reserved, cache->ro ?"[readonly]" :"" ); + cache->reserved, cache->zone_unusable, + cache->ro ?"[readonly]" :"" );spin_unlock (&cache->lock);btrfs_dump_free_space (cache, bytes); }
fs/btrfs/space-info.h +3 -1
@@ -17,6 +17,8 @@ struct btrfs_space_info {u64 bytes_may_use;/* number of bytes that may be used for delalloc/allocations */ u64 bytes_readonly;/* total bytes that are read only */ +u64 bytes_zone_unusable;/* total bytes that are unusable until +resetting the device zone */ u64 max_extent_size;/* This will hold the maximum extent size of the space info if we had an ENOSPC in the
@@ -119,7 +121,7 @@ DECLARE_SPACE_INFO_UPDATE(bytes_pinned, "pinned");int btrfs_init_space_info (struct btrfs_fs_info *fs_info);void btrfs_update_space_info (struct btrfs_fs_info *info,u64 flags,u64 total_bytes,u64 bytes_used, -u64 bytes_readonly, +u64 bytes_readonly,u64 bytes_zone_unusable,struct btrfs_space_info **space_info);struct btrfs_space_info *btrfs_find_space_info (struct btrfs_fs_info *info,u64 flags);
fs/btrfs/sysfs.c +2 -0
@@ -635,6 +635,7 @@ SPACE_INFO_ATTR(bytes_pinned);SPACE_INFO_ATTR (bytes_reserved);SPACE_INFO_ATTR (bytes_may_use);SPACE_INFO_ATTR (bytes_readonly); +SPACE_INFO_ATTR (bytes_zone_unusable);SPACE_INFO_ATTR (disk_used);SPACE_INFO_ATTR (disk_total); BTRFS_ATTR(space_info, total_bytes_pinned,
@@ -648,6 +649,7 @@ static struct attribute *space_info_attrs[] = {BTRFS_ATTR_PTR (space_info, bytes_reserved),BTRFS_ATTR_PTR (space_info, bytes_may_use),BTRFS_ATTR_PTR (space_info, bytes_readonly), +BTRFS_ATTR_PTR (space_info, bytes_zone_unusable),BTRFS_ATTR_PTR (space_info, disk_used),BTRFS_ATTR_PTR (space_info, disk_total), BTRFS_ATTR_PTR(space_info, total_bytes_pinned),
fs/btrfs/zoned.c +22 -0
@@ -995,3 +995,25 @@ int btrfs_load_block_group_zone_info(struct btrfs_block_group *cache)return ret; } + +void btrfs_calc_zone_unusable (struct btrfs_block_group *cache) +{ +u64 unusable, free; + +if (!btrfs_fs_incompat (cache->fs_info,ZONED )) +return ; + +WARN_ON (cache->bytes_super !=0 ); + unusable = cache->alloc_offset - cache->used; + free = cache->length - cache->alloc_offset; +/* we only need ->free_space in ALLOC_SEQ BGs */ + cache->last_byte_to_unpin = (u64)-1 ; + cache->cached =BTRFS_CACHE_FINISHED ; + cache->free_space_ctl->free_space = free; + cache->zone_unusable = unusable; +/* +* Should not have any excluded extents. Just +* in case, though. +*/ +btrfs_free_excluded_extents (cache); +}
fs/btrfs/zoned.h +2 -0
@@ -46,6 +46,7 @@ int btrfs_reset_device_zone(struct btrfs_device *device, u64 physical, u64 length, u64 *bytes);int btrfs_ensure_empty_zones (struct btrfs_device *device,u64 start,u64 size);int btrfs_load_block_group_zone_info (struct btrfs_block_group *cache); +void btrfs_calc_zone_unusable (struct btrfs_block_group *cache);#else /* CONFIG_BLK_DEV_ZONED */ static inline int btrfs_get_dev_zone (struct btrfs_device *device,u64 pos,struct blk_zone *zone)
@@ -111,6 +112,7 @@ static inline int btrfs_load_block_group_zone_info( {return 0 ; } +static inline void btrfs_calc_zone_unusable (struct btrfs_block_group *cache) { }#endif static inline bool btrfs_dev_is_sequential (struct btrfs_device *device,u64 pos)
Signature · 1 line
2.27.0
PATCH v8 17/41 btrfs: do sequential extent allocation in ZONED mode
In reply to Naohiro AotaThis 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.
--- 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(-)
fs/btrfs/block-group.c +4 -0
@@ -683,6 +683,10 @@ int btrfs_cache_block_group(struct btrfs_block_group *cache, int load_cache_onlystruct 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 ;
fs/btrfs/extent-tree.c +76 -6
144 lines not on this page · raw message
fs/btrfs/free-space-cache.c +6 -0
@@ -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);
Signature · 1 line
2.27.0
PATCH v8 18/41 btrfs: reset zones of unused block groups
In reply to Naohiro AotaFor an ZONED volume, a block group maps to a zone of the device. For deleted unused block groups, the zone of the block group can be reset to rewind the zone write pointer at the start of the zone.
--- fs/btrfs/block-group.c | 8 ++++++-- fs/btrfs/extent-tree.c | 17 ++++++++++++----- fs/btrfs/zoned.h | 16 ++++++++++++++++ 3 files changed, 34 insertions(+), 7 deletions(-)
fs/btrfs/block-group.c +6 -2
@@ -1468,8 +1468,12 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)if (!async_trim_enabled &&btrfs_test_opt (fs_info,DISCARD_ASYNC )) goto flip_async; -/* DISCARD can flip during remount */ - trimming =btrfs_test_opt (fs_info,DISCARD_SYNC ); +/* +* DISCARD can flip during remount. In ZONED mode, we need +* to reset sequential required zones. +*/ + trimming =btrfs_test_opt (fs_info,DISCARD_SYNC ) || +btrfs_fs_incompat (fs_info,ZONED );/* Implicit trim during transaction commit. */ if (trimming)
fs/btrfs/extent-tree.c +12 -5
@@ -1331,6 +1331,9 @@ int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr, stripe = bbio->stripes;for (i =0 ; i < bbio->num_stripes; i++, stripe++) { +struct btrfs_device *dev = stripe->dev; +u64 physical = stripe->physical; +u64 length = stripe->length;u64 bytes;struct request_queue *req_q;
@@ -1338,14 +1341,18 @@ int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,ASSERT (btrfs_test_opt (fs_info,DEGRADED ));continue ; } + req_q =bdev_get_queue (stripe->dev->bdev); -if (!blk_queue_discard (req_q)) +/* zone reset in ZONED mode */ +if (btrfs_can_zone_reset (dev, physical, length)) + ret =btrfs_reset_device_zone (dev, physical, + length, &bytes); +else if (blk_queue_discard (req_q)) + ret =btrfs_issue_discard (dev->bdev, physical, + length, &bytes); +else continue ; - ret =btrfs_issue_discard (stripe->dev->bdev, - stripe->physical, - stripe->length, - &bytes);if (!ret) { discarded_bytes += bytes; }else if (ret != -EOPNOTSUPP ) {
fs/btrfs/zoned.h +16 -0
@@ -199,4 +199,20 @@ static inline u64 btrfs_zone_align(struct btrfs_device *device, u64 pos) return ALIGN(pos, device->zone_info->zone_size); } +static inline bool btrfs_can_zone_reset (struct btrfs_device *device, +u64 physical,u64 length) +{ +u64 zone_size; + +if (!btrfs_dev_is_sequential (device, physical)) +return false; + + zone_size = device->zone_info->zone_size; +if (!IS_ALIGNED (physical, zone_size) || + !IS_ALIGNED (length, zone_size)) +return false; + +return true; +} +#endif
Signature · 1 line
2.27.0
PATCH v8 19/41 btrfs: redirty released extent buffers in ZONED mode
In reply to Naohiro AotaTree manipulating operations like merging nodes often release once-allocated tree nodes. Btrfs cleans such nodes so that pages in the node are not uselessly written out. On ZONED volumes, however, such optimization blocks the following IOs as the cancellation of the write out of the freed blocks breaks the sequential write sequence expected by the device.
This patch introduces a list of clean and unwritten extent buffers that have been released in a transaction. Btrfs redirty the buffer so that btree_write_cache_pages() can send proper bios to the devices.
Besides it clears the entire content of the extent buffer not to confuse raw block scanners e.g. btrfsck. By clearing the content, csum_dirty_buffer() complains about bytenr mismatch, so avoid the checking and checksum using newly introduced buffer flag EXTENT_BUFFER_NO_CHECK.
--- fs/btrfs/disk-io.c | 8 ++++++++ fs/btrfs/extent-tree.c | 12 +++++++++++- fs/btrfs/extent_io.c | 4 ++++ fs/btrfs/extent_io.h | 2 ++ fs/btrfs/transaction.c | 10 ++++++++++ fs/btrfs/transaction.h | 3 +++ fs/btrfs/tree-log.c | 6 ++++++ fs/btrfs/zoned.c | 37 +++++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 6 ++++++ 9 files changed, 87 insertions(+), 1 deletion(-)
fs/btrfs/disk-io.c +8 -0
@@ -462,6 +462,12 @@ static int csum_dirty_buffer(struct btrfs_fs_info *fs_info, struct page *page)return 0 ; found_start =btrfs_header_bytenr (eb); + +if (test_bit (EXTENT_BUFFER_NO_CHECK , &eb->bflags)) { +WARN_ON (found_start !=0 ); +return 0 ; + } +/* * Please do not consolidate these warnings into a single if. * It is useful to know what went wrong.
@@ -4614,6 +4620,8 @@ void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans, EXTENT_DIRTY);btrfs_destroy_pinned_extent (fs_info, &cur_trans->pinned_extents); +btrfs_free_redirty_list (cur_trans); + cur_trans->state =TRANS_STATE_COMPLETED ;wake_up (&cur_trans->commit_wait); }
fs/btrfs/extent-tree.c +11 -1
@@ -3421,8 +3421,10 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans,if (root->root_key.objectid !=BTRFS_TREE_LOG_OBJECTID ) { ret =check_ref_cleanup (trans, buf->start); -if (!ret) +if (!ret) { +btrfs_redirty_list_add (trans->transaction, buf); goto out; + } } pin =0 ;
@@ -3434,6 +3436,13 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans, goto out; } +if (btrfs_fs_incompat (fs_info,ZONED )) { +btrfs_redirty_list_add (trans->transaction, buf); +pin_down_extent (trans, cache, buf->start, buf->len,1 ); +btrfs_put_block_group (cache); + goto out; + } +WARN_ON (test_bit (EXTENT_BUFFER_DIRTY , &buf->bflags));btrfs_add_free_space (cache, buf->start, buf->len);
@@ -4767,6 +4776,7 @@ btrfs_init_new_buffer(struct btrfs_trans_handle *trans, struct btrfs_root *root,__btrfs_tree_lock (buf, nest);btrfs_clean_tree_block (buf);clear_bit (EXTENT_BUFFER_STALE , &buf->bflags); +clear_bit (EXTENT_BUFFER_NO_CHECK , &buf->bflags);btrfs_set_lock_blocking_write (buf);set_extent_buffer_uptodate (buf);
fs/btrfs/extent_io.c +4 -0
@@ -24,6 +24,7 @@#include "rcu-string.h" #include "backref.h" #include "disk-io.h" +#include "zoned.h" static struct kmem_cache *extent_state_cache;static struct kmem_cache *extent_buffer_cache;
@@ -4959,6 +4960,7 @@ __alloc_extent_buffer(struct btrfs_fs_info *fs_info, u64 start,btrfs_leak_debug_add (&fs_info->eb_leak_lock, &eb->leak_list, &fs_info->allocated_ebs); +INIT_LIST_HEAD (&eb->release_list);spin_lock_init (&eb->refs_lock);atomic_set (&eb->refs,1 );
@@ -5744,6 +5746,8 @@ void write_extent_buffer(const struct extent_buffer *eb, const void *srcv,char *src = (char *)srcv;unsigned long i = start >>PAGE_SHIFT ; +WARN_ON (test_bit (EXTENT_BUFFER_NO_CHECK , &eb->bflags)); +if (check_eb_range (eb, start, len))return ;
fs/btrfs/extent_io.h +2 -0
@@ -30,6 +30,7 @@ enum {EXTENT_BUFFER_IN_TREE ,/* write IO error */ EXTENT_BUFFER_WRITE_ERR , + EXTENT_BUFFER_NO_CHECK, };/* these are flags for __process_pages_contig */
@@ -107,6 +108,7 @@ struct extent_buffer {*/ wait_queue_head_t read_lock_wq;struct page *pages[INLINE_EXTENT_BUFFER_PAGES ]; +struct list_head release_list;#ifdef CONFIG_BTRFS_DEBUG int spinning_writers;atomic_t spinning_readers;
fs/btrfs/transaction.c +10 -0
@@ -22,6 +22,7 @@#include "qgroup.h" #include "block-group.h" #include "space-info.h" +#include "zoned.h" #define BTRFS_ROOT_TRANS_TAG 0
@@ -336,6 +337,8 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,spin_lock_init (&cur_trans->dirty_bgs_lock);INIT_LIST_HEAD (&cur_trans->deleted_bgs);spin_lock_init (&cur_trans->dropped_roots_lock); +INIT_LIST_HEAD (&cur_trans->releasing_ebs); +spin_lock_init (&cur_trans->releasing_ebs_lock);list_add_tail (&cur_trans->list, &fs_info->trans_list);extent_io_tree_init (fs_info, &cur_trans->dirty_pages,IO_TREE_TRANS_DIRTY_PAGES , fs_info->btree_inode);
@@ -2346,6 +2349,13 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans) goto scrub_continue; } +/* +* At this point, we should have written the all tree blocks +* allocated in this transaction. So it's now safe to free the +* redirtyied extent buffers. +*/ +btrfs_free_redirty_list (cur_trans); + ret =write_all_supers (fs_info,0 );/* * the super is written, we can safely allow the tree-loggers
fs/btrfs/transaction.h +3 -0
@@ -92,6 +92,9 @@ struct btrfs_transaction {*/ atomic_t pending_ordered;wait_queue_head_t pending_wait; + +spinlock_t releasing_ebs_lock; +struct list_head releasing_ebs; };#define __TRANS_FREEZABLE (1U << 0)
fs/btrfs/tree-log.c +6 -0
@@ -20,6 +20,7 @@#include "inode-map.h" #include "block-group.h" #include "space-info.h" +#include "zoned.h" /* magic values for the inode_only field in btrfs_log_inode: *
@@ -2742,6 +2743,8 @@ static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,free_extent_buffer (next);return ret; } +btrfs_redirty_list_add ( + trans->transaction, next); }else {if (test_and_clear_bit (EXTENT_BUFFER_DIRTY , &next->bflags))clear_extent_buffer_dirty (next);
@@ -3277,6 +3280,9 @@ static void free_log_tree(struct btrfs_trans_handle *trans,clear_extent_bits (&log->dirty_log_pages,0 , (u64)-1 ,EXTENT_DIRTY |EXTENT_NEW |EXTENT_NEED_WAIT );extent_io_tree_release (&log->log_csum_range); + +if (trans && log->node) +btrfs_redirty_list_add (trans->transaction, log->node);btrfs_put_root (log); }
fs/btrfs/zoned.c +37 -0
@@ -16,6 +16,7 @@#include "rcu-string.h" #include "disk-io.h" #include "block-group.h" +#include "transaction.h" /* Maximum number of zones to report per blkdev_report_zones() call */ #define BTRFS_REPORT_NR_ZONES 4096
@@ -1017,3 +1018,39 @@ void btrfs_calc_zone_unusable(struct btrfs_block_group *cache)*/ btrfs_free_excluded_extents (cache); } + +void btrfs_redirty_list_add (struct btrfs_transaction *trans, +struct extent_buffer *eb) +{ +struct btrfs_fs_info *fs_info = eb->fs_info; + +if (!btrfs_fs_incompat (fs_info,ZONED ) || +btrfs_header_flag (eb,BTRFS_HEADER_FLAG_WRITTEN ) || + !list_empty (&eb->release_list)) +return ; + +set_extent_buffer_dirty (eb); +set_extent_bits_nowait (&trans->dirty_pages, eb->start, + eb->start + eb->len -1 ,EXTENT_DIRTY ); +memzero_extent_buffer (eb,0 , eb->len); +set_bit (EXTENT_BUFFER_NO_CHECK , &eb->bflags); + +spin_lock (&trans->releasing_ebs_lock); +list_add_tail (&eb->release_list, &trans->releasing_ebs); +spin_unlock (&trans->releasing_ebs_lock); +atomic_inc (&eb->refs); +} + +void btrfs_free_redirty_list (struct btrfs_transaction *trans) +{ +spin_lock (&trans->releasing_ebs_lock); +while (!list_empty (&trans->releasing_ebs)) { +struct extent_buffer *eb; + + eb =list_first_entry (&trans->releasing_ebs, + struct extent_buffer, release_list); +list_del_init (&eb->release_list); +free_extent_buffer (eb); + } +spin_unlock (&trans->releasing_ebs_lock); +}
fs/btrfs/zoned.h +6 -0
@@ -47,6 +47,9 @@ int btrfs_reset_device_zone(struct btrfs_device *device, u64 physical,int btrfs_ensure_empty_zones (struct btrfs_device *device,u64 start,u64 size);int btrfs_load_block_group_zone_info (struct btrfs_block_group *cache);void btrfs_calc_zone_unusable (struct btrfs_block_group *cache); +void btrfs_redirty_list_add (struct btrfs_transaction *trans, +struct extent_buffer *eb); +void btrfs_free_redirty_list (struct btrfs_transaction *trans);#else /* CONFIG_BLK_DEV_ZONED */ static inline int btrfs_get_dev_zone (struct btrfs_device *device,u64 pos,struct blk_zone *zone)
@@ -113,6 +116,9 @@ static inline int btrfs_load_block_group_zone_info( return 0; }static inline void btrfs_calc_zone_unusable (struct btrfs_block_group *cache) { } +static inline void btrfs_redirty_list_add (struct btrfs_transaction *trans, +struct extent_buffer *eb) { } +static inline void btrfs_free_redirty_list (struct btrfs_transaction *trans) { }#endif static inline bool btrfs_dev_is_sequential (struct btrfs_device *device,u64 pos)
Signature · 1 line
2.27.0
PATCH v8 20/41 btrfs: extract page adding function
In reply to Naohiro AotaThis commit extract page adding to bio part from submit_extent_page(). The page is added only when bio_flags are the same, contiguous and the added page fits in the same stripe as pages in the bio.
Condition checkings are reordered to allow early return to avoid possibly heavy btrfs_bio_fits_in_stripe() calling.
--- fs/btrfs/extent_io.c | 55 ++++++++++++++++++++++++++++++++------------ 1 file changed, 40 insertions(+), 15 deletions(-)
fs/btrfs/extent_io.c +40 -15
@@ -3012,6 +3012,43 @@ struct bio *btrfs_bio_clone_partial(struct bio *orig, int offset, int size)return bio; } +/** +* btrfs_bio_add_page - attempt to add a page to bio +* @bio: destination bio +* @page: page to add to the bio +* @logical: offset of the new bio or to check whether we are adding +* a contiguous page to the previous one +* @pg_offset: starting offset in the page +* @size: portion of page that we want to write +* @prev_bio_flags: flags of previous bio to see if we can merge the current one +* @bio_flags: flags of the current bio to see if we can merge them +* +* Attempt to add a page to bio considering stripe alignment etc. Return +* true if successfully page added. Otherwise, return false. +*/ +bool btrfs_bio_add_page (struct bio *bio,struct page *page,u64 logical, +unsigned int size,unsigned int pg_offset, +unsigned long prev_bio_flags,unsigned long bio_flags) +{ +sector_t sector = logical >>SECTOR_SHIFT ; +bool contig; + +if (prev_bio_flags != bio_flags) +return false; + +if (prev_bio_flags &EXTENT_BIO_COMPRESSED ) + contig = bio->bi_iter.bi_sector == sector; +else + contig =bio_end_sector (bio) == sector; +if (!contig) +return false; + +if (btrfs_bio_fits_in_stripe (page, size, bio, bio_flags)) +return false; + +return bio_add_page (bio, page, size, pg_offset) == size; +} +/* * @opf: bio REQ_OP_* and REQ_* flags as one value * @wbc: optional writeback control for io accounting
@@ -3040,27 +3077,15 @@ static int submit_extent_page(unsigned int opf,int ret =0 ;struct bio *bio;size_t page_size =min_t (size_t, size,PAGE_SIZE ); -sector_t sector = offset >>9 ;struct extent_io_tree *tree = &BTRFS_I (page->mapping->host)->io_tree;ASSERT (bio_ret);if (*bio_ret) { -bool contig; -bool can_merge = true; - bio = *bio_ret; -if (prev_bio_flags &EXTENT_BIO_COMPRESSED ) - contig = bio->bi_iter.bi_sector == sector; -else - contig =bio_end_sector (bio) == sector; - -if (btrfs_bio_fits_in_stripe (page, page_size, bio, bio_flags)) - can_merge = false; - -if (prev_bio_flags != bio_flags || !contig || !can_merge || - force_bio_submit || -bio_add_page (bio, page, page_size, pg_offset) < page_size) { +if (force_bio_submit || + !btrfs_bio_add_page (bio, page, offset, page_size, pg_offset, + prev_bio_flags, bio_flags)) { ret =submit_one_bio (bio, mirror_num, prev_bio_flags);if (ret <0 ) { *bio_ret =NULL ;
Signature · 1 line
2.27.0
PATCH v8 21/41 btrfs: use bio_add_zone_append_page for zoned btrfs
In reply to Naohiro AotaZoned device has its own hardware restrictions e.g. max_zone_append_size when using REQ_OP_ZONE_APPEND. To follow the restrictions, use bio_add_zone_append_page() instead of bio_add_page(). We need target device to use bio_add_zone_append_page(), so this commit reads the chunk information to memoize the target device to btrfs_io_bio(bio)->device.
Currently, zoned btrfs only supports SINGLE profile. In the feature, btrfs_io_bio can hold extent_map and check the restrictions for all the devices the bio will be mapped.
--- fs/btrfs/extent_io.c | 37 ++++++++++++++++++++++++++++++++++--- 1 file changed, 34 insertions(+), 3 deletions(-)
fs/btrfs/extent_io.c +34 -3
@@ -3032,6 +3032,7 @@ bool btrfs_bio_add_page(struct bio *bio, struct page *page, u64 logical, {sector_t sector = logical >>SECTOR_SHIFT ;bool contig; +int ret;if (prev_bio_flags != bio_flags)return false;
@@ -3046,7 +3047,19 @@ bool btrfs_bio_add_page(struct bio *bio, struct page *page, u64 logical,if (btrfs_bio_fits_in_stripe (page, size, bio, bio_flags))return false; -return bio_add_page (bio, page, size, pg_offset) == size; +if (bio_op (bio) ==REQ_OP_ZONE_APPEND ) { +struct bio orig_bio; + +memset (&orig_bio,0 ,sizeof (orig_bio)); +bio_copy_dev (&orig_bio, bio); +bio_set_dev (bio,btrfs_io_bio (bio)->device->bdev); + ret =bio_add_zone_append_page (bio, page, size, pg_offset); +bio_copy_dev (bio, &orig_bio); + }else { + ret =bio_add_page (bio, page, size, pg_offset); + } + +return ret == size; }/*
@@ -3077,7 +3090,9 @@ static int submit_extent_page(unsigned int opf,int ret =0 ;struct bio *bio;size_t page_size =min_t (size_t, size,PAGE_SIZE ); -struct extent_io_tree *tree = &BTRFS_I (page->mapping->host)->io_tree; +struct btrfs_inode *inode =BTRFS_I (page->mapping->host); +struct extent_io_tree *tree = &inode->io_tree; +struct btrfs_fs_info *fs_info = inode->root->fs_info;ASSERT (bio_ret);
@@ -3108,11 +3123,27 @@ static int submit_extent_page(unsigned int opf,if (wbc) {struct block_device *bdev; - bdev =BTRFS_I (page->mapping->host)->root->fs_info->fs_devices->latest_bdev; + bdev = fs_info->fs_devices->latest_bdev;bio_set_dev (bio, bdev);wbc_init_bio (wbc, bio);wbc_account_cgroup_owner (wbc, page, page_size); } +if (btrfs_fs_incompat (fs_info,ZONED ) && +bio_op (bio) ==REQ_OP_ZONE_APPEND ) { +struct extent_map *em; +struct map_lookup *map; + + em =btrfs_get_chunk_map (fs_info, offset, page_size); +if (IS_ERR (em)) +return PTR_ERR (em); + + map = em->map_lookup; +/* only support SINGLE profile for now */ +ASSERT (map->num_stripes ==1 ); +btrfs_io_bio (bio)->device = map->stripes[0 ].dev; + +free_extent_map (em); + } *bio_ret = bio;
Signature · 1 line
2.27.0
PATCH v8 22/41 btrfs: handle REQ_OP_ZONE_APPEND as writing
In reply to Naohiro AotaZONED btrfs uses REQ_OP_ZONE_APPEND for a bio going to actual devices. Let btrfs_end_bio() and btrfs_op, who faces the bios, aware of it.
--- fs/btrfs/volumes.c | 3 ++- fs/btrfs/volumes.h | 1 + 2 files changed, 3 insertions(+), 1 deletion(-)
fs/btrfs/volumes.c +2 -1
@@ -6447,7 +6447,8 @@ static void btrfs_end_bio(struct bio *bio)struct btrfs_device *dev =btrfs_io_bio (bio)->device;ASSERT (dev->bdev); -if (bio_op (bio) ==REQ_OP_WRITE ) +if (bio_op (bio) ==REQ_OP_WRITE || +bio_op (bio) ==REQ_OP_ZONE_APPEND )btrfs_dev_stat_inc_and_print (dev,BTRFS_DEV_STAT_WRITE_ERRS );else if (!(bio->bi_opf &REQ_RAHEAD ))
fs/btrfs/volumes.h +1 -0
@@ -410,6 +410,7 @@ static inline enum btrfs_map_op btrfs_op(struct bio *bio)case REQ_OP_DISCARD :return BTRFS_MAP_DISCARD ;case REQ_OP_WRITE : +case REQ_OP_ZONE_APPEND :return BTRFS_MAP_WRITE ;default :WARN_ON_ONCE (1 );
Signature · 1 line
2.27.0
PATCH v8 23/41 btrfs: split ordered extent when bio is sent
In reply to Naohiro AotaThe device decides the written location of ZONE_APPEND write IO. Thus, we cannot ensure two bios to be written continuously on the device. So, we need to follow "one bio == one ordered extent" rule to ensure the region of ordered extent maps to contiguous region on the disk.
This commit implements splitting of an ordered extent and an extent map on submitting bio to follow the rule.
--- fs/btrfs/inode.c | 87 +++++++++++++++++++++++++++++++++++++++++ fs/btrfs/ordered-data.c | 73 ++++++++++++++++++++++++++++++++++ fs/btrfs/ordered-data.h | 2 + 3 files changed, 162 insertions(+)
fs/btrfs/inode.c +87 -0
@@ -2158,6 +2158,87 @@ static blk_status_t btrfs_submit_bio_start(void *private_data, struct bio *bio,return btrfs_csum_one_bio (BTRFS_I (inode), bio,0 ,0 ); } +int extract_ordered_extent (struct inode *inode,struct bio *bio) +{ +struct btrfs_ordered_extent *ordered; +struct extent_map *em =NULL , *em_new =NULL ; +struct page *page =bio_first_bvec_all (bio)->bv_page; +struct extent_map_tree *em_tree = &BTRFS_I (inode)->extent_tree; +u64 start = (u64 )bio->bi_iter.bi_sector <<SECTOR_SHIFT ; +u64 len = bio->bi_iter.bi_size; +u64 end = start + len; +u64 ordered_end; +u64 pre, post; +int ret =0 ; + + ordered =btrfs_lookup_ordered_extent (BTRFS_I (inode), +page_offset (page)); +if (WARN_ON_ONCE (!ordered)) +return -EIO ; + +/* no need to split */ +if (ordered->disk_num_bytes == len) + goto out; + +/* cannot split once end_bio'd ordered extent */ +if (WARN_ON_ONCE (ordered->bytes_left != ordered->disk_num_bytes)) { + ret = -EINVAL ; + goto out; + } + +/* we cannot split compressed ordered extent */ +if (WARN_ON_ONCE (ordered->disk_num_bytes != ordered->num_bytes)) { + ret = -EINVAL ; + goto out; + } + +/* cannot split waietd ordered extent */ +if (WARN_ON_ONCE (wq_has_sleeper (&ordered->wait))) { + ret = -EINVAL ; + goto out; + } + + ordered_end = ordered->disk_bytenr + ordered->disk_num_bytes; +/* bio must be in one ordered extent */ +if (WARN_ON_ONCE (start < ordered->disk_bytenr || end > ordered_end)) { + ret = -EINVAL ; + goto out; + } + +/* checksum list should be empty */ +if (WARN_ON_ONCE (!list_empty (&ordered->list))) { + ret = -EINVAL ; + goto out; + } + + pre = start - ordered->disk_bytenr; + post = ordered_end - end; + +btrfs_split_ordered_extent (ordered, pre, post); + +read_lock (&em_tree->lock); + em =lookup_extent_mapping (em_tree, ordered->file_offset, len); +if (!em) { +read_unlock (&em_tree->lock); + ret = -EIO ; + goto out; + } +read_unlock (&em_tree->lock); + +ASSERT (!test_bit (EXTENT_FLAG_COMPRESSED , &em->flags)); + em_new =create_io_em (BTRFS_I (inode), em->start + pre, len, + em->start + pre, em->block_start + pre, len, + len, len,BTRFS_COMPRESS_NONE , +BTRFS_ORDERED_REGULAR ); +free_extent_map (em_new); + +out: +free_extent_map (em); +btrfs_put_ordered_extent (ordered); + +return ret; +} +/* * extent_io.c submission hook. This does the right thing for csum calculation * on write, or reading the csums from the tree before a read.
@@ -2192,6 +2273,12 @@ blk_status_t btrfs_submit_data_bio(struct inode *inode, struct bio *bio,if (btrfs_is_free_space_inode (BTRFS_I (inode))) metadata =BTRFS_WQ_ENDIO_FREE_SPACE ; +if (bio_op (bio) ==REQ_OP_ZONE_APPEND ) { + ret =extract_ordered_extent (inode, bio); +if (ret) + goto out; + } +if (bio_op (bio) !=REQ_OP_WRITE ) { ret =btrfs_bio_wq_end_io (fs_info, bio, metadata);if (ret)
fs/btrfs/ordered-data.c +73 -0
79 lines not on this page · raw message
fs/btrfs/ordered-data.h +2 -0
@@ -193,6 +193,8 @@ void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, u64 nr,void btrfs_lock_and_flush_ordered_range (struct btrfs_inode *inode,u64 start,u64 end,struct extent_state **cached_state); +void btrfs_split_ordered_extent (struct btrfs_ordered_extent *ordered,u64 pre, +u64 post);int __init ordered_data_init (void );void __cold ordered_data_exit (void );
Signature · 1 line
2.27.0
PATCH v8 24/41 btrfs: extend btrfs_rmap_block for specifying a device
In reply to Naohiro Aotabtrfs_rmap_block currently reverse-map the physical address on all devices to logical addresses. This commit extends the function to match to a specified device. You can still query all devices by specifying NULL as a device.
This commit also exporet the function for later use.
--- fs/btrfs/block-group.c | 23 ++++++++++++++++++----- fs/btrfs/block-group.h | 3 +++ 2 files changed, 21 insertions(+), 5 deletions(-)
fs/btrfs/block-group.c +18 -5
@@ -1655,9 +1655,9 @@ static void set_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)* Used primarily to exclude those portions of a block group that contain super * block copies. */ -EXPORT_FOR_TESTS -int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start, -u64 physical,u64 **logical,int *naddrs,int *stripe_len) +int __btrfs_rmap_block (struct btrfs_fs_info *fs_info,u64 chunk_start, +struct block_device *bdev,u64 physical,u64 **logical, +int *naddrs,int *stripe_len) {struct extent_map *em;struct map_lookup *map;
@@ -1675,6 +1675,7 @@ int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start, map = em->map_lookup; data_stripe_length = em->orig_block_len; io_stripe_size = map->stripe_len; + chunk_start = em->start;/* For RAID5/6 adjust to a full IO stripe length */ if (map->type &BTRFS_BLOCK_GROUP_RAID56_MASK )
@@ -1689,14 +1690,18 @@ int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,for (i =0 ; i < map->num_stripes; i++) {bool already_inserted = false;u64 stripe_nr; +u64 offset;int j;if (!in_range (physical, map->stripes[i].physical, data_stripe_length))continue ; +if (bdev && map->stripes[i].dev->bdev != bdev) +continue ; + stripe_nr = physical - map->stripes[i].physical; - stripe_nr =div64_u64 (stripe_nr, map->stripe_len); + stripe_nr =div64_u64_rem (stripe_nr, map->stripe_len, &offset);if (map->type &BTRFS_BLOCK_GROUP_RAID10 ) { stripe_nr = stripe_nr * map->num_stripes + i;
@@ -1710,7 +1715,7 @@ int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,* instead of map->stripe_len */ - bytenr = chunk_start + stripe_nr * io_stripe_size; + bytenr = chunk_start + stripe_nr * io_stripe_size + offset;/* Ensure we don't add duplicate addresses */ for (j =0 ; j < nr; j++) {
@@ -1732,6 +1737,14 @@ int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,return ret; } +EXPORT_FOR_TESTS +int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start, +u64 physical,u64 **logical,int *naddrs,int *stripe_len) +{ +return __btrfs_rmap_block (fs_info, chunk_start,NULL , physical, logical, + naddrs, stripe_len); +} +static int exclude_super_stripes (struct btrfs_block_group *cache) {struct btrfs_fs_info *fs_info = cache->fs_info;
fs/btrfs/block-group.h +3 -0
@@ -275,6 +275,9 @@ void check_system_chunk(struct btrfs_trans_handle *trans, const u64 type);u64 btrfs_get_alloc_profile (struct btrfs_fs_info *fs_info,u64 orig_flags);void btrfs_put_block_group_cache (struct btrfs_fs_info *info);int btrfs_free_block_groups (struct btrfs_fs_info *info); +int __btrfs_rmap_block (struct btrfs_fs_info *fs_info,u64 chunk_start, +struct block_device *bdev,u64 physical,u64 **logical, +int *naddrs,int *stripe_len);static inline u64 btrfs_data_alloc_profile (struct btrfs_fs_info *fs_info) {
Signature · 1 line
2.27.0
PATCH v8 25/41 btrfs: use ZONE_APPEND write for ZONED btrfs
In reply to Naohiro AotaThis commit enables zone append writing for zoned btrfs. Three parts are necessary to enable it. First, it modifies bio to use REQ_OP_ZONE_APPEND in btrfs_submit_bio_hook() and adjust the bi_sector to point the beginning of the zone.
Second, it records returned physical address (and disk/partno) to the ordered extent in end_bio_extent_writepage().
Finally, it rewrites logical addresses of the extent mapping and checksum data according to the physical address (using __btrfs_rmap_block). If the returned address match to the originaly allocated address, we can skip the rewriting process.
[Johannes] fixed bvec handling
--- fs/btrfs/extent_io.c | 12 +++++++- fs/btrfs/inode.c | 6 +++- fs/btrfs/ordered-data.c | 3 ++ fs/btrfs/ordered-data.h | 4 +++ fs/btrfs/volumes.c | 9 ++++++ fs/btrfs/zoned.c | 68 +++++++++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 9 ++++++ 7 files changed, 109 insertions(+), 2 deletions(-)
fs/btrfs/extent_io.c +11 -1
@@ -2743,6 +2743,7 @@ static void end_bio_extent_writepage(struct bio *bio)u64 start;u64 end;struct bvec_iter_all iter_all; +bool first_bvec = true;ASSERT (!bio_flagged (bio,BIO_CLONED ));bio_for_each_segment_all (bvec, bio, iter_all) {
@@ -2769,6 +2770,11 @@ static void end_bio_extent_writepage(struct bio *bio) start =page_offset (page); end = start + bvec->bv_offset + bvec->bv_len -1 ; +if (first_bvec) { +btrfs_record_physical_zoned (inode, start, bio); + first_bvec = false; + } +end_extent_writepage (page, error, start, end);end_page_writeback (page); }
@@ -3531,6 +3537,7 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,size_t blocksize;int ret =0 ;int nr =0 ; +int opf =REQ_OP_WRITE ;const unsigned int write_flags =wbc_to_write_flags (wbc);bool compressed;
@@ -3543,6 +3550,9 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,return 1 ; } +if (btrfs_fs_incompat (inode->root->fs_info,ZONED )) + opf =REQ_OP_ZONE_APPEND ; +/* * we don't want to touch the inode after unlocking the page, * so we update the mapping writeback index now
@@ -3603,7 +3613,7 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode, page->index, cur, end); } - ret = submit_extent_page(REQ_OP_WRITE | write_flags, wbc, + ret = submit_extent_page(opf | write_flags, wbc, page, offset, iosize, pg_offset, &epd->bio, end_bio_extent_writepage,
fs/btrfs/inode.c +5 -1
@@ -51,6 +51,7 @@#include "delalloc-space.h" #include "block-group.h" #include "space-info.h" +#include "zoned.h" struct btrfs_iget_args {u64 ino;
@@ -2279,7 +2280,7 @@ blk_status_t btrfs_submit_data_bio(struct inode *inode, struct bio *bio, goto out; } -if (bio_op (bio) !=REQ_OP_WRITE ) { +if (btrfs_op (bio) !=BTRFS_MAP_WRITE ) { ret =btrfs_bio_wq_end_io (fs_info, bio, metadata);if (ret) goto out;
@@ -2674,6 +2675,9 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)bool clear_reserved_extent = true;unsigned int clear_bits; +if (ordered_extent->disk) +btrfs_rewrite_logical_zoned (ordered_extent); + start = ordered_extent->file_offset; end = start + ordered_extent->num_bytes -1 ;
fs/btrfs/ordered-data.c +3 -0
@@ -199,6 +199,9 @@ static int __btrfs_add_ordered_extent(struct btrfs_inode *inode, u64 file_offset entry->compress_type = compress_type; entry->truncated_len = (u64)-1 ; entry->qgroup_rsv = ret; + entry->physical = (u64)-1 ; + entry->disk =NULL ; + entry->partno = (u8)-1 ;if (type !=BTRFS_ORDERED_IO_DONE && type !=BTRFS_ORDERED_COMPLETE )set_bit (type, &entry->flags);
fs/btrfs/ordered-data.h +4 -0
@@ -127,6 +127,10 @@ struct btrfs_ordered_extent {struct completion completion;struct btrfs_work flush_work;struct list_head work_list; + +u64 physical; +struct gendisk *disk; +u8 partno; };/*
fs/btrfs/volumes.c +9 -0
@@ -6500,6 +6500,15 @@ static void submit_stripe_bio(struct btrfs_bio *bbio, struct bio *bio,btrfs_io_bio (bio)->device = dev; bio->bi_end_io = btrfs_end_bio; bio->bi_iter.bi_sector = physical >>9 ; +/* +* For zone append writing, bi_sector must point the beginning of the +* zone +*/ +if (bio_op (bio) ==REQ_OP_ZONE_APPEND ) { +u64 zone_start =round_down (physical, fs_info->zone_size); + + bio->bi_iter.bi_sector = zone_start >>SECTOR_SHIFT ; + } btrfs_debug_in_rcu(fs_info, "btrfs_map_bio: rw %d 0x%x, sector=%llu, dev=%lu (%s id %llu), size=%u", bio_op(bio), bio->bi_opf, (u64)bio->bi_iter.bi_sector,
fs/btrfs/zoned.c +68 -0
71 lines not on this page · raw message
fs/btrfs/zoned.h +9 -0
@@ -50,6 +50,9 @@ void btrfs_calc_zone_unusable(struct btrfs_block_group *cache);void btrfs_redirty_list_add (struct btrfs_transaction *trans,struct extent_buffer *eb);void btrfs_free_redirty_list (struct btrfs_transaction *trans); +void btrfs_record_physical_zoned (struct inode *inode,u64 file_offset, +struct bio *bio); +void btrfs_rewrite_logical_zoned (struct btrfs_ordered_extent *ordered);#else /* CONFIG_BLK_DEV_ZONED */ static inline int btrfs_get_dev_zone (struct btrfs_device *device,u64 pos,struct blk_zone *zone)
@@ -119,6 +122,12 @@ static inline void btrfs_calc_zone_unusable(struct btrfs_block_group *cache) { }static inline void btrfs_redirty_list_add (struct btrfs_transaction *trans,struct extent_buffer *eb) { }static inline void btrfs_free_redirty_list (struct btrfs_transaction *trans) { } +static inline void btrfs_record_physical_zoned (struct inode *inode, +u64 file_offset,struct bio *bio) +{ +} +static inline void +btrfs_rewrite_logical_zoned (struct btrfs_ordered_extent *ordered) { }#endif static inline bool btrfs_dev_is_sequential (struct btrfs_device *device,u64 pos)
Signature · 1 line
2.27.0
Re: [PATCH v8 25/41] btrfs: use ZONE_APPEND write for ZONED btrfs
Quoted 7 lines · Naohiro Aota
This commit enables zone append writing for zoned btrfs. Three parts are necessary to enable it. First, it modifies bio to use
REQ_OP_ZONE_APPENDinbtrfs_submit_bio_hook()and adjust thebi_sectorto point the beginning of the zone.Second, it records returned physical address (and disk/partno) to the ordered extent in
end_bio_extent_writepage().
That sounds fishy ...
Quoted 11 lines
Finally, it rewrites logical addresses of the extent mapping and checksum data according to the physical address (using
__btrfs_rmap_block). If the returned address match to the originaly allocated address, we can skip the rewriting process.[Johannes] fixed bvec handling
Signed-off-by Naohiro Aota <[email protected]>
fs/btrfs/ordered-data.h struct btrfs_ordered_extent { · line 133
Quoted 7 lines
fs/btrfs/ordered-data.h +4
-0@@ -127,6 +127,10 @@ struct btrfs_ordered_extent {struct completion completion;struct btrfs_work flush_work;struct list_head work_list; + +u64 physical; +struct gendisk *disk; +u8 partno;
btrfs_ordered_extent is on the logical layer, disk/partno is physical.
This needs proper explanation why it has to be done that way and that there's not really anything better than layering violation. Why __btrfs_rmap_block takes bdev is unexplained.
PATCH v8 26/41 btrfs: enable zone append writing for direct IO
In reply to Naohiro AotaThis commit enables zone append writing as same as in buffered write.
--- fs/btrfs/inode.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-)
fs/btrfs/inode.c +15 -1
@@ -7422,6 +7422,11 @@ static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start, current->journal_info == BTRFS_DIO_SYNC_STUB); current->journal_info =NULL ; +if (write && fs_info->max_zone_append_size) { + length =min_t (u64, length, fs_info->max_zone_append_size); + len = length; + } +if (!write) len =min_t (u64, len, fs_info->sectorsize);
@@ -7777,6 +7782,8 @@ static void btrfs_end_dio_bio(struct bio *bio)if (err) dip->dio_bio->bi_status = err; +btrfs_record_physical_zoned (dip->inode, dip->logical_offset, bio); +bio_put (bio);btrfs_dio_private_put (dip); }
@@ -7786,7 +7793,8 @@ static inline blk_status_t btrfs_submit_dio_bio(struct bio *bio, {struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_dio_private *dip = bio->bi_private; -bool write =bio_op (bio) ==REQ_OP_WRITE ; +bool write =bio_op (bio) ==REQ_OP_WRITE || +bio_op (bio) ==REQ_OP_ZONE_APPEND ;blk_status_t ret;/* Check btrfs_submit_bio_hook() for rules about async submit. */
@@ -7931,6 +7939,12 @@ static blk_qc_t btrfs_submit_direct(struct inode *inode, struct iomap *iomap, bio->bi_end_io = btrfs_end_dio_bio;btrfs_io_bio (bio)->logical = file_offset; +if (write &&btrfs_fs_incompat (fs_info,ZONED ) && + fs_info->max_zone_append_size) { + bio->bi_opf &= ~REQ_OP_MASK ; + bio->bi_opf |=REQ_OP_ZONE_APPEND ; + } +ASSERT (submit_len >= clone_len); submit_len -= clone_len;
Signature · 1 line
2.27.0
PATCH v8 27/41 btrfs: introduce dedicated data write path for ZONED mode
In reply to Naohiro AotaIf more than one IO is issued for one file extent, these IO can be written in a separate region on a device. Since we cannot map one file extent to such a separate area, we need to follow the "one IO == one ordered extent" rule.
Normal (buffered, uncompressed, not pre-allocated) write path (= cow_file_range()) sometime does not follow the rule. It can write a part of an ordered extent when specified a region to write e.g., called from fdatasync().
This commit introduces a dedicated (uncompressed buffered) data write path for ZONED mode. This write path CoW the region and write the region at once.
--- fs/btrfs/inode.c | 34 ++++++++++++++++++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-)
fs/btrfs/inode.c +32 -2
@@ -1350,6 +1350,29 @@ static int cow_file_range_async(struct btrfs_inode *inode,return 0 ; } +static noinline int run_delalloc_zoned(struct btrfs_inode *inode, +struct page *locked_page,u64 start, +u64 end,int *page_started, +unsigned long *nr_written) +{ +int ret; + + ret =cow_file_range (inode, locked_page, start, end, + page_started, nr_written,0 ); +if (ret) +return ret; + +if (*page_started) +return 0 ; + +__set_page_dirty_nobuffers (locked_page); +account_page_redirty (locked_page); +extent_write_locked_range (&inode->vfs_inode, start, end,WB_SYNC_ALL ); + *page_started =1 ; + +return 0 ; +} + static noinline int csum_exist_in_range(struct btrfs_fs_info *fs_info,u64 bytenr,u64 num_bytes) {
@@ -1820,17 +1843,24 @@ int btrfs_run_delalloc_range(struct btrfs_inode *inode, struct page *locked_page {int ret;int force_cow =need_force_cow (inode, start, end); +int do_compress =inode_can_compress (inode) && +inode_need_compress (inode, start, end); +bool zoned =btrfs_fs_incompat (inode->root->fs_info,ZONED );if (inode->flags &BTRFS_INODE_NODATACOW && !force_cow) { +ASSERT (!zoned); ret =run_delalloc_nocow (inode, locked_page, start, end, page_started,1 , nr_written); }else if (inode->flags &BTRFS_INODE_PREALLOC && !force_cow) { +ASSERT (!zoned); ret =run_delalloc_nocow (inode, locked_page, start, end, page_started,0 , nr_written); - }else if (!inode_can_compress (inode) || - !inode_need_compress (inode, start, end)) { + }else if (!do_compress && !zoned) { ret =cow_file_range (inode, locked_page, start, end, page_started, nr_written,1 ); + }else if (!do_compress && zoned) { + ret =run_delalloc_zoned (inode, locked_page, start, end, + page_started, nr_written); }else {set_bit (BTRFS_INODE_HAS_ASYNC_EXTENT , &inode->runtime_flags); ret = cow_file_range_async(inode, wbc, locked_page, start, end,
Signature · 1 line
2.27.0
PATCH v8 28/41 btrfs: serialize meta IOs on ZONED mode
In reply to Naohiro AotaWe cannot use zone append writing for metadata, because the B-tree nodes have references to each other using the logical address. Without knowing the address in advance, we cannot construct the tree in the first place. Thus, we need to serialize write IOs for metadata.
We cannot add mutex around allocation and submit because metadata blocks are allocated in an earlier stage to build up B-trees.
Thus, this commit add zoned_meta_io_lock and hold it during metadata IO submission in btree_write_cache_pages() to serialize IOs. Furthermore, this commit add per-block group metadata IO submission pointer "meta_write_pointer" to ensure sequential writing, which can be caused when writing back blocks in a not finished transaction.
--- fs/btrfs/block-group.h | 1 + fs/btrfs/ctree.h | 2 ++ fs/btrfs/disk-io.c | 1 + fs/btrfs/extent_io.c | 27 ++++++++++++++++++++++- fs/btrfs/zoned.c | 50 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 31 ++++++++++++++++++++++++++ 6 files changed, 111 insertions(+), 1 deletion(-)
fs/btrfs/block-group.h +1 -0
@@ -190,6 +190,7 @@ struct btrfs_block_group {*/ u64 alloc_offset;u64 zone_unusable; +u64 meta_write_pointer; };static inline u64 btrfs_block_group_end (struct btrfs_block_group *block_group)
fs/btrfs/ctree.h +2 -0
@@ -953,6 +953,8 @@ struct btrfs_fs_info {/* Type of exclusive operation running */ unsigned long exclusive_operation; +struct mutex zoned_meta_io_lock; +#ifdef CONFIG_BTRFS_FS_REF_VERIFY spinlock_t ref_verify_lock;struct rb_root block_tree;
fs/btrfs/disk-io.c +1 -0
@@ -2652,6 +2652,7 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)mutex_init (&fs_info->delete_unused_bgs_mutex);mutex_init (&fs_info->reloc_mutex);mutex_init (&fs_info->delalloc_root_mutex); +mutex_init (&fs_info->zoned_meta_io_lock);seqlock_init (&fs_info->profiles_lock);INIT_LIST_HEAD (&fs_info->dirty_cowonly_roots);
fs/btrfs/extent_io.c +26 -1
@@ -25,6 +25,7 @@#include "backref.h" #include "disk-io.h" #include "zoned.h" +#include "block-group.h" static struct kmem_cache *extent_state_cache;static struct kmem_cache *extent_buffer_cache;
@@ -4001,6 +4002,7 @@ int btree_write_cache_pages(struct address_space *mapping, struct writeback_control *wbc) {struct extent_buffer *eb, *prev_eb =NULL ; +struct btrfs_block_group *cache =NULL ;struct extent_page_data epd = { .bio =NULL , .extent_locked =0 ,
@@ -4035,6 +4037,7 @@ int btree_write_cache_pages(struct address_space *mapping, tag =PAGECACHE_TAG_TOWRITE ; else tag =PAGECACHE_TAG_DIRTY ; +btrfs_zoned_meta_io_lock (fs_info); retry:if (wbc->sync_mode ==WB_SYNC_ALL )tag_pages_for_writeback (mapping, index, end);
@@ -4077,12 +4080,30 @@ int btree_write_cache_pages(struct address_space *mapping,if (!ret)continue ; +if (!btrfs_check_meta_write_pointer (fs_info, eb, + &cache)) { +/* +* If for_sync, this hole will be filled with +* trasnsaction commit. +*/ +if (wbc->sync_mode ==WB_SYNC_ALL && + !wbc->for_sync) + ret = -EAGAIN ; +else + ret =0 ; + done =1 ; +free_extent_buffer (eb); +break ; + } + prev_eb = eb; ret =lock_extent_buffer_for_io (eb, &epd);if (!ret) { +btrfs_revert_meta_write_pointer (cache, eb);free_extent_buffer (eb);continue ; }else if (ret <0 ) { +btrfs_revert_meta_write_pointer (cache, eb); done =1 ;free_extent_buffer (eb);break ;
@@ -4115,10 +4136,12 @@ int btree_write_cache_pages(struct address_space *mapping, index =0 ; goto retry; } +if (cache) +btrfs_put_block_group (cache);ASSERT (ret <=0 );if (ret <0 ) {end_write_bio (&epd, ret); -return ret; + goto out; }/* * If something went wrong, don't allow any metadata write bio to be
@@ -4153,6 +4176,8 @@ int btree_write_cache_pages(struct address_space *mapping, ret = -EROFS ;end_write_bio (&epd, ret); } +out: +btrfs_zoned_meta_io_unlock (fs_info);return ret; }
fs/btrfs/zoned.c +50 -0
59 lines not on this page · raw message
fs/btrfs/zoned.h +31 -0
@@ -53,6 +53,11 @@ void btrfs_free_redirty_list(struct btrfs_transaction *trans);void btrfs_record_physical_zoned (struct inode *inode,u64 file_offset,struct bio *bio);void btrfs_rewrite_logical_zoned (struct btrfs_ordered_extent *ordered); +bool btrfs_check_meta_write_pointer (struct btrfs_fs_info *fs_info, +struct extent_buffer *eb, +struct btrfs_block_group **cache_ret); +void btrfs_revert_meta_write_pointer (struct btrfs_block_group *cache, +struct extent_buffer *eb);#else /* CONFIG_BLK_DEV_ZONED */ static inline int btrfs_get_dev_zone (struct btrfs_device *device,u64 pos,struct blk_zone *zone)
@@ -128,6 +133,18 @@ static inline void btrfs_record_physical_zoned(struct inode *inode, }static inline void btrfs_rewrite_logical_zoned (struct btrfs_ordered_extent *ordered) { } +static inline bool +btrfs_check_meta_write_pointer (struct btrfs_fs_info *fs_info, +struct extent_buffer *eb, +struct btrfs_block_group **cache_ret) +{ +return true; +} +static inline void +btrfs_revert_meta_write_pointer (struct btrfs_block_group *cache, +struct extent_buffer *eb) +{ +}#endif static inline bool btrfs_dev_is_sequential (struct btrfs_device *device,u64 pos)
@@ -230,4 +247,18 @@ static inline bool btrfs_can_zone_reset(struct btrfs_device *device, return true; } +static inline void btrfs_zoned_meta_io_lock (struct btrfs_fs_info *fs_info) +{ +if (!btrfs_fs_incompat (fs_info,ZONED )) +return ; +mutex_lock (&fs_info->zoned_meta_io_lock); +} + +static inline void btrfs_zoned_meta_io_unlock (struct btrfs_fs_info *fs_info) +{ +if (!btrfs_fs_incompat (fs_info,ZONED )) +return ; +mutex_unlock (&fs_info->zoned_meta_io_lock); +} +#endif
Signature · 1 line
2.27.0
PATCH v8 29/41 btrfs: wait existing extents before truncating
In reply to Naohiro AotaWhen truncating a file, file buffers which have already been allocated but not yet written may be truncated. Truncating these buffers could cause breakage of a sequential write pattern in a block group if the truncated blocks are for example followed by blocks allocated to another file. To avoid this problem, always wait for write out of all unwritten buffers before proceeding with the truncate execution.
--- fs/btrfs/inode.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
fs/btrfs/inode.c +10 -0
@@ -4953,6 +4953,16 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)btrfs_drew_write_unlock (&root->snapshot_lock);btrfs_end_transaction (trans); }else { +struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); + +if (btrfs_fs_incompat (fs_info,ZONED )) { + ret =btrfs_wait_ordered_range ( + inode, +ALIGN (newsize, fs_info->sectorsize), + (u64)-1 ); +if (ret) +return ret; + }/* * We're truncating a file that used to have good data down to
Signature · 1 line
2.27.0
PATCH v8 30/41 btrfs: avoid async metadata checksum on ZONED mode
In reply to Naohiro AotaIn ZONED, btrfs uses per-FS zoned_meta_io_lock to serialize the metadata write IOs.
Even with these serialization, write bios sent from btree_write_cache_pages can be reordered by async checksum workers as these workers are per CPU and not per zone.
To preserve write BIO ordering, we can disable async metadata checksum on ZONED. This does not result in lower performance with HDDs as a single CPU core is fast enough to do checksum for a single zone write stream with the maximum possible bandwidth of the device. If multiple zones are being written simultaneously, HDD seek overhead lowers the achievable maximum bandwidth, resulting again in a per zone checksum serialization not affecting performance.
--- fs/btrfs/disk-io.c | 2 ++ 1 file changed, 2 insertions(+)
fs/btrfs/disk-io.c +2 -0
@@ -813,6 +813,8 @@ static blk_status_t btree_submit_bio_start(void *private_data, struct bio *bio,static int check_async_write (struct btrfs_fs_info *fs_info,struct btrfs_inode *bi) { +if (btrfs_fs_incompat (fs_info,ZONED )) +return 0 ;if (atomic_read (&bi->sync_writers))return 0 ;if (test_bit (BTRFS_FS_CSUM_IMPL_FAST , &fs_info->flags))
Signature · 1 line
2.27.0
PATCH v8 31/41 btrfs: mark block groups to copy for device-replace
In reply to Naohiro AotaThis is the 1/4 patch to support device-replace in ZONED mode.
We have two types of I/Os during the device-replace process. One is an I/O to "copy" (by the scrub functions) all the device extents on the source device to the destination device. The other one is an I/O to "clone" (by handle_ops_on_dev_replace()) new incoming write I/Os from users to the source device into the target device.
Cloning incoming I/Os can break the sequential write rule in the target device. When writing is mapped in the middle of a block group, the I/O is directed in the middle of a target device zone, which breaks the sequential write rule.
However, the cloning function cannot be merely disabled since incoming I/Os targeting already copied device extents must be cloned so that the I/O is executed on the target device.
We cannot use dev_replace->cursor_{left,right} to determine whether bio is going to not yet copied region. Since we have a time gap between finishing btrfs_scrub_dev() and rewriting the mapping tree in btrfs_dev_replace_finishing(), we can have a newly allocated device extent which is never cloned nor copied.
So the point is to copy only already existing device extents. This patch introduces mark_block_group_to_copy() to mark existing block groups as a target of copying. Then, handle_ops_on_dev_replace() and dev-replace can check the flag to do their job.
--- fs/btrfs/block-group.h | 1 + fs/btrfs/dev-replace.c | 175 +++++++++++++++++++++++++++++++++++++++++ fs/btrfs/dev-replace.h | 3 + fs/btrfs/scrub.c | 17 ++++ 4 files changed, 196 insertions(+)
fs/btrfs/block-group.h +1 -0
@@ -95,6 +95,7 @@ struct btrfs_block_group { unsigned int iref:1; unsigned int has_caching_ctl:1; unsigned int removed:1; + unsigned int to_copy:1;int disk_cache_state;
fs/btrfs/dev-replace.c +175 -0
193 lines not on this page · raw message
fs/btrfs/dev-replace.h +3 -0
@@ -18,5 +18,8 @@ int btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info);void btrfs_dev_replace_suspend_for_unmount (struct btrfs_fs_info *fs_info);int btrfs_resume_dev_replace_async (struct btrfs_fs_info *fs_info);int __pure btrfs_dev_replace_is_ongoing (struct btrfs_dev_replace *dev_replace); +bool btrfs_finish_block_group_to_copy (struct btrfs_device *srcdev, +struct btrfs_block_group *cache, +u64 physical);#endif
fs/btrfs/scrub.c +17 -0
@@ -3500,6 +3500,17 @@ int scrub_enumerate_chunks(struct scrub_ctx *sctx,if (!cache) goto skip; + +if (sctx->is_dev_replace &&btrfs_fs_incompat (fs_info,ZONED )) { +spin_lock (&cache->lock); +if (!cache->to_copy) { +spin_unlock (&cache->lock); + ro_set =0 ; + goto done; + } +spin_unlock (&cache->lock); + } +/* * Make sure that while we are scrubbing the corresponding block * group doesn't get its logical address and its device extents
@@ -3631,6 +3642,12 @@ int scrub_enumerate_chunks(struct scrub_ctx *sctx,scrub_pause_off (fs_info); +if (sctx->is_dev_replace && + !btrfs_finish_block_group_to_copy (dev_replace->srcdev, + cache, found_key.offset)) + ro_set =0 ; + +done:down_write (&dev_replace->rwsem); dev_replace->cursor_left = dev_replace->cursor_right; dev_replace->item_needs_writeback =1 ;
Signature · 1 line
2.27.0
PATCH v8 32/41 btrfs: implement cloning for ZONED device-replace
In reply to Naohiro AotaThis is 2/4 patch to implement device-replace for ZONED mode.
On zoned mode, a block group must be either copied (from the source device to the destination device) or cloned (to the both device).
This commit implements the cloning part. If a block group targeted by an IO is marked to copy, we should not clone the IO to the destination device, because the block group is eventually copied by the replace process.
This commit also handles cloning of device reset.
--- fs/btrfs/extent-tree.c | 20 ++++++++++++++++++-- fs/btrfs/volumes.c | 33 +++++++++++++++++++++++++++++++-- fs/btrfs/zoned.c | 11 +++++++++++ 3 files changed, 60 insertions(+), 4 deletions(-)
fs/btrfs/extent-tree.c +18 -2
@@ -35,6 +35,7 @@#include "discard.h" #include "rcu-string.h" #include "zoned.h" +#include "dev-replace.h" #undef SCRAMBLE_DELAYED_REFS
@@ -1336,6 +1337,8 @@ int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,u64 length = stripe->length;u64 bytes;struct request_queue *req_q; +struct btrfs_dev_replace *dev_replace = + &fs_info->dev_replace;if (!stripe->dev->bdev) {ASSERT (btrfs_test_opt (fs_info,DEGRADED ));
@@ -1344,15 +1347,28 @@ int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr, req_q =bdev_get_queue (stripe->dev->bdev);/* zone reset in ZONED mode */ -if (btrfs_can_zone_reset (dev, physical, length)) +if (btrfs_can_zone_reset (dev, physical, length)) { ret =btrfs_reset_device_zone (dev, physical, length, &bytes); -else if (blk_queue_discard (req_q)) +if (ret) + goto next; +if (!btrfs_dev_replace_is_ongoing ( + dev_replace) || + dev != dev_replace->srcdev) + goto next; + + discarded_bytes += bytes; +/* send to replace target as well */ + ret =btrfs_reset_device_zone ( + dev_replace->tgtdev, + physical, length, &bytes); + }else if (blk_queue_discard (req_q)) ret =btrfs_issue_discard (dev->bdev, physical, length, &bytes);else continue ; +next:if (!ret) { discarded_bytes += bytes; }else if (ret != -EOPNOTSUPP ) {
fs/btrfs/volumes.c +31 -2
@@ -5965,9 +5965,29 @@ static int get_extra_mirror_from_replace(struct btrfs_fs_info *fs_info,return ret; } +static bool is_block_group_to_copy (struct btrfs_fs_info *fs_info,u64 logical) +{ +struct btrfs_block_group *cache; +bool ret; + +/* non-ZONED mode does not use "to_copy" flag */ +if (!btrfs_fs_incompat (fs_info,ZONED )) +return false; + + cache =btrfs_lookup_block_group (fs_info, logical); + +spin_lock (&cache->lock); + ret = cache->to_copy; +spin_unlock (&cache->lock); + +btrfs_put_block_group (cache); +return ret; +} +static void handle_ops_on_dev_replace (enum btrfs_map_op op,struct btrfs_bio **bbio_ret,struct btrfs_dev_replace *dev_replace, +u64 logical,int *num_stripes_ret,int *max_errors_ret) {struct btrfs_bio *bbio = *bbio_ret;
@@ -5980,6 +6000,15 @@ static void handle_ops_on_dev_replace(enum btrfs_map_op op,if (op ==BTRFS_MAP_WRITE ) {int index_where_to_add; +/* +* a block group which have "to_copy" set will +* eventually copied by dev-replace process. We can +* avoid cloning IO here. +*/ +if (is_block_group_to_copy (dev_replace->srcdev->fs_info, + logical)) +return ; +/* * duplicate the write operations while the dev replace * procedure is running. Since the copying of the old disk to
@@ -6375,8 +6404,8 @@ static int __btrfs_map_block(struct btrfs_fs_info *fs_info,if (dev_replace_is_ongoing && dev_replace->tgtdev !=NULL &&need_full_stripe (op)) { -handle_ops_on_dev_replace (op, &bbio, dev_replace, &num_stripes, - &max_errors); +handle_ops_on_dev_replace (op, &bbio, dev_replace, logical, + &num_stripes, &max_errors); } *bbio_ret = bbio;
fs/btrfs/zoned.c +11 -0
@@ -17,6 +17,7 @@#include "disk-io.h" #include "block-group.h" #include "transaction.h" +#include "dev-replace.h" /* Maximum number of zones to report per blkdev_report_zones() call */ #define BTRFS_REPORT_NR_ZONES 4096
@@ -892,6 +893,8 @@ int btrfs_load_block_group_zone_info(struct btrfs_block_group *cache)for (i =0 ; i < map->num_stripes; i++) {bool is_sequential;struct blk_zone zone; +struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace; +int dev_replace_is_ongoing =0 ; device = map->stripes[i].dev; physical = map->stripes[i].physical;
@@ -918,6 +921,14 @@ int btrfs_load_block_group_zone_info(struct btrfs_block_group *cache)*/ btrfs_dev_clear_zone_empty (device, physical); +down_read (&dev_replace->rwsem); + dev_replace_is_ongoing = +btrfs_dev_replace_is_ongoing (dev_replace); +if (dev_replace_is_ongoing && dev_replace->tgtdev !=NULL ) +btrfs_dev_clear_zone_empty (dev_replace->tgtdev, + physical); +up_read (&dev_replace->rwsem); +/* * The group is mapped to a sequential zone. Get the zone write * pointer to determine the allocation offset within the zone.
Signature · 1 line
2.27.0
PATCH v8 33/41 btrfs: implement copying for ZONED device-replace
In reply to Naohiro AotaThis is 3/4 patch to implement device-replace on ZONED mode.
This commit implement copying. So, it track the write pointer during device replace process. Device-replace's copying is smart to copy only used extents on source device, we have to fill the gap to honor the sequential write rule in the target device.
Device-replace process in ZONED mode must copy or clone all the extents in the source device exactly once. So, we need to use to ensure allocations started just before the dev-replace process to have their corresponding extent information in the B-trees. finish_extent_writes_for_zoned() implements that functionality, which basically is the removed code in the commit 042528f8d840 ("Btrfs: fix block group remaining RO forever after error during device replace").
--- fs/btrfs/scrub.c | 86 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.c | 12 +++++++ fs/btrfs/zoned.h | 7 ++++ 3 files changed, 105 insertions(+)
fs/btrfs/scrub.c +86 -0
@@ -169,6 +169,7 @@ struct scrub_ctx {int pages_per_rd_bio;int is_dev_replace; +u64 write_pointer;struct scrub_bio *wr_curr_bio;struct mutex wr_lock;
@@ -1623,6 +1624,25 @@ static int scrub_write_page_to_dev_replace(struct scrub_block *sblock,return scrub_add_page_to_wr_bio (sblock->sctx, spage); } +static int fill_writer_pointer_gap (struct scrub_ctx *sctx,u64 physical) +{ +int ret =0 ; +u64 length; + +if (!btrfs_fs_incompat (sctx->fs_info,ZONED )) +return 0 ; + +if (sctx->write_pointer < physical) { + length = physical - sctx->write_pointer; + + ret =btrfs_zoned_issue_zeroout (sctx->wr_tgtdev, + sctx->write_pointer, length); +if (!ret) + sctx->write_pointer = physical; + } +return ret; +} +static int scrub_add_page_to_wr_bio (struct scrub_ctx *sctx,struct scrub_page *spage) {
@@ -1645,6 +1665,13 @@ static int scrub_add_page_to_wr_bio(struct scrub_ctx *sctx,if (sbio->page_count ==0 ) {struct bio *bio; + ret =fill_writer_pointer_gap (sctx, + spage->physical_for_dev_replace); +if (ret) { +mutex_unlock (&sctx->wr_lock); +return ret; + } + sbio->physical = spage->physical_for_dev_replace; sbio->logical = spage->logical; sbio->dev = sctx->wr_tgtdev;
@@ -1706,6 +1733,10 @@ static void scrub_wr_submit(struct scrub_ctx *sctx)* doubled the write performance on spinning disks when measured * with Linux 3.5 */ btrfsic_submit_bio (sbio->bio); + +if (btrfs_fs_incompat (sctx->fs_info,ZONED )) + sctx->write_pointer = sbio->physical + + sbio->page_count *PAGE_SIZE ; }static void scrub_wr_bio_end_io (struct bio *bio)
@@ -2973,6 +3004,21 @@ static noinline_for_stack int scrub_raid56_parity(struct scrub_ctx *sctx,return ret <0 ? ret :0 ; } +static void sync_replace_for_zoned (struct scrub_ctx *sctx) +{ +if (!btrfs_fs_incompat (sctx->fs_info,ZONED )) +return ; + + sctx->flush_all_writes = true; +scrub_submit (sctx); +mutex_lock (&sctx->wr_lock); +scrub_wr_submit (sctx); +mutex_unlock (&sctx->wr_lock); + +wait_event (sctx->list_wait, +atomic_read (&sctx->bios_in_flight) ==0 ); +} + static noinline_for_stack int scrub_stripe(struct scrub_ctx *sctx, struct map_lookup *map, struct btrfs_device *scrub_dev,
@@ -3105,6 +3151,14 @@ static noinline_for_stack int scrub_stripe(struct scrub_ctx *sctx,*/ blk_start_plug (&plug); +if (sctx->is_dev_replace && +btrfs_dev_is_sequential (sctx->wr_tgtdev, physical)) { +mutex_lock (&sctx->wr_lock); + sctx->write_pointer = physical; +mutex_unlock (&sctx->wr_lock); + sctx->flush_all_writes = true; + } +/* * now find all extents for each stripe and scrub them */
@@ -3292,6 +3346,9 @@ static noinline_for_stack int scrub_stripe(struct scrub_ctx *sctx,if (ret) goto out; +if (sctx->is_dev_replace) +sync_replace_for_zoned (sctx); +if (extent_logical + extent_len < key.objectid + bytes) {if (map->type &BTRFS_BLOCK_GROUP_RAID56_MASK ) {
@@ -3414,6 +3471,25 @@ static noinline_for_stack int scrub_chunk(struct scrub_ctx *sctx,return ret; } +static int finish_extent_writes_for_zoned (struct btrfs_root *root, +struct btrfs_block_group *cache) +{ +struct btrfs_fs_info *fs_info = cache->fs_info; +struct btrfs_trans_handle *trans; + +if (!btrfs_fs_incompat (fs_info,ZONED )) +return 0 ; + +btrfs_wait_block_group_reservations (cache); +btrfs_wait_nocow_writers (cache); +btrfs_wait_ordered_roots (fs_info,U64_MAX , cache->start, cache->length); + + trans =btrfs_join_transaction (root); +if (IS_ERR (trans)) +return PTR_ERR (trans); +return btrfs_commit_transaction (trans); +} +static noinline_for_stack int scrub_enumerate_chunks(struct scrub_ctx *sctx,struct btrfs_device *scrub_dev,u64 start,u64 end)
@@ -3569,6 +3645,16 @@ int scrub_enumerate_chunks(struct scrub_ctx *sctx,* group is not RO. */ ret =btrfs_inc_block_group_ro (cache, sctx->is_dev_replace); +if (!ret && sctx->is_dev_replace) { + ret =finish_extent_writes_for_zoned (root, cache); +if (ret) { +btrfs_dec_block_group_ro (cache); +scrub_pause_off (fs_info); +btrfs_put_block_group (cache); +break ; + } + } +if (ret ==0 ) { ro_set =1 ; }else if (ret == -ENOSPC && !sctx->is_dev_replace) {
fs/btrfs/zoned.c +12 -0
@@ -1183,3 +1183,15 @@ void btrfs_revert_meta_write_pointer(struct btrfs_block_group *cache,ASSERT (cache->meta_write_pointer == eb->start + eb->len); cache->meta_write_pointer = eb->start; } + +int btrfs_zoned_issue_zeroout (struct btrfs_device *device,u64 physical, +u64 length) +{ +if (!btrfs_dev_is_sequential (device, physical)) +return -EOPNOTSUPP ; + +return blkdev_issue_zeroout (device->bdev, + physical >>SECTOR_SHIFT , + length >>SECTOR_SHIFT , +GFP_NOFS ,0 ); +}
fs/btrfs/zoned.h +7 -0
@@ -58,6 +58,8 @@ bool btrfs_check_meta_write_pointer(struct btrfs_fs_info *fs_info, struct btrfs_block_group **cache_ret);void btrfs_revert_meta_write_pointer (struct btrfs_block_group *cache,struct extent_buffer *eb); +int btrfs_zoned_issue_zeroout (struct btrfs_device *device,u64 physical, +u64 length);#else /* CONFIG_BLK_DEV_ZONED */ static inline int btrfs_get_dev_zone (struct btrfs_device *device,u64 pos,struct blk_zone *zone)
@@ -145,6 +147,11 @@ btrfs_revert_meta_write_pointer(struct btrfs_block_group *cache, struct extent_buffer *eb) { } +static inline int btrfs_zoned_issue_zeroout (struct btrfs_device *device, +u64 physical,u64 length) +{ +return -EOPNOTSUPP ; +}#endif static inline bool btrfs_dev_is_sequential (struct btrfs_device *device,u64 pos)
Signature · 1 line
2.27.0
PATCH v8 34/41 btrfs: support dev-replace in ZONED mode
In reply to Naohiro AotaThis is 4/4 patch to implement device-replace on ZONED mode.
Even after the copying is done, the write pointers of the source device and the destination device may not be synchronized. For example, when the last allocated extent is freed before device-replace process, the extent is not copied, leaving a hole there.
This patch synchronize the write pointers by writing zeros to the destination device.
--- fs/btrfs/scrub.c | 36 +++++++++++++++++++++++++ fs/btrfs/zoned.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 8 ++++++ 3 files changed, 113 insertions(+)
fs/btrfs/scrub.c +36 -0
@@ -3019,6 +3019,31 @@ static void sync_replace_for_zoned(struct scrub_ctx *sctx) atomic_read(&sctx->bios_in_flight) == 0); } +static int sync_write_pointer_for_zoned (struct scrub_ctx *sctx,u64 logical, +u64 physical,u64 physical_end) +{ +struct btrfs_fs_info *fs_info = sctx->fs_info; +int ret =0 ; + +if (!btrfs_fs_incompat (fs_info,ZONED )) +return 0 ; + +wait_event (sctx->list_wait,atomic_read (&sctx->bios_in_flight) ==0 ); + +mutex_lock (&sctx->wr_lock); +if (sctx->write_pointer < physical_end) { + ret =btrfs_sync_zone_write_pointer (sctx->wr_tgtdev, logical, + physical, + sctx->write_pointer); +if (ret) +btrfs_err (fs_info,"failed to recover write pointer" ); + } +mutex_unlock (&sctx->wr_lock); +btrfs_dev_clear_zone_empty (sctx->wr_tgtdev, physical); + +return ret; +} + static noinline_for_stack int scrub_stripe(struct scrub_ctx *sctx, struct map_lookup *map, struct btrfs_device *scrub_dev,
@@ -3416,6 +3441,17 @@ static noinline_for_stack int scrub_stripe(struct scrub_ctx *sctx,blk_finish_plug (&plug);btrfs_free_path (path);btrfs_free_path (ppath); + +if (sctx->is_dev_replace && ret >=0 ) { +int ret2; + + ret2 =sync_write_pointer_for_zoned (sctx, base + offset, + map->stripes[num].physical, + physical_end); +if (ret2) + ret = ret2; + } +return ret <0 ? ret :0 ; }
fs/btrfs/zoned.c +69 -0
78 lines not on this page · raw message
fs/btrfs/zoned.h +8 -0
@@ -60,6 +60,8 @@ void btrfs_revert_meta_write_pointer(struct btrfs_block_group *cache, struct extent_buffer *eb);int btrfs_zoned_issue_zeroout (struct btrfs_device *device,u64 physical,u64 length); +int btrfs_sync_zone_write_pointer (struct btrfs_device *tgt_dev,u64 logical, +u64 physical_start,u64 physical_pos);#else /* CONFIG_BLK_DEV_ZONED */ static inline int btrfs_get_dev_zone (struct btrfs_device *device,u64 pos,struct blk_zone *zone)
@@ -152,6 +154,12 @@ static inline int btrfs_zoned_issue_zeroout(struct btrfs_device *device, {return -EOPNOTSUPP ; } +static inline int btrfs_sync_zone_write_pointer (struct btrfs_device *tgt_dev, +u64 logical,u64 physical_start, +u64 physical_pos) +{ +return -EOPNOTSUPP ; +}#endif static inline bool btrfs_dev_is_sequential (struct btrfs_device *device,u64 pos)
Signature · 1 line
2.27.0
PATCH v8 35/41 btrfs: enable relocation in ZONED mode
In reply to Naohiro AotaTo serialize allocation and submit_bio, we introduced mutex around them. As a result, preallocation must be completely disabled to avoid a deadlock.
Since current relocation process relies on preallocation to move file data extents, it must be handled in another way. In ZONED mode, we just truncate the inode to the size that we wanted to pre-allocate. Then, we flush dirty pages on the file before finishing relocation process. run_delalloc_zoned() will handle all the allocation and submit IOs to the underlying layers.
--- fs/btrfs/relocation.c | 35 +++++++++++++++++++++++++++++++++-- 1 file changed, 33 insertions(+), 2 deletions(-)
fs/btrfs/relocation.c +33 -2
@@ -2603,6 +2603,32 @@ static noinline_for_stack int prealloc_file_extent_cluster(if (ret)return ret; +/* +* In ZONED mode, we cannot preallocate the file region. Instead, we +* dirty and fiemap_write the region. +*/ + +if (btrfs_fs_incompat (inode->root->fs_info,ZONED )) { +struct btrfs_root *root = inode->root; +struct btrfs_trans_handle *trans; + + end = cluster->end - offset +1 ; + trans =btrfs_start_transaction (root,1 ); +if (IS_ERR (trans)) +return PTR_ERR (trans); + + inode->vfs_inode.i_ctime =current_time (&inode->vfs_inode); +i_size_write (&inode->vfs_inode, end); + ret =btrfs_update_inode (trans, root, &inode->vfs_inode); +if (ret) { +btrfs_abort_transaction (trans, ret); +btrfs_end_transaction (trans); +return ret; + } + +return btrfs_end_transaction (trans); + } +inode_lock (&inode->vfs_inode);for (nr =0 ; nr < cluster->nr; nr++) { start = cluster->boundary[nr] - offset;
@@ -2799,6 +2825,8 @@ static int relocate_file_extent_cluster(struct inode *inode, } }WARN_ON (nr != cluster->nr); +if (btrfs_fs_incompat (fs_info,ZONED ) && !ret) + ret =btrfs_wait_ordered_range (inode,0 , (u64)-1 ); out:kfree (ra);return ret;
@@ -3434,8 +3462,12 @@ static int __insert_orphan_inode(struct btrfs_trans_handle *trans,struct btrfs_path *path;struct btrfs_inode_item *item;struct extent_buffer *leaf; +u64 flags =BTRFS_INODE_NOCOMPRESS |BTRFS_INODE_PREALLOC ;int ret; +if (btrfs_fs_incompat (trans->fs_info,ZONED )) + flags &= ~BTRFS_INODE_PREALLOC ; + path =btrfs_alloc_path ();if (!path)return -ENOMEM ;
@@ -3450,8 +3482,7 @@ static int __insert_orphan_inode(struct btrfs_trans_handle *trans,btrfs_set_inode_generation (leaf, item,1 );btrfs_set_inode_size (leaf, item,0 );btrfs_set_inode_mode (leaf, item,S_IFREG |0600 ); -btrfs_set_inode_flags (leaf, item,BTRFS_INODE_NOCOMPRESS | -BTRFS_INODE_PREALLOC ); +btrfs_set_inode_flags (leaf, item, flags);btrfs_mark_buffer_dirty (leaf); out:btrfs_free_path (path);
Signature · 1 line
2.27.0
PATCH v8 36/41 btrfs: relocate block group to repair IO failure in ZONED
In reply to Naohiro AotaWhen btrfs find a checksum error and if the file system has a mirror of the damaged data, btrfs read the correct data from the mirror and write the data to damaged blocks. This repairing, however, is against the sequential write required rule.
We can consider three methods to repair an IO failure in ZONED mode:
(1) Reset and rewrite the damaged zone
(2) Allocate new device extent and replace the damaged device extent to the new extent
(3) Relocate the corresponding block group
Method (1) is most similar to a behavior done with regular devices. However, it also wipes non-damaged data in the same device extent, and so it unnecessary degrades non-damaged data.
Method (2) is much like device replacing but done in the same device. It is safe because it keeps the device extent until the replacing finish. However, extending device replacing is non-trivial. It assumes "src_dev->physical == dst_dev->physical". Also, the extent mapping replacing function should be extended to support replacing device extent position in one device.
Method (3) invokes relocation of the damaged block group, so it is straightforward to implement. It relocates all the mirrored device extents, so it is, potentially, a more costly operation than method (1) or (2). But it relocates only using extents which reduce the total IO size.
Let's apply method (3) for now. In the future, we can extend device-replace and apply method (2).
For protecting a block group gets relocated multiple time with multiple IO errors, this commit introduces "relocating_repair" bit to show it's now relocating to repair IO failures. Also it uses a new kthread "btrfs-relocating-repair", not to block IO path with relocating process.
This commit also supports repairing in the scrub process.
--- fs/btrfs/block-group.h | 1 + fs/btrfs/extent_io.c | 3 ++ fs/btrfs/scrub.c | 3 ++ fs/btrfs/volumes.c | 71 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/volumes.h | 1 + 5 files changed, 79 insertions(+)
fs/btrfs/block-group.h +1 -0
@@ -96,6 +96,7 @@ struct btrfs_block_group { unsigned int has_caching_ctl:1; unsigned int removed:1; unsigned int to_copy:1; + unsigned int relocating_repair:1;int disk_cache_state;
fs/btrfs/extent_io.c +3 -0
@@ -2268,6 +2268,9 @@ int repair_io_failure(struct btrfs_fs_info *fs_info, u64 ino, u64 start,ASSERT (!(fs_info->sb->s_flags &SB_RDONLY ));BUG_ON (!mirror_num); +if (btrfs_fs_incompat (fs_info,ZONED )) +return btrfs_repair_one_zone (fs_info, logical); + bio =btrfs_io_bio_alloc (1 ); bio->bi_iter.bi_size =0 ; map_length = length;
fs/btrfs/scrub.c +3 -0
@@ -861,6 +861,9 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check) have_csum = sblock_to_check->pagev[0 ]->have_csum; dev = sblock_to_check->pagev[0 ]->dev; +if (btrfs_fs_incompat (fs_info,ZONED ) && !sctx->is_dev_replace) +return btrfs_repair_one_zone (fs_info, logical); +/* * We must use GFP_NOFS because the scrub task might be waiting for a * worker task executing this function and in turn a transaction commit
fs/btrfs/volumes.c +71 -0
74 lines not on this page · raw message
fs/btrfs/volumes.h +1 -0
@@ -584,5 +584,6 @@ void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info,int btrfs_bg_type_to_factor (u64 flags);const char *btrfs_bg_type_to_raid_name (u64 flags);int btrfs_verify_dev_extents (struct btrfs_fs_info *fs_info); +int btrfs_repair_one_zone (struct btrfs_fs_info *fs_info,u64 logical);#endif
Signature · 1 line
2.27.0
PATCH v8 37/41 btrfs: split alloc_log_tree()
In reply to Naohiro AotaThis is a preparation for the next patch. This commit split alloc_log_tree() to allocating tree structure part (remains in alloc_log_tree()) and allocating tree node part (moved in btrfs_alloc_log_tree_node()). The latter part is also exported to be used in the next patch.
--- fs/btrfs/disk-io.c | 27 ++++++++++++++++++++++++--- fs/btrfs/disk-io.h | 2 ++ 2 files changed, 26 insertions(+), 3 deletions(-)
fs/btrfs/disk-io.c +24 -3
@@ -1211,7 +1211,6 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans, struct btrfs_fs_info *fs_info) {struct btrfs_root *root; -struct extent_buffer *leaf; root =btrfs_alloc_root (fs_info,BTRFS_TREE_LOG_OBJECTID ,GFP_NOFS );if (!root)
@@ -1221,6 +1220,14 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans, root->root_key.type =BTRFS_ROOT_ITEM_KEY ; root->root_key.offset =BTRFS_TREE_LOG_OBJECTID ; +return root; +} + +int btrfs_alloc_log_tree_node (struct btrfs_trans_handle *trans, +struct btrfs_root *root) +{ +struct extent_buffer *leaf; +/* * DON'T set SHAREABLE bit for log trees. *
@@ -1235,24 +1242,31 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans, NULL, 0, 0, 0, BTRFS_NESTING_NORMAL);if (IS_ERR (leaf)) {btrfs_put_root (root); -return ERR_CAST (leaf); +return PTR_ERR (leaf); } root->node = leaf;btrfs_mark_buffer_dirty (root->node);btrfs_tree_unlock (root->node); -return root; + +return 0 ; }int btrfs_init_log_root_tree (struct btrfs_trans_handle *trans,struct btrfs_fs_info *fs_info) {struct btrfs_root *log_root; +int ret; log_root =alloc_log_tree (trans, fs_info);if (IS_ERR (log_root))return PTR_ERR (log_root); + ret =btrfs_alloc_log_tree_node (trans, log_root); +if (ret) { +kfree (log_root); +return ret; + }WARN_ON (fs_info->log_root_tree); fs_info->log_root_tree = log_root;return 0 ;
@@ -1264,11 +1278,18 @@ int btrfs_add_log_tree(struct btrfs_trans_handle *trans,struct btrfs_fs_info *fs_info = root->fs_info;struct btrfs_root *log_root;struct btrfs_inode_item *inode_item; +int ret; log_root =alloc_log_tree (trans, fs_info);if (IS_ERR (log_root))return PTR_ERR (log_root); + ret =btrfs_alloc_log_tree_node (trans, log_root); +if (ret) { +kfree (log_root); +return ret; + } + log_root->last_trans = trans->transid; log_root->root_key.offset = root->root_key.objectid;
fs/btrfs/disk-io.h +2 -0
@@ -115,6 +115,8 @@ blk_status_t btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct bio *bio, extent_submit_bio_start_t *submit_bio_start);blk_status_t btrfs_submit_bio_done (void *private_data,struct bio *bio,int mirror_num); +int btrfs_alloc_log_tree_node (struct btrfs_trans_handle *trans, +struct btrfs_root *root);int btrfs_init_log_root_tree (struct btrfs_trans_handle *trans,struct btrfs_fs_info *fs_info); int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
Signature · 1 line
2.27.0
PATCH v8 38/41 btrfs: extend zoned allocator to use dedicated tree-log block group
In reply to Naohiro AotaThis is the 1/3 patch to enable tree log on ZONED mode.
The tree-log feature does not work on ZONED mode as is. Blocks for a tree-log tree are allocated mixed with other metadata blocks, and btrfs writes and syncs the tree-log blocks to devices at the time of fsync(), which is different timing from a global transaction commit. As a result, both writing tree-log blocks and writing other metadata blocks become non-sequential writes that ZONED mode must avoid.
We can introduce a dedicated block group for tree-log blocks so that tree-log blocks and other metadata blocks can be separated write streams. As a result, each write stream can now be written to devices separately. "fs_info->treelog_bg" tracks the dedicated block group and btrfs assign "treelog_bg" on-demand on tree-log block allocation time.
This commit extends the zoned block allocator to use the block group.
--- fs/btrfs/block-group.c | 7 +++++ fs/btrfs/ctree.h | 2 ++ fs/btrfs/extent-tree.c | 65 ++++++++++++++++++++++++++++++++++++++---- 3 files changed, 69 insertions(+), 5 deletions(-)
fs/btrfs/block-group.c +7 -0
@@ -939,6 +939,13 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,btrfs_return_cluster_to_free_space (block_group, cluster);spin_unlock (&cluster->refill_lock); +if (btrfs_fs_incompat (fs_info,ZONED )) { +spin_lock (&fs_info->treelog_bg_lock); +if (fs_info->treelog_bg == block_group->start) + fs_info->treelog_bg =0 ; +spin_unlock (&fs_info->treelog_bg_lock); + } + path =btrfs_alloc_path ();if (!path) { ret = -ENOMEM ;
fs/btrfs/ctree.h +2 -0
@@ -954,6 +954,8 @@ struct btrfs_fs_info {unsigned long exclusive_operation;struct mutex zoned_meta_io_lock; +spinlock_t treelog_bg_lock; +u64 treelog_bg;#ifdef CONFIG_BTRFS_FS_REF_VERIFY spinlock_t ref_verify_lock;
fs/btrfs/extent-tree.c +60 -5
146 lines not on this page · raw message
Signature · 1 line
2.27.0
Re: [PATCH v8 38/41] btrfs: extend zoned allocator to use dedicated tree-log block group
fs/btrfs/extent-tree.c struct find_free_extent_ctl { · line 3661
Quoted 9 lines · Naohiro Aota
fs/btrfs/extent-tree.c +3
-0@@ -3656,6 +3656,9 @@ struct find_free_extent_ctl {/* Allocation policy */ enum btrfs_extent_allocation_policy policy; + +/* Allocation is called for tree-log */ +bool for_treelog;
There are already bool flags in find_free_extent_ctl, move it after orig_have_caching_bg.
Re: [PATCH v8 38/41] btrfs: extend zoned allocator to use dedicated tree-log block group
Quoted 5 lines · David Sterba
Quoted 4 lines · Naohiro Aota
fs/btrfs/extent-tree.c +0
-0@@ -3656,6 +3656,9 @@ struct find_free_extent_ctl {
Quoted 9 lines
fs/btrfs/extent-tree.c struct find_free_extent_ctl { · line 3661
Quoted 5 lines
fs/btrfs/extent-tree.c +3
-0/* Allocation policy */ enum btrfs_extent_allocation_policy policy; + +/* Allocation is called for tree-log */ +bool for_treelog;There are already bool flags in
find_free_extent_ctl, move it afterorig_have_caching_bg.
Fixed
PATCH v8 39/41 btrfs: serialize log transaction on ZONED mode
In reply to Naohiro AotaThis is the 2/3 patch to enable tree-log on ZONED mode.
Since we can start more than one log transactions per subvolume simultaneously, nodes from multiple transactions can be allocated interleaved. Such mixed allocation results in non-sequential writes at the time of log transaction commit. The nodes of the global log root tree (fs_info->log_root_tree), also have the same mixed allocation problem.
This patch serializes log transactions by waiting for a committing transaction when someone tries to start a new transaction, to avoid the mixed allocation problem. We must also wait for running log transactions from another subvolume, but there is no easy way to detect which subvolume root is running a log transaction. So, this patch forbids starting a new log transaction when other subvolumes already allocated the global log root tree.
--- fs/btrfs/tree-log.c | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-)
fs/btrfs/tree-log.c +24 -1
@@ -106,6 +106,7 @@ static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,struct btrfs_root *log, struct btrfs_path *path, u64 dirid, int del_all); +static void wait_log_commit (struct btrfs_root *root,int transid);/* * tree logging is a special write ahead log used to make sure that
@@ -140,16 +141,25 @@ static int start_log_trans(struct btrfs_trans_handle *trans, struct btrfs_log_ctx *ctx) {struct btrfs_fs_info *fs_info = root->fs_info; +bool zoned =btrfs_fs_incompat (fs_info,ZONED );int ret =0 ;mutex_lock (&root->log_mutex); +again:if (root->log_root) { +int index = (root->log_transid +1 ) %2 ; +if (btrfs_need_log_full_commit (trans)) { ret = -EAGAIN ; goto out; } +if (zoned &&atomic_read (&root->log_commit[index])) { +wait_log_commit (root, root->log_transid -1 ); + goto again; + } +if (!root->log_start_pid) {clear_bit (BTRFS_ROOT_MULTI_LOG_TASKS , &root->state); root->log_start_pid = current->pid;
@@ -158,8 +168,13 @@ static int start_log_trans(struct btrfs_trans_handle *trans, } }else {mutex_lock (&fs_info->tree_log_mutex); -if (!fs_info->log_root_tree) +if (zoned && fs_info->log_root_tree) { + ret = -EAGAIN ; +mutex_unlock (&fs_info->tree_log_mutex); + goto out; + }else if (!fs_info->log_root_tree) { ret =btrfs_init_log_root_tree (trans, fs_info); + }mutex_unlock (&fs_info->tree_log_mutex);if (ret) goto out;
@@ -193,14 +208,22 @@ static int start_log_trans(struct btrfs_trans_handle *trans,*/ static int join_running_log_trans (struct btrfs_root *root) { +bool zoned =btrfs_fs_incompat (root->fs_info,ZONED );int ret = -ENOENT ;if (!test_bit (BTRFS_ROOT_HAS_LOG_TREE , &root->state))return ret;mutex_lock (&root->log_mutex); +again:if (root->log_root) { +int index = (root->log_transid +1 ) %2 ; + ret =0 ; +if (zoned &&atomic_read (&root->log_commit[index])) { +wait_log_commit (root, root->log_transid -1 ); + goto again; + }atomic_inc (&root->log_writers); }mutex_unlock (&root->log_mutex);
Signature · 1 line
2.27.0
PATCH v8 40/41 btrfs: reorder log node allocation
In reply to Naohiro AotaThis is the 3/3 patch to enable tree-log on ZONED mode.
The allocation order of nodes of "fs_info->log_root_tree" and nodes of "root->log_root" is not the same as the writing order of them. So, the writing causes unaligned write errors.
This patch reorders the allocation of them by delaying allocation of the root node of "fs_info->log_root_tree," so that the node buffers can go out sequentially to devices.
--- fs/btrfs/disk-io.c | 6 ------ fs/btrfs/tree-log.c | 19 +++++++++++++------ 2 files changed, 13 insertions(+), 12 deletions(-)
fs/btrfs/disk-io.c +0 -6
@@ -1257,16 +1257,10 @@ int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans, struct btrfs_fs_info *fs_info) {struct btrfs_root *log_root; -int ret; log_root =alloc_log_tree (trans, fs_info);if (IS_ERR (log_root))return PTR_ERR (log_root); - ret =btrfs_alloc_log_tree_node (trans, log_root); -if (ret) { -kfree (log_root); -return ret; - }WARN_ON (fs_info->log_root_tree); fs_info->log_root_tree = log_root;return 0 ;
fs/btrfs/tree-log.c +13 -6
@@ -3143,6 +3143,11 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,list_add_tail (&root_log_ctx.list, &log_root_tree->log_ctxs[index2]); root_log_ctx.log_transid = log_root_tree->log_transid; +mutex_lock (&fs_info->tree_log_mutex); +if (!log_root_tree->node) +btrfs_alloc_log_tree_node (trans, log_root_tree); +mutex_unlock (&fs_info->tree_log_mutex); +/* * Now we are safe to update the log_root_tree because we're under the * log_mutex, and we're a current writer so we're holding the commit
@@ -3292,12 +3297,14 @@ static void free_log_tree(struct btrfs_trans_handle *trans, .process_func = process_one_buffer }; - ret =walk_log_tree (trans, log, &wc); -if (ret) { -if (trans) -btrfs_abort_transaction (trans, ret); -else -btrfs_handle_fs_error (log->fs_info, ret,NULL ); +if (log->node) { + ret =walk_log_tree (trans, log, &wc); +if (ret) { +if (trans) +btrfs_abort_transaction (trans, ret); +else +btrfs_handle_fs_error (log->fs_info, ret,NULL ); + } } clear_extent_bits(&log->dirty_log_pages, 0, (u64)-1,
Signature · 1 line
2.27.0
PATCH v8 41/41 btrfs: enable to mount ZONED incompat flag
In reply to Naohiro AotaThis final patch adds the ZONED incompat flag to BTRFS_FEATURE_INCOMPAT_SUPP and enables btrfs to mount ZONED flagged file system.
--- fs/btrfs/ctree.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/btrfs/ctree.h +2 -1
@@ -302,7 +302,8 @@ struct btrfs_super_block {BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA | \BTRFS_FEATURE_INCOMPAT_NO_HOLES | \BTRFS_FEATURE_INCOMPAT_METADATA_UUID | \ - BTRFS_FEATURE_INCOMPAT_RAID1C34) +BTRFS_FEATURE_INCOMPAT_RAID1C34 | \ + BTRFS_FEATURE_INCOMPAT_ZONED) #define BTRFS_FEATURE_INCOMPAT_SAFE_SET \ (BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF )
Signature · 1 line
2.27.0
Re: [PATCH v8 01/41] block: add bio_add_zone_append_page
In reply to Naohiro AotaNaohiro/Johannes,
Quoted 3 lines
Add
bio_add_zone_append_page(), a wrapper aroundbio_add_hw_page()which is intended to be used by file systems that directly add pages to a bio instead of usingbio_iov_iter_get_pages().
Why use the hardware limit? For filesystem I/O we generally use the queue soft limit to prevent I/Os getting too big which can lead to very unpredictable latency in mixed workloads.
max_zone_append_sectors also appears to be gated exclusively by hardware constraints. Is there user-controllable limit in place for append operations?
Signature · 1 line
Martin K. Petersen Oracle Linux Engineering
Re: [PATCH v8 01/41] block: add bio_add_zone_append_page
Quoted 10 lines · Martin K. Petersen
Naohiro/Johannes,
Quoted 3 lines
Add
bio_add_zone_append_page(), a wrapper aroundbio_add_hw_page()which is intended to be used by file systems that directly add pages to a bio instead of usingbio_iov_iter_get_pages().Why use the hardware limit? For filesystem I/O we generally use the queue soft limit to prevent I/Os getting too big which can lead to very unpredictable latency in mixed workloads.
max_zone_append_sectors is already gated by max_hw_sectors, but it is not gated by max_sectors/BLK_DEF_MAX_SECTORS. If we add such gating to blk_queue_max_zone_append_sectors(), max_zone_append_sectors would become a soft limit too. So should we have max_zone_append_sectors and max_hw_zone_append_sectors ?
Which also means that we should tweak queue_max_sectors_store() to gate max_zone_append_sectors to that limit upon a user change.
Quoted 4 lines
max_zone_append_sectorsalso appears to be gated exclusively by hardware constraints. Is there user-controllable limit in place for append operations?
No, none that I know of. At the HW level, max_zone_append_sectors is basically max_hw_sectors. That is gated by the zone size in blk_queue_max_zone_append_sectors(). If as mentioned above we tweak queue_max_sectors_store() to change max_zone_append_sectors too if needed, we would then have an indirect user-controllable limit. Or we could implement a queue_zone_append_max_store() too I guess. Yet, having everything indirectly controlled through queue_max_sectors_store() is probably simpler I think.
Signature · 2 lines
Damien Le Moal Western Digital Research
Re: [PATCH v8 01/41] block: add bio_add_zone_append_page
In reply to Martin K. PetersenQuoted 7 lines · Martin K. Petersen
Naohiro/Johannes,
Quoted 3 lines
Add
bio_add_zone_append_page(), a wrapper aroundbio_add_hw_page()which is intended to be used by file systems that directly add pages to a bio instead of usingbio_iov_iter_get_pages().
Quoted 7 lines
Why use the hardware limit? For filesystem I/O we generally use the queue soft limit to prevent I/Os getting too big which can lead to very unpredictable latency in mixed workloads.
max_zone_append_sectorsalso appears to be gated exclusively by hardware constraints. Is there user-controllable limit in place for append operations?
Zone Append operations can't be split, as they return the first written LBA to the caller. If you'd split it you'd now need to return multiple start LBA values.
Re: [PATCH v8 01/41] block: add bio_add_zone_append_page
Christoph,
Quoted 7 lines
Quoted 3 lines
max_zone_append_sectorsalso appears to be gated exclusively by hardware constraints. Is there user-controllable limit in place for append operations?Zone Append operations can't be split, as they return the first written LBA to the caller. If you'd split it you'd now need to return multiple start LBA values.
Yep, this limit would have to be enforced at the top.
Anyway, not sure how important this is given modern drives. I just know that for our workloads the soft limit is something we almost always end up tweaking.
Signature · 1 line
Martin K. Petersen Oracle Linux Engineering
Re: [PATCH v8 01/41] block: add bio_add_zone_append_page
Quoted 11 lines · Martin K. Petersen
Christoph,
Quoted 7 lines
Quoted 3 lines
max_zone_append_sectorsalso appears to be gated exclusively by hardware constraints. Is there user-controllable limit in place for append operations?Zone Append operations can't be split, as they return the first written LBA to the caller. If you'd split it you'd now need to return multiple start LBA values.
Quoted 5 lines
Yep, this limit would have to be enforced at the top.
Anyway, not sure how important this is given modern drives. I just know that for our workloads the soft limit is something we almost always end up tweaking.
We can fix the max_zone_append_sectors limit independently of this btrfs series. Right now, this attribute represents the hardware limit but we can easily rename it to max_hw_zone_append_sectors and define a soft max_zone_append_sectors which would be min(max_sectors, max_hw_zone_append_sectors). That will result in similar soft limit control as for regular writes & max_sectors/max_hw_sectors.
Signature · 2 lines
Damien Le Moal Western Digital Research
Quoted 12 lines · Naohiro Aota
This series adds zoned block device support to btrfs.
Changes from v7:
- Usebio_add_hw_page()to build up bio to honor hardware restrictions
- addbio_add_zone_append_page()as a wrapper of the function
- Split file extent on submitting bio
- Ifbio_add_zone_append_page()fails, split the file extent and send out bio
- so, we can ensure one bio == one file extent
- Fix build bot issues
- Rebased on misc-next
This is too big of a patch series for it to not conflict with some change to misc-next after a few days. I finally sat down to run this through xfstests locally and I couldn't get the patches to apply cleanly. Could you push this to a git branch publicly somewhere so I can just pull from that branch to do the xfstests testing I want to do while I'm reviewing it? Thanks,
Josef
Quoted 14 lines · Josef Bacik
Quoted 12 lines · Naohiro Aota
This series adds zoned block device support to btrfs.
Changes from v7:
- Usebio_add_hw_page()to build up bio to honor hardware restrictions
- addbio_add_zone_append_page()as a wrapper of the function
- Split file extent on submitting bio
- Ifbio_add_zone_append_page()fails, split the file extent and send out bio
- so, we can ensure one bio == one file extent
- Fix build bot issues
- Rebased on misc-next
Quoted 3 lines
This is too big of a patch series for it to not conflict with some change to misc-next after a few days. I finally sat down to run this through xfstests locally and I couldn't get the patches to apply cleanly. Could you push this to a git branch publicly somewhere so I can just pull from that branch to do the xfstests testing I want to do while I'm reviewing it? Thanks,
Josef
Indeed. I pushed zoned btrfs kernel & userland tools to the branches below.
I also prepared pre-compiled userland binaries because they require patched util-linux (libblkid) to deal with the log-structured superblock.
kernel https://github.com/naota/linux/tree/btrfs-zoned
userland https://github.com/naota/btrfs-progs/tree/btrfs-zoned
pre-compiled userland https://wdc.app.box.com/s/fnhqsb3otrvgkstq66o6bvdw6tk525kp
Thanks,
Naohiro