f2fs: zns zone-capacity support
Subsystems (3)
v3 cover f2fs: zns zone-capacity support
NVM Express Zoned Namespace command set specification allows host software to communicate with a NVM subsystem using zones. ZNS defines a host-managed zoned block device model for NVMe devices. It divides the logical address space of a namespace into zones. Each zone provides a LBA range that shall be written sequentially. An explicit reset of zone is needed to write to the zone again.
ZNS defines a per-zone capacity which can be equal or less than the zone-size. Zone-capacity is the number of usable blocks in the zone. This patchset implements support for ZNS devices with a zone-capacity that is less that the device zone-size.
This patch checks if zone-capacity is less than zone-size, if it is, then any segment which starts after the zone-capacity is marked as not-free in the free segment bitmap at initial mount time. These segments are marked as permanently used so they are not allocated for writes and consequently not needed to be garbage collected. In case the zone-capacity is not aligned to default segment size(2MB), then a segment can start before the zone-capacity and span across zone-capacity boundary. Such spanning segments are also considered as usable segments. It tracks the usable blocks in a spanning segment, so that during writes and GC, usable blocks in spanning segment is calculated to ensure writes/reads do not cross the zone-capacity boundary.
This patch is based on the git treegit://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git branch dev and requires the below patch in order to build.
https://lore.kernel.org/linux-nvme/[email protected]/T/#m19e0197ae1837b7fe959b13fbc2a859b1f2abc1e
The above patch has been merged to the nvme-5.9 branch in the git tree:git://git.infradead.org/nvme.git
Aravind Ramesh (1):
f2fs: support zone capacity less than zone size
Documentation/filesystems/f2fs.rst | 15 +++ fs/f2fs/f2fs.h | 5 + fs/f2fs/gc.c | 25 +++-- fs/f2fs/gc.h | 44 +++++++- fs/f2fs/segment.c | 156 ++++++++++++++++++++++++++--- fs/f2fs/segment.h | 26 +++-- fs/f2fs/super.c | 41 ++++++-- 7 files changed, 275 insertions(+), 37 deletions(-)
Signature · 1 line
2.19.1
PATCH v3 1/1 f2fs: support zone capacity less than zone size
NVMe Zoned Namespace devices can have zone-capacity less than zone-size. Zone-capacity indicates the maximum number of sectors that are usable in a zone beginning from the first sector of the zone. This makes the sectors sectors after the zone-capacity till zone-size to be unusable. This patch set tracks zone-size and zone-capacity in zoned devices and calculate the usable blocks per segment and usable segments per section.
If zone-capacity is less than zone-size mark only those segments which start before zone-capacity as free segments. All segments at and beyond zone-capacity are treated as permanently used segments. In cases where zone-capacity does not align with segment size the last segment will start before zone-capacity and end beyond the zone-capacity of the zone. For such spanning segments only sectors within the zone-capacity are used.
During writes and GC manage the usable segments in a section and usable blocks per segment. Segments which are beyond zone-capacity are never allocated, and do not need to be garbage collected, only the segments which are before zone-capacity needs to garbage collected. For spanning segments based on the number of usable blocks in that segment, write to blocks only up to zone-capacity.
Zone-capacity is device specific and cannot be configured by the user. Since NVMe ZNS device zones are sequentially write only, a block device with conventional zones or any normal block device is needed along with the ZNS device for the metadata operations of F2fs.
A typical nvme-cli output of a zoned device shows zone start and capacity and write pointer as below:
SLBA: 0x0 WP: 0x0 Cap: 0x18800 State: EMPTY Type: SEQWRITE_REQ
SLBA: 0x20000 WP: 0x20000 Cap: 0x18800 State: EMPTY Type: SEQWRITE_REQ
SLBA: 0x40000 WP: 0x40000 Cap: 0x18800 State: EMPTY Type: SEQWRITE_REQ
Here zone size is 64MB, capacity is 49MB, WP is at zone start as the zones are in EMPTY state. For each zone, only zone start + 49MB is usable area, any lba/sector after 49MB cannot be read or written to, the drive will fail any attempts to read/write. So, the second zone starts at 64MB and is usable till 113MB (64 + 49) and the range between 113 and 128MB is again unusable. The next zone starts at 128MB, and so on.
--- Documentation/filesystems/f2fs.rst | 15 +++ fs/f2fs/f2fs.h | 5 + fs/f2fs/gc.c | 25 +++-- fs/f2fs/gc.h | 44 +++++++- fs/f2fs/segment.c | 156 ++++++++++++++++++++++++++--- fs/f2fs/segment.h | 26 +++-- fs/f2fs/super.c | 41 ++++++-- 7 files changed, 275 insertions(+), 37 deletions(-)
Documentation/filesystems/f2fs.rst +15 -0
@@ -766,3 +766,18 @@ Compress metadata layout:: +-------------+-------------+----------+----------------------------+ | data length | data chksum | reserved | compressed data | +-------------+-------------+----------+----------------------------+ + +NVMe Zoned Namespace devices +---------------------------- + +- ZNS defines a per-zone capacity which can be equal or less than the + zone-size. Zone-capacity is the number of usable blocks in the zone. + F2fs checks if zone-capacity is less than zone-size, if it is, then any + segment which starts after the zone-capacity is marked as not-free in + the free segment bitmap at initial mount time. These segments are marked + as permanently used so they are not allocated for writes and + consequently are not needed to be garbage collected. In case the + zone-capacity is not aligned to default segment size(2MB), then a segment + can start before the zone-capacity and span across zone-capacity boundary. + Such spanning segments are also considered as usable segments. All blocks + past the zone-capacity are considered unusable in these segments.
fs/f2fs/f2fs.h +5 -0
@@ -1232,6 +1232,7 @@ struct f2fs_dev_info {#ifdef CONFIG_BLK_DEV_ZONED unsigned int nr_blkz;/* Total number of zones */ unsigned long *blkz_seq;/* Bitmap indicating sequential zones */ +block_t *zone_capacity_blocks;/* Array of zone capacity in blks */ #endif };
@@ -3395,6 +3396,10 @@ void f2fs_destroy_segment_manager_caches(void);int f2fs_rw_hint_to_seg_type (enum rw_hint hint);enum rw_hint f2fs_io_type_to_rw_hint (struct f2fs_sb_info *sbi,enum page_type type,enum temp_type temp); +unsigned int f2fs_usable_segs_in_sec (struct f2fs_sb_info *sbi, +unsigned int segno); +unsigned int f2fs_usable_blks_in_seg (struct f2fs_sb_info *sbi, +unsigned int segno);/* * checkpoint.c
fs/f2fs/gc.c +19 -6
@@ -266,13 +266,14 @@ static unsigned int get_cb_cost(struct f2fs_sb_info *sbi, unsigned int segno)unsigned char age =0 ;unsigned char u;unsigned int i; +unsigned int usable_segs_per_sec =f2fs_usable_segs_in_sec (sbi, segno); -for (i =0 ; i < sbi->segs_per_sec; i++) +for (i =0 ; i < usable_segs_per_sec; i++) mtime +=get_seg_entry (sbi, start + i)->mtime; vblocks =get_valid_blocks (sbi, segno, true); - mtime =div_u64 (mtime, sbi->segs_per_sec); - vblocks =div_u64 (vblocks, sbi->segs_per_sec); + mtime =div_u64 (mtime, usable_segs_per_sec); + vblocks =div_u64 (vblocks, usable_segs_per_sec); u = (vblocks *100 ) >> sbi->log_blocks_per_seg;
@@ -536,6 +537,7 @@ static int gc_node_segment(struct f2fs_sb_info *sbi,int phase =0 ;bool fggc = (gc_type ==FG_GC );int submitted =0 ; +unsigned int usable_blks_in_seg =f2fs_usable_blks_in_seg (sbi, segno); start_addr =START_BLOCK (sbi, segno);
@@ -545,7 +547,7 @@ static int gc_node_segment(struct f2fs_sb_info *sbi,if (fggc && phase ==2 )atomic_inc (&sbi->wb_sync_req[NODE ]); -for (off =0 ; off < sbi->blocks_per_seg; off++, entry++) { +for (off =0 ; off < usable_blks_in_seg; off++, entry++) {nid_t nid =le32_to_cpu (entry->nid);struct page *node_page;struct node_info ni;
@@ -1033,13 +1035,14 @@ static int gc_data_segment(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,int off;int phase =0 ;int submitted =0 ; +unsigned int usable_blks_in_seg =f2fs_usable_blks_in_seg (sbi, segno); start_addr =START_BLOCK (sbi, segno); next_step: entry = sum; -for (off =0 ; off < sbi->blocks_per_seg; off++, entry++) { +for (off =0 ; off < usable_blks_in_seg; off++, entry++) {struct page *data_page;struct inode *inode;struct node_info dni;/* dnode info for the data */
@@ -1204,6 +1207,15 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi,if (__is_large_section (sbi)) end_segno =rounddown (end_segno, sbi->segs_per_sec); +/* +* zone-capacity can be less than zone-size in zoned devices, +* resulting in less than expected usable segments in the zone, +* calculate the end segno in the zone which can be garbage collected +*/ +if (f2fs_sb_has_blkzoned (sbi)) + end_segno -= sbi->segs_per_sec - +f2fs_usable_segs_in_sec (sbi, segno); +/* readahead multi ssa blocks those have contiguous address */ if (__is_large_section (sbi)) f2fs_ra_meta_pages(sbi, GET_SUM_BLOCK(sbi, segno),
@@ -1356,7 +1368,8 @@ int f2fs_gc(struct f2fs_sb_info *sbi, bool sync, goto stop; seg_freed =do_garbage_collect (sbi, segno, &gc_list, gc_type); -if (gc_type ==FG_GC && seg_freed == sbi->segs_per_sec) +if (gc_type ==FG_GC && + seg_freed ==f2fs_usable_segs_in_sec (sbi, segno)) sec_freed++; total_freed += seg_freed;
fs/f2fs/gc.h +40 -4
53 lines not on this page · raw message
fs/f2fs/segment.c +144 -12
227 lines not on this page · raw message
fs/f2fs/segment.h +17 -9
@@ -411,6 +411,7 @@ static inline void __set_free(struct f2fs_sb_info *sbi, unsigned int segno)unsigned int secno =GET_SEC_FROM_SEG (sbi, segno);unsigned int start_segno =GET_SEG_FROM_SEC (sbi, secno);unsigned int next; +unsigned int usable_segs =f2fs_usable_segs_in_sec (sbi, segno);spin_lock (&free_i->segmap_lock);clear_bit (segno, free_i->free_segmap);
@@ -418,7 +419,7 @@ static inline void __set_free(struct f2fs_sb_info *sbi, unsigned int segno) next =find_next_bit (free_i->free_segmap, start_segno + sbi->segs_per_sec, start_segno); -if (next >= start_segno + sbi->segs_per_sec) { +if (next >= start_segno + usable_segs) {clear_bit (secno, free_i->free_secmap); free_i->free_sections++; }
@@ -444,6 +445,7 @@ static inline void __set_test_and_free(struct f2fs_sb_info *sbi,unsigned int secno =GET_SEC_FROM_SEG (sbi, segno);unsigned int start_segno =GET_SEG_FROM_SEC (sbi, secno);unsigned int next; +unsigned int usable_segs =f2fs_usable_segs_in_sec (sbi, segno);spin_lock (&free_i->segmap_lock);if (test_and_clear_bit (segno, free_i->free_segmap)) {
@@ -453,7 +455,7 @@ static inline void __set_test_and_free(struct f2fs_sb_info *sbi, goto skip_free; next =find_next_bit (free_i->free_segmap, start_segno + sbi->segs_per_sec, start_segno); -if (next >= start_segno + sbi->segs_per_sec) { +if (next >= start_segno + usable_segs) {if (test_and_clear_bit (secno, free_i->free_secmap)) free_i->free_sections++; }
@@ -546,8 +548,8 @@ static inline bool has_curseg_enough_space(struct f2fs_sb_info *sbi)/* check current node segment */ for (i =CURSEG_HOT_NODE ; i <=CURSEG_COLD_NODE ; i++) { segno =CURSEG_I (sbi, i)->segno; - left_blocks = sbi->blocks_per_seg - -get_seg_entry (sbi, segno)->ckpt_valid_blocks; + left_blocks =f2fs_usable_blks_in_seg (sbi, segno) - +get_seg_entry (sbi, segno)->ckpt_valid_blocks;if (node_blocks > left_blocks)return false;
@@ -555,7 +557,7 @@ static inline bool has_curseg_enough_space(struct f2fs_sb_info *sbi)/* check current data segment */ segno =CURSEG_I (sbi,CURSEG_HOT_DATA )->segno; - left_blocks = sbi->blocks_per_seg - + left_blocks =f2fs_usable_blks_in_seg (sbi, segno) -get_seg_entry (sbi, segno)->ckpt_valid_blocks;if (dent_blocks > left_blocks)return false;
@@ -677,21 +679,22 @@ static inline int check_block_count(struct f2fs_sb_info *sbi,bool is_valid =test_bit_le (0 , raw_sit->valid_map) ? true : false;int valid_blocks =0 ;int cur_pos =0 , next_pos; +unsigned int usable_blks_per_seg =f2fs_usable_blks_in_seg (sbi, segno);/* check bitmap with valid block count */ do {if (is_valid) { next_pos =find_next_zero_bit_le (&raw_sit->valid_map, - sbi->blocks_per_seg, + usable_blks_per_seg, cur_pos); valid_blocks += next_pos - cur_pos; }else next_pos =find_next_bit_le (&raw_sit->valid_map, - sbi->blocks_per_seg, + usable_blks_per_seg, cur_pos); cur_pos = next_pos; is_valid = !is_valid; - }while (cur_pos < sbi->blocks_per_seg); + }while (cur_pos < usable_blks_per_seg);if (unlikely (GET_SIT_VBLOCKS (raw_sit) != valid_blocks)) { f2fs_err(sbi, "Mismatch valid blocks %d vs. %d",
@@ -700,8 +703,13 @@ static inline int check_block_count(struct f2fs_sb_info *sbi,return -EFSCORRUPTED ; } +if (usable_blks_per_seg < sbi->blocks_per_seg) +f2fs_bug_on (sbi,find_next_bit_le (&raw_sit->valid_map, + sbi->blocks_per_seg, + usable_blks_per_seg) != sbi->blocks_per_seg); +/* check segment usage, and check boundary of a given segment number */ -if (unlikely (GET_SIT_VBLOCKS (raw_sit) > sbi->blocks_per_seg +if (unlikely (GET_SIT_VBLOCKS (raw_sit) > usable_blks_per_seg || segno >TOTAL_SEGS (sbi) -1 )) {f2fs_err (sbi,"Wrong valid blocks %d or segno %u" ,GET_SIT_VBLOCKS (raw_sit), segno);
fs/f2fs/super.c +35 -6
72 lines not on this page · raw message
Signature · 1 line
2.19.1
Re: [PATCH v3 1/1] f2fs: support zone capacity less than zone size
Quoted 40 lines · Aravind Ramesh
NVMe Zoned Namespace devices can have zone-capacity less than zone-size. Zone-capacity indicates the maximum number of sectors that are usable in a zone beginning from the first sector of the zone. This makes the sectors sectors after the zone-capacity till zone-size to be unusable. This patch set tracks zone-size and zone-capacity in zoned devices and calculate the usable blocks per segment and usable segments per section.
If zone-capacity is less than zone-size mark only those segments which start before zone-capacity as free segments. All segments at and beyond zone-capacity are treated as permanently used segments. In cases where zone-capacity does not align with segment size the last segment will start before zone-capacity and end beyond the zone-capacity of the zone. For such spanning segments only sectors within the zone-capacity are used.
During writes and GC manage the usable segments in a section and usable blocks per segment. Segments which are beyond zone-capacity are never allocated, and do not need to be garbage collected, only the segments which are before zone-capacity needs to garbage collected. For spanning segments based on the number of usable blocks in that segment, write to blocks only up to zone-capacity.
Zone-capacity is device specific and cannot be configured by the user. Since NVMe ZNS device zones are sequentially write only, a block device with conventional zones or any normal block device is needed along with the ZNS device for the metadata operations of F2fs.
A typical nvme-cli output of a zoned device shows zone start and capacity and write pointer as below:
SLBA:
0x0WP:0x0Cap:0x18800State: EMPTY Type:SEQWRITE_REQ
SLBA:0x20000WP:0x20000Cap:0x18800State: EMPTY Type:SEQWRITE_REQ
SLBA:0x40000WP:0x40000Cap:0x18800State: EMPTY Type:SEQWRITE_REQHere zone size is 64MB, capacity is 49MB, WP is at zone start as the zones are in EMPTY state. For each zone, only zone start + 49MB is usable area, any lba/sector after 49MB cannot be read or written to, the drive will fail any attempts to read/write. So, the second zone starts at 64MB and is usable till 113MB (64 + 49) and the range between 113 and 128MB is again unusable. The next zone starts at 128MB, and so on.
Quoted 3 lines
Signed-off-by Aravind Ramesh <[email protected]>Signed-off-by Damien Le Moal <[email protected]>Signed-off-by Niklas Cassel <[email protected]>
Thanks,