*** adding and exposing SANITIZE capability to the user space via a unique IOCTL ***
Subsystems (5)
v9 cover *** adding and exposing SANITIZE capability to the user space via a unique IOCTL ***
*** adding and exposing SANITIZE capability to the user space via a unique IOCTL ***
Yaniv Gardi (2):
block: ioctl support for sanitize in eMMC 4.5
mmc: card: Adding support for sanitize in eMMC 4.5
block/blk-core.c | 8 +++++ block/blk-lib.c | 51 ++++++++++++++++++++++++++++++ block/blk-merge.c | 4 ++ block/elevator.c | 6 +++- block/ioctl.c | 9 +++++ drivers/mmc/card/block.c | 75 +++++++++++++++++++++++++++++++------------- drivers/mmc/card/queue.c | 10 +++++- include/linux/blk_types.h | 7 +++- include/linux/blkdev.h | 6 +++ include/linux/mmc/host.h | 1 + include/uapi/linux/fs.h | 1 + kernel/trace/blktrace.c | 2 + 12 files changed, 154 insertions(+), 26 deletions(-)
Signature · 4 lines
1.7.6 -- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum
PATCH v9 1/2 block: ioctl support for sanitize in eMMC 4.5
Adding a new ioctl to support sanitize operation in eMMC cards version 4.5.
The sanitize ioctl-support, helps performing this operation via user application
--- block/blk-core.c | 8 +++++++ block/blk-lib.c | 51 +++++++++++++++++++++++++++++++++++++++++++++ block/blk-merge.c | 4 +++ block/elevator.c | 6 ++++- block/ioctl.c | 9 ++++++++ include/linux/blk_types.h | 7 ++++- include/linux/blkdev.h | 6 +++++ include/uapi/linux/fs.h | 1 + kernel/trace/blktrace.c | 2 + 9 files changed, 91 insertions(+), 3 deletions(-)
block/blk-core.c +8 -0
@@ -1740,6 +1740,14 @@ generic_make_request_checks(struct bio *bio) goto end_io; } +if ((bio->bi_rw &REQ_SANITIZE ) && + (!blk_queue_sanitize (q))) { +pr_info ("%s - Queue doesn't support sanitize requests" , + __func__); + err = -EOPNOTSUPP ; + goto end_io; + } +if (bio->bi_rw &REQ_WRITE_SAME && !bdev_write_same (bio->bi_bdev)) { err = -EOPNOTSUPP ; goto end_io;
block/blk-lib.c +51 -0
57 lines not on this page · raw message
block/blk-merge.c +4 -0
@@ -507,6 +507,10 @@ bool blk_rq_merge_ok(struct request *rq, struct bio *bio)if (!rq_mergeable (rq) || !bio_mergeable (bio))return false; +/* don't merge file system requests and sanitize requests */ +if ((bio->bi_rw &REQ_SANITIZE ) != (rq->bio->bi_rw &REQ_SANITIZE )) +return false; +if (!blk_check_merge_flags (rq->cmd_flags, bio->bi_rw))return false;
block/elevator.c +5 -1
@@ -364,6 +364,9 @@ void elv_dispatch_sort(struct request_queue *q, struct request *rq)if ((rq->cmd_flags &REQ_DISCARD ) != (pos->cmd_flags &REQ_DISCARD ))break ; +if ((rq->cmd_flags &REQ_SANITIZE ) != + (pos->cmd_flags &REQ_SANITIZE )) +break ;if (rq_data_dir (rq) !=rq_data_dir (pos))break ;if (pos->cmd_flags & stop_flags)
@@ -570,7 +573,8 @@ void __elv_add_request(struct request_queue *q, struct request *rq, int where)if (rq->cmd_flags &REQ_SOFTBARRIER ) {/* barriers are scheduling boundary, update end_sector */ -if (rq->cmd_type ==REQ_TYPE_FS ) { +if ((rq->cmd_type ==REQ_TYPE_FS ) || + (rq->cmd_flags &REQ_SANITIZE )) { q->end_sector =rq_end_sector (rq); q->boundary_rq = rq; }
block/ioctl.c +9 -0
@@ -185,6 +185,11 @@ static int blk_ioctl_discard(struct block_device *bdev, uint64_t start,return blkdev_issue_discard (bdev, start, len,GFP_KERNEL , flags); } +static int blk_ioctl_sanitize (struct block_device *bdev) +{ +return blkdev_issue_sanitize (bdev,GFP_KERNEL ); +} +static int blk_ioctl_zeroout (struct block_device *bdev,uint64_t start,uint64_t len) {
@@ -303,6 +308,10 @@ int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,set_device_ro (bdev, n);return 0 ; +case BLKSANITIZE : + ret =blk_ioctl_sanitize (bdev); +break ; +case BLKDISCARD :case BLKSECDISCARD : {uint64_t range[2 ];
include/linux/blk_types.h +5 -2
@@ -175,6 +175,7 @@ enum rq_flag_bits { __REQ_IO_STAT,/* account I/O stat */ __REQ_MIXED_MERGE,/* merge of different types, fail separately */ __REQ_KERNEL,/* direct IO to kernel pages */ + __REQ_SANITIZE,/* sanitize */ __REQ_NR_BITS, /* stops here */ };
@@ -187,6 +188,7 @@ enum rq_flag_bits {#define REQ_PRIO (1 << __REQ_PRIO)#define REQ_DISCARD (1 << __REQ_DISCARD)#define REQ_WRITE_SAME (1 << __REQ_WRITE_SAME) +#define REQ_SANITIZE (1 << __REQ_SANITIZE)#define REQ_NOIDLE (1 << __REQ_NOIDLE)#define REQ_FAILFAST_MASK \
@@ -194,12 +196,13 @@ enum rq_flag_bits {#define REQ_COMMON_MASK \ (REQ_WRITE | REQ_FAILFAST_MASK | REQ_SYNC | REQ_META | REQ_PRIO | \ REQ_DISCARD | REQ_WRITE_SAME | REQ_NOIDLE | REQ_FLUSH | REQ_FUA | \ - REQ_SECURE) + REQ_SECURE | REQ_SANITIZE)#define REQ_CLONE_MASK REQ_COMMON_MASK/* This mask is used for both bio and request merge checking */ #define REQ_NOMERGE_FLAGS \ - (REQ_NOMERGE | REQ_STARTED | REQ_SOFTBARRIER | REQ_FLUSH | REQ_FUA) + (REQ_NOMERGE | REQ_STARTED | REQ_SOFTBARRIER | REQ_FLUSH | REQ_FUA | \ + REQ_SANITIZE)#define REQ_RAHEAD (1 << __REQ_RAHEAD)#define REQ_THROTTLED (1 << __REQ_THROTTLED)
include/linux/blkdev.h +6 -0
@@ -459,6 +459,7 @@ struct request_queue {#define QUEUE_FLAG_SECDISCARD 17/* supports SECDISCARD */ #define QUEUE_FLAG_SAME_FORCE 18/* force complete on same CPU */ #define QUEUE_FLAG_DEAD 19/* queue tear-down finished */ +#define QUEUE_FLAG_SANITIZE 20/* supports SANITIZE */ #define QUEUE_FLAG_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) | \ (1 << QUEUE_FLAG_STACKABLE) | \
@@ -540,6 +541,7 @@ static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)#define blk_queue_stackable (q) \ test_bit(QUEUE_FLAG_STACKABLE, &(q)->queue_flags)#define blk_queue_discard (q) test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags) +#define blk_queue_sanitize (q) test_bit(QUEUE_FLAG_SANITIZE, &(q)->queue_flags)#define blk_queue_secdiscard (q) (blk_queue_discard(q) && \ test_bit(QUEUE_FLAG_SECDISCARD, &(q)->queue_flags))
@@ -620,6 +622,9 @@ static inline bool blk_check_merge_flags(unsigned int flags1,if ((flags1 &REQ_DISCARD ) != (flags2 &REQ_DISCARD ))return false; +if ((flags1 &REQ_SANITIZE ) != (flags2 &REQ_SANITIZE )) +return false; +if ((flags1 &REQ_SECURE ) != (flags2 &REQ_SECURE ))return false;
@@ -1041,6 +1046,7 @@ static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,extern int blkdev_issue_flush (struct block_device *,gfp_t ,sector_t *);extern int blkdev_issue_discard (struct block_device *bdev,sector_t sector,sector_t nr_sects,gfp_t gfp_mask,unsigned long flags); +extern int blkdev_issue_sanitize (struct block_device *bdev,gfp_t gfp_mask);extern int blkdev_issue_write_same (struct block_device *bdev,sector_t sector,sector_t nr_sects,gfp_t gfp_mask,struct page *page); extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
include/uapi/linux/fs.h +1 -0
@@ -144,6 +144,7 @@ struct inodes_stat_t {#define BLKSECDISCARD _IO(0x12,125)#define BLKROTATIONAL _IO(0x12,126)#define BLKZEROOUT _IO(0x12,127) +#define BLKSANITIZE _IO(0x12, 128)#define BMAP_IOCTL 1/* obsolete - kept for compatibility */ #define FIBMAP _IO(0x00,1)/* bmap access */
kernel/trace/blktrace.c +2 -0
@@ -1788,6 +1788,8 @@ void blk_fill_rwbs(char *rwbs, u32 rw, int bytes) rwbs[i++] ='W' ; else if (rw & REQ_DISCARD) rwbs[i++] ='D' ; + else if (rw & REQ_SANITIZE) + rwbs[i++] ='Z' ; else if (bytes) rwbs[i++] ='R' ; else
Signature · 4 lines
1.7.6 -- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum
PATCH v9 2/2 mmc: card: Adding support for sanitize in eMMC 4.5
In reply to Yaniv GardiThis feature deletes the unmap memory region of the eMMC card, by writing to a specific register in the EXT_CSD. unmap region is the memory region that was previously deleted (by erase, trim or discard operation).
In order to avoid timeout when sanitizing large-scale cards, the timeout for sanitize operation is 240 seconds.
--- drivers/mmc/card/block.c | 75 ++++++++++++++++++++++++++++++++------------- drivers/mmc/card/queue.c | 10 +++++- include/linux/mmc/host.h | 1 + 3 files changed, 63 insertions(+), 23 deletions(-)
drivers/mmc/card/block.c +53 -22
@@ -58,6 +58,7 @@ MODULE_ALIAS("mmc:block");#define INAND_CMD38_ARG_SECTRIM1 0x81#define INAND_CMD38_ARG_SECTRIM2 0x88#define MMC_BLK_TIMEOUT_MS (10 * 60 * 1000)/* 10 minute timeout */ +#define MMC_SANITIZE_REQ_TIMEOUT 240000static DEFINE_MUTEX (block_mutex);
@@ -925,10 +926,10 @@ static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq, {struct mmc_blk_data *md = mq->data;struct mmc_card *card = md->queue.card; -unsigned int from, nr, arg, trim_arg, erase_arg; +unsigned int from, nr, arg;int err =0 , type =MMC_BLK_SECDISCARD ; -if (!(mmc_can_secure_erase_trim (card) ||mmc_can_sanitize (card))) { +if (!(mmc_can_secure_erase_trim (card))) { err = -EOPNOTSUPP ; goto out; }
@@ -936,23 +937,11 @@ static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq, from =blk_rq_pos (req); nr =blk_rq_sectors (req); -/* The sanitize operation is supported at v4.5 only */ -if (mmc_can_sanitize (card)) { - erase_arg =MMC_ERASE_ARG ; - trim_arg =MMC_TRIM_ARG ; - }else { - erase_arg =MMC_SECURE_ERASE_ARG ; - trim_arg =MMC_SECURE_TRIM1_ARG ; - } +if (mmc_can_trim (card) && !mmc_erase_group_aligned (card, from, nr)) + arg =MMC_SECURE_TRIM1_ARG ; +else + arg =MMC_SECURE_ERASE_ARG ; -if (mmc_erase_group_aligned (card, from, nr)) - arg = erase_arg; -else if (mmc_can_trim (card)) - arg = trim_arg; -else { - err = -EINVAL ; - goto out; - } retry:if (card->quirks &MMC_QUIRK_INAND_CMD38 ) { err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
@@ -988,9 +977,6 @@ retry: goto out; } -if (mmc_can_sanitize (card)) - err =mmc_switch (card,EXT_CSD_CMD_SET_NORMAL , -EXT_CSD_SANITIZE_START ,1 ,0 ); out_retry:if (err && !mmc_blk_reset (md, card->host, type)) goto retry;
@@ -1002,6 +988,46 @@ out:return err ?0 :1 ; } +static int mmc_blk_issue_sanitize_rq (struct mmc_queue *mq, +struct request *req) +{ +struct mmc_blk_data *md = mq->data; +struct mmc_card *card = md->queue.card; +int err =0 ; + +BUG_ON (!card); +BUG_ON (!card->host); + +if (!(mmc_can_sanitize (card) && + (card->host->caps2 &MMC_CAP2_SANITIZE ))) { +pr_warn ("%s: %s - SANITIZE is not supported\n" , +mmc_hostname (card->host), __func__); + err = -EOPNOTSUPP ; + goto out; + } + +pr_debug ("%s: %s - SANITIZE IN PROGRESS...\n" , +mmc_hostname (card->host), __func__); + + err =mmc_switch (card,EXT_CSD_CMD_SET_NORMAL , +EXT_CSD_SANITIZE_START ,1 ,MMC_SANITIZE_REQ_TIMEOUT ); + +if (err) +pr_err ("%s: %s - mmc_switch() with SANITIZE failed. err=%d\n" , +mmc_hostname (card->host), __func__, err); + +pr_debug ("%s: %s - SANITIZE COMPLETED\n" ,mmc_hostname (card->host), + __func__); + +out: +spin_lock_irq (&md->lock); +__blk_end_request (req, err,blk_rq_bytes (req)); +spin_unlock_irq (&md->lock); + +return err ?0 :1 ; +} + +static int mmc_blk_issue_flush (struct mmc_queue *mq,struct request *req) {struct mmc_blk_data *md = mq->data;
@@ -1486,7 +1512,12 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req) goto out; } -if (req && req->cmd_flags &REQ_DISCARD ) { +if (req && req->cmd_flags &REQ_SANITIZE ) { +/* complete ongoing async transfer before issuing sanitize */ +if (card->host && card->host->areq) +mmc_blk_issue_rw_rq (mq,NULL ); + ret =mmc_blk_issue_sanitize_rq (mq, req); + }else if (req && req->cmd_flags &REQ_DISCARD ) {/* complete ongoing async transfer before issuing discard */ if (card->host->areq)mmc_blk_issue_rw_rq (mq,NULL );
drivers/mmc/card/queue.c +9 -1
@@ -148,10 +148,15 @@ static void mmc_queue_setup_discard(struct request_queue *q,/* granularity must not be greater than max. discard */ if (card->pref_erase > max_discard) q->limits.discard_granularity =0 ; -if (mmc_can_secure_erase_trim (card) ||mmc_can_sanitize (card)) +if (mmc_can_secure_erase_trim (card))queue_flag_set_unlocked (QUEUE_FLAG_SECDISCARD , q); } +static void mmc_queue_setup_sanitize (struct request_queue *q) +{ +queue_flag_set_unlocked (QUEUE_FLAG_SANITIZE , q); +} +/** * mmc_init_queue - initialise a queue structure. * @mq: mmc queue
@@ -187,6 +192,9 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,if (mmc_can_erase (card))mmc_queue_setup_discard (mq->queue, card); +if ((mmc_can_sanitize (card) && (host->caps2 &MMC_CAP2_SANITIZE ))) +mmc_queue_setup_sanitize (mq->queue); +#ifdef CONFIG_MMC_BLOCK_BOUNCE if (host->max_segs ==1 ) {unsigned int bouncesz;
include/linux/mmc/host.h +1 -0
@@ -258,6 +258,7 @@ struct mmc_host {#define MMC_CAP2_HC_ERASE_SZ (1 << 9)/* High-capacity erase size */ #define MMC_CAP2_CD_ACTIVE_HIGH (1 << 10)/* Card-detect signal active high */ #define MMC_CAP2_RO_ACTIVE_HIGH (1 << 11)/* Write-protect signal active high */ +#define MMC_CAP2_SANITIZE (1 << 12)/* Support Sanitize */ mmc_pm_flag_t pm_caps;/* supported pm features */
Signature · 4 lines
1.7.6 -- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum
Quoted 1 line · Yaniv Gardi
*** adding and exposing SANITIZE capability to the user space via a unique IOCTL ***
If this is something eMMC specific and not expected to have in-kernel consumer, unlike DISCARD which filesystems use, why not just use SG_IO?
Thanks.
Signature · 1 line
tejun