Pass data lifetime information to SCSI disk devices
Subsystems (8)
v6 cover Pass data lifetime information to SCSI disk devices
Hi Martin,
UFS vendors need the data lifetime information to achieve good performance. Providing data lifetime information to UFS devices can result in up to 40% lower write amplification. Hence this patch series that adds support in F2FS and also in the block layer for data lifetime information. The SCSI disk (sd) driver is modified such that it passes write hint information to SCSI devices via the GROUP NUMBER field.
Please consider this patch series for the next merge window.
Thank you,
Bart.
Changes compared to v5:
- Added compile-time tests that compare the WRITE_LIFE_* and RWH_* constants.
- Split the F_[GS]ET_RW_HINT handlers.
- Removed the structure member kiocb.ki_hint again. Instead, copy the data lifetime information directly from struct file into a bio.
- Together with Doug Gilbert, fixed multiple bugs in the scsi_debug patches. Added Doug's Tested-by.
- Changed the type of "rscs:1" from bool into unsigned.
- Added unit tests for the new SCSI protocol data structures.
- Improved multiple patch descriptions.
Changes compared to v4:
- Dropped the patch that renames the WRITE_LIFE_* constants.
- Added a fix for an argument check in fcntl_rw_hint().
- Reordered the patches that restore data lifetime support.
- Included a fix for data lifetime support for buffered I/O to raw block devices.
Changes compared to v3:
- Renamed the data lifetime constants (WRITE_LIFE_*).
- Fixed a checkpatch complaint by changing "unsigned" into "unsigned int".
- Rebased this patch series on top of kernel v6.7-rc1.
Changes compared to v2:
- Instead of storing data lifetime information in bi_ioprio, introduce the new struct bio member bi_lifetime and also the struct request member 'lifetime'.
- Removed the bio_set_data_lifetime() and bio_get_data_lifetime() functions and replaced these with direct assignments.
- Dropped all changes related to I/O priority.
- Improved patch descriptions.
Changes compared to v1:
- Use six bits from the ioprio field for data lifetime information. The bio->bi_write_hint / req->write_hint / iocb->ki_hint members that were introduced in v1 have been removed again.
- The F_GET_FILE_RW_HINT and F_SET_FILE_RW_HINT fcntls have been removed.
- In the SCSI disk (sd) driver, query the stream status and check the PERM bit.
- The GET STREAM STATUS command has been implemented in the scsi_debug driver.
Bart Van Assche (20):
fs: Fix rw_hint validation
fs: Verify write lifetime constants at compile time
fs: Split fcntl_rw_hint()
fs: Move enum rw_hint into a new header file
fs: Restore F_[GS]ET_FILE_RW_HINT support
block, fs: Restore the per-bio/request data lifetime fields block, fs: Propagate write hints to the block device inode fs/f2fs: Restore the whint_mode mount option
fs/f2fs: Restore support for tracing data lifetimes
scsi: core: Query the Block Limits Extension VPD page
scsi: scsi_proto: Add structures and constants related to I/O groups
and streams
scsi: sd: Translate data lifetime information
scsi: scsi_debug: Reduce code duplication
scsi: scsi_debug: Support the block limits extension VPD page
scsi: scsi_debug: Rework page code error handling
scsi: scsi_debug: Rework subpage code error handling
scsi: scsi_debug: Allocate the MODE SENSE response from the heap
scsi: scsi_debug: Implement the IO Advice Hints Grouping mode page
scsi: scsi_debug: Implement GET STREAM STATUS
scsi: scsi_debug: Maintain write statistics per group number
Documentation/filesystems/f2fs.rst | 70 +++++++ block/bio.c | 2 + block/blk-crypto-fallback.c | 1 + block/blk-merge.c | 8 + block/blk-mq.c | 2 + block/bounce.c | 1 + block/fops.c | 14 ++ drivers/scsi/Kconfig | 5 + drivers/scsi/Makefile | 2 + drivers/scsi/scsi.c | 2 + drivers/scsi/scsi_debug.c | 293 ++++++++++++++++++++++------- drivers/scsi/scsi_proto_test.c | 56 ++++++ drivers/scsi/scsi_sysfs.c | 10 + drivers/scsi/sd.c | 111 ++++++++++- drivers/scsi/sd.h | 3 + fs/buffer.c | 12 +- fs/direct-io.c | 2 + fs/f2fs/data.c | 2 + fs/f2fs/f2fs.h | 10 + fs/f2fs/segment.c | 95 ++++++++++ fs/f2fs/super.c | 32 +++- fs/fcntl.c | 100 +++++++--- fs/inode.c | 1 + fs/iomap/buffered-io.c | 2 + fs/iomap/direct-io.c | 1 + fs/mpage.c | 1 + fs/open.c | 1 + include/linux/blk-mq.h | 2 + include/linux/blk_types.h | 2 + include/linux/fs.h | 26 ++- include/linux/rw_hint.h | 21 +++ include/scsi/scsi_device.h | 1 + include/scsi/scsi_proto.h | 78 ++++++++ include/trace/events/f2fs.h | 5 +- 34 files changed, 859 insertions(+), 115 deletions(-) create mode 100644 drivers/scsi/scsi_proto_test.c create mode 100644 include/linux/rw_hint.h
PATCH v6 1/20 fs: Fix rw_hint validation
Reject values that are valid rw_hints after truncation but not before truncation by passing an untruncated value to rw_hint_valid().
--- fs/fcntl.c | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-)
fs/fcntl.c +5 -7
@@ -268,7 +268,7 @@ static int f_getowner_uids(struct file *filp, unsigned long arg) }#endif -static bool rw_hint_valid (enum rw_hint hint) +static bool rw_hint_valid (u64 hint) {switch (hint) {case RWH_WRITE_LIFE_NOT_SET :
@@ -288,19 +288,17 @@ static long fcntl_rw_hint(struct file *file, unsigned int cmd, {struct inode *inode =file_inode (file);u64 __user *argp = (u64 __user *)arg; -enum rw_hint hint; -u64 h; +u64 hint;switch (cmd) {case F_GET_RW_HINT : - h = inode->i_write_hint; -if (copy_to_user (argp, &h,sizeof (*argp))) + hint = inode->i_write_hint; +if (copy_to_user (argp, &hint,sizeof (*argp)))return -EFAULT ;return 0 ;case F_SET_RW_HINT : -if (copy_from_user (&h, argp,sizeof (h))) +if (copy_from_user (&hint, argp,sizeof (hint)))return -EFAULT ; - hint = (enum rw_hint ) h;if (!rw_hint_valid (hint))return -EINVAL ;
PATCH v6 2/20 fs: Verify write lifetime constants at compile time
In reply to Bart Van AsscheThe code in fs/fcntl.c converts RWH_* constants to and from WRITE_LIFE_* constants using casts. Verify at compile time that these casts will yield the intended effect.
--- fs/fcntl.c | 7 +++++++ 1 file changed, 7 insertions(+)
fs/fcntl.c +7 -0
@@ -270,6 +270,13 @@ static int f_getowner_uids(struct file *filp, unsigned long arg)static bool rw_hint_valid (u64 hint) { +BUILD_BUG_ON (WRITE_LIFE_NOT_SET !=RWH_WRITE_LIFE_NOT_SET ); +BUILD_BUG_ON (WRITE_LIFE_NONE !=RWH_WRITE_LIFE_NONE ); +BUILD_BUG_ON (WRITE_LIFE_SHORT !=RWH_WRITE_LIFE_SHORT ); +BUILD_BUG_ON (WRITE_LIFE_MEDIUM !=RWH_WRITE_LIFE_MEDIUM ); +BUILD_BUG_ON (WRITE_LIFE_LONG !=RWH_WRITE_LIFE_LONG ); +BUILD_BUG_ON (WRITE_LIFE_EXTREME !=RWH_WRITE_LIFE_EXTREME ); +switch (hint) {case RWH_WRITE_LIFE_NOT_SET :case RWH_WRITE_LIFE_NONE :
Re: [PATCH v6 02/20] fs: Verify write lifetime constants at compile time
Looks good:
Re: [PATCH v6 02/20] fs: Verify write lifetime constants at compile time
In reply to Bart Van AsscheLooks good,
PATCH v6 3/20 fs: Split fcntl_rw_hint()
In reply to Bart Van AsschePrepare for restoring F_[GS]ET_FILE_RW_HINT by splitting fcntl_rw_hint() such that there is one helper function per fcntl. No functionality is changed by this patch.
--- fs/fcntl.c | 47 ++++++++++++++++++++++++++--------------------- 1 file changed, 26 insertions(+), 21 deletions(-)
fs/fcntl.c +26 -21
@@ -290,32 +290,35 @@ static bool rw_hint_valid(u64 hint) } } -static long fcntl_rw_hint (struct file *file,unsigned int cmd, -unsigned long arg) +static long fcntl_get_rw_hint (struct file *file,unsigned int cmd, +unsigned long arg) {struct inode *inode =file_inode (file);u64 __user *argp = (u64 __user *)arg; -u64 hint; +u64 hint = inode->i_write_hint; -switch (cmd) { -case F_GET_RW_HINT : - hint = inode->i_write_hint; -if (copy_to_user (argp, &hint,sizeof (*argp))) -return -EFAULT ; -return 0 ; -case F_SET_RW_HINT : -if (copy_from_user (&hint, argp,sizeof (hint))) -return -EFAULT ; -if (!rw_hint_valid (hint)) -return -EINVAL ; +if (copy_to_user (argp, &hint,sizeof (*argp))) +return -EFAULT ; +return 0 ; +} -inode_lock (inode); - inode->i_write_hint = hint; -inode_unlock (inode); -return 0 ; -default : +static long fcntl_set_rw_hint (struct file *file,unsigned int cmd, +unsigned long arg) +{ +struct inode *inode =file_inode (file); +u64 __user *argp = (u64 __user *)arg; +u64 hint; + +if (copy_from_user (&hint, argp,sizeof (hint))) +return -EFAULT ; +if (!rw_hint_valid (hint))return -EINVAL ; - } + +inode_lock (inode); + inode->i_write_hint = hint; +inode_unlock (inode); + +return 0 ; } static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
@@ -421,8 +424,10 @@ static long do_fcntl(int fd, unsigned int cmd, unsigned long arg, err =memfd_fcntl (filp, cmd, argi);break ;case F_GET_RW_HINT : + err =fcntl_get_rw_hint (filp, cmd, arg); +break ;case F_SET_RW_HINT : - err =fcntl_rw_hint (filp, cmd, arg); + err =fcntl_set_rw_hint (filp, cmd, arg);break ;default :break ;
Re: [PATCH v6 03/20] fs: Split fcntl_rw_hint()
Looks good:
PATCH v6 4/20 fs: Move enum rw_hint into a new header file
In reply to Bart Van AsscheMove enum rw_hint into a new header file to prepare for using this data type in the block layer. Add the attribute __packed to reduce the space occupied by instances of this data type from four bytes to one byte. Change the data type of i_write_hint from u8 into enum rw_hint.
--- fs/f2fs/f2fs.h | 1 + fs/fcntl.c | 1 + fs/inode.c | 1 + include/linux/fs.h | 16 ++-------------- include/linux/rw_hint.h | 21 +++++++++++++++++++++ 5 files changed, 26 insertions(+), 14 deletions(-) create mode 100644 include/linux/rw_hint.h
fs/f2fs/f2fs.h +1 -0
@@ -24,6 +24,7 @@#include <linux/blkdev.h> #include <linux/quotaops.h> #include <linux/part_stat.h> +#include <linux/rw_hint.h> #include <crypto/hash.h> #include <linux/fscrypt.h>
fs/fcntl.c +1 -0
@@ -27,6 +27,7 @@#include <linux/memfd.h> #include <linux/compat.h> #include <linux/mount.h> +#include <linux/rw_hint.h> #include <linux/poll.h> #include <asm/siginfo.h>
fs/inode.c +1 -0
@@ -20,6 +20,7 @@#include <linux/ratelimit.h> #include <linux/list_lru.h> #include <linux/iversion.h> +#include <linux/rw_hint.h> #include <trace/events/writeback.h> #include "internal.h"
include/linux/fs.h +2 -14
@@ -43,6 +43,7 @@#include <linux/cred.h> #include <linux/mnt_idmapping.h> #include <linux/slab.h> +#include <linux/rw_hint.h> #include <asm/byteorder.h> #include <uapi/linux/fs.h>
@@ -309,19 +310,6 @@ struct address_space;struct writeback_control ;struct readahead_control ; -/* -* Write life time hint values. -* Stored in struct inode as u8. -*/ -enum rw_hint { -WRITE_LIFE_NOT_SET =0 , -WRITE_LIFE_NONE =RWH_WRITE_LIFE_NONE , -WRITE_LIFE_SHORT =RWH_WRITE_LIFE_SHORT , -WRITE_LIFE_MEDIUM =RWH_WRITE_LIFE_MEDIUM , -WRITE_LIFE_LONG =RWH_WRITE_LIFE_LONG , -WRITE_LIFE_EXTREME =RWH_WRITE_LIFE_EXTREME , -}; -/* Match RWF_* bits to IOCB bits */ #define IOCB_HIPRI (__force int) RWF_HIPRI#define IOCB_DSYNC (__force int) RWF_DSYNC
@@ -677,7 +665,7 @@ struct inode {spinlock_t i_lock;/* i_blocks, i_bytes, maybe i_size */ unsigned short i_bytes;u8 i_blkbits; -u8 i_write_hint; +enum rw_hint i_write_hint;blkcnt_t i_blocks;#ifdef __NEED_I_SIZE_ORDERED
include/linux/rw_hint.h new file +21 -0
@@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _LINUX_RW_HINT_H +#define _LINUX_RW_HINT_H + +#include <linux/build_bug.h> +#include <linux/compiler_attributes.h> +#include <uapi/linux/fcntl.h> + +/* Block storage write lifetime hint values. */ +enum rw_hint { +WRITE_LIFE_NOT_SET =RWH_WRITE_LIFE_NOT_SET , +WRITE_LIFE_NONE =RWH_WRITE_LIFE_NONE , +WRITE_LIFE_SHORT =RWH_WRITE_LIFE_SHORT , +WRITE_LIFE_MEDIUM =RWH_WRITE_LIFE_MEDIUM , +WRITE_LIFE_LONG =RWH_WRITE_LIFE_LONG , +WRITE_LIFE_EXTREME =RWH_WRITE_LIFE_EXTREME , +} __packed; + +static_assert (sizeof (enum rw_hint ) ==1 ); + +#endif /* _LINUX_RW_HINT_H */
Re: [PATCH v6 04/20] fs: Move enum rw_hint into a new header file
Looks good:
PATCH v6 5/20 fs: Restore F_[GS]ET_FILE_RW_HINT support
In reply to Bart Van AsscheSince there are applications (e.g. Ceph) that use F_[GS]ET_FILE_RW_HINT, restore support for these fcntls. This patch restores functionality that was removed by commit 7b12e49669c9 ("fs: remove fs.f_write_hint").
--- fs/fcntl.c | 37 +++++++++++++++++++++++++++++++++++++ fs/open.c | 1 + include/linux/fs.h | 9 +++++++++ 3 files changed, 47 insertions(+)
fs/fcntl.c +37 -0
@@ -322,6 +322,37 @@ static long fcntl_set_rw_hint(struct file *file, unsigned int cmd,return 0 ; } +static long fcntl_get_file_rw_hint (struct file *file,unsigned int cmd, +unsigned long arg) +{ +struct inode *inode =file_inode (file); +u64 __user *argp = (u64 __user *)arg; +u64 hint = inode->i_write_hint; + + hint =file_write_hint (file); +if (copy_to_user (argp, &hint,sizeof (*argp))) +return -EFAULT ; +return 0 ; +} + +static long fcntl_set_file_rw_hint (struct file *file,unsigned int cmd, +unsigned long arg) +{ +u64 __user *argp = (u64 __user *)arg; +u64 hint; + +if (copy_from_user (&hint, argp,sizeof (hint))) +return -EFAULT ; +if (!rw_hint_valid (hint)) +return -EINVAL ; + +spin_lock (&file->f_lock); + file->f_write_hint = hint; +spin_unlock (&file->f_lock); + +return 0 ; +} +static long do_fcntl (int fd,unsigned int cmd,unsigned long arg,struct file *filp) {
@@ -430,6 +461,12 @@ static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,case F_SET_RW_HINT : err =fcntl_set_rw_hint (filp, cmd, arg);break ; +case F_GET_FILE_RW_HINT : + err =fcntl_get_file_rw_hint (filp, cmd, arg); +break ; +case F_SET_FILE_RW_HINT : + err =fcntl_set_file_rw_hint (filp, cmd, arg); +break ;default :break ; }
fs/open.c +1 -0
@@ -961,6 +961,7 @@ static int do_dentry_open(struct file *f,if (f->f_mapping->a_ops && f->f_mapping->a_ops->direct_IO) f->f_mode |=FMODE_CAN_ODIRECT ; + f->f_write_hint =WRITE_LIFE_NOT_SET ; f->f_flags &= ~(O_CREAT |O_EXCL |O_NOCTTY |O_TRUNC ); f->f_iocb_flags =iocb_flags (f);
include/linux/fs.h +9 -0
@@ -989,6 +989,7 @@ struct file {* Must not be taken from IRQ context. */ spinlock_t f_lock; +enum rw_hint f_write_hint;fmode_t f_mode;atomic_long_t f_count;struct mutex f_pos_lock;
@@ -2162,6 +2163,14 @@ static inline bool HAS_UNMAPPED_ID(struct mnt_idmap *idmap, !vfsgid_valid (i_gid_into_vfsgid (idmap, inode)); } +static inline enum rw_hint file_write_hint (struct file *file) +{ +if (file->f_write_hint !=WRITE_LIFE_NOT_SET ) +return file->f_write_hint; + +return file_inode (file)->i_write_hint; +} +static inline void init_sync_kiocb (struct kiocb *kiocb,struct file *filp) { *kiocb = (struct kiocb ) {
Re: [PATCH v6 05/20] fs: Restore F_[GS]ET_FILE_RW_HINT support
NAK, we should not bloat struct file without a reason.
Christian Brauner
maintainerRe: [PATCH v6 05/20] fs: Restore F_[GS]ET_FILE_RW_HINT support
Quoted 1 line · Christoph Hellwig
NAK, we should not bloat struct file without a reason.
Worth noting, that we would've gained 32bit in the fmode_t expansion and another 32bit in here. So 64bit in one cycle...
PATCH v6 6/20 block, fs: Restore the per-bio/request data lifetime fields
In reply to Bart Van AsscheRestore support for passing data lifetime information from filesystems to block drivers. This patch reverts commit b179c98f7697 ("block: Remove request.write_hint") and commit c75e707fe1aa ("block: remove the per-bio/request write hint").
--- block/bio.c | 2 ++ block/blk-crypto-fallback.c | 1 + block/blk-merge.c | 8 ++++++++ block/blk-mq.c | 2 ++ block/bounce.c | 1 + block/fops.c | 3 +++ fs/buffer.c | 12 ++++++++---- fs/direct-io.c | 2 ++ fs/iomap/buffered-io.c | 2 ++ fs/iomap/direct-io.c | 1 + fs/mpage.c | 1 + include/linux/blk-mq.h | 2 ++ include/linux/blk_types.h | 2 ++ 13 files changed, 35 insertions(+), 4 deletions(-)
block/bio.c +2 -0
@@ -251,6 +251,7 @@ void bio_init(struct bio *bio, struct block_device *bdev, struct bio_vec *table, bio->bi_opf = opf; bio->bi_flags =0 ; bio->bi_ioprio =0 ; + bio->bi_write_hint =0 ; bio->bi_status =0 ; bio->bi_iter.bi_sector =0 ; bio->bi_iter.bi_size =0 ;
@@ -813,6 +814,7 @@ static int __bio_clone(struct bio *bio, struct bio *bio_src, gfp_t gfp) {bio_set_flag (bio,BIO_CLONED ); bio->bi_ioprio = bio_src->bi_ioprio; + bio->bi_write_hint = bio_src->bi_write_hint; bio->bi_iter = bio_src->bi_iter;if (bio->bi_bdev) {
block/blk-crypto-fallback.c +1 -0
@@ -172,6 +172,7 @@ static struct bio *blk_crypto_fallback_clone_bio(struct bio *bio_src)if (bio_flagged (bio_src,BIO_REMAPPED ))bio_set_flag (bio,BIO_REMAPPED ); bio->bi_ioprio = bio_src->bi_ioprio; + bio->bi_write_hint = bio_src->bi_write_hint; bio->bi_iter.bi_sector = bio_src->bi_iter.bi_sector; bio->bi_iter.bi_size = bio_src->bi_iter.bi_size;
block/blk-merge.c +8 -0
@@ -814,6 +814,10 @@ static struct request *attempt_merge(struct request_queue *q,if (rq_data_dir (req) !=rq_data_dir (next))return NULL ; +/* Don't merge requests with different write hints. */ +if (req->write_hint != next->write_hint) +return NULL ; +if (req->ioprio != next->ioprio)return NULL ;
@@ -941,6 +945,10 @@ bool blk_rq_merge_ok(struct request *rq, struct bio *bio)if (!bio_crypt_rq_ctx_compatible (rq, bio))return false; +/* Don't merge requests with different write hints. */ +if (rq->write_hint != bio->bi_write_hint) +return false; +if (rq->ioprio !=bio_prio (bio))return false;
block/blk-mq.c +2 -0
@@ -2551,6 +2551,7 @@ static void blk_mq_bio_to_request(struct request *rq, struct bio *bio, rq->cmd_flags |=REQ_FAILFAST_MASK ; rq->__sector = bio->bi_iter.bi_sector; + rq->write_hint = bio->bi_write_hint;blk_rq_bio_prep (rq, bio, nr_segs);/* This can't fail, since GFP_NOIO includes __GFP_DIRECT_RECLAIM. */
@@ -3143,6 +3144,7 @@ int blk_rq_prep_clone(struct request *rq, struct request *rq_src, } rq->nr_phys_segments = rq_src->nr_phys_segments; rq->ioprio = rq_src->ioprio; + rq->write_hint = rq_src->write_hint;if (rq->bio &&blk_crypto_rq_bio_prep (rq, rq->bio, gfp_mask) <0 ) goto free_and_out;
block/bounce.c +1 -0
@@ -169,6 +169,7 @@ static struct bio *bounce_clone_bio(struct bio *bio_src)if (bio_flagged (bio_src,BIO_REMAPPED ))bio_set_flag (bio,BIO_REMAPPED ); bio->bi_ioprio = bio_src->bi_ioprio; + bio->bi_write_hint = bio_src->bi_write_hint; bio->bi_iter.bi_sector = bio_src->bi_iter.bi_sector; bio->bi_iter.bi_size = bio_src->bi_iter.bi_size;
block/fops.c +3 -0
@@ -73,6 +73,7 @@ static ssize_t __blkdev_direct_IO_simple(struct kiocb *iocb,bio_init (&bio, bdev, vecs, nr_pages,dio_bio_write_op (iocb)); } bio.bi_iter.bi_sector = pos >>SECTOR_SHIFT ; + bio.bi_write_hint =file_write_hint (iocb->ki_filp); bio.bi_ioprio = iocb->ki_ioprio; ret =bio_iov_iter_get_pages (&bio, iter);
@@ -203,6 +204,7 @@ static ssize_t __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter,for (;;) { bio->bi_iter.bi_sector = pos >>SECTOR_SHIFT ; + bio->bi_write_hint =file_write_hint (iocb->ki_filp); bio->bi_private = dio; bio->bi_end_io = blkdev_bio_end_io; bio->bi_ioprio = iocb->ki_ioprio;
@@ -321,6 +323,7 @@ static ssize_t __blkdev_direct_IO_async(struct kiocb *iocb, dio->flags =0 ; dio->iocb = iocb; bio->bi_iter.bi_sector = pos >>SECTOR_SHIFT ; + bio->bi_write_hint =file_write_hint (iocb->ki_filp); bio->bi_end_io = blkdev_bio_end_io_async; bio->bi_ioprio = iocb->ki_ioprio;
fs/buffer.c +8 -4
@@ -55,7 +55,7 @@static int fsync_buffers_list (spinlock_t *lock,struct list_head *list);static void submit_bh_wbc (blk_opf_t opf,struct buffer_head *bh, -struct writeback_control *wbc); +enum rw_hint hint,struct writeback_control *wbc);#define BH_ENTRY (list) list_entry((list), struct buffer_head, b_assoc_buffers)
@@ -1903,7 +1903,8 @@ int __block_write_full_folio(struct inode *inode, struct folio *folio, do { struct buffer_head *next = bh->b_this_page; if (buffer_async_write(bh)) { - submit_bh_wbc(REQ_OP_WRITE | write_flags, bh, wbc); + submit_bh_wbc(REQ_OP_WRITE | write_flags, bh, + inode->i_write_hint, wbc); nr_underway++; } bh = next;
@@ -1957,7 +1958,8 @@ int __block_write_full_folio(struct inode *inode, struct folio *folio,struct buffer_head *next = bh->b_this_page;if (buffer_async_write (bh)) {clear_buffer_dirty (bh); -submit_bh_wbc (REQ_OP_WRITE | write_flags, bh, wbc); +submit_bh_wbc (REQ_OP_WRITE | write_flags, bh, + inode->i_write_hint, wbc); nr_underway++; } bh = next;
@@ -2777,6 +2779,7 @@ static void end_bio_bh_io_sync(struct bio *bio) }static void submit_bh_wbc (blk_opf_t opf,struct buffer_head *bh, +enum rw_hint write_hint,struct writeback_control *wbc) {const enum req_op op = opf &REQ_OP_MASK ;
@@ -2804,6 +2807,7 @@ static void submit_bh_wbc(blk_opf_t opf, struct buffer_head *bh,fscrypt_set_bio_crypt_ctx_bh (bio, bh,GFP_NOIO ); bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >>9 ); + bio->bi_write_hint = write_hint;__bio_add_page (bio, bh->b_page, bh->b_size,bh_offset (bh));
@@ -2823,7 +2827,7 @@ static void submit_bh_wbc(blk_opf_t opf, struct buffer_head *bh,void submit_bh (blk_opf_t opf,struct buffer_head *bh) { -submit_bh_wbc (opf, bh,NULL ); +submit_bh_wbc (opf, bh,WRITE_LIFE_NOT_SET ,NULL ); }EXPORT_SYMBOL (submit_bh);
fs/direct-io.c +2 -0
@@ -410,6 +410,8 @@ dio_bio_alloc(struct dio *dio, struct dio_submit *sdio, bio->bi_end_io = dio_bio_end_io;if (dio->is_pinned)bio_set_flag (bio,BIO_PAGE_PINNED ); + bio->bi_write_hint =file_write_hint (dio->iocb->ki_filp); + sdio->bio = bio; sdio->logical_offset_in_bio = sdio->cur_page_fs_offset; }
fs/iomap/buffered-io.c +2 -0
@@ -1677,6 +1677,7 @@ iomap_alloc_ioend(struct inode *inode, struct iomap_writepage_ctx *wpc,REQ_OP_WRITE |wbc_to_write_flags (wbc), GFP_NOFS, &iomap_ioend_bioset); bio->bi_iter.bi_sector = sector; + bio->bi_write_hint = inode->i_write_hint;wbc_init_bio (wbc, bio); ioend = container_of(bio, struct iomap_ioend, io_inline_bio);
@@ -1707,6 +1708,7 @@ iomap_chain_bio(struct bio *prev) new =bio_alloc (prev->bi_bdev,BIO_MAX_VECS , prev->bi_opf,GFP_NOFS );bio_clone_blkg_association (new, prev); new->bi_iter.bi_sector =bio_end_sector (prev); + new->bi_write_hint = prev->bi_write_hint;bio_chain (prev, new);bio_get (prev);/* for iomap_finish_ioend */
fs/iomap/direct-io.c +1 -0
@@ -380,6 +380,7 @@ static loff_t iomap_dio_bio_iter(const struct iomap_iter *iter,fscrypt_set_bio_crypt_ctx (bio, inode, pos >> inode->i_blkbits,GFP_KERNEL ); bio->bi_iter.bi_sector =iomap_sector (iomap, pos); + bio->bi_write_hint =file_write_hint (dio->iocb->ki_filp); bio->bi_ioprio = dio->iocb->ki_ioprio; bio->bi_private = dio; bio->bi_end_io = iomap_dio_bio_end_io;
fs/mpage.c +1 -0
@@ -611,6 +611,7 @@ static int __mpage_writepage(struct folio *folio, struct writeback_control *wbc, GFP_NOFS); bio->bi_iter.bi_sector = blocks[0 ] << (blkbits -9 );wbc_init_bio (wbc, bio); + bio->bi_write_hint = inode->i_write_hint; }/*
include/linux/blk-mq.h +2 -0
@@ -8,6 +8,7 @@#include <linux/scatterlist.h> #include <linux/prefetch.h> #include <linux/srcu.h> +#include <linux/rw_hint.h> struct blk_mq_tags ;struct blk_flush_queue ;
@@ -135,6 +136,7 @@ struct request {struct blk_crypto_keyslot *crypt_keyslot;#endif +enum rw_hint write_hint;unsigned short ioprio;enum mq_rq_state state;
include/linux/blk_types.h +2 -0
@@ -10,6 +10,7 @@#include <linux/bvec.h> #include <linux/device.h> #include <linux/ktime.h> +#include <linux/rw_hint.h> struct bio_set ;struct bio ;
@@ -269,6 +270,7 @@ struct bio {*/ unsigned short bi_flags;/* BIO_* below */ unsigned short bi_ioprio; +enum rw_hint bi_write_hint;blk_status_t bi_status;atomic_t __bi_remaining;
PATCH v6 7/20 block, fs: Propagate write hints to the block device inode
In reply to Bart Van AsscheWrite hints applied with F_SET_RW_HINT on a block device affect the shmem inode only. Propagate these hints to the block device inode because that is the inode used when writing back dirty pages.
--- block/fops.c | 11 +++++++++++ fs/fcntl.c | 4 ++++ include/linux/fs.h | 1 + 3 files changed, 16 insertions(+)
block/fops.c +11 -0
@@ -620,6 +620,16 @@ static int blkdev_release(struct inode *inode, struct file *filp)return 0 ; } +static void blkdev_apply_whint (struct file *file,enum rw_hint hint) +{ +struct bdev_handle *handle = file->private_data; +struct inode *bd_inode = handle->bdev->bd_inode; + +inode_lock (bd_inode); + bd_inode->i_write_hint = hint; +inode_unlock (bd_inode); +} +static ssize_t blkdev_direct_write (struct kiocb *iocb,struct iov_iter *from) {
@@ -854,6 +864,7 @@ const struct file_operations def_blk_fops = { .splice_read = filemap_splice_read, .splice_write = iter_file_splice_write, .fallocate = blkdev_fallocate, + .apply_whint = blkdev_apply_whint, };static __init int blkdev_init (void )
fs/fcntl.c +4 -0
@@ -306,6 +306,7 @@ static long fcntl_get_rw_hint(struct file *file, unsigned int cmd,static long fcntl_set_rw_hint (struct file *file,unsigned int cmd,unsigned long arg) { +void (*apply_whint)(struct file *,enum rw_hint );struct inode *inode =file_inode (file);u64 __user *argp = (u64 __user *)arg;u64 hint;
@@ -317,6 +318,9 @@ static long fcntl_set_rw_hint(struct file *file, unsigned int cmd,inode_lock (inode); inode->i_write_hint = hint; + apply_whint = inode->i_fop->apply_whint; +if (apply_whint) +apply_whint (file, hint);inode_unlock (inode);return 0 ;
include/linux/fs.h +1 -0
@@ -1945,6 +1945,7 @@ struct file_operations {int (*uring_cmd)(struct io_uring_cmd *ioucmd,unsigned int issue_flags);int (*uring_cmd_iopoll)(struct io_uring_cmd *,struct io_comp_batch *,unsigned int poll_flags); +void (*apply_whint)(struct file *,enum rw_hint hint); } __randomize_layout;/* Wrap a directory iterator that needs exclusive inode access */
PATCH v6 8/20 fs/f2fs: Restore the whint_mode mount option
In reply to Bart Van AsscheAllow users to control which write hints are passed to the block layer:
- whint_mode=off - no write hints are passed to the block layer.
- whint_mode=user-based - write hints are derived from inode->i_write_hint and also from the system.advise xattr information (hot and cold bits).
- whint_mode=fs-based - F2FS chooses write hints.
This patch reverts commit 930e2607638d ("f2fs: remove obsolete whint_mode").
--- Documentation/filesystems/f2fs.rst | 70 ++++++++++++++++++++++ fs/f2fs/data.c | 2 + fs/f2fs/f2fs.h | 9 +++ fs/f2fs/segment.c | 95 ++++++++++++++++++++++++++++++ fs/f2fs/super.c | 32 +++++++++- 5 files changed, 207 insertions(+), 1 deletion(-)
Documentation/filesystems/f2fs.rst +70 -0
@@ -242,6 +242,12 @@ offgrpjquota Turn off group journalled quota. offprjjquota Turn off project journalled quota. quota Enable plain user disk quota accounting. noquota Disable all plain disk quota option. +whint_mode=%s Control which write hints are passed down to block + layer. This supports "off", "user-based", and + "fs-based". In "off" mode (default), f2fs does not pass + down hints. In "user-based" mode, f2fs tries to pass + down hints given by users. And in "fs-based" mode, f2fs + passes down hints with its policy. alloc_mode=%s Adjust block allocation policy, which supports "reuse" and "default". fsync_mode=%s Control the policy of fsync. Currently supports "posix",
@@ -776,6 +782,70 @@ In order to identify whether the data in the victim segment are valid or not, F2FS manages a bitmap. Each bit represents the validity of a block, and the bitmap is composed of a bit stream covering whole blocks in main area. +Write-hint Policy +----------------- + +1) whint_mode=off. F2FS only passes down WRITE_LIFE_NOT_SET. + +2) whint_mode=user-based. F2FS tries to pass down hints given by +users. + +===================== ======================== =================== +User F2FS Block +===================== ======================== =================== +N/A META WRITE_LIFE_NOT_SET +N/A HOT_NODE " +N/A WARM_NODE " +N/A COLD_NODE " +ioctl(COLD) COLD_DATA WRITE_LIFE_EXTREME +extension list " " + +-- buffered io +WRITE_LIFE_EXTREME COLD_DATA WRITE_LIFE_EXTREME +WRITE_LIFE_SHORT HOT_DATA WRITE_LIFE_SHORT +WRITE_LIFE_NOT_SET WARM_DATA WRITE_LIFE_NOT_SET +WRITE_LIFE_NONE " " +WRITE_LIFE_MEDIUM " " +WRITE_LIFE_LONG " " + +-- direct io +WRITE_LIFE_EXTREME COLD_DATA WRITE_LIFE_EXTREME +WRITE_LIFE_SHORT HOT_DATA WRITE_LIFE_SHORT +WRITE_LIFE_NOT_SET WARM_DATA WRITE_LIFE_NOT_SET +WRITE_LIFE_NONE " WRITE_LIFE_NONE +WRITE_LIFE_MEDIUM " WRITE_LIFE_MEDIUM +WRITE_LIFE_LONG " WRITE_LIFE_LONG +===================== ======================== =================== + +3) whint_mode=fs-based. F2FS passes down hints with its policy. + +===================== ======================== =================== +User F2FS Block +===================== ======================== =================== +N/A META WRITE_LIFE_MEDIUM; +N/A HOT_NODE WRITE_LIFE_NOT_SET +N/A WARM_NODE " +N/A COLD_NODE WRITE_LIFE_NONE +ioctl(COLD) COLD_DATA WRITE_LIFE_EXTREME +extension list " " + +-- buffered io +WRITE_LIFE_EXTREME COLD_DATA WRITE_LIFE_EXTREME +WRITE_LIFE_SHORT HOT_DATA WRITE_LIFE_SHORT +WRITE_LIFE_NOT_SET WARM_DATA WRITE_LIFE_LONG +WRITE_LIFE_NONE " " +WRITE_LIFE_MEDIUM " " +WRITE_LIFE_LONG " " + +-- direct io +WRITE_LIFE_EXTREME COLD_DATA WRITE_LIFE_EXTREME +WRITE_LIFE_SHORT HOT_DATA WRITE_LIFE_SHORT +WRITE_LIFE_NOT_SET WARM_DATA WRITE_LIFE_NOT_SET +WRITE_LIFE_NONE " WRITE_LIFE_NONE +WRITE_LIFE_MEDIUM " WRITE_LIFE_MEDIUM +WRITE_LIFE_LONG " WRITE_LIFE_LONG +===================== ======================== =================== + Fallocate(2) Policy -------------------
fs/f2fs/data.c +2 -0
@@ -478,6 +478,8 @@ static struct bio *__bio_alloc(struct f2fs_io_info *fio, int npages) }else { bio->bi_end_io = f2fs_write_end_io; bio->bi_private = sbi; + bio->bi_write_hint =f2fs_io_type_to_rw_hint (sbi, + fio->type, fio->temp); }iostat_alloc_and_bind_ctx (sbi, bio,NULL );
fs/f2fs/f2fs.h +9 -0
@@ -141,6 +141,12 @@ struct f2fs_rwsem {#endif }; +enum whint_mode { +WHINT_MODE_OFF ,/* not pass down write hints */ +WHINT_MODE_USER ,/* try to pass down hints given by users */ +WHINT_MODE_FS ,/* pass down hints with F2FS policy */ +}; +struct f2fs_mount_info {unsigned int opt;int write_io_size_bits;/* Write IO size bits */
@@ -158,6 +164,7 @@ struct f2fs_mount_info {int s_jquota_fmt;/* Format of quota to use */ #endif /* For which write hints are passed down to block layer */ +enum whint_mode whint_mode;int alloc_mode;/* segment allocation policy */ int fsync_mode;/* fsync policy */ int fs_mode;/* fs mode: LFS or ADAPTIVE */
@@ -3731,6 +3738,8 @@ void f2fs_destroy_segment_manager(struct f2fs_sb_info *sbi);int __init f2fs_create_segment_manager_caches (void );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,
fs/f2fs/segment.c +95 -0
101 lines not on this page · raw message
fs/f2fs/super.c +31 -1
@@ -156,6 +156,7 @@ enum { Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_jqfmt_vfsv1, + Opt_whint, Opt_alloc, Opt_fsync, Opt_test_dummy_encryption,
@@ -235,6 +236,7 @@ static match_table_t f2fs_tokens = { {Opt_jqfmt_vfsold, "jqfmt=vfsold"}, {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"}, {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"}, + {Opt_whint, "whint_mode=%s"}, {Opt_alloc, "alloc_mode=%s"}, {Opt_fsync, "fsync_mode=%s"}, {Opt_test_dummy_encryption, "test_dummy_encryption=%s"},
@@ -1026,6 +1028,22 @@ static int parse_options(struct super_block *sb, char *options, bool is_remount)f2fs_info (sbi,"quota operations not supported" );break ;#endif +case Opt_whint: + name =match_strdup (&args[0 ]); +if (!name) +return -ENOMEM ; +if (!strcmp (name,"user-based" )) { +F2FS_OPTION (sbi).whint_mode =WHINT_MODE_USER ; + }else if (!strcmp (name,"off" )) { +F2FS_OPTION (sbi).whint_mode =WHINT_MODE_OFF ; + }else if (!strcmp (name,"fs-based" )) { +F2FS_OPTION (sbi).whint_mode =WHINT_MODE_FS ; + }else { +kfree (name); +return -EINVAL ; + } +kfree (name); +break ;case Opt_alloc: name =match_strdup (&args[0 ]);if (!name)
@@ -1437,6 +1455,12 @@ static int parse_options(struct super_block *sb, char *options, bool is_remount)return -EINVAL ; } +/* Not pass down write hints if the number of active logs is less +* than NR_CURSEG_PERSIST_TYPE. +*/ +if (F2FS_OPTION (sbi).active_logs !=NR_CURSEG_PERSIST_TYPE ) +F2FS_OPTION (sbi).whint_mode =WHINT_MODE_OFF ; +if (f2fs_sb_has_readonly (sbi) && !f2fs_readonly (sbi->sb)) {f2fs_err (sbi,"Allow to mount readonly mode only" );return -EROFS ;
@@ -2108,6 +2132,10 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)seq_puts (seq,",prjquota" );#endif f2fs_show_quota_options (seq, sbi->sb); +if (F2FS_OPTION (sbi).whint_mode ==WHINT_MODE_USER ) +seq_printf (seq,",whint_mode=%s" ,"user-based" ); +else if (F2FS_OPTION (sbi).whint_mode ==WHINT_MODE_FS ) +seq_printf (seq,",whint_mode=%s" ,"fs-based" );fscrypt_show_test_dummy_encryption (seq,',' , sbi->sb);
@@ -2177,6 +2205,7 @@ static void default_options(struct f2fs_sb_info *sbi, bool remount)F2FS_OPTION (sbi).active_logs =NR_CURSEG_PERSIST_TYPE ;F2FS_OPTION (sbi).inline_xattr_size =DEFAULT_INLINE_XATTR_ADDRS ; +F2FS_OPTION (sbi).whint_mode =WHINT_MODE_OFF ;if (le32_to_cpu (F2FS_RAW_SUPER (sbi)->segment_count_main) <=SMALL_VOLUME_SEGMENTS )F2FS_OPTION (sbi).alloc_mode =ALLOC_MODE_REUSE ;
@@ -2491,7 +2520,8 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data) need_stop_gc = true; } -if (*flags &SB_RDONLY ) { +if (*flags &SB_RDONLY || +F2FS_OPTION (sbi).whint_mode != org_mount_opt.whint_mode) {sync_inodes_sb (sb);set_sbi_flag (sbi,SBI_IS_DIRTY );
PATCH v6 9/20 fs/f2fs: Restore support for tracing data lifetimes
In reply to Bart Van AsscheThis patch restores code that was removed by commit 41d36a9f3e53 ("fs:
remove kiocb.ki_hint").
--- include/trace/events/f2fs.h | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
include/trace/events/f2fs.h +4 -1
@@ -946,6 +946,7 @@ TRACE_EVENT(f2fs_direct_IO_enter, __field(ino_t, ino) __field(loff_t, ki_pos) __field(int, ki_flags) + __field(u16, ki_hint) __field(u16, ki_ioprio) __field(unsigned long, len)__field (int , rw)
@@ -956,16 +957,18 @@ TRACE_EVENT(f2fs_direct_IO_enter, __entry->ino = inode->i_ino; __entry->ki_pos = iocb->ki_pos; __entry->ki_flags = iocb->ki_flags; + __entry->ki_hint =file_write_hint (iocb->ki_filp); __entry->ki_ioprio = iocb->ki_ioprio; __entry->len = len; __entry->rw = rw; ), -TP_printk ("dev = (%d,%d), ino = %lu pos = %lld len = %lu ki_flags = %x ki_ioprio = %x rw = %d" , +TP_printk ("dev = (%d,%d), ino = %lu pos = %lld len = %lu ki_flags = %x ki_hint = %x ki_ioprio = %x rw = %d" ,show_dev_ino (__entry), __entry->ki_pos, __entry->len, __entry->ki_flags, + __entry->ki_hint, __entry->ki_ioprio, __entry->rw) );
PATCH v6 10/20 scsi: core: Query the Block Limits Extension VPD page
In reply to Bart Van AsscheParse the Reduced Stream Control Supported (RSCS) bit from the block limits extension VPD page. The RSCS bit is defined in SBC-5 r05
(https://www.t10.org/cgi-bin/ac.pl?t=f&f=sbc5r05.pdf).
--- drivers/scsi/scsi.c | 2 ++ drivers/scsi/scsi_sysfs.c | 10 ++++++++++ drivers/scsi/sd.c | 13 +++++++++++++ drivers/scsi/sd.h | 1 + include/scsi/scsi_device.h | 1 + 5 files changed, 27 insertions(+)
drivers/scsi/scsi.c +2 -0
@@ -499,6 +499,8 @@ void scsi_attach_vpd(struct scsi_device *sdev)scsi_update_vpd_page (sdev,0xb1 , &sdev->vpd_pgb1);if (vpd_buf->data[i] ==0xb2 )scsi_update_vpd_page (sdev,0xb2 , &sdev->vpd_pgb2); +if (vpd_buf->data[i] ==0xb7 ) +scsi_update_vpd_page (sdev,0xb7 , &sdev->vpd_pgb7); }kfree (vpd_buf); }
drivers/scsi/scsi_sysfs.c +10 -0
@@ -449,6 +449,7 @@ static void scsi_device_dev_release(struct device *dev)struct scsi_vpd *vpd_pg80 =NULL , *vpd_pg83 =NULL ;struct scsi_vpd *vpd_pg0 =NULL , *vpd_pg89 =NULL ;struct scsi_vpd *vpd_pgb0 =NULL , *vpd_pgb1 =NULL , *vpd_pgb2 =NULL ; +struct scsi_vpd *vpd_pgb7 =NULL ;unsigned long flags;might_sleep ();
@@ -494,6 +495,8 @@ static void scsi_device_dev_release(struct device *dev) lockdep_is_held(&sdev->inquiry_mutex)); vpd_pgb2 =rcu_replace_pointer (sdev->vpd_pgb2, vpd_pgb2,lockdep_is_held (&sdev->inquiry_mutex)); + vpd_pgb7 =rcu_replace_pointer (sdev->vpd_pgb7, vpd_pgb7, +lockdep_is_held (&sdev->inquiry_mutex));mutex_unlock (&sdev->inquiry_mutex);if (vpd_pg0)
@@ -510,6 +513,8 @@ static void scsi_device_dev_release(struct device *dev)kfree_rcu (vpd_pgb1, rcu);if (vpd_pgb2)kfree_rcu (vpd_pgb2, rcu); +if (vpd_pgb7) +kfree_rcu (vpd_pgb7, rcu);kfree (sdev->inquiry);kfree (sdev);
@@ -921,6 +926,7 @@ sdev_vpd_pg_attr(pg89);sdev_vpd_pg_attr (pgb0);sdev_vpd_pg_attr (pgb1);sdev_vpd_pg_attr (pgb2); +sdev_vpd_pg_attr (pgb7);sdev_vpd_pg_attr (pg0); static ssize_t show_inquiry(struct file *filep, struct kobject *kobj,
@@ -1295,6 +1301,9 @@ static umode_t scsi_sdev_bin_attr_is_visible(struct kobject *kobj,if (attr == &dev_attr_vpd_pgb2 && !sdev->vpd_pgb2)return 0 ; +if (attr == &dev_attr_vpd_pgb7 && !sdev->vpd_pgb7) +return 0 ; +return S_IRUGO ; }
@@ -1347,6 +1356,7 @@ static struct bin_attribute *scsi_sdev_bin_attrs[] = { &dev_attr_vpd_pgb0, &dev_attr_vpd_pgb1, &dev_attr_vpd_pgb2, + &dev_attr_vpd_pgb7, &dev_attr_inquiry, NULL };
drivers/scsi/sd.c +13 -0
@@ -3103,6 +3103,18 @@ static void sd_read_block_limits(struct scsi_disk *sdkp)rcu_read_unlock (); } +/* Parse the Block Limits Extension VPD page (0xb7) */ +static void sd_read_block_limits_ext (struct scsi_disk *sdkp) +{ +struct scsi_vpd *vpd; + +rcu_read_lock (); + vpd =rcu_dereference (sdkp->device->vpd_pgb7); +if (vpd && vpd->len >=2 ) + sdkp->rscs = vpd->data[5 ] &1 ; +rcu_read_unlock (); +} +/** * sd_read_block_characteristics - Query block dev. characteristics * @sdkp: disk to query
@@ -3457,6 +3469,7 @@ static int sd_revalidate_disk(struct gendisk *disk)if (scsi_device_supports_vpd (sdp)) {sd_read_block_provisioning (sdkp);sd_read_block_limits (sdkp); +sd_read_block_limits_ext (sdkp);sd_read_block_characteristics (sdkp);sd_zbc_read_zones (sdkp, buffer);sd_read_cpr (sdkp);
drivers/scsi/sd.h +1 -0
@@ -151,6 +151,7 @@ struct scsi_disk { unsigned urswrz : 1; unsigned security : 1; unsigned ignore_medium_access_errors : 1; + bool rscs : 1; /* reduced stream control support */ };#define to_scsi_disk (obj) container_of(obj, struct scsi_disk, disk_dev)
include/scsi/scsi_device.h +1 -0
@@ -153,6 +153,7 @@ struct scsi_device {struct scsi_vpd __rcu *vpd_pgb0;struct scsi_vpd __rcu *vpd_pgb1;struct scsi_vpd __rcu *vpd_pgb2; +struct scsi_vpd __rcu *vpd_pgb7;struct scsi_target *sdev_target;
PATCH v6 11/20 scsi: scsi_proto: Add structures and constants related to I/O groups and streams
In reply to Bart Van AsschePrepare for adding code that will query the I/O advice hints group descriptors and for adding code that will retrieve the stream status.
--- drivers/scsi/Kconfig | 5 +++ drivers/scsi/Makefile | 2 + drivers/scsi/scsi_proto_test.c | 56 ++++++++++++++++++++++++ include/scsi/scsi_proto.h | 78 ++++++++++++++++++++++++++++++++++ 4 files changed, 141 insertions(+) create mode 100644 drivers/scsi/scsi_proto_test.c
drivers/scsi/Kconfig +5 -0
@@ -232,6 +232,11 @@ config SCSI_SCAN_ASYNC Note that this setting also affects whether resuming from system suspend will be performed asynchronously. +config SCSI_PROTO_TEST + tristate "scsi_proto.h unit tests" if !KUNIT_ALL_TESTS + depends on SCSI && KUNIT + default KUNIT_ALL_TESTS + menu "SCSI Transports" depends on SCSI
drivers/scsi/Makefile +2 -0
@@ -24,6 +24,8 @@ obj-$(CONFIG_SCSI_COMMON) += scsi_common.o obj-$(CONFIG_RAID_ATTRS) += raid_class.o +obj-$(CONFIG_SCSI_PROTO_TEST) += scsi_proto_test.o + # --- NOTE ORDERING HERE --- # For kernel non-modular link, transport attributes need to # be initialised before drivers
drivers/scsi/scsi_proto_test.c new file +56 -0
56 lines not on this page · raw message
include/scsi/scsi_proto.h +78 -0
96 lines not on this page · raw message
PATCH v6 12/20 scsi: sd: Translate data lifetime information
In reply to Bart Van AsscheRecently T10 standardized SBC constrained streams. This mechanism allows to pass data lifetime information to SCSI devices in the group number field. Add support for translating write hint information into a permanent stream number in the sd driver. Use WRITE(10) instead of WRITE(6) if data lifetime information is present because the WRITE(6) command does not have a GROUP NUMBER field.
--- drivers/scsi/sd.c | 98 +++++++++++++++++++++++++++++++++++++++++++++-- drivers/scsi/sd.h | 4 +- 2 files changed, 98 insertions(+), 4 deletions(-)
drivers/scsi/sd.c +95 -3
@@ -47,6 +47,7 @@#include <linux/blkpg.h> #include <linux/blk-pm.h> #include <linux/delay.h> +#include <linux/rw_hint.h> #include <linux/major.h> #include <linux/mutex.h> #include <linux/string_helpers.h>
@@ -1080,12 +1081,38 @@ static blk_status_t sd_setup_flush_cmnd(struct scsi_cmnd *cmd)return BLK_STS_OK ; } +/** +* sd_group_number() - Compute the GROUP NUMBER field +* @cmd: SCSI command for which to compute the value of the six-bit GROUP NUMBER +* field. +* +* From SBC-5 r05 (https://www.t10.org/cgi-bin/ac.pl?t=f&f=sbc5r05.pdf): +* 0: no relative lifetime. +* 1: shortest relative lifetime. +* 2: second shortest relative lifetime. +* 3 - 0x3d: intermediate relative lifetimes. +* 0x3e: second longest relative lifetime. +* 0x3f: longest relative lifetime. +*/ +static u8 sd_group_number (struct scsi_cmnd *cmd) +{ +const struct request *rq =scsi_cmd_to_rq (cmd); +struct scsi_disk *sdkp =scsi_disk (rq->q->disk); + +if (!sdkp->rscs) +return 0 ; + +return min3 ((u32 )rq->write_hint, (u32 )sdkp->permanent_stream_count, +0x3fu ); +} +static blk_status_t sd_setup_rw32_cmnd (struct scsi_cmnd *cmd,bool write,sector_t lba,unsigned int nr_blocks,unsigned char flags,unsigned int dld) { cmd->cmd_len =SD_EXT_CDB_SIZE ; cmd->cmnd[0 ] =VARIABLE_LENGTH_CMD ; + cmd->cmnd[6 ] =sd_group_number (cmd); cmd->cmnd[7 ] =0x18 ;/* Additional CDB len */ cmd->cmnd[9 ] = write ?WRITE_32 :READ_32 ; cmd->cmnd[10 ] = flags;
@@ -1104,7 +1131,7 @@ static blk_status_t sd_setup_rw16_cmnd(struct scsi_cmnd *cmd, bool write, cmd->cmd_len =16 ; cmd->cmnd[0 ] = write ?WRITE_16 :READ_16 ; cmd->cmnd[1 ] = flags | ((dld >>2 ) &0x01 ); - cmd->cmnd[14 ] = (dld &0x03 ) <<6 ; + cmd->cmnd[14 ] = ((dld &0x03 ) <<6 ) |sd_group_number (cmd); cmd->cmnd[15 ] =0 ;put_unaligned_be64 (lba, &cmd->cmnd[2 ]);put_unaligned_be32 (nr_blocks, &cmd->cmnd[10 ]);
@@ -1119,7 +1146,7 @@ static blk_status_t sd_setup_rw10_cmnd(struct scsi_cmnd *cmd, bool write, cmd->cmd_len =10 ; cmd->cmnd[0 ] = write ?WRITE_10 :READ_10 ; cmd->cmnd[1 ] = flags; - cmd->cmnd[6 ] =0 ; + cmd->cmnd[6 ] =sd_group_number (cmd); cmd->cmnd[9 ] =0 ;put_unaligned_be32 (lba, &cmd->cmnd[2 ]);put_unaligned_be16 (nr_blocks, &cmd->cmnd[7 ]);
@@ -1256,7 +1283,7 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd) ret =sd_setup_rw16_cmnd (cmd, write, lba, nr_blocks, protect | fua, dld); }else if ((nr_blocks >0xff ) || (lba >0x1fffff ) || - sdp->use_10_for_rw || protect) { + sdp->use_10_for_rw || protect || rq->write_hint) { ret =sd_setup_rw10_cmnd (cmd, write, lba, nr_blocks, protect | fua); }else {
@@ -2996,6 +3023,70 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer) sdkp->DPOFUA =0 ; } +static bool sd_is_perm_stream (struct scsi_disk *sdkp,unsigned int stream_id) +{ +u8 cdb[16 ] = {SERVICE_ACTION_IN_16 ,SAI_GET_STREAM_STATUS }; +struct { +struct scsi_stream_status_header h; +struct scsi_stream_status s; + } buf; +struct scsi_device *sdev = sdkp->device; +struct scsi_sense_hdr sshdr; +const struct scsi_exec_args exec_args = { + .sshdr = &sshdr, + }; +int res; + +put_unaligned_be16 (stream_id, &cdb[4 ]); +put_unaligned_be32 (sizeof (buf), &cdb[10 ]); + + res =scsi_execute_cmd (sdev, cdb,REQ_OP_DRV_IN , &buf,sizeof (buf), +SD_TIMEOUT , sdkp->max_retries, &exec_args); +if (res <0 ) +return false; +if (scsi_status_is_check_condition (res) &&scsi_sense_valid (&sshdr)) +sd_print_sense_hdr (sdkp, &sshdr); +if (res) +return false; +if (get_unaligned_be32 (&buf.h.len) <sizeof (struct scsi_stream_status )) +return false; +return buf.h.stream_status[0 ].perm; +} + +static void sd_read_io_hints (struct scsi_disk *sdkp,unsigned char *buffer) +{ +struct scsi_device *sdp = sdkp->device; +const struct scsi_io_group_descriptor *desc, *start, *end; +struct scsi_sense_hdr sshdr; +struct scsi_mode_data data; +int res; + + res =scsi_mode_sense (sdp,/*dbd=*/ 0x8 ,/*modepage=*/ 0x0a , +/*subpage=*/ 0x05 , buffer,SD_BUF_SIZE ,SD_TIMEOUT , + sdkp->max_retries, &data, &sshdr); +if (res <0 ) +return ; + start = (void *)buffer + data.header_length +16 ; + end = (void *)buffer +ALIGN_DOWN (data.header_length + data.length, +sizeof (*end)); +/* +* From "SBC-5 Constrained Streams with Data Lifetimes": Device severs +* should assign the lowest numbered stream identifiers to permanent +* streams. +*/ +for (desc = start; desc < end; desc++) +if (!desc->st_enble || !sd_is_perm_stream (sdkp, desc - start)) +break ; + sdkp->permanent_stream_count = desc - start; +if (sdkp->rscs && sdkp->permanent_stream_count <2 ) +sd_printk (KERN_INFO , sdkp, +"Unexpected: RSCS has been set and the permanent stream count is %u\n" , + sdkp->permanent_stream_count); +else if (sdkp->permanent_stream_count) +sd_printk (KERN_INFO , sdkp,"permanent stream count = %d\n" , + sdkp->permanent_stream_count); +} +/* * The ATO bit indicates whether the DIF application tag is available * for use by the operating system.
@@ -3479,6 +3570,7 @@ static int sd_revalidate_disk(struct gendisk *disk)sd_read_write_protect_flag (sdkp, buffer);sd_read_cache_type (sdkp, buffer); +sd_read_io_hints (sdkp, buffer);sd_read_app_tag_own (sdkp, buffer);sd_read_write_same (sdkp, buffer);sd_read_security (sdkp, buffer);
drivers/scsi/sd.h +3 -1
@@ -125,6 +125,8 @@ struct scsi_disk {unsigned int physical_block_size;unsigned int max_medium_access_timeouts;unsigned int medium_access_timed_out; +/* number of permanent streams */ +u16 permanent_stream_count;u8 media_present;u8 write_prot;u8 protection_type;/* Data Integrity Field */
@@ -151,7 +153,7 @@ struct scsi_disk { unsigned urswrz : 1; unsigned security : 1; unsigned ignore_medium_access_errors : 1; - bool rscs : 1; /* reduced stream control support */ + unsigned rscs : 1; /* reduced stream control support */ };#define to_scsi_disk (obj) container_of(obj, struct scsi_disk, disk_dev)
PATCH v6 13/20 scsi: scsi_debug: Reduce code duplication
In reply to Bart Van AsscheAll VPD pages have the page code in byte one. Reduce code duplication by storing the VPD page code once.
--- drivers/scsi/scsi_debug.c | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-)
drivers/scsi/scsi_debug.c +2 -14
@@ -1909,7 +1909,8 @@ static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)u32 len;char lu_id_str[6 ];int host_no = devip->sdbg_host->shost->host_no; - + + arr[1 ] = cmd[2 ]; port_group_id = (((host_no +1 ) &0x7f ) <<8 ) + (devip->channel &0x7f );if (sdebug_vpd_use_hostno ==0 )
@@ -1920,7 +1921,6 @@ static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) (devip->target *1000 ) -3 ; len =scnprintf (lu_id_str,6 ,"%d" , lu_id_num);if (0 == cmd[2 ]) {/* supported vital product data pages */ - arr[1 ] = cmd[2 ];/*sanity */ n =4 ; arr[n++] =0x0 ;/* this page */ arr[n++] =0x80 ;/* unit serial number */
@@ -1941,23 +1941,18 @@ static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) } arr[3 ] = n -4 ;/* number of supported VPD pages */ }else if (0x80 == cmd[2 ]) {/* unit serial number */ - arr[1 ] = cmd[2 ];/*sanity */ arr[3 ] = len;memcpy (&arr[4 ], lu_id_str, len); }else if (0x83 == cmd[2 ]) {/* device identification */ - arr[1 ] = cmd[2 ];/*sanity */ arr[3 ] =inquiry_vpd_83 (&arr[4 ], port_group_id, target_dev_id, lu_id_num, lu_id_str, len, &devip->lu_name); }else if (0x84 == cmd[2 ]) {/* Software interface ident. */ - arr[1 ] = cmd[2 ];/*sanity */ arr[3 ] =inquiry_vpd_84 (&arr[4 ]); }else if (0x85 == cmd[2 ]) {/* Management network addresses */ - arr[1 ] = cmd[2 ];/*sanity */ arr[3 ] =inquiry_vpd_85 (&arr[4 ]); }else if (0x86 == cmd[2 ]) {/* extended inquiry */ - arr[1 ] = cmd[2 ];/*sanity */ arr[3 ] =0x3c ;/* number of following entries */ if (sdebug_dif ==T10_PI_TYPE3_PROTECTION ) arr[4 ] =0x4 ;/* SPT: GRD_CHK:1 */
@@ -1967,30 +1962,23 @@ static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) arr[4 ] =0x0 ;/* no protection stuff */ arr[5 ] =0x7 ;/* head of q, ordered + simple q's */ }else if (0x87 == cmd[2 ]) {/* mode page policy */ - arr[1 ] = cmd[2 ];/*sanity */ arr[3 ] =0x8 ;/* number of following entries */ arr[4 ] =0x2 ;/* disconnect-reconnect mp */ arr[6 ] =0x80 ;/* mlus, shared */ arr[8 ] =0x18 ;/* protocol specific lu */ arr[10 ] =0x82 ;/* mlus, per initiator port */ }else if (0x88 == cmd[2 ]) {/* SCSI Ports */ - arr[1 ] = cmd[2 ];/*sanity */ arr[3 ] =inquiry_vpd_88 (&arr[4 ], target_dev_id); }else if (is_disk_zbc &&0x89 == cmd[2 ]) {/* ATA info */ - arr[1 ] = cmd[2 ];/*sanity */ n =inquiry_vpd_89 (&arr[4 ]);put_unaligned_be16 (n, arr +2 ); }else if (is_disk_zbc &&0xb0 == cmd[2 ]) {/* Block limits */ - arr[1 ] = cmd[2 ];/*sanity */ arr[3 ] =inquiry_vpd_b0 (&arr[4 ]); }else if (is_disk_zbc &&0xb1 == cmd[2 ]) {/* Block char. */ - arr[1 ] = cmd[2 ];/*sanity */ arr[3 ] =inquiry_vpd_b1 (devip, &arr[4 ]); }else if (is_disk &&0xb2 == cmd[2 ]) {/* LB Prov. */ - arr[1 ] = cmd[2 ];/*sanity */ arr[3 ] =inquiry_vpd_b2 (&arr[4 ]); }else if (is_zbc && cmd[2 ] ==0xb6 ) {/* ZB dev. charact. */ - arr[1 ] = cmd[2 ];/*sanity */ arr[3 ] =inquiry_vpd_b6 (devip, &arr[4 ]); }else {mk_sense_invalid_fld (scp,SDEB_IN_CDB ,2 ,-1 );
PATCH v6 14/20 scsi: scsi_debug: Support the block limits extension VPD page
In reply to Bart Van AsscheFrom SBC-5 r05:
"Reduced stream control:
a) reduces the maximum number of streams that the device server supports; and
b) increases the number of write commands that are able to specify a stream to be written in any write command that contains the GROUP NUMBER field in its CDB.
If the RSCS bit (see 6.6.5) is set to one, then the device server shall:
a) support per group stream identifier usage as described in 4.32.2;
b) support the IO Advice Hints Grouping mode page (see 6.5.7); and
c) set the MAXIMUM NUMBER OF STREAMS field (see 6.6.5) to a value that is less than 64.
Device servers that set the RSCS bit to one may support other features (e.g., permanent streams (see 4.32.4)).
4.32.4 Permanent streams
A permanent stream is a stream for which the device server does not allow closing or otherwise modifying the configuration of that stream. The PERM bit (see 5.9.2.3) indicates whether a stream is a permanent stream. If a STREAM CONTROL command (see 5.32) specifies the closing of a permanent stream, the device server terminates that command with CHECK CONDITION status instead of closing the specified stream. A permanent stream is always an open stream. Device severs should assign the lowest numbered stream identifiers to permanent streams."
Report that reduced stream control is supported.
--- drivers/scsi/scsi_debug.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
drivers/scsi/scsi_debug.c +16 -0
@@ -1873,6 +1873,19 @@ static int inquiry_vpd_b6(struct sdebug_dev_info *devip, unsigned char *arr)return 0x3c ; } +#define SDEBUG_BLE_LEN_AFTER_B4 28/* thus vpage 32 bytes long */ + +enum {MAXIMUM_NUMBER_OF_STREAMS =6 ,PERMANENT_STREAM_COUNT =5 }; + +/* Block limits extension VPD page (SBC-4) */ +static int inquiry_vpd_b7 (unsigned char *arrb4) +{ +memset (arrb4,0 ,SDEBUG_BLE_LEN_AFTER_B4 ); + arrb4[1 ] =1 ;/* Reduced stream control support (RSCS) */ +put_unaligned_be16 (MAXIMUM_NUMBER_OF_STREAMS , &arrb4[2 ]); +return SDEBUG_BLE_LEN_AFTER_B4 ; +} +#define SDEBUG_LONG_INQ_SZ 96#define SDEBUG_MAX_INQ_ARR_SZ 584
@@ -1938,6 +1951,7 @@ static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) arr[n++] =0xb2 ;/* LB Provisioning */ if (is_zbc) arr[n++] =0xb6 ;/* ZB dev. char. */ + arr[n++] =0xb7 ;/* Block limits extension */ } arr[3 ] = n -4 ;/* number of supported VPD pages */ }else if (0x80 == cmd[2 ]) {/* unit serial number */
@@ -1980,6 +1994,8 @@ static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) arr[3 ] =inquiry_vpd_b2 (&arr[4 ]); }else if (is_zbc && cmd[2 ] ==0xb6 ) {/* ZB dev. charact. */ arr[3 ] =inquiry_vpd_b6 (devip, &arr[4 ]); + }else if (cmd[2 ] ==0xb7 ) {/* block limits extension page */ + arr[3 ] =inquiry_vpd_b7 (&arr[4 ]); }else {mk_sense_invalid_fld (scp,SDEB_IN_CDB ,2 ,-1 );kfree (arr);
PATCH v6 15/20 scsi: scsi_debug: Rework page code error handling
In reply to Bart Van AsscheInstead of tracking whether or not the page code is valid in a boolean variable, jump to error handling code if an unsupported page code is encountered.
--- drivers/scsi/scsi_debug.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-)
drivers/scsi/scsi_debug.c +12 -12
@@ -2650,7 +2650,7 @@ static int resp_mode_sense(struct scsi_cmnd *scp,unsigned char *ap;unsigned char arr[SDEBUG_MAX_MSENSE_SZ ];unsigned char *cmd = scp->cmnd; -bool dbd, llbaa, msense_6, is_disk, is_zbc, bad_pcode; +bool dbd, llbaa, msense_6, is_disk, is_zbc; dbd = !!(cmd[1 ] &0x8 );/* disable block descriptors */ pcontrol = (cmd[2 ] &0xc0 ) >>6 ;
@@ -2714,7 +2714,6 @@ static int resp_mode_sense(struct scsi_cmnd *scp,mk_sense_invalid_fld (scp,SDEB_IN_CDB ,3 ,-1 );return check_condition_result; } - bad_pcode = false;switch (pcode) {case 0x1 :/* Read-Write error recovery page, direct access */
@@ -2729,15 +2728,17 @@ static int resp_mode_sense(struct scsi_cmnd *scp,if (is_disk) { len =resp_format_pg (ap, pcontrol, target); offset += len; - }else - bad_pcode = true; + }else { + goto bad_pcode; + }break ;case 0x8 :/* Caching page, direct access */ if (is_disk || is_zbc) { len =resp_caching_pg (ap, pcontrol, target); offset += len; - }else - bad_pcode = true; + }else { + goto bad_pcode; + }break ;case 0xa :/* Control Mode page, all devices */ len =resp_ctrl_m_pg (ap, pcontrol, target);
@@ -2790,18 +2791,17 @@ static int resp_mode_sense(struct scsi_cmnd *scp, }break ;default : - bad_pcode = true; -break ; - } -if (bad_pcode) { -mk_sense_invalid_fld (scp,SDEB_IN_CDB ,2 ,5 ); -return check_condition_result; + goto bad_pcode; }if (msense_6) arr[0 ] = offset -1 ;else put_unaligned_be16 ((offset -2 ), arr +0 );return fill_from_dev_buffer (scp, arr,min_t (u32, alloc_len, offset)); + +bad_pcode: +mk_sense_invalid_fld (scp,SDEB_IN_CDB ,2 ,5 ); +return check_condition_result; }#define SDEBUG_MAX_MSELECT_SZ 512
PATCH v6 16/20 scsi: scsi_debug: Rework subpage code error handling
In reply to Bart Van AsscheMove the subpage code checks into the switch statement to make it easier to add support for new page code / subpage code combinations.
--- drivers/scsi/scsi_debug.c | 70 ++++++++++++++++++++------------------- 1 file changed, 36 insertions(+), 34 deletions(-)
drivers/scsi/scsi_debug.c +36 -34
@@ -2709,22 +2709,22 @@ static int resp_mode_sense(struct scsi_cmnd *scp, ap = arr + offset; } -if ((subpcode >0x0 ) && (subpcode <0xff ) && (0x19 != pcode)) { -/* TODO: Control Extension page */ -mk_sense_invalid_fld (scp,SDEB_IN_CDB ,3 ,-1 ); -return check_condition_result; - } -switch (pcode) {case 0x1 :/* Read-Write error recovery page, direct access */ +if (subpcode >0x0 && subpcode <0xff ) + goto bad_subpcode; len =resp_err_recov_pg (ap, pcontrol, target); offset += len;break ;case 0x2 :/* Disconnect-Reconnect page, all devices */ +if (subpcode >0x0 && subpcode <0xff ) + goto bad_subpcode; len =resp_disconnect_pg (ap, pcontrol, target); offset += len;break ;case 0x3 :/* Format device page, direct access */ +if (subpcode >0x0 && subpcode <0xff ) + goto bad_subpcode;if (is_disk) { len =resp_format_pg (ap, pcontrol, target); offset += len;
@@ -2733,6 +2733,8 @@ static int resp_mode_sense(struct scsi_cmnd *scp, }break ;case 0x8 :/* Caching page, direct access */ +if (subpcode >0x0 && subpcode <0xff ) + goto bad_subpcode;if (is_disk || is_zbc) { len =resp_caching_pg (ap, pcontrol, target); offset += len;
@@ -2741,14 +2743,14 @@ static int resp_mode_sense(struct scsi_cmnd *scp, }break ;case 0xa :/* Control Mode page, all devices */ +if (subpcode >0x0 && subpcode <0xff ) + goto bad_subpcode; len =resp_ctrl_m_pg (ap, pcontrol, target); offset += len;break ;case 0x19 :/* if spc==1 then sas phy, control+discover */ -if ((subpcode >0x2 ) && (subpcode <0xff )) { -mk_sense_invalid_fld (scp,SDEB_IN_CDB ,3 ,-1 ); -return check_condition_result; - } +if (subpcode >0x2 && subpcode <0xff ) + goto bad_subpcode; len =0 ;if ((0x0 == subpcode) || (0xff == subpcode)) len +=resp_sas_sf_m_pg (ap + len, pcontrol, target);
@@ -2760,35 +2762,31 @@ static int resp_mode_sense(struct scsi_cmnd *scp, offset += len;break ;case 0x1c :/* Informational Exceptions Mode page, all devices */ +if (subpcode >0x0 && subpcode <0xff ) + goto bad_subpcode; len =resp_iec_m_pg (ap, pcontrol, target); offset += len;break ;case 0x3f :/* Read all Mode pages */ -if ((0 == subpcode) || (0xff == subpcode)) { - len =resp_err_recov_pg (ap, pcontrol, target); - len +=resp_disconnect_pg (ap + len, pcontrol, target); -if (is_disk) { - len +=resp_format_pg (ap + len, pcontrol, - target); - len +=resp_caching_pg (ap + len, pcontrol, - target); - }else if (is_zbc) { - len +=resp_caching_pg (ap + len, pcontrol, - target); - } - len +=resp_ctrl_m_pg (ap + len, pcontrol, target); - len +=resp_sas_sf_m_pg (ap + len, pcontrol, target); -if (0xff == subpcode) { - len +=resp_sas_pcd_m_spg (ap + len, pcontrol, - target, target_dev_id); - len +=resp_sas_sha_m_spg (ap + len, pcontrol); - } - len +=resp_iec_m_pg (ap + len, pcontrol, target); - offset += len; - }else { -mk_sense_invalid_fld (scp,SDEB_IN_CDB ,3 ,-1 ); -return check_condition_result; +if (subpcode >0x0 && subpcode <0xff ) + goto bad_subpcode; + len =resp_err_recov_pg (ap, pcontrol, target); + len +=resp_disconnect_pg (ap + len, pcontrol, target); +if (is_disk) { + len +=resp_format_pg (ap + len, pcontrol, target); + len +=resp_caching_pg (ap + len, pcontrol, target); + }else if (is_zbc) { + len +=resp_caching_pg (ap + len, pcontrol, target); + } + len +=resp_ctrl_m_pg (ap + len, pcontrol, target); + len +=resp_sas_sf_m_pg (ap + len, pcontrol, target); +if (0xff == subpcode) { + len +=resp_sas_pcd_m_spg (ap + len, pcontrol, target, + target_dev_id); + len +=resp_sas_sha_m_spg (ap + len, pcontrol); } + len +=resp_iec_m_pg (ap + len, pcontrol, target); + offset += len;break ;default : goto bad_pcode;
@@ -2802,6 +2800,10 @@ static int resp_mode_sense(struct scsi_cmnd *scp, bad_pcode:mk_sense_invalid_fld (scp,SDEB_IN_CDB ,2 ,5 );return check_condition_result; + +bad_subpcode: +mk_sense_invalid_fld (scp,SDEB_IN_CDB ,3 ,-1 ); +return check_condition_result; }#define SDEBUG_MAX_MSELECT_SZ 512
PATCH v6 17/20 scsi: scsi_debug: Allocate the MODE SENSE response from the heap
In reply to Bart Van AsscheMake the MODE SENSE response buffer larger and allocate it from the heap. This patch prepares for adding support for the IO Advice Hints Grouping mode page.
--- drivers/scsi/scsi_debug.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
drivers/scsi/scsi_debug.c +7 -2
@@ -43,6 +43,7 @@#include <linux/prefetch.h> #include <linux/debugfs.h> #include <linux/async.h> +#include <linux/cleanup.h> #include <net/checksum.h>
@@ -2637,7 +2638,8 @@ static int resp_sas_sha_m_spg(unsigned char *p, int pcontrol)return sizeof (sas_sha_m_pg); } -#define SDEBUG_MAX_MSENSE_SZ 256 +/* PAGE_SIZE is more than necessary but provides room for future expansion. */ +#define SDEBUG_MAX_MSENSE_SZ PAGE_SIZEstatic int resp_mode_sense (struct scsi_cmnd *scp,struct sdebug_dev_info *devip)
@@ -2648,10 +2650,13 @@ static int resp_mode_sense(struct scsi_cmnd *scp,int target_dev_id;int target = scp->device->id;unsigned char *ap; -unsigned char arr[SDEBUG_MAX_MSENSE_SZ ]; + unsigned char *arr __free(kfree);unsigned char *cmd = scp->cmnd;bool dbd, llbaa, msense_6, is_disk, is_zbc; + arr =kzalloc (SDEBUG_MAX_MSENSE_SZ ,GFP_ATOMIC ); +if (!arr) +return -ENOMEM ; dbd = !!(cmd[1 ] &0x8 );/* disable block descriptors */ pcontrol = (cmd[2 ] &0xc0 ) >>6 ; pcode = cmd[2 ] &0x3f ;
PATCH v6 18/20 scsi: scsi_debug: Implement the IO Advice Hints Grouping mode page
In reply to Bart Van AsscheImplement an IO Advice Hints Grouping mode page with three permanent streams. A permanent stream is a stream for which the device server does not allow closing or otherwise modifying the configuration of that stream. The stream identifier enable (ST_ENBLE) bit specifies whether the stream identifier may be used in the GROUP NUMBER field of SCSI WRITE commands.
--- drivers/scsi/scsi_debug.c | 61 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 3 deletions(-)
drivers/scsi/scsi_debug.c +58 -3
@@ -1975,7 +1975,11 @@ static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) arr[4 ] =0x5 ;/* SPT: GRD_CHK:1, REF_CHK:1 */ else arr[4 ] =0x0 ;/* no protection stuff */ - arr[5 ] =0x7 ;/* head of q, ordered + simple q's */ +/* +* GROUP_SUP=1; HEADSUP=1 (HEAD OF QUEUE); ORDSUP=1 +* (ORDERED queuing); SIMPSUP=1 (SIMPLE queuing). +*/ + arr[5 ] =0x17 ; }else if (0x87 == cmd[2 ]) {/* mode page policy */ arr[3 ] =0x8 ;/* number of following entries */ arr[4 ] =0x2 ;/* disconnect-reconnect mp */
@@ -2565,6 +2569,40 @@ static int resp_ctrl_m_pg(unsigned char *p, int pcontrol, int target)return sizeof (ctrl_m_pg); } +/* IO Advice Hints Grouping mode page */ +static int resp_grouping_m_pg (unsigned char *p,int pcontrol,int target) +{ +/* IO Advice Hints Grouping mode page */ +struct grouping_m_pg { +u8 page_code;/* OR 0x40 when subpage_code > 0 */ +u8 subpage_code; +__be16 page_length; +u8 reserved[12 ]; +struct scsi_io_group_descriptor descr[MAXIMUM_NUMBER_OF_STREAMS ]; + }; +static const struct grouping_m_pg gr_m_pg = { + .page_code =0xa |0x40 , + .subpage_code =5 , + .page_length =cpu_to_be16 (sizeof (gr_m_pg) -4 ), + .descr = { + { .st_enble =1 }, + { .st_enble =1 }, + { .st_enble =1 }, + { .st_enble =1 }, + { .st_enble =1 }, + { .st_enble =0 }, + } + }; + +BUILD_BUG_ON (sizeof (struct grouping_m_pg ) != +16 +MAXIMUM_NUMBER_OF_STREAMS *16 ); +memcpy (p, &gr_m_pg,sizeof (gr_m_pg)); +if (1 == pcontrol) { +/* There are no changeable values so clear from byte 4 on. */ +memset (p +4 ,0 ,sizeof (gr_m_pg) -4 ); + } +return sizeof (gr_m_pg); +}static int resp_iec_m_pg (unsigned char *p,int pcontrol,int target) {/* Informational Exceptions control mode page for mode_sense */
@@ -2714,6 +2752,10 @@ static int resp_mode_sense(struct scsi_cmnd *scp, ap = arr + offset; } +/* +* N.B. If len>0 before resp_*_pg() call, then form of that call should be: +* len += resp_*_pg(ap + len, pcontrol, target); +*/ switch (pcode) {case 0x1 :/* Read-Write error recovery page, direct access */ if (subpcode >0x0 && subpcode <0xff )
@@ -2748,9 +2790,20 @@ static int resp_mode_sense(struct scsi_cmnd *scp, }break ;case 0xa :/* Control Mode page, all devices */ -if (subpcode >0x0 && subpcode <0xff ) +switch (subpcode) { +case 0 : + len =resp_ctrl_m_pg (ap, pcontrol, target); +break ; +case 0x05 : + len =resp_grouping_m_pg (ap, pcontrol, target); +break ; +case 0xff : + len =resp_ctrl_m_pg (ap, pcontrol, target); + len +=resp_grouping_m_pg (ap + len, pcontrol, target); +break ; +default : goto bad_subpcode; - len =resp_ctrl_m_pg (ap, pcontrol, target); + } offset += len;break ;case 0x19 :/* if spc==1 then sas phy, control+discover */
@@ -2784,6 +2837,8 @@ static int resp_mode_sense(struct scsi_cmnd *scp, len +=resp_caching_pg (ap + len, pcontrol, target); } len +=resp_ctrl_m_pg (ap + len, pcontrol, target); +if (0xff == subpcode) + len +=resp_grouping_m_pg (ap + len, pcontrol, target); len +=resp_sas_sf_m_pg (ap + len, pcontrol, target);if (0xff == subpcode) { len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
PATCH v6 19/20 scsi: scsi_debug: Implement GET STREAM STATUS
In reply to Bart Van AsscheImplement the GET STREAM STATUS SCSI command. Report that the first five stream indexes correspond to permanent streams.
--- drivers/scsi/scsi_debug.c | 50 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+)
drivers/scsi/scsi_debug.c +50 -0
@@ -533,6 +533,8 @@ static int resp_write_scat(struct scsi_cmnd *, struct sdebug_dev_info *);static int resp_start_stop (struct scsi_cmnd *,struct sdebug_dev_info *);static int resp_readcap16 (struct scsi_cmnd *,struct sdebug_dev_info *);static int resp_get_lba_status (struct scsi_cmnd *,struct sdebug_dev_info *); +static int resp_get_stream_status (struct scsi_cmnd *scp, +struct sdebug_dev_info *devip);static int resp_report_tgtpgs (struct scsi_cmnd *,struct sdebug_dev_info *);static int resp_unmap (struct scsi_cmnd *,struct sdebug_dev_info *);static int resp_rsup_opcodes (struct scsi_cmnd *,struct sdebug_dev_info *);
@@ -607,6 +609,9 @@ static const struct opcode_info_t sa_in_16_iarr[] = { {0 ,0x9e ,0x12 ,F_SA_LOW |F_D_IN , resp_get_lba_status,NULL , {16, 0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0xc7} }, /* GET LBA STATUS(16) */ + {0, 0x9e, 0x16, F_SA_LOW | F_D_IN, resp_get_stream_status, NULL, + {16, 0x16, 0, 0, 0xff, 0xff, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, + 0, 0} }, /* GET STREAM STATUS */ }; static const struct opcode_info_t vl_iarr[] = { /* VARIABLE LENGTH */
@@ -4581,6 +4586,51 @@ static int resp_get_lba_status(struct scsi_cmnd *scp,return fill_from_dev_buffer (scp, arr,SDEBUG_GET_LBA_STATUS_LEN ); } +static int resp_get_stream_status (struct scsi_cmnd *scp, +struct sdebug_dev_info *devip) +{ +u16 starting_stream_id, stream_id; +const u8 *cmd = scp->cmnd; +u32 alloc_len, offset; +u8 arr[256 ] = {}; +struct scsi_stream_status_header *h = (void *)arr; + + starting_stream_id =get_unaligned_be16 (cmd +4 ); + alloc_len =get_unaligned_be32 (cmd +10 ); + +if (alloc_len <8 ) { +mk_sense_invalid_fld (scp,SDEB_IN_CDB ,10 ,-1 ); +return check_condition_result; + } + +if (starting_stream_id >=MAXIMUM_NUMBER_OF_STREAMS ) { +mk_sense_invalid_fld (scp,SDEB_IN_CDB ,4 ,-1 ); +return check_condition_result; + } + +/* +* The GET STREAM STATUS command only reports status information +* about open streams. Treat the non-permanent stream as open. +*/ +put_unaligned_be16 (MAXIMUM_NUMBER_OF_STREAMS , + &h->number_of_open_streams); + +for (offset =8 , stream_id = starting_stream_id; + offset +8 <=min_t (u32, alloc_len,sizeof (arr)) && + stream_id <MAXIMUM_NUMBER_OF_STREAMS ; + offset +=8 , stream_id++) { +struct scsi_stream_status *stream_status = (void *)arr + offset; + + stream_status->perm = stream_id <PERMANENT_STREAM_COUNT ; +put_unaligned_be16 (stream_id, + &stream_status->stream_identifier); + stream_status->rel_lifetime = stream_id +1 ; + } +put_unaligned_be32 (offset -8 , &h->len);/* PARAMETER DATA LENGTH */ + +return fill_from_dev_buffer (scp, arr,min (offset, alloc_len)); +} +static int resp_sync_cache (struct scsi_cmnd *scp,struct sdebug_dev_info *devip) {
PATCH v6 20/20 scsi: scsi_debug: Maintain write statistics per group number
In reply to Bart Van AsscheTrack per GROUP NUMBER how many write commands have been processed. Make this information available in sysfs. Reset these statistics if any data is written into the sysfs attribute.
Note: SCSI devices should only interpret the information in the GROUP NUMBER field as a stream identifier if the ST_ENBLE bit has been set to one. This patch follows a simpler approach: count the number of writes per GROUP NUMBER whether or not the group number represents a stream identifier.
--- drivers/scsi/scsi_debug.c | 49 +++++++++++++++++++++++++++++++++++---- 1 file changed, 45 insertions(+), 4 deletions(-)
drivers/scsi/scsi_debug.c +45 -4
@@ -899,6 +899,8 @@ static int sdeb_zbc_nr_conv = DEF_ZBC_NR_CONV_ZONES;static int submit_queues =DEF_SUBMIT_QUEUES ;/* > 1 for multi-queue (mq) */ static int poll_queues;/* iouring iopoll interface.*/ +static atomic_long_t writes_by_group_number[64 ]; +static char sdebug_proc_name[] =MY_NAME ;static const char *my_name =MY_NAME ;
@@ -3385,7 +3387,8 @@ static inline struct sdeb_store_info *devip2sip(struct sdebug_dev_info *devip,/* Returns number of bytes copied or -1 if error. */ static int do_device_access (struct sdeb_store_info *sip,struct scsi_cmnd *scp, -u32 sg_skip,u64 lba,u32 num,bool do_write) +u32 sg_skip,u64 lba,u32 num,bool do_write, +u8 group_number) {int ret;u64 block, rest =0 ;
@@ -3404,6 +3407,10 @@ static int do_device_access(struct sdeb_store_info *sip, struct scsi_cmnd *scp,return 0 ;if (scp->sc_data_direction != dir)return -1 ; + +if (do_write && group_number <ARRAY_SIZE (writes_by_group_number)) +atomic_long_inc (&writes_by_group_number[group_number]); + fsp = sip->storep; block =do_div (lba, sdebug_store_sectors);
@@ -3777,7 +3784,7 @@ static int resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) } } - ret =do_device_access (sip, scp,0 , lba, num, false); + ret =do_device_access (sip, scp,0 , lba, num, false,0 );sdeb_read_unlock (sip);if (unlikely (ret ==-1 ))return DID_ERROR <<16 ;
@@ -3962,6 +3969,7 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) {bool check_prot;u32 num; +u8 group =0 ;u32 ei_lba;int ret;u64 lba;
@@ -3973,11 +3981,13 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) ei_lba =0 ; lba =get_unaligned_be64 (cmd +2 ); num =get_unaligned_be32 (cmd +10 ); + group = cmd[14 ] &0x3f ; check_prot = true;break ;case WRITE_10 : ei_lba =0 ; lba =get_unaligned_be32 (cmd +2 ); + group = cmd[6 ] &0x3f ; num =get_unaligned_be16 (cmd +7 ); check_prot = true;break ;
@@ -3992,15 +4002,18 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) ei_lba =0 ; lba =get_unaligned_be32 (cmd +2 ); num =get_unaligned_be32 (cmd +6 ); + group = cmd[6 ] &0x3f ; check_prot = true;break ;case 0x53 :/* XDWRITEREAD(10) */ ei_lba =0 ; lba =get_unaligned_be32 (cmd +2 ); + group = cmd[6 ] &0x1f ; num =get_unaligned_be16 (cmd +7 ); check_prot = false;break ;default :/* assume WRITE(32) */ + group = cmd[6 ] &0x3f ; lba =get_unaligned_be64 (cmd +12 ); ei_lba =get_unaligned_be32 (cmd +20 ); num =get_unaligned_be32 (cmd +28 );
@@ -4055,7 +4068,7 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) } } - ret =do_device_access (sip, scp,0 , lba, num, true); + ret =do_device_access (sip, scp,0 , lba, num, true, group);if (unlikely (scsi_debug_lbp ()))map_region (sip, lba, num);/* If ZBC zone then bump its write pointer */
@@ -4107,12 +4120,14 @@ static int resp_write_scat(struct scsi_cmnd *scp,u32 lb_size = sdebug_sector_size;u32 ei_lba;u64 lba; +u8 group;int ret, res;bool is_16;static const u32 lrd_size =32 ;/* + parameter list header size */ if (cmd[0 ] ==VARIABLE_LENGTH_CMD ) { is_16 = false; + group = cmd[6 ] &0x3f ; wrprotect = (cmd[10 ] >>5 ) &0x7 ; lbdof =get_unaligned_be16 (cmd +12 ); num_lrd =get_unaligned_be16 (cmd +16 );
@@ -4123,6 +4138,7 @@ static int resp_write_scat(struct scsi_cmnd *scp, lbdof =get_unaligned_be16 (cmd +4 ); num_lrd =get_unaligned_be16 (cmd +8 ); bt_len =get_unaligned_be32 (cmd +10 ); + group = cmd[14 ] &0x3f ;if (unlikely (have_dif_prot)) {if (sdebug_dif ==T10_PI_TYPE2_PROTECTION && wrprotect) {
@@ -4211,7 +4227,7 @@ static int resp_write_scat(struct scsi_cmnd *scp, } } - ret =do_device_access (sip, scp, sg_off, lba, num, true); + ret =do_device_access (sip, scp, sg_off, lba, num, true, group);/* If ZBC zone then bump its write pointer */ if (sdebug_dev_is_zoned (devip))zbc_inc_wp (devip, lba, num);
@@ -7306,6 +7322,30 @@ static ssize_t tur_ms_to_ready_show(struct device_driver *ddp, char *buf) }static DRIVER_ATTR_RO (tur_ms_to_ready); +static ssize_t group_number_stats_show (struct device_driver *ddp,char *buf) +{ +char *p = buf, *end = buf +PAGE_SIZE ; +int i; + +for (i =0 ; i <ARRAY_SIZE (writes_by_group_number); i++) + p +=scnprintf (p, end - p,"%d %ld\n" , i, +atomic_long_read (&writes_by_group_number[i])); + +return p - buf; +} + +static ssize_t group_number_stats_store (struct device_driver *ddp, +const char *buf,size_t count) +{ +int i; + +for (i =0 ; i <ARRAY_SIZE (writes_by_group_number); i++) +atomic_long_set (&writes_by_group_number[i],0 ); + +return count; +} +static DRIVER_ATTR_RW (group_number_stats); +/* Note: The following array creates attribute files in the /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these files (over those found in the /sys/module/scsi_debug/parameters
@@ -7352,6 +7392,7 @@ static struct attribute *sdebug_drv_attrs[] = { &driver_attr_cdb_len.attr, &driver_attr_tur_ms_to_ready.attr, &driver_attr_zbc.attr, + &driver_attr_group_number_stats.attr,NULL , };ATTRIBUTE_GROUPS (sdebug_drv);