[RFC PATCH 01/39] blktrace_api: add new trace definitions

[RFC PATCH 01/39] blktrace_api: add new trace definitions

[Chaitanya Kulkarni]

This patch adds a new trace categories, trace actions adds a new
version number for the trace extentions, adds new trace extension
structure to hold actual trace along with structure nedded to execute
various IOCTLs to configure trace from user space.

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 include/uapi/linux/blktrace_api.h | 110 ++++++++++++++++++++++++------
 1 file changed, 89 insertions(+), 21 deletions(-)

diff --git a/include/uapi/linux/blktrace_api.h b/include/uapi/linux/blktrace_api.h
index 690621b610e5..fdb3a5cdfa22 100644
--- a/include/uapi/linux/blktrace_api.h
+++ b/include/uapi/linux/blktrace_api.h
@@ -8,30 +8,41 @@
  * Trace categories
  */
 enum blktrace_cat {
-	BLK_TC_READ	= 1 << 0,	/* reads */
-	BLK_TC_WRITE	= 1 << 1,	/* writes */
-	BLK_TC_FLUSH	= 1 << 2,	/* flush */
-	BLK_TC_SYNC	= 1 << 3,	/* sync IO */
-	BLK_TC_SYNCIO	= BLK_TC_SYNC,
-	BLK_TC_QUEUE	= 1 << 4,	/* queueing/merging */
-	BLK_TC_REQUEUE	= 1 << 5,	/* requeueing */
-	BLK_TC_ISSUE	= 1 << 6,	/* issue */
-	BLK_TC_COMPLETE	= 1 << 7,	/* completions */
-	BLK_TC_FS	= 1 << 8,	/* fs requests */
-	BLK_TC_PC	= 1 << 9,	/* pc requests */
-	BLK_TC_NOTIFY	= 1 << 10,	/* special message */
-	BLK_TC_AHEAD	= 1 << 11,	/* readahead */
-	BLK_TC_META	= 1 << 12,	/* metadata */
-	BLK_TC_DISCARD	= 1 << 13,	/* discard requests */
-	BLK_TC_DRV_DATA	= 1 << 14,	/* binary per-driver data */
-	BLK_TC_FUA	= 1 << 15,	/* fua requests */
-
-	BLK_TC_END	= 1 << 15,	/* we've run out of bits! */
+	BLK_TC_READ		= 1 << 0,	/* reads */
+	BLK_TC_WRITE		= 1 << 1,	/* writes */
+	BLK_TC_FLUSH		= 1 << 2,	/* flush */
+	BLK_TC_SYNC		= 1 << 3,	/* sync IO */
+	BLK_TC_SYNCIO		= BLK_TC_SYNC,
+	BLK_TC_QUEUE		= 1 << 4,	/* queueing/merging */
+	BLK_TC_REQUEUE		= 1 << 5,	/* requeueing */
+	BLK_TC_ISSUE		= 1 << 6,	/* issue */
+	BLK_TC_COMPLETE		= 1 << 7,	/* completions */
+	BLK_TC_FS		= 1 << 8,	/* fs requests */
+	BLK_TC_PC		= 1 << 9,	/* pc requests */
+	BLK_TC_NOTIFY		= 1 << 10,	/* special message */
+	BLK_TC_AHEAD		= 1 << 11,	/* readahead */
+	BLK_TC_META		= 1 << 12,	/* metadata */
+	BLK_TC_DISCARD		= 1 << 13,	/* discard requests */
+	BLK_TC_DRV_DATA		= 1 << 14,	/* binary per-driver data */
+	BLK_TC_FUA		= 1 << 15,	/* fua requests */
+	BLK_TC_WRITE_ZEROES	= 1 << 16,	/* write-zeores */
+	BLK_TC_ZONE_RESET	= 1 << 17,	/* zone-reset */
+	BLK_TC_ZONE_RESET_ALL	= 1 << 18,	/* zone-reset-all */
+	BLK_TC_ZONE_APPEND	= 1 << 19,	/* zone-append */
+	BLK_TC_ZONE_OPEN	= 1 << 20,	/* zone-open */
+	BLK_TC_ZONE_CLOSE	= 1 << 21,	/* zone-close */
+	BLK_TC_ZONE_FINISH	= 1 << 22,	/* zone-finish */
+
+	BLK_TC_END		= 1 << 15,	/* we've run out of bits! */
+	BLK_TC_END_EXT		= 1 << 31,	/* we've run out of bits! */
 };
 
 #define BLK_TC_SHIFT		(16)
 #define BLK_TC_ACT(act)		((act) << BLK_TC_SHIFT)
 
+#define BLK_TC_SHIFT_EXT   	(32)
+#define BLK_TC_ACT_EXT(act)		(((u64)act) << BLK_TC_SHIFT_EXT)
+
 /*
  * Basic trace actions
  */
@@ -88,12 +99,38 @@ enum blktrace_notify {
 #define BLK_TA_ABORT		(__BLK_TA_ABORT | BLK_TC_ACT(BLK_TC_QUEUE))
 #define BLK_TA_DRV_DATA	(__BLK_TA_DRV_DATA | BLK_TC_ACT(BLK_TC_DRV_DATA))
 
+#define BLK_TA_QUEUE_EXT	(__BLK_TA_QUEUE | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
+#define BLK_TA_BACKMERGE_EXT	(__BLK_TA_BACKMERGE | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
+#define BLK_TA_FRONTMERGE_EXT	(__BLK_TA_FRONTMERGE | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
+#define BLK_TA_GETRQ_EXT	(__BLK_TA_GETRQ | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
+#define BLK_TA_SLEEPRQ_EXT	(__BLK_TA_SLEEPRQ | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
+#define BLK_TA_REQUEUE_EXT	(__BLK_TA_REQUEUE | BLK_TC_ACT_EXT(BLK_TC_REQUEUE))
+#define BLK_TA_ISSUE_EXT	(__BLK_TA_ISSUE | BLK_TC_ACT_EXT(BLK_TC_ISSUE))
+#define BLK_TA_COMPLETE_EXT	(__BLK_TA_COMPLETE | BLK_TC_ACT_EXT(BLK_TC_COMPLETE))
+#define BLK_TA_PLUG_EXT		(__BLK_TA_PLUG | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
+#define BLK_TA_UNPLUG_IO_EXT	(__BLK_TA_UNPLUG_IO | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
+#define BLK_TA_UNPLUG_TIMER_EXT		\
+	(__BLK_TA_UNPLUG_TIMER | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
+#define BLK_TA_INSERT_EXT	(__BLK_TA_INSERT | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
+#define BLK_TA_SPLIT_EXT	(__BLK_TA_SPLIT)
+#define BLK_TA_BOUNCE_EXT	(__BLK_TA_BOUNCE)
+#define BLK_TA_REMAP_EXT	(__BLK_TA_REMAP | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
+#define BLK_TA_ABORT_EXT	(__BLK_TA_ABORT | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
+#define BLK_TA_DRV_DATA_EXT	\
+	(__BLK_TA_DRV_DATA | BLK_TC_ACT_EXT(BLK_TC_DRV_DATA))
+
 #define BLK_TN_PROCESS		(__BLK_TN_PROCESS | BLK_TC_ACT(BLK_TC_NOTIFY))
 #define BLK_TN_TIMESTAMP	(__BLK_TN_TIMESTAMP | BLK_TC_ACT(BLK_TC_NOTIFY))
 #define BLK_TN_MESSAGE		(__BLK_TN_MESSAGE | BLK_TC_ACT(BLK_TC_NOTIFY))
 
-#define BLK_IO_TRACE_MAGIC	0x65617400
-#define BLK_IO_TRACE_VERSION	0x07
+#define BLK_TN_PROCESS_EXT	(__BLK_TN_PROCESS | BLK_TC_ACT_EXT(BLK_TC_NOTIFY))
+#define BLK_TN_TIMESTAMP_EXT	(__BLK_TN_TIMESTAMP | BLK_TC_ACT_EXT(BLK_TC_NOTIFY))
+#define BLK_TN_MESSAGE_EXT	(__BLK_TN_MESSAGE | BLK_TC_ACT_EXT(BLK_TC_NOTIFY))
+
+#define BLK_IO_TRACE_MAGIC             0x65617400
+#define BLK_IO_TRACE_VERSION           0x07
+#define BLK_IO_TRACE_VERSION_EXT       0x08
+
 
 /*
  * The trace itself
@@ -113,6 +150,23 @@ struct blk_io_trace {
 	/* cgroup id will be stored here if exists */
 };
 
+struct blk_io_trace_ext {
+	__u32 magic;		/* MAGIC << 8 | version */
+	__u32 sequence;		/* event number */
+	__u64 time;		/* in nanoseconds */
+	__u64 sector;		/* disk offset */
+	__u32 bytes;		/* transfer length */
+	__u64 action;		/* what happened */
+	__u32 ioprio;		/* I/O priority */
+	__u32 pid;		/* who did it */
+	__u32 device;		/* device number */
+	__u32 cpu;		/* on what cpu did it happen */
+	__u16 error;		/* completion error */
+	__u16 pdu_len;		/* length of data after this trace */
+	/* cgroup id will be stored here if exists */
+};
+
+
 /*
  * The remap event
  */
@@ -143,4 +197,18 @@ struct blk_user_trace_setup {
 	__u32 pid;
 };
 
+/*
+ * User setup structure passed with BLKTRACESETUP_EXT
+ */
+struct blk_user_trace_setup_ext {
+	char name[BLKTRACE_BDEV_SIZE];	/* output */
+	__u64 act_mask;			/* input */
+	__u32 prio_mask;		/* input */
+	__u32 buf_size;			/* input */
+	__u32 buf_nr;			/* input */
+	__u64 start_lba;
+	__u64 end_lba;
+	__u32 pid;
+};
+
 #endif /* _UAPIBLKTRACE_H */
-- 
2.22.1

Re: [RFC PATCH 01/39] blktrace_api: add new trace definitions

[Damien Le Moal]

On 2021/02/25 16:03, Chaitanya Kulkarni wrote:
> This patch adds a new trace categories, trace actions adds a new
> version number for the trace extentions, adds new trace extension
> structure to hold actual trace along with structure nedded to execute
> various IOCTLs to configure trace from user space.
> 
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
> ---
>  include/uapi/linux/blktrace_api.h | 110 ++++++++++++++++++++++++------
>  1 file changed, 89 insertions(+), 21 deletions(-)
> 
> diff --git a/include/uapi/linux/blktrace_api.h b/include/uapi/linux/blktrace_api.h
> index 690621b610e5..fdb3a5cdfa22 100644
> --- a/include/uapi/linux/blktrace_api.h
> +++ b/include/uapi/linux/blktrace_api.h
> @@ -8,30 +8,41 @@
>   * Trace categories
>   */
>  enum blktrace_cat {
> -	BLK_TC_READ	= 1 << 0,	/* reads */
> -	BLK_TC_WRITE	= 1 << 1,	/* writes */
> -	BLK_TC_FLUSH	= 1 << 2,	/* flush */
> -	BLK_TC_SYNC	= 1 << 3,	/* sync IO */
> -	BLK_TC_SYNCIO	= BLK_TC_SYNC,
> -	BLK_TC_QUEUE	= 1 << 4,	/* queueing/merging */
> -	BLK_TC_REQUEUE	= 1 << 5,	/* requeueing */
> -	BLK_TC_ISSUE	= 1 << 6,	/* issue */
> -	BLK_TC_COMPLETE	= 1 << 7,	/* completions */
> -	BLK_TC_FS	= 1 << 8,	/* fs requests */
> -	BLK_TC_PC	= 1 << 9,	/* pc requests */
> -	BLK_TC_NOTIFY	= 1 << 10,	/* special message */
> -	BLK_TC_AHEAD	= 1 << 11,	/* readahead */
> -	BLK_TC_META	= 1 << 12,	/* metadata */
> -	BLK_TC_DISCARD	= 1 << 13,	/* discard requests */
> -	BLK_TC_DRV_DATA	= 1 << 14,	/* binary per-driver data */
> -	BLK_TC_FUA	= 1 << 15,	/* fua requests */
> -
> -	BLK_TC_END	= 1 << 15,	/* we've run out of bits! */
> +	BLK_TC_READ		= 1 << 0,	/* reads */
> +	BLK_TC_WRITE		= 1 << 1,	/* writes */
> +	BLK_TC_FLUSH		= 1 << 2,	/* flush */
> +	BLK_TC_SYNC		= 1 << 3,	/* sync IO */
> +	BLK_TC_SYNCIO		= BLK_TC_SYNC,
> +	BLK_TC_QUEUE		= 1 << 4,	/* queueing/merging */
> +	BLK_TC_REQUEUE		= 1 << 5,	/* requeueing */
> +	BLK_TC_ISSUE		= 1 << 6,	/* issue */
> +	BLK_TC_COMPLETE		= 1 << 7,	/* completions */
> +	BLK_TC_FS		= 1 << 8,	/* fs requests */
> +	BLK_TC_PC		= 1 << 9,	/* pc requests */
> +	BLK_TC_NOTIFY		= 1 << 10,	/* special message */
> +	BLK_TC_AHEAD		= 1 << 11,	/* readahead */
> +	BLK_TC_META		= 1 << 12,	/* metadata */
> +	BLK_TC_DISCARD		= 1 << 13,	/* discard requests */
> +	BLK_TC_DRV_DATA		= 1 << 14,	/* binary per-driver data */
> +	BLK_TC_FUA		= 1 << 15,	/* fua requests */
> +	BLK_TC_WRITE_ZEROES	= 1 << 16,	/* write-zeores */
> +	BLK_TC_ZONE_RESET	= 1 << 17,	/* zone-reset */
> +	BLK_TC_ZONE_RESET_ALL	= 1 << 18,	/* zone-reset-all */
> +	BLK_TC_ZONE_APPEND	= 1 << 19,	/* zone-append */
> +	BLK_TC_ZONE_OPEN	= 1 << 20,	/* zone-open */
> +	BLK_TC_ZONE_CLOSE	= 1 << 21,	/* zone-close */
> +	BLK_TC_ZONE_FINISH	= 1 << 22,	/* zone-finish */
> +
> +	BLK_TC_END		= 1 << 15,	/* we've run out of bits! */

BLK_TC_FUA has the same value. Is that intentional ?

> +	BLK_TC_END_EXT		= 1 << 31,	/* we've run out of bits! */
>  };
>  
>  #define BLK_TC_SHIFT		(16)
>  #define BLK_TC_ACT(act)		((act) << BLK_TC_SHIFT)
>  
> +#define BLK_TC_SHIFT_EXT   	(32)
> +#define BLK_TC_ACT_EXT(act)		(((u64)act) << BLK_TC_SHIFT_EXT)
> +
>  /*
>   * Basic trace actions
>   */
> @@ -88,12 +99,38 @@ enum blktrace_notify {
>  #define BLK_TA_ABORT		(__BLK_TA_ABORT | BLK_TC_ACT(BLK_TC_QUEUE))
>  #define BLK_TA_DRV_DATA	(__BLK_TA_DRV_DATA | BLK_TC_ACT(BLK_TC_DRV_DATA))
>  
> +#define BLK_TA_QUEUE_EXT	(__BLK_TA_QUEUE | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
> +#define BLK_TA_BACKMERGE_EXT	(__BLK_TA_BACKMERGE | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
> +#define BLK_TA_FRONTMERGE_EXT	(__BLK_TA_FRONTMERGE | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
> +#define BLK_TA_GETRQ_EXT	(__BLK_TA_GETRQ | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
> +#define BLK_TA_SLEEPRQ_EXT	(__BLK_TA_SLEEPRQ | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
> +#define BLK_TA_REQUEUE_EXT	(__BLK_TA_REQUEUE | BLK_TC_ACT_EXT(BLK_TC_REQUEUE))
> +#define BLK_TA_ISSUE_EXT	(__BLK_TA_ISSUE | BLK_TC_ACT_EXT(BLK_TC_ISSUE))
> +#define BLK_TA_COMPLETE_EXT	(__BLK_TA_COMPLETE | BLK_TC_ACT_EXT(BLK_TC_COMPLETE))
> +#define BLK_TA_PLUG_EXT		(__BLK_TA_PLUG | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
> +#define BLK_TA_UNPLUG_IO_EXT	(__BLK_TA_UNPLUG_IO | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
> +#define BLK_TA_UNPLUG_TIMER_EXT		\
> +	(__BLK_TA_UNPLUG_TIMER | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
> +#define BLK_TA_INSERT_EXT	(__BLK_TA_INSERT | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
> +#define BLK_TA_SPLIT_EXT	(__BLK_TA_SPLIT)
> +#define BLK_TA_BOUNCE_EXT	(__BLK_TA_BOUNCE)
> +#define BLK_TA_REMAP_EXT	(__BLK_TA_REMAP | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
> +#define BLK_TA_ABORT_EXT	(__BLK_TA_ABORT | BLK_TC_ACT_EXT(BLK_TC_QUEUE))
> +#define BLK_TA_DRV_DATA_EXT	\
> +	(__BLK_TA_DRV_DATA | BLK_TC_ACT_EXT(BLK_TC_DRV_DATA))
> +
>  #define BLK_TN_PROCESS		(__BLK_TN_PROCESS | BLK_TC_ACT(BLK_TC_NOTIFY))
>  #define BLK_TN_TIMESTAMP	(__BLK_TN_TIMESTAMP | BLK_TC_ACT(BLK_TC_NOTIFY))
>  #define BLK_TN_MESSAGE		(__BLK_TN_MESSAGE | BLK_TC_ACT(BLK_TC_NOTIFY))
>  
> -#define BLK_IO_TRACE_MAGIC	0x65617400
> -#define BLK_IO_TRACE_VERSION	0x07
> +#define BLK_TN_PROCESS_EXT	(__BLK_TN_PROCESS | BLK_TC_ACT_EXT(BLK_TC_NOTIFY))
> +#define BLK_TN_TIMESTAMP_EXT	(__BLK_TN_TIMESTAMP | BLK_TC_ACT_EXT(BLK_TC_NOTIFY))
> +#define BLK_TN_MESSAGE_EXT	(__BLK_TN_MESSAGE | BLK_TC_ACT_EXT(BLK_TC_NOTIFY))
> +
> +#define BLK_IO_TRACE_MAGIC             0x65617400
> +#define BLK_IO_TRACE_VERSION           0x07
> +#define BLK_IO_TRACE_VERSION_EXT       0x08

It is a little weird to have 2 versions. Why not simply increase the version
number ? BLK_IO_TRACE_VERSION == 7 means "support only old trace format" and
BLK_IO_TRACE_VERSION == 8 means "support old and new extended trace format"
would be better. From just the code in this patch, not sure how this is being
used though.

> +

blank line not needed.

>  
>  /*
>   * The trace itself
> @@ -113,6 +150,23 @@ struct blk_io_trace {
>  	/* cgroup id will be stored here if exists */
>  };
>  
> +struct blk_io_trace_ext {
> +	__u32 magic;		/* MAGIC << 8 | version */
> +	__u32 sequence;		/* event number */
> +	__u64 time;		/* in nanoseconds */
> +	__u64 sector;		/* disk offset */
> +	__u32 bytes;		/* transfer length */
> +	__u64 action;		/* what happened */
> +	__u32 ioprio;		/* I/O priority */
> +	__u32 pid;		/* who did it */
> +	__u32 device;		/* device number */
> +	__u32 cpu;		/* on what cpu did it happen */
> +	__u16 error;		/* completion error */
> +	__u16 pdu_len;		/* length of data after this trace */
> +	/* cgroup id will be stored here if exists */
> +};
> +
> +

extra blank line not needed.

>  /*
>   * The remap event
>   */
> @@ -143,4 +197,18 @@ struct blk_user_trace_setup {
>  	__u32 pid;
>  };
>  
> +/*
> + * User setup structure passed with BLKTRACESETUP_EXT
> + */
> +struct blk_user_trace_setup_ext {
> +	char name[BLKTRACE_BDEV_SIZE];	/* output */
> +	__u64 act_mask;			/* input */
> +	__u32 prio_mask;		/* input */
> +	__u32 buf_size;			/* input */
> +	__u32 buf_nr;			/* input */
> +	__u64 start_lba;
> +	__u64 end_lba;
> +	__u32 pid;
> +};
> +
>  #endif /* _UAPIBLKTRACE_H */
> 


-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 02/39] blktrace_api: add new trace definition

[Chaitanya Kulkarni]

This patch adds new structure similar to struct blk_trace to support
block trace extensions.

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 include/linux/blktrace_api.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index a083e15df608..6c2654f45ad2 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -27,6 +27,24 @@ struct blk_trace {
 	atomic_t dropped;
 };
 
+struct blk_trace_ext {
+	int trace_state;
+	struct rchan *rchan;
+	unsigned long __percpu *sequence;
+	unsigned char __percpu *msg_data;
+	u64 act_mask;
+	u32 prio_mask;
+	u64 start_lba;
+	u64 end_lba;
+	u32 pid;
+	u32 dev;
+	struct dentry *dir;
+	struct dentry *dropped_file;
+	struct dentry *msg_file;
+	struct list_head running_ext_list;
+	atomic_t dropped;
+};
+
 struct blkcg;
 
 extern int blk_trace_ioctl(struct block_device *, unsigned, char __user *);
-- 
2.22.1

Re: [RFC PATCH 02/39] blktrace_api: add new trace definition

[Damien Le Moal]

On 2021/02/25 16:03, Chaitanya Kulkarni wrote:
> This patch adds new structure similar to struct blk_trace to support
> block trace extensions.
> 
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
> ---
>  include/linux/blktrace_api.h | 18 ++++++++++++++++++
>  1 file changed, 18 insertions(+)
> 
> diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
> index a083e15df608..6c2654f45ad2 100644
> --- a/include/linux/blktrace_api.h
> +++ b/include/linux/blktrace_api.h
> @@ -27,6 +27,24 @@ struct blk_trace {
>  	atomic_t dropped;
>  };
>  
> +struct blk_trace_ext {
> +	int trace_state;
> +	struct rchan *rchan;
> +	unsigned long __percpu *sequence;
> +	unsigned char __percpu *msg_data;
> +	u64 act_mask;
> +	u32 prio_mask;
> +	u64 start_lba;
> +	u64 end_lba;
> +	u32 pid;
> +	u32 dev;
> +	struct dentry *dir;
> +	struct dentry *dropped_file;
> +	struct dentry *msg_file;
> +	struct list_head running_ext_list;
> +	atomic_t dropped;
> +};

A comment describing what this structure is for would be nice.

> +
>  struct blkcg;
>  
>  extern int blk_trace_ioctl(struct block_device *, unsigned, char __user *);
> 


-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 03/39] blkdev.h: add new trace ext as a queue member

[Chaitanya Kulkarni]

Update a struct queue with block trace extension.

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 include/linux/blkdev.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index c032cfe133c7..7c21f22f2077 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -533,6 +533,7 @@ struct request_queue {
 	struct mutex		debugfs_mutex;
 #ifdef CONFIG_BLK_DEV_IO_TRACE
 	struct blk_trace __rcu	*blk_trace;
+	struct blk_trace_ext __rcu	*blk_trace_ext;
 #endif
 	/*
 	 * for flush operations
-- 
2.22.1

Re: [RFC PATCH 03/39] blkdev.h: add new trace ext as a queue member

[Damien Le Moal]

On 2021/02/25 16:03, Chaitanya Kulkarni wrote:
> Update a struct queue with block trace extension.
> 
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
> ---
>  include/linux/blkdev.h | 1 +
>  1 file changed, 1 insertion(+)
> 
> diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
> index c032cfe133c7..7c21f22f2077 100644
> --- a/include/linux/blkdev.h
> +++ b/include/linux/blkdev.h
> @@ -533,6 +533,7 @@ struct request_queue {
>  	struct mutex		debugfs_mutex;
>  #ifdef CONFIG_BLK_DEV_IO_TRACE
>  	struct blk_trace __rcu	*blk_trace;
> +	struct blk_trace_ext __rcu	*blk_trace_ext;
>  #endif
>  	/*
>  	 * for flush operations
> 

You lost me here... why is blk_trace_ext defined in addition to the existing
blk_trace ? Why not extend the definition of struct blk_trace ?

And this patch should probably be squashed into patch 2.

-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 04/39] blktrace: add a new global list

[Chaitanya Kulkarni]

Add a separate list to hold running extension traces.

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index ca6f0ceba09b..e45bbfcb5daf 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -36,6 +36,9 @@ static bool blk_tracer_enabled __read_mostly;
 static LIST_HEAD(running_trace_list);
 static __cacheline_aligned_in_smp DEFINE_SPINLOCK(running_trace_lock);
 
+static LIST_HEAD(running_trace_ext_list);
+static __cacheline_aligned_in_smp DEFINE_SPINLOCK(running_trace_ext_lock);
+
 /* Select an alternative, minimalistic output than the original one */
 #define TRACE_BLK_OPT_CLASSIC	0x1
 #define TRACE_BLK_OPT_CGROUP	0x2
-- 
2.22.1

Re: [RFC PATCH 04/39] blktrace: add a new global list

[Damien Le Moal]

On 2021/02/25 16:03, Chaitanya Kulkarni wrote:
> Add a separate list to hold running extension traces.
> 
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
> ---
>  kernel/trace/blktrace.c | 3 +++
>  1 file changed, 3 insertions(+)
> 
> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> index ca6f0ceba09b..e45bbfcb5daf 100644
> --- a/kernel/trace/blktrace.c
> +++ b/kernel/trace/blktrace.c
> @@ -36,6 +36,9 @@ static bool blk_tracer_enabled __read_mostly;
>  static LIST_HEAD(running_trace_list);
>  static __cacheline_aligned_in_smp DEFINE_SPINLOCK(running_trace_lock);
>  
> +static LIST_HEAD(running_trace_ext_list);
> +static __cacheline_aligned_in_smp DEFINE_SPINLOCK(running_trace_ext_lock);

Why is this necessary ? This is not explained. Why cannot you keep using
running_trace_lock ?

> +
>  /* Select an alternative, minimalistic output than the original one */
>  #define TRACE_BLK_OPT_CLASSIC	0x1
>  #define TRACE_BLK_OPT_CGROUP	0x2
> 


-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 05/39] blktrace: add trace note APIs

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 113 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 113 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index e45bbfcb5daf..4871934b9717 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -114,6 +114,52 @@ static void trace_note(struct blk_trace *bt, pid_t pid, int action,
 	}
 }
 
+static void trace_note_ext(struct blk_trace_ext *bt, pid_t pid, u64 action,
+			   const void *data, size_t len, u64 cgid, u32 ioprio)
+{
+	struct blk_io_trace_ext *t;
+	struct ring_buffer_event *event = NULL;
+	struct trace_buffer *buffer = NULL;
+	int pc = 0;
+	int cpu = smp_processor_id();
+	bool blk_tracer = blk_tracer_enabled;
+	ssize_t cgid_len = cgid ? sizeof(cgid) : 0;
+
+	if (blk_tracer) {
+		buffer = blk_tr->array_buffer.buffer;
+		pc = preempt_count();
+		event = trace_buffer_lock_reserve(buffer, TRACE_BLK,
+						  sizeof(*t) + len + cgid_len,
+						  0, pc);
+		if (!event)
+			return;
+		t = ring_buffer_event_data(event);
+		goto record_it;
+	}
+
+	if (!bt->rchan)
+		return;
+
+	t = relay_reserve(bt->rchan, sizeof(*t) + len + cgid_len);
+	if (t) {
+		t->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION_EXT;
+		t->time = ktime_to_ns(ktime_get());
+record_it:
+		t->device = bt->dev;
+		t->action = action | (cgid ? __BLK_TN_CGROUP : 0);
+		t->ioprio = ioprio;
+		t->pid = pid;
+		t->cpu = cpu;
+		t->pdu_len = len + cgid_len;
+		if (cgid_len)
+			memcpy((void *)t + sizeof(*t), &cgid, cgid_len);
+		memcpy((void *) t + sizeof(*t) + cgid_len, data, len);
+
+		if (blk_tracer)
+			trace_buffer_unlock_commit(blk_tr, buffer, event, 0, pc);
+	}
+}
+
 /*
  * Send out a notify for this process, if we haven't done so since a trace
  * started
@@ -132,6 +178,20 @@ static void trace_note_tsk(struct task_struct *tsk)
 	spin_unlock_irqrestore(&running_trace_lock, flags);
 }
 
+static void trace_note_tsk_ext(struct task_struct *tsk, u32 ioprio)
+{
+	unsigned long flags;
+	struct blk_trace_ext *bt;
+
+	tsk->btrace_seq = blktrace_seq;
+	spin_lock_irqsave(&running_trace_ext_lock, flags);
+	list_for_each_entry(bt, &running_trace_ext_list, running_ext_list) {
+		trace_note_ext(bt, tsk->pid, BLK_TN_PROCESS_EXT, tsk->comm,
+			   sizeof(tsk->comm), 0, ioprio);
+	}
+	spin_unlock_irqrestore(&running_trace_ext_lock, flags);
+}
+
 static void trace_note_time(struct blk_trace *bt)
 {
 	struct timespec64 now;
@@ -148,6 +208,22 @@ static void trace_note_time(struct blk_trace *bt)
 	local_irq_restore(flags);
 }
 
+static void trace_note_time_ext(struct blk_trace_ext *bt)
+{
+	struct timespec64 now;
+	unsigned long flags;
+	u32 words[2];
+
+	/* need to check user space to see if this breaks in y2038 or y2106 */
+	ktime_get_real_ts64(&now);
+	words[0] = (u32)now.tv_sec;
+	words[1] = now.tv_nsec;
+
+	local_irq_save(flags);
+	trace_note_ext(bt, 0, BLK_TN_TIMESTAMP, words, sizeof(words), 0, 0);
+	local_irq_restore(flags);
+}
+
 void __trace_note_message(struct blk_trace *bt, struct blkcg *blkcg,
 	const char *fmt, ...)
 {
@@ -185,6 +261,43 @@ void __trace_note_message(struct blk_trace *bt, struct blkcg *blkcg,
 }
 EXPORT_SYMBOL_GPL(__trace_note_message);
 
+void __trace_note_message_ext(struct blk_trace_ext *bt, struct blkcg *blkcg,
+	const char *fmt, ...)
+{
+	int n;
+	va_list args;
+	unsigned long flags;
+	char *buf;
+
+	if (unlikely(bt->trace_state != Blktrace_running &&
+		     !blk_tracer_enabled))
+		return;
+
+	/*
+	 * If the BLK_TC_NOTIFY action mask isn't set, don't send any note
+	 * message to the trace.
+	 */
+	if (!(bt->act_mask & BLK_TC_NOTIFY))
+		return;
+
+	local_irq_save(flags);
+	buf = this_cpu_ptr(bt->msg_data);
+	va_start(args, fmt);
+	n = vscnprintf(buf, BLK_TN_MAX_MSG, fmt, args);
+	va_end(args);
+
+	if (!(blk_tracer_flags.val & TRACE_BLK_OPT_CGROUP))
+		blkcg = NULL;
+#ifdef CONFIG_BLK_CGROUP
+	trace_note_ext(bt, 0, BLK_TN_MESSAGE_EXT, buf, n,
+		blkcg ? cgroup_id(blkcg->css.cgroup) : 1, 0);
+#else
+	trace_note_ext(bt, 0, BLK_TN_MESSAGE_EXT, buf, n, 0, 0);
+#endif
+	local_irq_restore(flags);
+}
+EXPORT_SYMBOL_GPL(__trace_note_message_ext);
+
 static int act_log_check(struct blk_trace *bt, u32 what, sector_t sector,
 			 pid_t pid)
 {
-- 
2.22.1

Re: [RFC PATCH 05/39] blktrace: add trace note APIs

[Damien Le Moal]

No commit message. Add one please.

On 2021/02/25 16:03, Chaitanya Kulkarni wrote:
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
> ---
>  kernel/trace/blktrace.c | 113 ++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 113 insertions(+)
> 
> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> index e45bbfcb5daf..4871934b9717 100644
> --- a/kernel/trace/blktrace.c
> +++ b/kernel/trace/blktrace.c
> @@ -114,6 +114,52 @@ static void trace_note(struct blk_trace *bt, pid_t pid, int action,
>  	}
>  }
>  
> +static void trace_note_ext(struct blk_trace_ext *bt, pid_t pid, u64 action,
> +			   const void *data, size_t len, u64 cgid, u32 ioprio)
> +{
> +	struct blk_io_trace_ext *t;
> +	struct ring_buffer_event *event = NULL;
> +	struct trace_buffer *buffer = NULL;
> +	int pc = 0;
> +	int cpu = smp_processor_id();
> +	bool blk_tracer = blk_tracer_enabled;
> +	ssize_t cgid_len = cgid ? sizeof(cgid) : 0;
> +
> +	if (blk_tracer) {
> +		buffer = blk_tr->array_buffer.buffer;
> +		pc = preempt_count();
> +		event = trace_buffer_lock_reserve(buffer, TRACE_BLK,
> +						  sizeof(*t) + len + cgid_len,
> +						  0, pc);
> +		if (!event)
> +			return;
> +		t = ring_buffer_event_data(event);
> +		goto record_it;
> +	}
> +
> +	if (!bt->rchan)
> +		return;
> +
> +	t = relay_reserve(bt->rchan, sizeof(*t) + len + cgid_len);
> +	if (t) {
> +		t->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION_EXT;
> +		t->time = ktime_to_ns(ktime_get());
> +record_it:
> +		t->device = bt->dev;
> +		t->action = action | (cgid ? __BLK_TN_CGROUP : 0);
> +		t->ioprio = ioprio;
> +		t->pid = pid;
> +		t->cpu = cpu;
> +		t->pdu_len = len + cgid_len;
> +		if (cgid_len)
> +			memcpy((void *)t + sizeof(*t), &cgid, cgid_len);
> +		memcpy((void *) t + sizeof(*t) + cgid_len, data, len);
> +
> +		if (blk_tracer)
> +			trace_buffer_unlock_commit(blk_tr, buffer, event, 0, pc);
> +	}
> +}
> +
>  /*
>   * Send out a notify for this process, if we haven't done so since a trace
>   * started
> @@ -132,6 +178,20 @@ static void trace_note_tsk(struct task_struct *tsk)
>  	spin_unlock_irqrestore(&running_trace_lock, flags);
>  }
>  
> +static void trace_note_tsk_ext(struct task_struct *tsk, u32 ioprio)
> +{
> +	unsigned long flags;
> +	struct blk_trace_ext *bt;
> +
> +	tsk->btrace_seq = blktrace_seq;
> +	spin_lock_irqsave(&running_trace_ext_lock, flags);
> +	list_for_each_entry(bt, &running_trace_ext_list, running_ext_list) {
> +		trace_note_ext(bt, tsk->pid, BLK_TN_PROCESS_EXT, tsk->comm,
> +			   sizeof(tsk->comm), 0, ioprio);
> +	}
> +	spin_unlock_irqrestore(&running_trace_ext_lock, flags);
> +}
> +
>  static void trace_note_time(struct blk_trace *bt)
>  {
>  	struct timespec64 now;
> @@ -148,6 +208,22 @@ static void trace_note_time(struct blk_trace *bt)
>  	local_irq_restore(flags);
>  }
>  
> +static void trace_note_time_ext(struct blk_trace_ext *bt)
> +{
> +	struct timespec64 now;
> +	unsigned long flags;
> +	u32 words[2];
> +
> +	/* need to check user space to see if this breaks in y2038 or y2106 */
> +	ktime_get_real_ts64(&now);
> +	words[0] = (u32)now.tv_sec;
> +	words[1] = now.tv_nsec;
> +
> +	local_irq_save(flags);
> +	trace_note_ext(bt, 0, BLK_TN_TIMESTAMP, words, sizeof(words), 0, 0);
> +	local_irq_restore(flags);
> +}
> +
>  void __trace_note_message(struct blk_trace *bt, struct blkcg *blkcg,
>  	const char *fmt, ...)
>  {
> @@ -185,6 +261,43 @@ void __trace_note_message(struct blk_trace *bt, struct blkcg *blkcg,
>  }
>  EXPORT_SYMBOL_GPL(__trace_note_message);
>  
> +void __trace_note_message_ext(struct blk_trace_ext *bt, struct blkcg *blkcg,
> +	const char *fmt, ...)
> +{
> +	int n;
> +	va_list args;
> +	unsigned long flags;
> +	char *buf;
> +
> +	if (unlikely(bt->trace_state != Blktrace_running &&
> +		     !blk_tracer_enabled))
> +		return;
> +
> +	/*
> +	 * If the BLK_TC_NOTIFY action mask isn't set, don't send any note
> +	 * message to the trace.
> +	 */
> +	if (!(bt->act_mask & BLK_TC_NOTIFY))
> +		return;
> +
> +	local_irq_save(flags);
> +	buf = this_cpu_ptr(bt->msg_data);
> +	va_start(args, fmt);
> +	n = vscnprintf(buf, BLK_TN_MAX_MSG, fmt, args);
> +	va_end(args);
> +
> +	if (!(blk_tracer_flags.val & TRACE_BLK_OPT_CGROUP))
> +		blkcg = NULL;
> +#ifdef CONFIG_BLK_CGROUP
> +	trace_note_ext(bt, 0, BLK_TN_MESSAGE_EXT, buf, n,
> +		blkcg ? cgroup_id(blkcg->css.cgroup) : 1, 0);
> +#else
> +	trace_note_ext(bt, 0, BLK_TN_MESSAGE_EXT, buf, n, 0, 0);
> +#endif
> +	local_irq_restore(flags);
> +}
> +EXPORT_SYMBOL_GPL(__trace_note_message_ext);
> +
>  static int act_log_check(struct blk_trace *bt, u32 what, sector_t sector,
>  			 pid_t pid)
>  {
> 

I fail to see why the xxx_ext functions need the different blk_trcae_ext
structure. It seems that everything should work with a modified blk_trace
structure. With such approach, a lot of the xxx_ext functions in here may not be
necessary at all. Simply change the interface of the existing note functions.
There are not that many call sites to change, right ?


-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 06/39] blktrace: add act and prio check helpers

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 4871934b9717..feb823b917ec 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -311,6 +311,43 @@ static int act_log_check(struct blk_trace *bt, u32 what, sector_t sector,
 	return 0;
 }
 
+static inline bool prio_log_check(struct blk_trace_ext *bt, u32 ioprio)
+{
+	bool ret;
+
+	switch (IOPRIO_PRIO_CLASS(ioprio)) {
+	case IOPRIO_CLASS_NONE:
+		ret = (bt->prio_mask & 0x01) ? true : false;
+		break;
+	case IOPRIO_CLASS_RT:
+		ret = (bt->prio_mask & 0x02) ? true : false;
+		break;
+	case IOPRIO_CLASS_BE:
+		ret = (bt->prio_mask & 0x04) ? true : false;
+		break;
+	case IOPRIO_CLASS_IDLE:
+		ret = (bt->prio_mask & 0x08) ? true : false;
+		break;
+	default:
+		/*XXX: print rate limit warn here */
+		ret = false;
+	}
+	return ret;
+}
+
+static inline int act_log_check_ext(struct blk_trace_ext *bt, u64 what,
+			     sector_t sector, pid_t pid)
+{
+	if (((bt->act_mask << BLK_TC_SHIFT_EXT) & what) == 0)
+		return 1;
+	if (sector && (sector < bt->start_lba || sector > bt->end_lba))
+		return 1;
+	if (bt->pid && pid != bt->pid)
+		return 1;
+
+	return 0;
+}
+
 /*
  * Data direction bit lookup
  */
-- 
2.22.1

Re: [RFC PATCH 06/39] blktrace: add act and prio check helpers

[Damien Le Moal]

On 2021/02/25 16:03, Chaitanya Kulkarni wrote:
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
> ---
>  kernel/trace/blktrace.c | 37 +++++++++++++++++++++++++++++++++++++
>  1 file changed, 37 insertions(+)
> 
> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> index 4871934b9717..feb823b917ec 100644
> --- a/kernel/trace/blktrace.c
> +++ b/kernel/trace/blktrace.c
> @@ -311,6 +311,43 @@ static int act_log_check(struct blk_trace *bt, u32 what, sector_t sector,
>  	return 0;
>  }
>  
> +static inline bool prio_log_check(struct blk_trace_ext *bt, u32 ioprio)
> +{
> +	bool ret;
> +
> +	switch (IOPRIO_PRIO_CLASS(ioprio)) {
> +	case IOPRIO_CLASS_NONE:
> +		ret = (bt->prio_mask & 0x01) ? true : false;
> +		break;
> +	case IOPRIO_CLASS_RT:
> +		ret = (bt->prio_mask & 0x02) ? true : false;
> +		break;
> +	case IOPRIO_CLASS_BE:
> +		ret = (bt->prio_mask & 0x04) ? true : false;
> +		break;
> +	case IOPRIO_CLASS_IDLE:
> +		ret = (bt->prio_mask & 0x08) ? true : false;
> +		break;
> +	default:
> +		/*XXX: print rate limit warn here */
> +		ret = false;
> +	}
> +	return ret;
> +}
> +
> +static inline int act_log_check_ext(struct blk_trace_ext *bt, u64 what,
> +			     sector_t sector, pid_t pid)
> +{
> +	if (((bt->act_mask << BLK_TC_SHIFT_EXT) & what) == 0)
> +		return 1;
> +	if (sector && (sector < bt->start_lba || sector > bt->end_lba))
> +		return 1;
> +	if (bt->pid && pid != bt->pid)
> +		return 1;
> +
> +	return 0;
> +}
> +
>  /*
>   * Data direction bit lookup
>   */
> 

Without the code using these helpers in the same patch, it is hard to see what
these are for...

-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 07/39] blktrace: add core trace API

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 130 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 130 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index feb823b917ec..1aef55fdefa9 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -462,6 +462,136 @@ static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes,
 	local_irq_restore(flags);
 }
 
+/*
+ * Data direction bit lookup
+ */
+static const u64 ddir_act_ext[2] = { BLK_TC_ACT_EXT(BLK_TC_READ),
+				 BLK_TC_ACT_EXT(BLK_TC_WRITE) };
+
+/* The ilog2() calls fall out because they're constant */
+#define MASK_TC_BIT_EXT(rw, __name) ((rw & REQ_ ## __name) << \
+	  (ilog2(BLK_TC_ ## __name) + BLK_TC_SHIFT_EXT - __REQ_ ## __name))
+
+/*
+ * The worker for the various blk_add_trace*() types. Fills out a
+ * blk_io_trace structure and places it in a per-cpu subbuffer.
+ */
+static void __blk_add_trace_ext(struct blk_trace_ext *bt, sector_t sector, int bytes,
+		     int op, int op_flags, u64 what, int error, int pdu_len,
+		     void *pdu_data, u64 cgid, u32 ioprio)
+{
+	struct task_struct *tsk = current;
+	struct ring_buffer_event *event = NULL;
+	struct trace_buffer *buffer = NULL;
+	struct blk_io_trace_ext *t;
+	unsigned long flags = 0;
+	unsigned long *sequence;
+	pid_t pid;
+	int cpu, pc = 0;
+	bool blk_tracer = blk_tracer_enabled;
+	ssize_t cgid_len = cgid ? sizeof(cgid) : 0;
+
+	if (unlikely(bt->trace_state != Blktrace_running && !blk_tracer))
+		return;
+
+	what |= ddir_act_ext[op_is_write(op) ? WRITE : READ];
+	what |= MASK_TC_BIT_EXT(op_flags, SYNC);
+	what |= MASK_TC_BIT_EXT(op_flags, RAHEAD);
+	what |= MASK_TC_BIT_EXT(op_flags, META);
+	what |= MASK_TC_BIT_EXT(op_flags, PREFLUSH);
+	what |= MASK_TC_BIT_EXT(op_flags, FUA);
+	if (op == REQ_OP_ZONE_APPEND)
+		what |= BLK_TC_ACT_EXT(BLK_TC_ZONE_APPEND);
+	if (op == REQ_OP_DISCARD || op == REQ_OP_SECURE_ERASE)
+		what |= BLK_TC_ACT_EXT(BLK_TC_DISCARD);
+	if (op == REQ_OP_FLUSH)
+		what |= BLK_TC_ACT_EXT(BLK_TC_FLUSH);
+	if (unlikely(op == REQ_OP_WRITE_ZEROES))
+		what |= BLK_TC_ACT_EXT(BLK_TC_WRITE_ZEROES);
+	if (unlikely(op == REQ_OP_ZONE_RESET))
+		what |= BLK_TC_ACT_EXT(BLK_TC_ZONE_RESET);
+	if (unlikely(op == REQ_OP_ZONE_RESET_ALL))
+		what |= BLK_TC_ACT_EXT(BLK_TC_ZONE_RESET_ALL);
+	if (unlikely(op == REQ_OP_ZONE_OPEN))
+		what |= BLK_TC_ACT_EXT(BLK_TC_ZONE_OPEN);
+	if (unlikely(op == REQ_OP_ZONE_CLOSE))
+		what |= BLK_TC_ACT_EXT(BLK_TC_ZONE_CLOSE);
+	if (unlikely(op == REQ_OP_ZONE_FINISH))
+		what |= BLK_TC_ACT_EXT(BLK_TC_ZONE_FINISH);
+
+	if (cgid)
+		what |= __BLK_TA_CGROUP;
+
+	pid = tsk->pid;
+	if (act_log_check_ext(bt, what, sector, pid))
+		return;
+	if (bt->prio_mask && !prio_log_check(bt, ioprio))
+		return;
+
+	cpu = raw_smp_processor_id();
+
+	if (blk_tracer) {
+		tracing_record_cmdline(current);
+
+		buffer = blk_tr->array_buffer.buffer;
+		pc = preempt_count();
+		event = trace_buffer_lock_reserve(buffer, TRACE_BLK,
+						  sizeof(*t) + pdu_len + cgid_len,
+						  0, pc);
+		if (!event)
+			return;
+		t = ring_buffer_event_data(event);
+		goto record_it;
+	}
+
+	if (unlikely(tsk->btrace_seq != blktrace_seq))
+		trace_note_tsk_ext(tsk, ioprio);
+
+	/*
+	 * A word about the locking here - we disable interrupts to reserve
+	 * some space in the relay per-cpu buffer, to prevent an irq
+	 * from coming in and stepping on our toes.
+	 */
+	local_irq_save(flags);
+	t = relay_reserve(bt->rchan, sizeof(*t) + pdu_len + cgid_len);
+	if (t) {
+		sequence = per_cpu_ptr(bt->sequence, cpu);
+
+		t->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION_EXT;
+		t->sequence = ++(*sequence);
+		t->time = ktime_to_ns(ktime_get());
+record_it:
+		/*
+		 * These two are not needed in ftrace as they are in the
+		 * generic trace_entry, filled by tracing_generic_entry_update,
+		 * but for the trace_event->bin() synthesizer benefit we do it
+		 * here too.
+		 */
+		t->cpu = cpu;
+		t->pid = pid;
+
+		t->sector = sector;
+		t->bytes = bytes;
+		t->action = what;
+		t->ioprio = ioprio;
+		t->device = bt->dev;
+		t->error = error;
+		t->pdu_len = pdu_len + cgid_len;
+
+		if (cgid_len)
+			memcpy((void *)t + sizeof(*t), &cgid, cgid_len);
+		if (pdu_len)
+			memcpy((void *)t + sizeof(*t) + cgid_len, pdu_data, pdu_len);
+
+		if (blk_tracer) {
+			trace_buffer_unlock_commit(blk_tr, buffer, event, 0, pc);
+			return;
+		}
+	}
+
+	local_irq_restore(flags);
+}
+
 static void blk_trace_free(struct blk_trace *bt)
 {
 	relay_close(bt->rchan);
-- 
2.22.1

Re: [RFC PATCH 07/39] blktrace: add core trace API

[Damien Le Moal]

On 2021/02/25 16:03, Chaitanya Kulkarni wrote:
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>

No commit message. Please add one.


> ---
>  kernel/trace/blktrace.c | 130 ++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 130 insertions(+)
> 
> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> index feb823b917ec..1aef55fdefa9 100644
> --- a/kernel/trace/blktrace.c
> +++ b/kernel/trace/blktrace.c
> @@ -462,6 +462,136 @@ static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes,
>  	local_irq_restore(flags);
>  }
>  
> +/*
> + * Data direction bit lookup
> + */
> +static const u64 ddir_act_ext[2] = { BLK_TC_ACT_EXT(BLK_TC_READ),
> +				 BLK_TC_ACT_EXT(BLK_TC_WRITE) };
> +
> +/* The ilog2() calls fall out because they're constant */
> +#define MASK_TC_BIT_EXT(rw, __name) ((rw & REQ_ ## __name) << \
> +	  (ilog2(BLK_TC_ ## __name) + BLK_TC_SHIFT_EXT - __REQ_ ## __name))
> +
> +/*
> + * The worker for the various blk_add_trace*() types. Fills out a
> + * blk_io_trace structure and places it in a per-cpu subbuffer.
> + */

The comment is wrong. You are filling a blk_io_trace_ext structure. But I do not
see why that structure is needed in the first place. So the function below may
not be needed either. Modifying the existing one seems like a simpler approach
to me.

> +static void __blk_add_trace_ext(struct blk_trace_ext *bt, sector_t sector, int bytes,
> +		     int op, int op_flags, u64 what, int error, int pdu_len,
> +		     void *pdu_data, u64 cgid, u32 ioprio)
> +{
> +	struct task_struct *tsk = current;
> +	struct ring_buffer_event *event = NULL;
> +	struct trace_buffer *buffer = NULL;
> +	struct blk_io_trace_ext *t;
> +	unsigned long flags = 0;
> +	unsigned long *sequence;
> +	pid_t pid;
> +	int cpu, pc = 0;
> +	bool blk_tracer = blk_tracer_enabled;
> +	ssize_t cgid_len = cgid ? sizeof(cgid) : 0;
> +
> +	if (unlikely(bt->trace_state != Blktrace_running && !blk_tracer))
> +		return;
> +
> +	what |= ddir_act_ext[op_is_write(op) ? WRITE : READ];
> +	what |= MASK_TC_BIT_EXT(op_flags, SYNC);
> +	what |= MASK_TC_BIT_EXT(op_flags, RAHEAD);
> +	what |= MASK_TC_BIT_EXT(op_flags, META);
> +	what |= MASK_TC_BIT_EXT(op_flags, PREFLUSH);
> +	what |= MASK_TC_BIT_EXT(op_flags, FUA);
> +	if (op == REQ_OP_ZONE_APPEND)
> +		what |= BLK_TC_ACT_EXT(BLK_TC_ZONE_APPEND);
> +	if (op == REQ_OP_DISCARD || op == REQ_OP_SECURE_ERASE)
> +		what |= BLK_TC_ACT_EXT(BLK_TC_DISCARD);
> +	if (op == REQ_OP_FLUSH)
> +		what |= BLK_TC_ACT_EXT(BLK_TC_FLUSH);
> +	if (unlikely(op == REQ_OP_WRITE_ZEROES))
> +		what |= BLK_TC_ACT_EXT(BLK_TC_WRITE_ZEROES);
> +	if (unlikely(op == REQ_OP_ZONE_RESET))
> +		what |= BLK_TC_ACT_EXT(BLK_TC_ZONE_RESET);
> +	if (unlikely(op == REQ_OP_ZONE_RESET_ALL))
> +		what |= BLK_TC_ACT_EXT(BLK_TC_ZONE_RESET_ALL);
> +	if (unlikely(op == REQ_OP_ZONE_OPEN))
> +		what |= BLK_TC_ACT_EXT(BLK_TC_ZONE_OPEN);
> +	if (unlikely(op == REQ_OP_ZONE_CLOSE))
> +		what |= BLK_TC_ACT_EXT(BLK_TC_ZONE_CLOSE);
> +	if (unlikely(op == REQ_OP_ZONE_FINISH))
> +		what |= BLK_TC_ACT_EXT(BLK_TC_ZONE_FINISH);
> +
> +	if (cgid)
> +		what |= __BLK_TA_CGROUP;
> +
> +	pid = tsk->pid;
> +	if (act_log_check_ext(bt, what, sector, pid))
> +		return;
> +	if (bt->prio_mask && !prio_log_check(bt, ioprio))
> +		return;
> +
> +	cpu = raw_smp_processor_id();
> +
> +	if (blk_tracer) {
> +		tracing_record_cmdline(current);
> +
> +		buffer = blk_tr->array_buffer.buffer;
> +		pc = preempt_count();
> +		event = trace_buffer_lock_reserve(buffer, TRACE_BLK,
> +						  sizeof(*t) + pdu_len + cgid_len,
> +						  0, pc);
> +		if (!event)
> +			return;
> +		t = ring_buffer_event_data(event);
> +		goto record_it;
> +	}
> +
> +	if (unlikely(tsk->btrace_seq != blktrace_seq))
> +		trace_note_tsk_ext(tsk, ioprio);
> +
> +	/*
> +	 * A word about the locking here - we disable interrupts to reserve
> +	 * some space in the relay per-cpu buffer, to prevent an irq
> +	 * from coming in and stepping on our toes.
> +	 */
> +	local_irq_save(flags);
> +	t = relay_reserve(bt->rchan, sizeof(*t) + pdu_len + cgid_len);
> +	if (t) {
> +		sequence = per_cpu_ptr(bt->sequence, cpu);
> +
> +		t->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION_EXT;
> +		t->sequence = ++(*sequence);
> +		t->time = ktime_to_ns(ktime_get());
> +record_it:
> +		/*
> +		 * These two are not needed in ftrace as they are in the
> +		 * generic trace_entry, filled by tracing_generic_entry_update,
> +		 * but for the trace_event->bin() synthesizer benefit we do it
> +		 * here too.
> +		 */
> +		t->cpu = cpu;
> +		t->pid = pid;
> +
> +		t->sector = sector;
> +		t->bytes = bytes;
> +		t->action = what;
> +		t->ioprio = ioprio;
> +		t->device = bt->dev;
> +		t->error = error;
> +		t->pdu_len = pdu_len + cgid_len;
> +
> +		if (cgid_len)
> +			memcpy((void *)t + sizeof(*t), &cgid, cgid_len);
> +		if (pdu_len)
> +			memcpy((void *)t + sizeof(*t) + cgid_len, pdu_data, pdu_len);
> +
> +		if (blk_tracer) {
> +			trace_buffer_unlock_commit(blk_tr, buffer, event, 0, pc);
> +			return;
> +		}
> +	}
> +
> +	local_irq_restore(flags);
> +}
> +
>  static void blk_trace_free(struct blk_trace *bt)
>  {
>  	relay_close(bt->rchan);
> 


-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 08/39] blktrace: update blk_add_trace_rq()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 30 +++++++++++++++++++++---------
 1 file changed, 21 insertions(+), 9 deletions(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 1aef55fdefa9..280ad94f99b6 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1099,24 +1099,36 @@ blk_trace_request_get_cgid(struct request *rq)
  *
  **/
 static void blk_add_trace_rq(struct request *rq, int error,
-			     unsigned int nr_bytes, u32 what, u64 cgid)
+			     unsigned int nr_bytes, u64 what, u64 cgid)
 {
 	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
 
 	rcu_read_lock();
 	bt = rcu_dereference(rq->q->blk_trace);
-	if (likely(!bt)) {
+	bte = rcu_dereference(rq->q->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
 		rcu_read_unlock();
 		return;
 	}
 
-	if (blk_rq_is_passthrough(rq))
-		what |= BLK_TC_ACT(BLK_TC_PC);
-	else
-		what |= BLK_TC_ACT(BLK_TC_FS);
-
-	__blk_add_trace(bt, blk_rq_trace_sector(rq), nr_bytes, req_op(rq),
-			rq->cmd_flags, what, error, 0, NULL, cgid);
+	if (bt) {
+		if (blk_rq_is_passthrough(rq))
+			what |= BLK_TC_ACT(BLK_TC_PC);
+		else
+			what |= BLK_TC_ACT(BLK_TC_FS);
+		__blk_add_trace(bt, blk_rq_trace_sector(rq), nr_bytes,
+				req_op(rq), rq->cmd_flags, (u32)what, error, 0,
+				NULL, cgid);
+	} else if (bte) {
+		if (blk_rq_is_passthrough(rq))
+			what |= BLK_TC_ACT_EXT(BLK_TC_PC);
+		else
+			what |= BLK_TC_ACT_EXT(BLK_TC_FS);
+		__blk_add_trace_ext(bte, blk_rq_trace_sector(rq), nr_bytes,
+				    req_op(rq), rq->cmd_flags, what, error, 0,
+				    NULL, cgid, req_get_ioprio(rq));
+	}
 	rcu_read_unlock();
 }
 
-- 
2.22.1

Re: [RFC PATCH 08/39] blktrace: update blk_add_trace_rq()

[Damien Le Moal]

On 2021/02/25 16:04, Chaitanya Kulkarni wrote:
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>

No commit message.

> ---
>  kernel/trace/blktrace.c | 30 +++++++++++++++++++++---------
>  1 file changed, 21 insertions(+), 9 deletions(-)
> 
> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> index 1aef55fdefa9..280ad94f99b6 100644
> --- a/kernel/trace/blktrace.c
> +++ b/kernel/trace/blktrace.c
> @@ -1099,24 +1099,36 @@ blk_trace_request_get_cgid(struct request *rq)
>   *
>   **/
>  static void blk_add_trace_rq(struct request *rq, int error,
> -			     unsigned int nr_bytes, u32 what, u64 cgid)
> +			     unsigned int nr_bytes, u64 what, u64 cgid)
>  {
>  	struct blk_trace *bt;
> +	struct blk_trace_ext *bte;
>  
>  	rcu_read_lock();
>  	bt = rcu_dereference(rq->q->blk_trace);
> -	if (likely(!bt)) {
> +	bte = rcu_dereference(rq->q->blk_trace_ext);
> +	if (likely(!bt) && likely(!bte)) {
>  		rcu_read_unlock();
>  		return;
>  	}
>  
> -	if (blk_rq_is_passthrough(rq))
> -		what |= BLK_TC_ACT(BLK_TC_PC);
> -	else
> -		what |= BLK_TC_ACT(BLK_TC_FS);
> -
> -	__blk_add_trace(bt, blk_rq_trace_sector(rq), nr_bytes, req_op(rq),
> -			rq->cmd_flags, what, error, 0, NULL, cgid);
> +	if (bt) {
> +		if (blk_rq_is_passthrough(rq))
> +			what |= BLK_TC_ACT(BLK_TC_PC);
> +		else
> +			what |= BLK_TC_ACT(BLK_TC_FS);
> +		__blk_add_trace(bt, blk_rq_trace_sector(rq), nr_bytes,
> +				req_op(rq), rq->cmd_flags, (u32)what, error, 0,
> +				NULL, cgid);
> +	} else if (bte) {
> +		if (blk_rq_is_passthrough(rq))
> +			what |= BLK_TC_ACT_EXT(BLK_TC_PC);
> +		else
> +			what |= BLK_TC_ACT_EXT(BLK_TC_FS);
> +		__blk_add_trace_ext(bte, blk_rq_trace_sector(rq), nr_bytes,
> +				    req_op(rq), rq->cmd_flags, what, error, 0,
> +				    NULL, cgid, req_get_ioprio(rq));
> +	}

I fail to see why you cannot reuse __blk_add_trace() with the what argument
changed to a 64bit, exactly like you did for this blk_add_trace_rq() function.

>  	rcu_read_unlock();
>  }
>  
> 


-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 09/39] blktrace: update blk_add_trace_rq_insert()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 280ad94f99b6..906afa0982c2 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1134,7 +1134,25 @@ static void blk_add_trace_rq(struct request *rq, int error,
 
 static void blk_add_trace_rq_insert(void *ignore, struct request *rq)
 {
-	blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), BLK_TA_INSERT,
+	u64 ta = 0;
+	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
+
+	rcu_read_lock();
+	bt = rcu_dereference(rq->q->blk_trace);
+	bte = rcu_dereference(rq->q->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
+		rcu_read_unlock();
+		return;
+	}
+
+	if (bt) {
+		ta = BLK_TA_INSERT;
+	} else if (bte) {
+		ta = BLK_TA_INSERT_EXT;
+	}
+	rcu_read_unlock();
+	blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), ta,
 			 blk_trace_request_get_cgid(rq));
 }
 
-- 
2.22.1

Re: [RFC PATCH 09/39] blktrace: update blk_add_trace_rq_insert()

[Damien Le Moal]

On 2021/02/25 16:04, Chaitanya Kulkarni wrote:
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
> ---
>  kernel/trace/blktrace.c | 20 +++++++++++++++++++-
>  1 file changed, 19 insertions(+), 1 deletion(-)
> 
> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> index 280ad94f99b6..906afa0982c2 100644
> --- a/kernel/trace/blktrace.c
> +++ b/kernel/trace/blktrace.c
> @@ -1134,7 +1134,25 @@ static void blk_add_trace_rq(struct request *rq, int error,
>  
>  static void blk_add_trace_rq_insert(void *ignore, struct request *rq)
>  {
> -	blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), BLK_TA_INSERT,
> +	u64 ta = 0;
> +	struct blk_trace *bt;
> +	struct blk_trace_ext *bte;
> +
> +	rcu_read_lock();
> +	bt = rcu_dereference(rq->q->blk_trace);
> +	bte = rcu_dereference(rq->q->blk_trace_ext);
> +	if (likely(!bt) && likely(!bte)) {
> +		rcu_read_unlock();
> +		return;
> +	}
> +
> +	if (bt) {
> +		ta = BLK_TA_INSERT;
> +	} else if (bte) {
> +		ta = BLK_TA_INSERT_EXT;
> +	}

Braces are not needed here. Removing blk_trace_ext and reusing blk_trace would
make all of this unnecessary.

> +	rcu_read_unlock();
> +	blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), ta,
>  			 blk_trace_request_get_cgid(rq));
>  }
>  
> 


-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 10/39] blktrace: update blk_add_trace_rq_issue()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 906afa0982c2..e1646d74ac9a 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1158,7 +1158,25 @@ static void blk_add_trace_rq_insert(void *ignore, struct request *rq)
 
 static void blk_add_trace_rq_issue(void *ignore, struct request *rq)
 {
-	blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), BLK_TA_ISSUE,
+	u64 ta;
+	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
+
+	rcu_read_lock();
+	bt = rcu_dereference(rq->q->blk_trace);
+	bte = rcu_dereference(rq->q->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
+		rcu_read_unlock();
+		return;
+	}
+
+	if (bt) {
+		ta = BLK_TA_ISSUE;
+	} else if (bte) {
+		ta = BLK_TA_ISSUE_EXT;
+	}
+	rcu_read_unlock();
+	blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), ta,
 			 blk_trace_request_get_cgid(rq));
 }
 
-- 
2.22.1

Re: [RFC PATCH 10/39] blktrace: update blk_add_trace_rq_issue()

[Damien Le Moal]

On 2021/02/25 16:04, Chaitanya Kulkarni wrote:
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
> ---
>  kernel/trace/blktrace.c | 20 +++++++++++++++++++-
>  1 file changed, 19 insertions(+), 1 deletion(-)
> 
> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> index 906afa0982c2..e1646d74ac9a 100644
> --- a/kernel/trace/blktrace.c
> +++ b/kernel/trace/blktrace.c
> @@ -1158,7 +1158,25 @@ static void blk_add_trace_rq_insert(void *ignore, struct request *rq)
>  
>  static void blk_add_trace_rq_issue(void *ignore, struct request *rq)
>  {
> -	blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), BLK_TA_ISSUE,
> +	u64 ta;
> +	struct blk_trace *bt;
> +	struct blk_trace_ext *bte;
> +
> +	rcu_read_lock();
> +	bt = rcu_dereference(rq->q->blk_trace);
> +	bte = rcu_dereference(rq->q->blk_trace_ext);
> +	if (likely(!bt) && likely(!bte)) {
> +		rcu_read_unlock();
> +		return;
> +	}
> +
> +	if (bt) {
> +		ta = BLK_TA_ISSUE;
> +	} else if (bte) {
> +		ta = BLK_TA_ISSUE_EXT;
> +	}

Same comments as for patch 9.

> +	rcu_read_unlock();
> +	blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), ta,
>  			 blk_trace_request_get_cgid(rq));
>  }
>  
> 


-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 11/39] blktrace: update blk_add_trace_rq_requeue()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index e1646d74ac9a..8a7fedfac6b3 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1188,7 +1188,25 @@ static void blk_add_trace_rq_merge(void *ignore, struct request *rq)
 
 static void blk_add_trace_rq_requeue(void *ignore, struct request *rq)
 {
-	blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), BLK_TA_REQUEUE,
+	u64 ta;
+	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
+
+	rcu_read_lock();
+	bt = rcu_dereference(rq->q->blk_trace);
+	bte = rcu_dereference(rq->q->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
+		rcu_read_unlock();
+		return;
+	}
+
+	if (bt) {
+		ta = BLK_TA_REQUEUE;
+	} else if (bte) {
+		ta = BLK_TA_REQUEUE_EXT;
+	}
+	rcu_read_unlock();
+	blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), ta,
 			 blk_trace_request_get_cgid(rq));
 }
 
-- 
2.22.1

Re: [RFC PATCH 11/39] blktrace: update blk_add_trace_rq_requeue()

[Damien Le Moal]

On 2021/02/25 16:04, Chaitanya Kulkarni wrote:
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
> ---
>  kernel/trace/blktrace.c | 20 +++++++++++++++++++-
>  1 file changed, 19 insertions(+), 1 deletion(-)
> 
> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> index e1646d74ac9a..8a7fedfac6b3 100644
> --- a/kernel/trace/blktrace.c
> +++ b/kernel/trace/blktrace.c
> @@ -1188,7 +1188,25 @@ static void blk_add_trace_rq_merge(void *ignore, struct request *rq)
>  
>  static void blk_add_trace_rq_requeue(void *ignore, struct request *rq)
>  {
> -	blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), BLK_TA_REQUEUE,
> +	u64 ta;
> +	struct blk_trace *bt;
> +	struct blk_trace_ext *bte;
> +
> +	rcu_read_lock();
> +	bt = rcu_dereference(rq->q->blk_trace);
> +	bte = rcu_dereference(rq->q->blk_trace_ext);
> +	if (likely(!bt) && likely(!bte)) {
> +		rcu_read_unlock();
> +		return;
> +	}
> +
> +	if (bt) {
> +		ta = BLK_TA_REQUEUE;
> +	} else if (bte) {
> +		ta = BLK_TA_REQUEUE_EXT;
> +	}
> +	rcu_read_unlock();
> +	blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), ta,
>  			 blk_trace_request_get_cgid(rq));
>  }
>  
> 

Same comments as for patch 9.

-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 12/39] blktrace: update blk_add_trace_rq_complete()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 8a7fedfac6b3..07f71a052a0d 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1213,7 +1213,25 @@ static void blk_add_trace_rq_requeue(void *ignore, struct request *rq)
 static void blk_add_trace_rq_complete(void *ignore, struct request *rq,
 			int error, unsigned int nr_bytes)
 {
-	blk_add_trace_rq(rq, error, nr_bytes, BLK_TA_COMPLETE,
+	u64 ta;
+	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
+
+	rcu_read_lock();
+	bt = rcu_dereference(rq->q->blk_trace);
+	bte = rcu_dereference(rq->q->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
+		rcu_read_unlock();
+		return;
+	}
+
+	if (bt) {
+		ta = BLK_TA_COMPLETE;
+	} else if (bte) {
+		ta = BLK_TA_COMPLETE_EXT;
+	}
+	rcu_read_unlock();
+	blk_add_trace_rq(rq, error, nr_bytes, ta,
 			 blk_trace_request_get_cgid(rq));
 }
 
-- 
2.22.1

Re: [RFC PATCH 12/39] blktrace: update blk_add_trace_rq_complete()

[Damien Le Moal]

On 2021/02/25 16:04, Chaitanya Kulkarni wrote:
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
> ---
>  kernel/trace/blktrace.c | 20 +++++++++++++++++++-
>  1 file changed, 19 insertions(+), 1 deletion(-)
> 
> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> index 8a7fedfac6b3..07f71a052a0d 100644
> --- a/kernel/trace/blktrace.c
> +++ b/kernel/trace/blktrace.c
> @@ -1213,7 +1213,25 @@ static void blk_add_trace_rq_requeue(void *ignore, struct request *rq)
>  static void blk_add_trace_rq_complete(void *ignore, struct request *rq,
>  			int error, unsigned int nr_bytes)
>  {
> -	blk_add_trace_rq(rq, error, nr_bytes, BLK_TA_COMPLETE,
> +	u64 ta;
> +	struct blk_trace *bt;
> +	struct blk_trace_ext *bte;
> +
> +	rcu_read_lock();
> +	bt = rcu_dereference(rq->q->blk_trace);
> +	bte = rcu_dereference(rq->q->blk_trace_ext);
> +	if (likely(!bt) && likely(!bte)) {
> +		rcu_read_unlock();
> +		return;
> +	}
> +
> +	if (bt) {
> +		ta = BLK_TA_COMPLETE;
> +	} else if (bte) {
> +		ta = BLK_TA_COMPLETE_EXT;
> +	}
> +	rcu_read_unlock();
> +	blk_add_trace_rq(rq, error, nr_bytes, ta,
>  			 blk_trace_request_get_cgid(rq));
>  }
>  
> 

Same comment as for patch 9.


-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 13/39] blktrace: update blk_add_trace_bio()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 07f71a052a0d..14658b2a3fc8 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1247,20 +1247,31 @@ static void blk_add_trace_rq_complete(void *ignore, struct request *rq,
  *
  **/
 static void blk_add_trace_bio(struct request_queue *q, struct bio *bio,
-			      u32 what, int error)
+			      u64 what, int error)
 {
 	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
 
 	rcu_read_lock();
 	bt = rcu_dereference(q->blk_trace);
-	if (likely(!bt)) {
+	bte = rcu_dereference(q->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
 		rcu_read_unlock();
 		return;
 	}
 
-	__blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
-			bio_op(bio), bio->bi_opf, what, error, 0, NULL,
-			blk_trace_bio_get_cgid(q, bio));
+	if (bt) {
+		__blk_add_trace(bt, bio->bi_iter.bi_sector,
+				bio->bi_iter.bi_size, bio_op(bio),
+				bio->bi_opf, (u32)what, error, 0, NULL,
+				blk_trace_bio_get_cgid(q, bio));
+	} else if (bte) {
+		__blk_add_trace_ext(bte, bio->bi_iter.bi_sector,
+				    bio->bi_iter.bi_size, bio_op(bio),
+				    bio->bi_opf, what, error, 0, NULL,
+				    blk_trace_bio_get_cgid(q, bio),
+				    bio_prio(bio));
+	}
 	rcu_read_unlock();
 }
 
-- 
2.22.1

Re: [RFC PATCH 13/39] blktrace: update blk_add_trace_bio()

[Damien Le Moal]

On 2021/02/25 16:04, Chaitanya Kulkarni wrote:
> Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>

No commit message.

> ---
>  kernel/trace/blktrace.c | 21 ++++++++++++++++-----
>  1 file changed, 16 insertions(+), 5 deletions(-)
> 
> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> index 07f71a052a0d..14658b2a3fc8 100644
> --- a/kernel/trace/blktrace.c
> +++ b/kernel/trace/blktrace.c
> @@ -1247,20 +1247,31 @@ static void blk_add_trace_rq_complete(void *ignore, struct request *rq,
>   *
>   **/
>  static void blk_add_trace_bio(struct request_queue *q, struct bio *bio,
> -			      u32 what, int error)
> +			      u64 what, int error)
>  {
>  	struct blk_trace *bt;
> +	struct blk_trace_ext *bte;
>  
>  	rcu_read_lock();
>  	bt = rcu_dereference(q->blk_trace);
> -	if (likely(!bt)) {
> +	bte = rcu_dereference(q->blk_trace_ext);
> +	if (likely(!bt) && likely(!bte)) {
>  		rcu_read_unlock();
>  		return;
>  	}
>  
> -	__blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
> -			bio_op(bio), bio->bi_opf, what, error, 0, NULL,
> -			blk_trace_bio_get_cgid(q, bio));
> +	if (bt) {
> +		__blk_add_trace(bt, bio->bi_iter.bi_sector,
> +				bio->bi_iter.bi_size, bio_op(bio),
> +				bio->bi_opf, (u32)what, error, 0, NULL,
> +				blk_trace_bio_get_cgid(q, bio));
> +	} else if (bte) {
> +		__blk_add_trace_ext(bte, bio->bi_iter.bi_sector,
> +				    bio->bi_iter.bi_size, bio_op(bio),
> +				    bio->bi_opf, what, error, 0, NULL,
> +				    blk_trace_bio_get_cgid(q, bio),
> +				    bio_prio(bio));
> +	}
>  	rcu_read_unlock();
>  }
>  
> 


-- 
Damien Le Moal
Western Digital Research

[RFC PATCH 14/39] blktrace: update blk_add_trace_bio_bounce()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 14658b2a3fc8..d4c3ae0f419e 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1277,7 +1277,25 @@ static void blk_add_trace_bio(struct request_queue *q, struct bio *bio,
 
 static void blk_add_trace_bio_bounce(void *ignore, struct bio *bio)
 {
-	blk_add_trace_bio(bio->bi_bdev->bd_disk->queue, bio, BLK_TA_BOUNCE, 0);
+	u64 ta = 0;
+	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
+
+	rcu_read_lock();
+	bt = rcu_dereference(bio->bi_bdev->bd_disk->queue->blk_trace);
+	bte = rcu_dereference(bio->bi_bdev->bd_disk->queue->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
+		rcu_read_unlock();
+		return;
+	}
+
+	if (bt) {
+		ta = BLK_TA_BOUNCE;
+	} else if (bte) {
+		ta = BLK_TA_BOUNCE_EXT;
+	}
+	rcu_read_unlock();
+	blk_add_trace_bio(bio->bi_bdev->bd_disk->queue, bio, ta, 0);
 }
 
 static void blk_add_trace_bio_complete(void *ignore,
-- 
2.22.1

[RFC PATCH 15/39] blktrace: update blk_add_trace_bio_complete()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index d4c3ae0f419e..e3210951f1f0 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1301,7 +1301,25 @@ static void blk_add_trace_bio_bounce(void *ignore, struct bio *bio)
 static void blk_add_trace_bio_complete(void *ignore,
 				       struct request_queue *q, struct bio *bio)
 {
-	blk_add_trace_bio(q, bio, BLK_TA_COMPLETE,
+	u64 ta = 0;
+	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
+
+	rcu_read_lock();
+	bt = rcu_dereference(bio->bi_bdev->bd_disk->queue->blk_trace);
+	bte = rcu_dereference(bio->bi_bdev->bd_disk->queue->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
+		rcu_read_unlock();
+		return;
+	}
+
+	if (bt) {
+		ta = BLK_TA_COMPLETE;
+	} else if (bte) {
+		ta = BLK_TA_COMPLETE_EXT;
+	}
+	rcu_read_unlock();
+	blk_add_trace_bio(bio->bi_bdev->bd_disk->queue, bio, ta,
 			  blk_status_to_errno(bio->bi_status));
 }
 
-- 
2.22.1

[RFC PATCH 16/39] blktrace: update blk_add_trace_bio_backmerge()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index e3210951f1f0..1ebaffb6a3d2 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1325,8 +1325,25 @@ static void blk_add_trace_bio_complete(void *ignore,
 
 static void blk_add_trace_bio_backmerge(void *ignore, struct bio *bio)
 {
-	blk_add_trace_bio(bio->bi_bdev->bd_disk->queue, bio, BLK_TA_BACKMERGE,
-			0);
+	u64 ta = 0;
+	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
+
+	rcu_read_lock();
+	bt = rcu_dereference(bio->bi_bdev->bd_disk->queue->blk_trace);
+	bte = rcu_dereference(bio->bi_bdev->bd_disk->queue->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
+		rcu_read_unlock();
+		return;
+	}
+
+	if (bt) {
+		ta = BLK_TA_BACKMERGE;
+	} else if (bte) {
+		ta = BLK_TA_BACKMERGE_EXT;
+	}
+	rcu_read_unlock();
+	blk_add_trace_bio(bio->bi_bdev->bd_disk->queue, bio, ta, 0);
 }
 
 static void blk_add_trace_bio_frontmerge(void *ignore, struct bio *bio)
-- 
2.22.1

[RFC PATCH 17/39] blktrace: update blk_add_trace_bio_frontmerge()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 1ebaffb6a3d2..92c4e5eb8948 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1348,8 +1348,25 @@ static void blk_add_trace_bio_backmerge(void *ignore, struct bio *bio)
 
 static void blk_add_trace_bio_frontmerge(void *ignore, struct bio *bio)
 {
-	blk_add_trace_bio(bio->bi_bdev->bd_disk->queue, bio, BLK_TA_FRONTMERGE,
-			0);
+	u64 ta = 0;
+	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
+
+	rcu_read_lock();
+	bt = rcu_dereference(bio->bi_bdev->bd_disk->queue->blk_trace);
+	bte = rcu_dereference(bio->bi_bdev->bd_disk->queue->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
+		rcu_read_unlock();
+		return;
+	}
+
+	if (bt) {
+		ta = BLK_TA_FRONTMERGE;
+	} else if (bte) {
+		ta = BLK_TA_FRONTMERGE_EXT;
+	}
+	rcu_read_unlock();
+	blk_add_trace_bio(bio->bi_bdev->bd_disk->queue, bio, ta, 0);
 }
 
 static void blk_add_trace_bio_queue(void *ignore, struct bio *bio)
-- 
2.22.1

[RFC PATCH 18/39] blktrace: update blk_add_trace_bio_queue()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 92c4e5eb8948..45327201ebf6 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1371,7 +1371,25 @@ static void blk_add_trace_bio_frontmerge(void *ignore, struct bio *bio)
 
 static void blk_add_trace_bio_queue(void *ignore, struct bio *bio)
 {
-	blk_add_trace_bio(bio->bi_bdev->bd_disk->queue, bio, BLK_TA_QUEUE, 0);
+	u64 ta = 0;
+	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
+
+	rcu_read_lock();
+	bt = rcu_dereference(bio->bi_bdev->bd_disk->queue->blk_trace);
+	bte = rcu_dereference(bio->bi_bdev->bd_disk->queue->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
+		rcu_read_unlock();
+		return;
+	}
+
+	if (bt) {
+		ta = BLK_TA_QUEUE;
+	} else if (bte) {
+		ta = BLK_TA_QUEUE_EXT;
+	}
+	rcu_read_unlock();
+	blk_add_trace_bio(bio->bi_bdev->bd_disk->queue, bio, ta, 0);
 }
 
 static void blk_add_trace_getrq(void *ignore, struct bio *bio)
-- 
2.22.1

[RFC PATCH 19/39] blktrace: update blk_add_trace_getrq()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 45327201ebf6..51c10d86aa92 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1394,7 +1394,24 @@ static void blk_add_trace_bio_queue(void *ignore, struct bio *bio)
 
 static void blk_add_trace_getrq(void *ignore, struct bio *bio)
 {
-	blk_add_trace_bio(bio->bi_bdev->bd_disk->queue, bio, BLK_TA_GETRQ, 0);
+	u64 ta = 0;
+	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
+
+	rcu_read_lock();
+	bt = rcu_dereference(bio->bi_bdev->bd_disk->queue->blk_trace);
+	bte = rcu_dereference(bio->bi_bdev->bd_disk->queue->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
+		rcu_read_unlock();
+		return;
+	}
+	if (bt) {
+		ta = BLK_TA_GETRQ;
+	} else if (bte) {
+		ta = BLK_TA_GETRQ_EXT;
+	}
+	rcu_read_unlock();
+	blk_add_trace_bio(bio->bi_bdev->bd_disk->queue, bio, ta, 0);
 }
 
 static void blk_add_trace_plug(void *ignore, struct request_queue *q)
-- 
2.22.1

[RFC PATCH 20/39] blktrace: update blk_add_trace_plug()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 51c10d86aa92..0a9b491bac9e 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1417,11 +1417,20 @@ static void blk_add_trace_getrq(void *ignore, struct bio *bio)
 static void blk_add_trace_plug(void *ignore, struct request_queue *q)
 {
 	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
 
 	rcu_read_lock();
 	bt = rcu_dereference(q->blk_trace);
+	bte = rcu_dereference(q->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
+		rcu_read_unlock();
+		return;
+	}
 	if (bt)
 		__blk_add_trace(bt, 0, 0, 0, 0, BLK_TA_PLUG, 0, 0, NULL, 0);
+	else if (bte)
+		__blk_add_trace_ext(bte, 0, 0, 0, 0, BLK_TA_PLUG_EXT, 0, 0,
+				    NULL, 0, 0);
 	rcu_read_unlock();
 }
 
-- 
2.22.1

[RFC PATCH 21/39] blktrace: update blk_add_trace_unplug()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 0a9b491bac9e..1f2857cdbcee 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1438,9 +1438,11 @@ static void blk_add_trace_unplug(void *ignore, struct request_queue *q,
 				    unsigned int depth, bool explicit)
 {
 	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
 
 	rcu_read_lock();
 	bt = rcu_dereference(q->blk_trace);
+	bte = rcu_dereference(q->blk_trace_ext);
 	if (bt) {
 		__be64 rpdu = cpu_to_be64(depth);
 		u32 what;
@@ -1451,6 +1453,16 @@ static void blk_add_trace_unplug(void *ignore, struct request_queue *q,
 			what = BLK_TA_UNPLUG_TIMER;
 
 		__blk_add_trace(bt, 0, 0, 0, 0, what, 0, sizeof(rpdu), &rpdu, 0);
+	} else if (bte) {
+		__be64 rpdu = cpu_to_be64(depth);
+		u64 what;
+
+		if (explicit)
+			what = BLK_TA_UNPLUG_IO_EXT;
+		else
+			what = BLK_TA_UNPLUG_TIMER_EXT;
+		__blk_add_trace_ext(bte, 0, 0, 0, 0, what, 0, sizeof(rpdu),
+				&rpdu, 0, 0);
 	}
 	rcu_read_unlock();
 }
-- 
2.22.1

[RFC PATCH 22/39] blktrace: update blk_add_trace_split()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 1f2857cdbcee..35a01cf956a5 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1471,18 +1471,29 @@ static void blk_add_trace_split(void *ignore, struct bio *bio, unsigned int pdu)
 {
 	struct request_queue *q = bio->bi_bdev->bd_disk->queue;
 	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
+	__be64 rpdu = cpu_to_be64(pdu);
 
 	rcu_read_lock();
 	bt = rcu_dereference(q->blk_trace);
+	bte = rcu_dereference(q->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
+		rcu_read_unlock();
+		return;
+	}
 	if (bt) {
-		__be64 rpdu = cpu_to_be64(pdu);
-
 		__blk_add_trace(bt, bio->bi_iter.bi_sector,
 				bio->bi_iter.bi_size, bio_op(bio), bio->bi_opf,
 				BLK_TA_SPLIT,
 				blk_status_to_errno(bio->bi_status),
 				sizeof(rpdu), &rpdu,
 				blk_trace_bio_get_cgid(q, bio));
+	} else if (bte) {
+		__blk_add_trace_ext(bte, bio->bi_iter.bi_sector,
+				    bio->bi_iter.bi_size, bio_op(bio),
+				    bio->bi_opf, BLK_TA_SPLIT_EXT,
+				    bio->bi_status, sizeof(rpdu), &rpdu,
+				    blk_trace_bio_get_cgid(q, bio), 0);
 	}
 	rcu_read_unlock();
 }
-- 
2.22.1

[RFC PATCH 23/39] blktrace: update blk_add_trace_bio_remap()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 35a01cf956a5..e12317f48795 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1512,11 +1512,13 @@ static void blk_add_trace_bio_remap(void *ignore, struct bio *bio, dev_t dev,
 {
 	struct request_queue *q = bio->bi_bdev->bd_disk->queue;
 	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
 	struct blk_io_trace_remap r;
 
 	rcu_read_lock();
 	bt = rcu_dereference(q->blk_trace);
-	if (likely(!bt)) {
+	bte = rcu_dereference(q->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
 		rcu_read_unlock();
 		return;
 	}
@@ -1525,10 +1527,18 @@ static void blk_add_trace_bio_remap(void *ignore, struct bio *bio, dev_t dev,
 	r.device_to   = cpu_to_be32(bio_dev(bio));
 	r.sector_from = cpu_to_be64(from);
 
-	__blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
-			bio_op(bio), bio->bi_opf, BLK_TA_REMAP,
-			blk_status_to_errno(bio->bi_status),
-			sizeof(r), &r, blk_trace_bio_get_cgid(q, bio));
+	if (bt) {
+		__blk_add_trace(bt, bio->bi_iter.bi_sector,
+				bio->bi_iter.bi_size, bio_op(bio), bio->bi_opf,
+				BLK_TA_REMAP, bio->bi_status, sizeof(r), &r,
+				blk_trace_bio_get_cgid(q, bio));
+	} else if (bte) {
+		__blk_add_trace_ext(bte, bio->bi_iter.bi_sector,
+				    bio->bi_iter.bi_size, bio_op(bio),
+				    bio->bi_opf, BLK_TA_REMAP_EXT, bio->bi_status,
+				    sizeof(r), &r,
+				    blk_trace_bio_get_cgid(q, bio), 0);
+	}
 	rcu_read_unlock();
 }
 
-- 
2.22.1

[RFC PATCH 24/39] blktrace: update blk_add_trace_rq_remap()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index e12317f48795..0710f2e40404 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1557,12 +1557,14 @@ static void blk_add_trace_bio_remap(void *ignore, struct bio *bio, dev_t dev,
 static void blk_add_trace_rq_remap(void *ignore, struct request *rq, dev_t dev,
 				   sector_t from)
 {
+	struct blk_trace_ext *bte;
 	struct blk_trace *bt;
 	struct blk_io_trace_remap r;
 
 	rcu_read_lock();
 	bt = rcu_dereference(rq->q->blk_trace);
-	if (likely(!bt)) {
+	bte = rcu_dereference(rq->q->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
 		rcu_read_unlock();
 		return;
 	}
@@ -1571,9 +1573,17 @@ static void blk_add_trace_rq_remap(void *ignore, struct request *rq, dev_t dev,
 	r.device_to   = cpu_to_be32(disk_devt(rq->rq_disk));
 	r.sector_from = cpu_to_be64(from);
 
-	__blk_add_trace(bt, blk_rq_pos(rq), blk_rq_bytes(rq),
-			rq_data_dir(rq), 0, BLK_TA_REMAP, 0,
-			sizeof(r), &r, blk_trace_request_get_cgid(rq));
+	if (bt) {
+		__blk_add_trace(bt, blk_rq_pos(rq), blk_rq_bytes(rq),
+				rq_data_dir(rq), 0, BLK_TA_REMAP, 0,
+				sizeof(r), &r,
+				blk_trace_request_get_cgid(rq));
+	} else if (bte) {
+		__blk_add_trace_ext(bte, blk_rq_pos(rq), blk_rq_bytes(rq),
+				    rq_data_dir(rq), 0, BLK_TA_REMAP_EXT, 0,
+				    sizeof(r), &r,
+				    blk_trace_request_get_cgid(rq), 0);
+	}
 	rcu_read_unlock();
 }
 
-- 
2.22.1

[RFC PATCH 25/39] blktrace: update blk_add_driver_data()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 0710f2e40404..1f9bc2eb31da 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1600,17 +1600,26 @@ static void blk_add_trace_rq_remap(void *ignore, struct request *rq, dev_t dev,
 void blk_add_driver_data(struct request *rq, void *data, size_t len)
 {
 	struct blk_trace *bt;
+	struct blk_trace_ext *bte;
 
 	rcu_read_lock();
 	bt = rcu_dereference(rq->q->blk_trace);
-	if (likely(!bt)) {
+	bte = rcu_dereference(rq->q->blk_trace_ext);
+	if (likely(!bt) && likely(!bte)) {
 		rcu_read_unlock();
 		return;
 	}
 
-	__blk_add_trace(bt, blk_rq_trace_sector(rq), blk_rq_bytes(rq), 0, 0,
-				BLK_TA_DRV_DATA, 0, len, data,
+	if (bt) {
+		__blk_add_trace(bt, blk_rq_trace_sector(rq), blk_rq_bytes(rq), 0,
+				0, BLK_TA_DRV_DATA, 0, len, data,
 				blk_trace_request_get_cgid(rq));
+	} else if (bte) {
+		__blk_add_trace_ext(bte, blk_rq_trace_sector(rq),
+				blk_rq_bytes(rq), 0, 0, BLK_TA_DRV_DATA_EXT, 0,
+				len, data, blk_trace_request_get_cgid(rq),
+				req_get_ioprio(rq));
+	}
 	rcu_read_unlock();
 }
 EXPORT_SYMBOL_GPL(blk_add_driver_data);
-- 
2.22.1

[RFC PATCH 26/39] blktrace: add trace entry & pdu helpers

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 55 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 1f9bc2eb31da..84bee8677162 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1728,52 +1728,107 @@ const struct blk_io_trace *te_blk_io_trace(const struct trace_entry *ent)
 	return (const struct blk_io_trace *)ent;
 }
 
+static inline
+const struct blk_io_trace_ext *te_blk_io_trace_ext(const struct trace_entry *ent)
+{
+	return (const struct blk_io_trace_ext *)ent;
+}
+
 static inline const void *pdu_start(const struct trace_entry *ent, bool has_cg)
 {
 	return (void *)(te_blk_io_trace(ent) + 1) + (has_cg ? sizeof(u64) : 0);
 }
 
+static inline const void *pdu_start_ext(const struct trace_entry *ent, bool has_cg)
+{
+	return (void *)(te_blk_io_trace_ext(ent) + 1) +
+		(has_cg ? sizeof(u64) : 0);
+
+}
+
 static inline u64 t_cgid(const struct trace_entry *ent)
 {
 	return *(u64 *)(te_blk_io_trace(ent) + 1);
 }
 
+static inline const void *cgid_start_ext(const struct trace_entry *ent)
+{
+	return (void *)(te_blk_io_trace_ext(ent) + 1);
+}
+
 static inline int pdu_real_len(const struct trace_entry *ent, bool has_cg)
 {
 	return te_blk_io_trace(ent)->pdu_len - (has_cg ? sizeof(u64) : 0);
 }
 
+static inline int pdu_real_len_ext(const struct trace_entry *ent, bool has_cg)
+{
+	return te_blk_io_trace_ext(ent)->pdu_len -
+			(has_cg ? sizeof(u64) : 0);
+}
+
 static inline u32 t_action(const struct trace_entry *ent)
 {
 	return te_blk_io_trace(ent)->action;
 }
 
+static inline u64 t_action_ext(const struct trace_entry *ent)
+{
+	return te_blk_io_trace_ext(ent)->action;
+}
+
 static inline u32 t_bytes(const struct trace_entry *ent)
 {
 	return te_blk_io_trace(ent)->bytes;
 }
 
+static inline u32 t_bytes_ext(const struct trace_entry *ent)
+{
+	return te_blk_io_trace_ext(ent)->bytes;
+}
+
 static inline u32 t_sec(const struct trace_entry *ent)
 {
 	return te_blk_io_trace(ent)->bytes >> 9;
 }
 
+static inline u32 t_sec_ext(const struct trace_entry *ent)
+{
+	return te_blk_io_trace_ext(ent)->bytes >> 9;
+}
+
 static inline unsigned long long t_sector(const struct trace_entry *ent)
 {
 	return te_blk_io_trace(ent)->sector;
 }
 
+static inline unsigned long long t_sector_ext(const struct trace_entry *ent)
+{
+	return te_blk_io_trace_ext(ent)->sector;
+}
+
 static inline __u16 t_error(const struct trace_entry *ent)
 {
 	return te_blk_io_trace(ent)->error;
 }
 
+static inline __u16 t_error_ext(const struct trace_entry *ent)
+{
+	return te_blk_io_trace_ext(ent)->error;
+}
+
 static __u64 get_pdu_int(const struct trace_entry *ent, bool has_cg)
 {
 	const __be64 *val = pdu_start(ent, has_cg);
 	return be64_to_cpu(*val);
 }
 
+static __u64 get_pdu_int_ext(const struct trace_entry *ent, bool has_cg)
+{
+	const __u64 *val = pdu_start_ext(ent, has_cg);
+	return be64_to_cpu(*val);
+}
+
 typedef void (blk_log_action_t) (struct trace_iterator *iter, const char *act,
 	bool has_cg);
 
-- 
2.22.1

[RFC PATCH 27/39] blktrace: add a new formatting routine

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 57 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 84bee8677162..2241c7304749 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1722,6 +1722,62 @@ static void fill_rwbs(char *rwbs, const struct blk_io_trace *t)
 	rwbs[i] = '\0';
 }
 
+static void fill_rwbs_ext(char *rwbs, const struct blk_io_trace_ext *t)
+{
+	int i = 0;
+	int tc = t->action >> BLK_TC_SHIFT_EXT;
+
+	if ((t->action & ~__BLK_TN_CGROUP) == BLK_TN_MESSAGE_EXT) {
+		rwbs[i++] = 'N';
+		goto out;
+	}
+
+	if (tc & BLK_TC_FLUSH)
+		rwbs[i++] = 'F';
+
+	if (tc & BLK_TC_DISCARD)
+		rwbs[i++] = 'D';
+	else if ((tc & BLK_TC_WRITE_ZEROES)) {
+		rwbs[i++] = 'W';
+		rwbs[i++] = 'Z';
+	} else if ((tc & BLK_TC_ZONE_RESET)) {
+		rwbs[i++] = 'Z';
+		rwbs[i++] = 'R';
+	} else if ((tc & BLK_TC_ZONE_RESET_ALL)) {
+		rwbs[i++] = 'Z';
+		rwbs[i++] = 'R';
+		rwbs[i++] = 'A';
+	} else if ((tc & BLK_TC_ZONE_APPEND)) {
+		rwbs[i++] = 'Z';
+		rwbs[i++] = 'A';
+	} else if ((tc & BLK_TC_ZONE_OPEN)) {
+		rwbs[i++] = 'Z';
+		rwbs[i++] = 'O';
+	} else if ((tc & BLK_TC_ZONE_CLOSE)) {
+		rwbs[i++] = 'Z';
+		rwbs[i++] = 'C';
+	} else if ((tc & BLK_TC_ZONE_FINISH)) {
+		rwbs[i++] = 'Z';
+		rwbs[i++] = 'F';
+	} else if (tc & BLK_TC_WRITE)
+		rwbs[i++] = 'W';
+	else if (t->bytes)
+		rwbs[i++] = 'R';
+	else
+		rwbs[i++] = 'N';
+
+	if (tc & BLK_TC_FUA)
+		rwbs[i++] = 'F';
+	if (tc & BLK_TC_AHEAD)
+		rwbs[i++] = 'A';
+	if (tc & BLK_TC_SYNC)
+		rwbs[i++] = 'S';
+	if (tc & BLK_TC_META)
+		rwbs[i++] = 'M';
+out:
+	rwbs[i] = '\0';
+}
+
 static inline
 const struct blk_io_trace *te_blk_io_trace(const struct trace_entry *ent)
 {
@@ -2514,5 +2570,6 @@ void blk_fill_rwbs(char *rwbs, unsigned int op)
 }
 EXPORT_SYMBOL_GPL(blk_fill_rwbs);
 
+
 #endif /* CONFIG_EVENT_TRACING */
 
-- 
2.22.1

[RFC PATCH 28/39] blktrace: add blk_log_xxx helpers()

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 175 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 175 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 2241c7304749..425756a62457 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1905,6 +1905,23 @@ static void blk_log_action_classic(struct trace_iterator *iter, const char *act,
 			 secs, nsec_rem, iter->ent->pid, act, rwbs);
 }
 
+static void blk_log_action_classic_ext(struct trace_iterator *iter, const char *act,
+	bool has_cg)
+{
+	char rwbs[RWBS_LEN];
+	unsigned long long ts  = iter->ts;
+	unsigned long nsec_rem = do_div(ts, NSEC_PER_SEC);
+	unsigned secs	       = (unsigned long)ts;
+	const struct blk_io_trace_ext *t = te_blk_io_trace_ext(iter->ent);
+
+	fill_rwbs_ext(rwbs, t);
+
+	trace_seq_printf(&iter->seq,
+			 "%3d,%-3d %2d %5d.%09lu %5u %2s %3s ",
+			 MAJOR(t->device), MINOR(t->device), iter->cpu,
+			 secs, nsec_rem, iter->ent->pid, act, rwbs);
+}
+
 static void blk_log_action(struct trace_iterator *iter, const char *act,
 	bool has_cg)
 {
@@ -1947,6 +1964,35 @@ static void blk_log_action(struct trace_iterator *iter, const char *act,
 				 MAJOR(t->device), MINOR(t->device), act, rwbs);
 }
 
+static void blk_log_action_ext(struct trace_iterator *iter, const char *act,
+	bool has_cg)
+{
+	char rwbs[RWBS_LEN];
+	const struct blk_io_trace_ext *t = te_blk_io_trace_ext(iter->ent);
+
+	fill_rwbs_ext(rwbs, t);
+	if (has_cg) {
+		u64 id = t_cgid(iter->ent);
+
+		if (blk_tracer_flags.val & TRACE_BLK_OPT_CGNAME) {
+			char blkcg_name_buf[NAME_MAX + 1] = "<...>";
+
+			cgroup_path_from_kernfs_id(id, blkcg_name_buf,
+				sizeof(blkcg_name_buf));
+			trace_seq_printf(&iter->seq, "%3d,%-3d %s %2s %3s ",
+				 MAJOR(t->device), MINOR(t->device),
+				 blkcg_name_buf, act, rwbs);
+		} else
+			trace_seq_printf(&iter->seq,
+				 "%3d,%-3d %llx,%-llx %2s %3s ",
+				 MAJOR(t->device), MINOR(t->device),
+				 id & U32_MAX, id >> 32, act, rwbs);
+	} else
+		trace_seq_printf(&iter->seq, "%3d,%-3d %2s %3s ",
+				 MAJOR(t->device), MINOR(t->device), act, rwbs);
+}
+
+
 static void blk_log_dump_pdu(struct trace_seq *s,
 	const struct trace_entry *ent, bool has_cg)
 {
@@ -1986,6 +2032,45 @@ static void blk_log_dump_pdu(struct trace_seq *s,
 	trace_seq_puts(s, ") ");
 }
 
+static void blk_log_dump_pdu_ext(struct trace_seq *s,
+	const struct trace_entry *ent, bool has_cg)
+{
+	const unsigned char *pdu_buf;
+	int pdu_len;
+	int i, end;
+
+	pdu_buf = pdu_start_ext(ent, has_cg);
+	pdu_len = pdu_real_len_ext(ent, has_cg);
+
+	if (!pdu_len)
+		return;
+
+	/* find the last zero that needs to be printed */
+	for (end = pdu_len - 1; end >= 0; end--)
+		if (pdu_buf[end])
+			break;
+	end++;
+
+	trace_seq_putc(s, '(');
+
+	for (i = 0; i < pdu_len; i++) {
+
+		trace_seq_printf(s, "%s%02x",
+				 i == 0 ? "" : " ", pdu_buf[i]);
+
+		/*
+		 * stop when the rest is just zeroes and indicate so
+		 * with a ".." appended
+		 */
+		if (i == end && end != pdu_len - 1) {
+			trace_seq_puts(s, " ..) ");
+			return;
+		}
+	}
+
+	trace_seq_puts(s, ") ");
+}
+
 static void blk_log_generic(struct trace_seq *s, const struct trace_entry *ent, bool has_cg)
 {
 	char cmd[TASK_COMM_LEN];
@@ -2005,6 +2090,28 @@ static void blk_log_generic(struct trace_seq *s, const struct trace_entry *ent,
 	}
 }
 
+static void blk_log_generic_ext(struct trace_seq *s,
+				const struct trace_entry *ent,
+				bool has_cg)
+{
+	char cmd[TASK_COMM_LEN];
+
+	trace_find_cmdline(ent->pid, cmd);
+
+	if (t_action(ent) & BLK_TC_ACT_EXT(BLK_TC_PC)) {
+		trace_seq_printf(s, "%u ", t_bytes_ext(ent));
+		blk_log_dump_pdu_ext(s, ent, has_cg);
+		trace_seq_printf(s, "[%s]\n", cmd);
+	} else {
+		if (t_sec_ext(ent))
+			trace_seq_printf(s, "%llu + %u [%s]\n",
+						t_sector_ext(ent),
+						t_sec_ext(ent), cmd);
+		else
+			trace_seq_printf(s, "[%s]\n", cmd);
+	}
+}
+
 static void blk_log_with_error(struct trace_seq *s,
 			      const struct trace_entry *ent, bool has_cg)
 {
@@ -2022,6 +2129,23 @@ static void blk_log_with_error(struct trace_seq *s,
 	}
 }
 
+static void blk_log_with_error_ext(struct trace_seq *s,
+			      const struct trace_entry *ent, bool has_cg)
+{
+	if (t_action_ext(ent) & BLK_TC_ACT_EXT(BLK_TC_PC)) {
+		blk_log_dump_pdu_ext(s, ent, has_cg);
+		trace_seq_printf(s, "[%d]\n", t_error_ext(ent));
+	} else {
+		if (t_sec_ext(ent))
+			trace_seq_printf(s, "%llu + %u [%d]\n",
+					 t_sector_ext(ent),
+					 t_sec_ext(ent), t_error_ext(ent));
+		else
+			trace_seq_printf(s, "%llu [%d]\n",
+					 t_sector_ext(ent), t_error_ext(ent));
+	}
+}
+
 static void blk_log_remap(struct trace_seq *s, const struct trace_entry *ent, bool has_cg)
 {
 	const struct blk_io_trace_remap *__r = pdu_start(ent, has_cg);
@@ -2033,6 +2157,18 @@ static void blk_log_remap(struct trace_seq *s, const struct trace_entry *ent, bo
 			 be64_to_cpu(__r->sector_from));
 }
 
+static void blk_log_remap_ext(struct trace_seq *s, const struct trace_entry *ent,
+		bool has_cg)
+{
+	const struct blk_io_trace_remap *__r = pdu_start_ext(ent, has_cg);
+
+	trace_seq_printf(s, "%llu + %u <- (%d,%d) %llu\n",
+			 t_sector_ext(ent), t_sec_ext(ent),
+			 MAJOR(be32_to_cpu(__r->device_from)),
+			 MINOR(be32_to_cpu(__r->device_from)),
+			 be64_to_cpu(__r->sector_from));
+}
+
 static void blk_log_plug(struct trace_seq *s, const struct trace_entry *ent, bool has_cg)
 {
 	char cmd[TASK_COMM_LEN];
@@ -2042,6 +2178,16 @@ static void blk_log_plug(struct trace_seq *s, const struct trace_entry *ent, boo
 	trace_seq_printf(s, "[%s]\n", cmd);
 }
 
+static void blk_log_plug_ext(struct trace_seq *s, const struct trace_entry *ent,
+		bool has_cg)
+{
+	char cmd[TASK_COMM_LEN];
+
+	trace_find_cmdline(ent->pid, cmd);
+
+	trace_seq_printf(s, "[%s] %llu\n", cmd, get_pdu_int_ext(ent, has_cg));
+}
+
 static void blk_log_unplug(struct trace_seq *s, const struct trace_entry *ent, bool has_cg)
 {
 	char cmd[TASK_COMM_LEN];
@@ -2051,6 +2197,16 @@ static void blk_log_unplug(struct trace_seq *s, const struct trace_entry *ent, b
 	trace_seq_printf(s, "[%s] %llu\n", cmd, get_pdu_int(ent, has_cg));
 }
 
+static void blk_log_unplug_ext(struct trace_seq *s, const struct trace_entry *ent,
+		bool has_cg)
+{
+	char cmd[TASK_COMM_LEN];
+
+	trace_find_cmdline(ent->pid, cmd);
+
+	trace_seq_printf(s, "[%s] %llu\n", cmd, get_pdu_int_ext(ent, has_cg));
+}
+
 static void blk_log_split(struct trace_seq *s, const struct trace_entry *ent, bool has_cg)
 {
 	char cmd[TASK_COMM_LEN];
@@ -2061,6 +2217,16 @@ static void blk_log_split(struct trace_seq *s, const struct trace_entry *ent, bo
 			 get_pdu_int(ent, has_cg), cmd);
 }
 
+static void blk_log_split_ext(struct trace_seq *s, const struct trace_entry *ent, bool has_cg)
+{
+	char cmd[TASK_COMM_LEN];
+
+	trace_find_cmdline(ent->pid, cmd);
+
+	trace_seq_printf(s, "%llu / %llu [%s]\n", t_sector_ext(ent),
+			 get_pdu_int_ext(ent, has_cg), cmd);
+}
+
 static void blk_log_msg(struct trace_seq *s, const struct trace_entry *ent,
 			bool has_cg)
 {
@@ -2070,6 +2236,15 @@ static void blk_log_msg(struct trace_seq *s, const struct trace_entry *ent,
 	trace_seq_putc(s, '\n');
 }
 
+static void blk_log_msg_ext(struct trace_seq *s, const struct trace_entry *ent,
+			bool has_cg)
+{
+
+	trace_seq_putmem(s, pdu_start_ext(ent, has_cg),
+		pdu_real_len_ext(ent, has_cg));
+	trace_seq_putc(s, '\n');
+}
+
 /*
  * struct tracer operations
  */
-- 
2.22.1

[RFC PATCH 29/39] blktrace: link blk_log_xxx() to trace action

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 425756a62457..4a4ba1d45cb9 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -2301,6 +2301,28 @@ static const struct {
 	[__BLK_TA_REMAP]	= {{  "A", "remap" },	   blk_log_remap },
 };
 
+static const struct {
+	const char *act[2];
+	void	   (*print)(struct trace_seq *s, const struct trace_entry *ent,
+			    bool has_cg);
+} what2act_ext[] = {
+	[__BLK_TA_QUEUE]	= {{  "Q", "queue" },	   blk_log_generic_ext },
+	[__BLK_TA_BACKMERGE]	= {{  "M", "backmerge" },  blk_log_generic_ext },
+	[__BLK_TA_FRONTMERGE]	= {{  "F", "frontmerge" }, blk_log_generic_ext },
+	[__BLK_TA_GETRQ]	= {{  "G", "getrq" },	   blk_log_generic_ext },
+	[__BLK_TA_SLEEPRQ]	= {{  "S", "sleeprq" },	   blk_log_generic_ext },
+	[__BLK_TA_REQUEUE]	= {{  "R", "requeue" },	   blk_log_with_error_ext },
+	[__BLK_TA_ISSUE]	= {{  "D", "issue" },	   blk_log_generic_ext },
+	[__BLK_TA_COMPLETE]	= {{  "C", "complete" },   blk_log_with_error_ext },
+	[__BLK_TA_PLUG]		= {{  "P", "plug" },	   blk_log_plug },
+	[__BLK_TA_UNPLUG_IO]	= {{  "U", "unplug_io" },  blk_log_unplug_ext },
+	[__BLK_TA_UNPLUG_TIMER]	= {{ "UT", "unplug_timer" }, blk_log_unplug_ext},
+	[__BLK_TA_INSERT]	= {{  "I", "insert" },	   blk_log_generic_ext},
+	[__BLK_TA_SPLIT]	= {{  "X", "split" },	   blk_log_split_ext },
+	[__BLK_TA_BOUNCE]	= {{  "B", "bounce" },	   blk_log_generic_ext },
+	[__BLK_TA_REMAP]	= {{  "A", "remap" },	   blk_log_remap_ext },
+};
+
 static enum print_line_t print_one_line(struct trace_iterator *iter,
 					bool classic)
 {
-- 
2.22.1

[RFC PATCH 30/39] blktrace: add trace event print helper

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 4a4ba1d45cb9..75b2ec88d8c4 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -2356,12 +2356,51 @@ static enum print_line_t print_one_line(struct trace_iterator *iter,
 	return trace_handle_return(s);
 }
 
+static enum print_line_t print_one_line_ext(struct trace_iterator *iter,
+					bool classic)
+{
+	struct trace_array *tr = iter->tr;
+	struct trace_seq *s = &iter->seq;
+	const struct blk_io_trace_ext *t;
+	u32 what;
+	bool long_act;
+	blk_log_action_t *log_action;
+	bool has_cg;
+
+	t	   = te_blk_io_trace_ext(iter->ent);
+	what	   = (t->action & ((1ULL << BLK_TC_SHIFT_EXT) - 1)) & ~__BLK_TA_CGROUP;
+	long_act   = !!(tr->trace_flags & TRACE_ITER_VERBOSE);
+	log_action = classic ? &blk_log_action_classic_ext : &blk_log_action_ext;
+	has_cg	   = t->action & __BLK_TA_CGROUP;
+
+	if ((t->action & ~__BLK_TN_CGROUP) == BLK_TN_MESSAGE_EXT) {
+		log_action(iter, long_act ? "message" : "m", has_cg);
+		blk_log_msg_ext(s, iter->ent, has_cg);
+		return trace_handle_return(s);
+	}
+
+	if (unlikely(what == 0 || what >= ARRAY_SIZE(what2act_ext)))
+		trace_seq_printf(s, "Unknown action %x\n", what);
+	else {
+		log_action(iter, what2act_ext[what].act[long_act], has_cg);
+		what2act_ext[what].print(s, iter->ent, has_cg);
+	}
+
+	return trace_handle_return(s);
+}
+
 static enum print_line_t blk_trace_event_print(struct trace_iterator *iter,
 					       int flags, struct trace_event *event)
 {
 	return print_one_line(iter, false);
 }
 
+static enum print_line_t blk_trace_event_print_ext(struct trace_iterator *iter,
+					       int flags, struct trace_event *event)
+{
+	return print_one_line_ext(iter, false);
+}
+
 static void blk_trace_synthesize_old_trace(struct trace_iterator *iter)
 {
 	struct trace_seq *s = &iter->seq;
-- 
2.22.1

[RFC PATCH 31/39] blktrace: add trace_synthesize helper

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 75b2ec88d8c4..a904a800b696 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -2416,6 +2416,21 @@ static void blk_trace_synthesize_old_trace(struct trace_iterator *iter)
 			 sizeof(old) - offset + t->pdu_len);
 }
 
+static void blk_trace_synthesize_old_trace_ext(struct trace_iterator *iter)
+{
+	struct trace_seq *s = &iter->seq;
+	struct blk_io_trace_ext *t = (struct blk_io_trace_ext *)iter->ent;
+	const int offset = offsetof(struct blk_io_trace_ext, sector);
+	struct blk_io_trace_ext old = {
+		.magic	  = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION_EXT,
+		.time     = iter->ts,
+	};
+
+	trace_seq_putmem(s, &old, offset);
+	trace_seq_putmem(s, &t->sector,
+			 sizeof(old) - offset + t->pdu_len);
+}
+
 static enum print_line_t
 blk_trace_event_print_binary(struct trace_iterator *iter, int flags,
 			     struct trace_event *event)
-- 
2.22.1

[RFC PATCH 32/39] blktrace: add trace print helpers

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index a904a800b696..53bba8537294 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -2440,6 +2440,15 @@ blk_trace_event_print_binary(struct trace_iterator *iter, int flags,
 	return trace_handle_return(&iter->seq);
 }
 
+static enum print_line_t
+blk_trace_event_print_binary_ext(struct trace_iterator *iter, int flags,
+			     struct trace_event *event)
+{
+	blk_trace_synthesize_old_trace_ext(iter);
+
+	return trace_handle_return(&iter->seq);
+}
+
 static enum print_line_t blk_tracer_print_line(struct trace_iterator *iter)
 {
 	if (!(blk_tracer_flags.val & TRACE_BLK_OPT_CLASSIC))
@@ -2448,6 +2457,14 @@ static enum print_line_t blk_tracer_print_line(struct trace_iterator *iter)
 	return print_one_line(iter, true);
 }
 
+static enum print_line_t blk_tracer_print_line_ext(struct trace_iterator *iter)
+{
+	if (!(blk_tracer_flags.val & TRACE_BLK_OPT_CLASSIC))
+		return TRACE_TYPE_UNHANDLED;
+
+	return print_one_line_ext(iter, true);
+}
+
 static int
 blk_tracer_set_flag(struct trace_array *tr, u32 old_flags, u32 bit, int set)
 {
-- 
2.22.1

[RFC PATCH 33/39] blktrace: add blkext tracer

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 47 ++++++++++++++++++++++++++++++++++++++---
 kernel/trace/trace.h    |  1 +
 2 files changed, 45 insertions(+), 3 deletions(-)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 53bba8537294..f707ebde0062 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -2490,18 +2490,42 @@ static struct tracer blk_tracer __read_mostly = {
 	.set_flag	= blk_tracer_set_flag,
 };
 
+static struct tracer blk_tracer_ext __read_mostly = {
+	.name		= "blkext",
+	.init		= blk_tracer_init,
+	.reset		= blk_tracer_reset,
+	.start		= blk_tracer_start,
+	.stop		= blk_tracer_stop,
+	.print_header	= blk_tracer_print_header,
+	.print_line	= blk_tracer_print_line_ext,
+	.flags		= &blk_tracer_flags,
+	.set_flag	= blk_tracer_set_flag,
+};
+
 static struct trace_event_functions trace_blk_event_funcs = {
 	.trace		= blk_trace_event_print,
 	.binary		= blk_trace_event_print_binary,
 };
 
+static struct trace_event_functions trace_blk_event_funcs_ext = {
+	.trace		= blk_trace_event_print_ext,
+	.binary		= blk_trace_event_print_binary_ext,
+};
+
 static struct trace_event trace_blk_event = {
 	.type		= TRACE_BLK,
 	.funcs		= &trace_blk_event_funcs,
 };
 
+static struct trace_event trace_blk_event_ext = {
+	.type		= TRACE_BLK_EXT,
+	.funcs		= &trace_blk_event_funcs_ext,
+};
+
 static int __init init_blk_tracer(void)
 {
+	int ret = 0;
+
 	if (!register_trace_event(&trace_blk_event)) {
 		pr_warn("Warning: could not register block events\n");
 		return 1;
@@ -2509,11 +2533,28 @@ static int __init init_blk_tracer(void)
 
 	if (register_tracer(&blk_tracer) != 0) {
 		pr_warn("Warning: could not register the block tracer\n");
-		unregister_trace_event(&trace_blk_event);
-		return 1;
+		goto unregister_trace_event;
 	}
 
-	return 0;
+	if (!register_trace_event(&trace_blk_event_ext)) {
+		pr_warn("Warning: could not register block events\n");
+		/* unregister blk_tracer */
+		goto unregister_trace_event;
+	}
+
+	if (register_tracer(&blk_tracer_ext) != 0) {
+		pr_warn("Warning: could not register the block tracer\n");
+		goto unregister_trace_event_ext;
+	}
+out:
+	return ret;
+
+unregister_trace_event_ext:
+	unregister_trace_event(&trace_blk_event_ext);
+unregister_trace_event:
+	unregister_trace_event(&trace_blk_event);
+	ret = 1;
+	goto out;
 }
 
 device_initcall(init_blk_tracer);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index e448d2da0b99..8bb010753a17 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -42,6 +42,7 @@ enum trace_type {
 	TRACE_GRAPH_ENT,
 	TRACE_USER_STACK,
 	TRACE_BLK,
+	TRACE_BLK_EXT,
 	TRACE_BPUTS,
 	TRACE_HWLAT,
 	TRACE_RAW_DATA,
-- 
2.22.1

Re: [blktrace] c055908abe: WARNING:at_kernel/trace/trace.c:#create_trace_option_files

[Steven Rostedt]

On Sat, 27 Feb 2021 19:44:40 +0800
kernel test robot <oliver.sang@intel.com> wrote:

> [   20.216017] WARNING: CPU: 0 PID: 1 at kernel/trace/trace.c:8370 create_trace_option_files (kbuild/src/consumer/kernel/trace/trace.c:8370 (discriminator 1)) 
> [   20.218480] Modules linked in:
> [   20.219395] CPU: 0 PID: 1 Comm: swapper/0 Not tainted 5.11.0-09341-gc055908abe0d #1
> [   20.221182] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.12.0-1 04/01/2014
> [   20.224540] EIP: create_trace_option_files (kbuild/src/consumer/kernel/trace/trace.c:8370 (discriminator 1)) 
> [ 20.225816] Code: d5 01 83 15 2c b7 08 d5 00 83 c0 01 39 c8 0f 84 c7 00 00 00 8b 14 c7 39 72 44 75 df 83 05 10 b7 08 d5 01 83 15 14 b7 08 d5 00 <0f> 0b 83 05 18 b7 08 d5 01 83 15 1c b7 08 d5 00 83 05 20 b7 08 d5

Looks to be from this:

> +static struct tracer blk_tracer_ext __read_mostly = {
> +	.name		= "blkext",
> +	.init		= blk_tracer_init,
> +	.reset		= blk_tracer_reset,
> +	.start		= blk_tracer_start,
> +	.stop		= blk_tracer_stop,
> +	.print_header	= blk_tracer_print_header,
> +	.print_line	= blk_tracer_print_line_ext,
> +	.flags		= &blk_tracer_flags,

                          ^^^

As blk_tracer already registers those flags, when it gets registered as
a tracer, and flag names can not be duplicated.

I could fix the infrastructure to detect the same set of flags being
registered by two different tracers, but in the mean time, it may still
work to use the blk_trace_flags from blk_tracer, and keep .flags NULL
here.

-- Steve


> +	.set_flag	= blk_tracer_set_flag,
> +};
> +

Re: [blktrace] c055908abe: WARNING:at_kernel/trace/trace.c:#create_trace_option_files

[Chaitanya Kulkarni]

On 2/27/21 06:49, Steven Rostedt wrote:
> On Sat, 27 Feb 2021 19:44:40 +0800
> kernel test robot <oliver.sang@intel.com> wrote:
>
>> [   20.216017] WARNING: CPU: 0 PID: 1 at kernel/trace/trace.c:8370 create_trace_option_files (kbuild/src/consumer/kernel/trace/trace.c:8370 (discriminator 1)) 
>> [   20.218480] Modules linked in:
>> [   20.219395] CPU: 0 PID: 1 Comm: swapper/0 Not tainted 5.11.0-09341-gc055908abe0d #1
>> [   20.221182] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.12.0-1 04/01/2014
>> [   20.224540] EIP: create_trace_option_files (kbuild/src/consumer/kernel/trace/trace.c:8370 (discriminator 1)) 
>> [ 20.225816] Code: d5 01 83 15 2c b7 08 d5 00 83 c0 01 39 c8 0f 84 c7 00 00 00 8b 14 c7 39 72 44 75 df 83 05 10 b7 08 d5 01 83 15 14 b7 08 d5 00 <0f> 0b 83 05 18 b7 08 d5 01 83 15 1c b7 08 d5 00 83 05 20 b7 08 d5
> Looks to be from this:
>
>> +static struct tracer blk_tracer_ext __read_mostly = {
>> +	.name		= "blkext",
>> +	.init		= blk_tracer_init,
>> +	.reset		= blk_tracer_reset,
>> +	.start		= blk_tracer_start,
>> +	.stop		= blk_tracer_stop,
>> +	.print_header	= blk_tracer_print_header,
>> +	.print_line	= blk_tracer_print_line_ext,
>> +	.flags		= &blk_tracer_flags,
>                           ^^^
>
> As blk_tracer already registers those flags, when it gets registered as
> a tracer, and flag names can not be duplicated.
>
> I could fix the infrastructure to detect the same set of flags being
> registered by two different tracers, but in the mean time, it may still
> work to use the blk_trace_flags from blk_tracer, and keep .flags NULL
> here.
>
> -- Steve
Thanks for the reply Steve. This is still under currently discussion and
I'm still
waiting formore people to reply on this approach, if we end up having
this as
a part of final implementation we may need to fix that.

>
>> +	.set_flag	= blk_tracer_set_flag,
>> +};
>> +

[RFC PATCH 34/39] blktrace: implement setup-start-stop ioclts

[Chaitanya Kulkarni]

Implement newly introduced IOCTLs for setup/start/stop/teardown.

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 include/uapi/linux/fs.h |   5 +
 kernel/trace/blktrace.c | 294 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 299 insertions(+)

diff --git a/include/uapi/linux/fs.h b/include/uapi/linux/fs.h
index f44eb0a04afd..ca722ecbd3de 100644
--- a/include/uapi/linux/fs.h
+++ b/include/uapi/linux/fs.h
@@ -184,6 +184,11 @@ struct fsxattr {
 #define BLKSECDISCARD _IO(0x12,125)
 #define BLKROTATIONAL _IO(0x12,126)
 #define BLKZEROOUT _IO(0x12,127)
+#define BLKTRACESETUP_EXT _IOWR(0x12,128,struct blk_user_trace_setup_ext)
+#define BLKTRACESTART_EXT _IO(0x12,129)
+#define BLKTRACESTOP_EXT _IO(0x12,130)
+#define BLKTRACETEARDOWN_EXT _IO(0x12,131)
+
 /*
  * A jump here: 130-131 are reserved for zoned block devices
  * (see uapi/linux/blkzoned.h)
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index f707ebde0062..3bd56b741379 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -609,6 +609,17 @@ static void get_probe_ref(void)
 	mutex_unlock(&blk_probe_mutex);
 }
 
+static void blk_trace_free_ext(struct blk_trace_ext *bt)
+{
+	debugfs_remove(bt->msg_file);
+	debugfs_remove(bt->dropped_file);
+	relay_close(bt->rchan);
+	debugfs_remove(bt->dir);
+	free_percpu(bt->sequence);
+	free_percpu(bt->msg_data);
+	kfree(bt);
+}
+
 static void put_probe_ref(void)
 {
 	mutex_lock(&blk_probe_mutex);
@@ -624,6 +635,13 @@ static void blk_trace_cleanup(struct blk_trace *bt)
 	put_probe_ref();
 }
 
+static void blk_trace_cleanup_ext(struct blk_trace_ext *bt)
+{
+	synchronize_rcu();
+	blk_trace_free_ext(bt);
+	put_probe_ref();
+}
+
 static int __blk_trace_remove(struct request_queue *q)
 {
 	struct blk_trace *bt;
@@ -639,12 +657,28 @@ static int __blk_trace_remove(struct request_queue *q)
 	return 0;
 }
 
+static int __blk_trace_remove_ext(struct request_queue *q)
+{
+	struct blk_trace_ext *bt;
+
+	bt = xchg(&q->blk_trace_ext, NULL);
+	if (!bt)
+		return -EINVAL;
+
+	if (bt->trace_state != Blktrace_running)
+		blk_trace_cleanup_ext(bt);
+
+	return 0;
+}
+
 int blk_trace_remove(struct request_queue *q)
 {
 	int ret;
 
 	mutex_lock(&q->debugfs_mutex);
 	ret = __blk_trace_remove(q);
+	if (ret)
+		__blk_trace_remove_ext(q);
 	mutex_unlock(&q->debugfs_mutex);
 
 	return ret;
@@ -662,6 +696,17 @@ static ssize_t blk_dropped_read(struct file *filp, char __user *buffer,
 	return simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));
 }
 
+static ssize_t blk_dropped_read_ext(struct file *filp, char __user *buffer,
+				size_t count, loff_t *ppos)
+{
+	struct blk_trace_ext *bt = filp->private_data;
+	char buf[16];
+
+	snprintf(buf, sizeof(buf), "%u\n", atomic_read(&bt->dropped));
+
+	return simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));
+}
+
 static const struct file_operations blk_dropped_fops = {
 	.owner =	THIS_MODULE,
 	.open =		simple_open,
@@ -669,6 +714,13 @@ static const struct file_operations blk_dropped_fops = {
 	.llseek =	default_llseek,
 };
 
+static const struct file_operations blk_dropped_fops_ext = {
+	.owner =	THIS_MODULE,
+	.open =		simple_open,
+	.read =		blk_dropped_read_ext,
+	.llseek =	default_llseek,
+};
+
 static ssize_t blk_msg_write(struct file *filp, const char __user *buffer,
 				size_t count, loff_t *ppos)
 {
@@ -689,6 +741,26 @@ static ssize_t blk_msg_write(struct file *filp, const char __user *buffer,
 	return count;
 }
 
+static ssize_t blk_msg_write_ext(struct file *filp, const char __user *buffer,
+				size_t count, loff_t *ppos)
+{
+	char *msg;
+	struct blk_trace_ext *bt;
+
+	if (count >= BLK_TN_MAX_MSG)
+		return -EINVAL;
+
+	msg = memdup_user_nul(buffer, count);
+       if (IS_ERR(msg))
+		return PTR_ERR(msg);
+
+	bt = filp->private_data;
+	__trace_note_message_ext(bt, NULL, "%s", msg);
+	kfree(msg);
+
+	return count;
+}
+
 static const struct file_operations blk_msg_fops = {
 	.owner =	THIS_MODULE,
 	.open =		simple_open,
@@ -696,6 +768,13 @@ static const struct file_operations blk_msg_fops = {
 	.llseek =	noop_llseek,
 };
 
+static const struct file_operations blk_msg_fops_ext = {
+	.owner =	THIS_MODULE,
+	.open =		simple_open,
+	.write =	blk_msg_write_ext,
+	.llseek =	noop_llseek,
+};
+
 /*
  * Keep track of how many times we encountered a full subbuffer, to aid
  * the user space app in telling how many lost events there were.
@@ -730,12 +809,31 @@ static struct dentry *blk_create_buf_file_callback(const char *filename,
 					&relay_file_operations);
 }
 
+static int blk_subbuf_start_callback_ext(struct rchan_buf *buf, void *subbuf,
+				     void *prev_subbuf, size_t prev_padding)
+{
+	struct blk_trace_ext *bt;
+
+	if (!relay_buf_full(buf))
+		return 1;
+
+	bt = buf->chan->private_data;
+	atomic_inc(&bt->dropped);
+	return 0;
+}
+
 static const struct rchan_callbacks blk_relay_callbacks = {
 	.subbuf_start		= blk_subbuf_start_callback,
 	.create_buf_file	= blk_create_buf_file_callback,
 	.remove_buf_file	= blk_remove_buf_file_callback,
 };
 
+static struct rchan_callbacks blk_relay_callbacks_ext = {
+	.subbuf_start		= blk_subbuf_start_callback_ext,
+	.create_buf_file	= blk_create_buf_file_callback,
+	.remove_buf_file	= blk_remove_buf_file_callback,
+};
+
 static void blk_trace_setup_lba(struct blk_trace *bt,
 				struct block_device *bdev)
 {
@@ -748,6 +846,18 @@ static void blk_trace_setup_lba(struct blk_trace *bt,
 	}
 }
 
+static void blk_trace_setup_lba_ext(struct blk_trace_ext *bt,
+				struct block_device *bdev)
+{
+	if (bdev) {
+		bt->start_lba = bdev->bd_start_sect;
+		bt->end_lba = bdev->bd_start_sect + bdev_nr_sectors(bdev);
+	} else {
+		bt->start_lba = 0;
+		bt->end_lba = -1ULL;
+	}
+}
+
 /*
  * Setup everything required to start tracing
  */
@@ -858,6 +968,106 @@ static int do_blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
 	return ret;
 }
 
+static int do_blk_trace_setup_ext(struct request_queue *q, char *name, dev_t dev,
+			      struct block_device *bdev,
+			      struct blk_user_trace_setup_ext *buts)
+{
+	struct blk_trace_ext *bt = NULL;
+	struct dentry *dir = NULL;
+	int ret;
+
+	if (q->blk_trace) {
+		pr_err("queue is already associated with legecy trace\n");
+		return -EINVAL;
+	}
+	if (!buts->buf_size || !buts->buf_nr)
+		return -EINVAL;
+
+	if (!blk_debugfs_root)
+		return -ENOENT;
+
+	strncpy(buts->name, name, BLKTRACE_BDEV_SIZE);
+	buts->name[BLKTRACE_BDEV_SIZE - 1] = '\0';
+
+	/*
+	 * some device names have larger paths - convert the slashes
+	 * to underscores for this to work as expected
+	 */
+	strreplace(buts->name, '/', '_');
+
+	bt = kzalloc(sizeof(*bt), GFP_KERNEL);
+	if (!bt)
+		return -ENOMEM;
+
+	ret = -ENOMEM;
+	bt->sequence = alloc_percpu(unsigned long);
+	if (!bt->sequence)
+		goto err;
+
+	bt->msg_data = __alloc_percpu(BLK_TN_MAX_MSG, __alignof__(char));
+	if (!bt->msg_data)
+		goto err;
+
+	ret = -ENOENT;
+
+	dir = debugfs_lookup(buts->name, blk_debugfs_root);
+	if (!dir)
+		bt->dir = dir = debugfs_create_dir(buts->name, blk_debugfs_root);
+	if (!dir)
+		goto err;
+
+	bt->dev = dev;
+	atomic_set(&bt->dropped, 0);
+	INIT_LIST_HEAD(&bt->running_ext_list);
+
+	ret = -EIO;
+	bt->dropped_file = debugfs_create_file("dropped", 0444, dir, bt,
+					       &blk_dropped_fops_ext);
+	if (!bt->dropped_file)
+		goto err;
+
+	bt->msg_file = debugfs_create_file("msg", 0222, dir, bt, &blk_msg_fops_ext);
+	if (!bt->msg_file)
+		goto err;
+
+	bt->rchan = relay_open("trace", dir, buts->buf_size,
+				buts->buf_nr, &blk_relay_callbacks_ext, bt);
+	if (!bt->rchan)
+		goto err;
+
+	bt->act_mask = buts->act_mask;
+	if (!bt->act_mask)
+		bt->act_mask = (u64) -1ULL;
+
+	bt->prio_mask = buts->prio_mask;
+
+	blk_trace_setup_lba_ext(bt, bdev);
+
+	/* overwrite with user settings */
+	if (buts->start_lba)
+		bt->start_lba = buts->start_lba;
+	if (buts->end_lba)
+		bt->end_lba = buts->end_lba;
+
+	bt->pid = buts->pid;
+	bt->trace_state = Blktrace_setup;
+
+	ret = -EBUSY;
+	if (cmpxchg(&q->blk_trace_ext, NULL, bt))
+		goto err;
+
+	get_probe_ref();
+
+	ret = 0;
+err:
+	if (dir && !bt->dir)
+		dput(dir);
+	if (ret)
+		blk_trace_free_ext(bt);
+	return ret;
+}
+
+
 static int __blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
 			     struct block_device *bdev, char __user *arg)
 {
@@ -879,6 +1089,27 @@ static int __blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
 	return 0;
 }
 
+static int __blk_trace_setup_ext(struct request_queue *q, char *name, dev_t dev,
+			     struct block_device *bdev, char __user *arg)
+{
+	struct blk_user_trace_setup_ext buts;
+	int ret;
+
+	ret = copy_from_user(&buts, arg, sizeof(buts));
+	if (ret)
+		return -EFAULT;
+
+	ret = do_blk_trace_setup_ext(q, name, dev, bdev, &buts);
+	if (ret)
+		return ret;
+
+	if (copy_to_user(arg, &buts, sizeof(buts))) {
+		__blk_trace_remove_ext(q);
+		return -EFAULT;
+	}
+	return 0;
+}
+
 int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
 		    struct block_device *bdev,
 		    char __user *arg)
@@ -969,12 +1200,57 @@ static int __blk_trace_startstop(struct request_queue *q, int start)
 	return ret;
 }
 
+static int __blk_trace_startstop_ext(struct request_queue *q, int start)
+{
+	int ret;
+	struct blk_trace_ext *bt;
+
+	bt = rcu_dereference_protected(q->blk_trace_ext,
+				       lockdep_is_held(&q->debugfs_mutex));
+	if (bt == NULL)
+		return -EINVAL;
+
+	/*
+	 * For starting a trace, we can transition from a setup or stopped
+	 * trace. For stopping a trace, the state must be running
+	 */
+	ret = -EINVAL;
+	if (start) {
+		if (bt->trace_state == Blktrace_setup ||
+		    bt->trace_state == Blktrace_stopped) {
+			blktrace_seq++;
+			smp_mb();
+			bt->trace_state = Blktrace_running;
+			spin_lock_irq(&running_trace_ext_lock);
+			list_add(&bt->running_ext_list,
+					&running_trace_ext_list);
+			spin_unlock_irq(&running_trace_ext_lock);
+
+			trace_note_time_ext(bt);
+			ret = 0;
+		}
+	} else {
+		if (bt->trace_state == Blktrace_running) {
+			bt->trace_state = Blktrace_stopped;
+			spin_lock_irq(&running_trace_ext_lock);
+			list_del_init(&bt->running_ext_list);
+			spin_unlock_irq(&running_trace_ext_lock);
+			relay_flush(bt->rchan);
+			ret = 0;
+		}
+	}
+
+	return ret;
+}
+
 int blk_trace_startstop(struct request_queue *q, int start)
 {
 	int ret;
 
 	mutex_lock(&q->debugfs_mutex);
 	ret = __blk_trace_startstop(q, start);
+	if (ret)
+		ret = __blk_trace_startstop_ext(q, start);
 	mutex_unlock(&q->debugfs_mutex);
 
 	return ret;
@@ -1011,6 +1287,10 @@ int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg)
 		bdevname(bdev, b);
 		ret = __blk_trace_setup(q, b, bdev->bd_dev, bdev, arg);
 		break;
+	case BLKTRACESETUP_EXT:
+		bdevname(bdev, b);
+		ret = __blk_trace_setup_ext(q, b, bdev->bd_dev, bdev, arg);
+		break;
 #if defined(CONFIG_COMPAT) && defined(CONFIG_X86_64)
 	case BLKTRACESETUP32:
 		bdevname(bdev, b);
@@ -1023,9 +1303,18 @@ int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg)
 	case BLKTRACESTOP:
 		ret = __blk_trace_startstop(q, start);
 		break;
+	case BLKTRACESTART_EXT:
+		start = 1;
+		/* fallthrough */
+	case BLKTRACESTOP_EXT:
+		ret = __blk_trace_startstop_ext(q, start);
+		break;
 	case BLKTRACETEARDOWN:
 		ret = __blk_trace_remove(q);
 		break;
+	case BLKTRACETEARDOWN_EXT:
+		ret = __blk_trace_remove_ext(q);
+		break;
 	default:
 		ret = -ENOTTY;
 		break;
@@ -1049,6 +1338,11 @@ void blk_trace_shutdown(struct request_queue *q)
 		__blk_trace_remove(q);
 	}
 
+	if (rcu_dereference_protected(q->blk_trace_ext,
+				      lockdep_is_held(&q->debugfs_mutex))) {
+		__blk_trace_startstop_ext(q, 0);
+		__blk_trace_remove_ext(q);
+	}
 	mutex_unlock(&q->debugfs_mutex);
 }
 
-- 
2.22.1

[RFC PATCH 35/39] block: update blkdev_ioctl with new trace ioctls

[Chaitanya Kulkarni]

Add newly intoduce IOCTLs so that userspace tools can call them.

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 block/ioctl.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/block/ioctl.c b/block/ioctl.c
index ff241e663c01..9d5e742ce8be 100644
--- a/block/ioctl.c
+++ b/block/ioctl.c
@@ -509,6 +509,10 @@ static int blkdev_common_ioctl(struct block_device *bdev, fmode_t mode,
 	case BLKTRACESTART:
 	case BLKTRACESTOP:
 	case BLKTRACETEARDOWN:
+	case BLKTRACESETUP_EXT:
+	case BLKTRACESTART_EXT:
+	case BLKTRACESTOP_EXT:
+	case BLKTRACETEARDOWN_EXT:
 		return blk_trace_ioctl(bdev, cmd, argp);
 	case IOC_PR_REGISTER:
 		return blkdev_pr_register(bdev, argp);
-- 
2.22.1

[RFC PATCH 36/39] blktrace: add integrity tracking support

[Chaitanya Kulkarni]

This patch adds support to track the integrity related information.
We update struct blk_io_trace_ext with two new members :-
1. seed :- to track the integrity seed.
2. integrity :- to store the integrity related flags and integrity
   size buffer.

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
Suggested-by: Martin K. Petersen <martin.petersen@oracle.com>
---
 include/uapi/linux/blktrace_api.h |  2 ++
 kernel/trace/blktrace.c           | 60 ++++++++++++++++++++++---------
 2 files changed, 46 insertions(+), 16 deletions(-)

diff --git a/include/uapi/linux/blktrace_api.h b/include/uapi/linux/blktrace_api.h
index fdb3a5cdfa22..ac533a0b0928 100644
--- a/include/uapi/linux/blktrace_api.h
+++ b/include/uapi/linux/blktrace_api.h
@@ -158,6 +158,8 @@ struct blk_io_trace_ext {
 	__u32 bytes;		/* transfer length */
 	__u64 action;		/* what happened */
 	__u32 ioprio;		/* I/O priority */
+	__u64 seed;		/* integrity seed */
+	__u64 integrity;	/* store integrity flags */
 	__u32 pid;		/* who did it */
 	__u32 device;		/* device number */
 	__u32 cpu;		/* on what cpu did it happen */
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 3bd56b741379..6759ac7bc6c7 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -66,6 +66,26 @@ static int blk_probes_ref;
 static void blk_register_tracepoints(void);
 static void blk_unregister_tracepoints(void);
 
+#ifdef CONFIG_BLK_DEV_INTEGRITY
+static void set_integrity(struct blk_io_trace_ext *t,
+			  struct bio_integrity_payload *bip)
+{
+	t->seed = (u64)bip_get_seed(bip);
+	/*
+	 * We store integrity buffer size and flags as :-
+	 *
+	 * 63            48          32            16     5           0
+	 * |          reserved       | buffer size | rsvd | bip flags |
+	 */
+	t->integrity = (bip->bip_iter.bi_size << 16) | bip->bip_flags;
+}
+#else
+static void set_integrity(struct blk_io_trace_ext *t, void *bip)
+{
+
+}
+#endif
+
 /*
  * Send out a notify message.
  */
@@ -115,7 +135,8 @@ static void trace_note(struct blk_trace *bt, pid_t pid, int action,
 }
 
 static void trace_note_ext(struct blk_trace_ext *bt, pid_t pid, u64 action,
-			   const void *data, size_t len, u64 cgid, u32 ioprio)
+			   const void *data, size_t len, u64 cgid, u32 ioprio,
+			   struct bio_integrity_payload *bip)
 {
 	struct blk_io_trace_ext *t;
 	struct ring_buffer_event *event = NULL;
@@ -148,6 +169,8 @@ static void trace_note_ext(struct blk_trace_ext *bt, pid_t pid, u64 action,
 		t->device = bt->dev;
 		t->action = action | (cgid ? __BLK_TN_CGROUP : 0);
 		t->ioprio = ioprio;
+		if (bip)
+			set_integrity(t, bip);
 		t->pid = pid;
 		t->cpu = cpu;
 		t->pdu_len = len + cgid_len;
@@ -178,7 +201,8 @@ static void trace_note_tsk(struct task_struct *tsk)
 	spin_unlock_irqrestore(&running_trace_lock, flags);
 }
 
-static void trace_note_tsk_ext(struct task_struct *tsk, u32 ioprio)
+static void trace_note_tsk_ext(struct task_struct *tsk, u32 ioprio,
+			       struct bio_integrity_payload *bip)
 {
 	unsigned long flags;
 	struct blk_trace_ext *bt;
@@ -187,7 +211,7 @@ static void trace_note_tsk_ext(struct task_struct *tsk, u32 ioprio)
 	spin_lock_irqsave(&running_trace_ext_lock, flags);
 	list_for_each_entry(bt, &running_trace_ext_list, running_ext_list) {
 		trace_note_ext(bt, tsk->pid, BLK_TN_PROCESS_EXT, tsk->comm,
-			   sizeof(tsk->comm), 0, ioprio);
+			       sizeof(tsk->comm), 0, ioprio, bip);
 	}
 	spin_unlock_irqrestore(&running_trace_ext_lock, flags);
 }
@@ -220,7 +244,7 @@ static void trace_note_time_ext(struct blk_trace_ext *bt)
 	words[1] = now.tv_nsec;
 
 	local_irq_save(flags);
-	trace_note_ext(bt, 0, BLK_TN_TIMESTAMP, words, sizeof(words), 0, 0);
+	trace_note_ext(bt, 0, BLK_TN_TIMESTAMP, words, sizeof(words), 0, 0, NULL);
 	local_irq_restore(flags);
 }
 
@@ -290,9 +314,9 @@ void __trace_note_message_ext(struct blk_trace_ext *bt, struct blkcg *blkcg,
 		blkcg = NULL;
 #ifdef CONFIG_BLK_CGROUP
 	trace_note_ext(bt, 0, BLK_TN_MESSAGE_EXT, buf, n,
-		blkcg ? cgroup_id(blkcg->css.cgroup) : 1, 0);
+		blkcg ? cgroup_id(blkcg->css.cgroup) : 1, 0, NULL);
 #else
-	trace_note_ext(bt, 0, BLK_TN_MESSAGE_EXT, buf, n, 0, 0);
+	trace_note_ext(bt, 0, BLK_TN_MESSAGE_EXT, buf, n, 0, 0, NULL);
 #endif
 	local_irq_restore(flags);
 }
@@ -478,7 +502,7 @@ static const u64 ddir_act_ext[2] = { BLK_TC_ACT_EXT(BLK_TC_READ),
  */
 static void __blk_add_trace_ext(struct blk_trace_ext *bt, sector_t sector, int bytes,
 		     int op, int op_flags, u64 what, int error, int pdu_len,
-		     void *pdu_data, u64 cgid, u32 ioprio)
+		     void *pdu_data, u64 cgid, u32 ioprio, void *bip)
 {
 	struct task_struct *tsk = current;
 	struct ring_buffer_event *event = NULL;
@@ -545,7 +569,7 @@ static void __blk_add_trace_ext(struct blk_trace_ext *bt, sector_t sector, int b
 	}
 
 	if (unlikely(tsk->btrace_seq != blktrace_seq))
-		trace_note_tsk_ext(tsk, ioprio);
+		trace_note_tsk_ext(tsk, ioprio, bip);
 
 	/*
 	 * A word about the locking here - we disable interrupts to reserve
@@ -1421,7 +1445,7 @@ static void blk_add_trace_rq(struct request *rq, int error,
 			what |= BLK_TC_ACT_EXT(BLK_TC_FS);
 		__blk_add_trace_ext(bte, blk_rq_trace_sector(rq), nr_bytes,
 				    req_op(rq), rq->cmd_flags, what, error, 0,
-				    NULL, cgid, req_get_ioprio(rq));
+				    NULL, cgid, req_get_ioprio(rq), NULL);
 	}
 	rcu_read_unlock();
 }
@@ -1564,7 +1588,7 @@ static void blk_add_trace_bio(struct request_queue *q, struct bio *bio,
 				    bio->bi_iter.bi_size, bio_op(bio),
 				    bio->bi_opf, what, error, 0, NULL,
 				    blk_trace_bio_get_cgid(q, bio),
-				    bio_prio(bio));
+				    bio_prio(bio), bio_integrity(bio));
 	}
 	rcu_read_unlock();
 }
@@ -1724,7 +1748,7 @@ static void blk_add_trace_plug(void *ignore, struct request_queue *q)
 		__blk_add_trace(bt, 0, 0, 0, 0, BLK_TA_PLUG, 0, 0, NULL, 0);
 	else if (bte)
 		__blk_add_trace_ext(bte, 0, 0, 0, 0, BLK_TA_PLUG_EXT, 0, 0,
-				    NULL, 0, 0);
+				    NULL, 0, 0, NULL);
 	rcu_read_unlock();
 }
 
@@ -1756,7 +1780,7 @@ static void blk_add_trace_unplug(void *ignore, struct request_queue *q,
 		else
 			what = BLK_TA_UNPLUG_TIMER_EXT;
 		__blk_add_trace_ext(bte, 0, 0, 0, 0, what, 0, sizeof(rpdu),
-				&rpdu, 0, 0);
+				&rpdu, 0, 0, NULL);
 	}
 	rcu_read_unlock();
 }
@@ -1787,7 +1811,9 @@ static void blk_add_trace_split(void *ignore, struct bio *bio, unsigned int pdu)
 				    bio->bi_iter.bi_size, bio_op(bio),
 				    bio->bi_opf, BLK_TA_SPLIT_EXT,
 				    bio->bi_status, sizeof(rpdu), &rpdu,
-				    blk_trace_bio_get_cgid(q, bio), 0);
+				    blk_trace_bio_get_cgid(q, bio),
+				    bio_prio(bio),
+				    bio_integrity(bio));
 	}
 	rcu_read_unlock();
 }
@@ -1831,7 +1857,9 @@ static void blk_add_trace_bio_remap(void *ignore, struct bio *bio, dev_t dev,
 				    bio->bi_iter.bi_size, bio_op(bio),
 				    bio->bi_opf, BLK_TA_REMAP_EXT, bio->bi_status,
 				    sizeof(r), &r,
-				    blk_trace_bio_get_cgid(q, bio), 0);
+				    blk_trace_bio_get_cgid(q, bio),
+				    bio_prio(bio),
+				    bio_integrity(bio));
 	}
 	rcu_read_unlock();
 }
@@ -1876,7 +1904,7 @@ static void blk_add_trace_rq_remap(void *ignore, struct request *rq, dev_t dev,
 		__blk_add_trace_ext(bte, blk_rq_pos(rq), blk_rq_bytes(rq),
 				    rq_data_dir(rq), 0, BLK_TA_REMAP_EXT, 0,
 				    sizeof(r), &r,
-				    blk_trace_request_get_cgid(rq), 0);
+				    blk_trace_request_get_cgid(rq), 0, NULL);
 	}
 	rcu_read_unlock();
 }
@@ -1912,7 +1940,7 @@ void blk_add_driver_data(struct request *rq, void *data, size_t len)
 		__blk_add_trace_ext(bte, blk_rq_trace_sector(rq),
 				blk_rq_bytes(rq), 0, 0, BLK_TA_DRV_DATA_EXT, 0,
 				len, data, blk_trace_request_get_cgid(rq),
-				req_get_ioprio(rq));
+				req_get_ioprio(rq), NULL);
 	}
 	rcu_read_unlock();
 }
-- 
2.22.1

[RFC PATCH 37/39] blktrace: update blk_fill_rwbs() with new requests

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 kernel/trace/blktrace.c | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 6759ac7bc6c7..32100c5db7a6 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -3184,6 +3184,35 @@ void blk_fill_rwbs(char *rwbs, unsigned int op)
 	case REQ_OP_READ:
 		rwbs[i++] = 'R';
 		break;
+	case REQ_OP_WRITE_ZEROES:
+		rwbs[i++] = 'W';
+		rwbs[i++] = 'Z';
+		break;
+	case REQ_OP_ZONE_RESET:
+		rwbs[i++] = 'Z';
+		rwbs[i++] = 'R';
+		break;
+	case REQ_OP_ZONE_RESET_ALL:
+		rwbs[i++] = 'Z';
+		rwbs[i++] = 'R';
+		rwbs[i++] = 'A';
+		break;
+	case REQ_OP_ZONE_APPEND:
+		rwbs[i++] = 'Z';
+		rwbs[i++] = 'A';
+		break;
+	case REQ_OP_ZONE_OPEN:
+		rwbs[i++] = 'Z';
+		rwbs[i++] = 'O';
+		break;
+	case REQ_OP_ZONE_CLOSE:
+		rwbs[i++] = 'Z';
+		rwbs[i++] = 'C';
+		break;
+	case REQ_OP_ZONE_FINISH:
+		rwbs[i++] = 'Z';
+		rwbs[i++] = 'F';
+		break;
 	default:
 		rwbs[i++] = 'N';
 	}
-- 
2.22.1

[RFC PATCH 38/39] blktrace: track zone appaend completion sector

[Chaitanya Kulkarni]

The request type REQ_OP_ZONE_APPENDT needs zone start the when issued
not the actual sector where this I/O lands and returns completion sector
in for trace complete event 'C'. Right now we cannot track submission &
completion sector for this special request with existing format.

Add a new completion sector field in the blk_io_trace_ext structure,
when generating the trace when req_op is REQ_OP_ZONE_APPEND update
the completion sector from the I/O and store the zone start (where
actual I/O was issued) in the secor field of the trace.

With this new format we can track completion sector. (* is not a part
real trace it is here as a place holder so that it is easy to read for
reviewers) :-

252,0 15  1 92.785481956  6139  Q ZAS N 262144 + 8 [dd]
252,0 15  2 92.785490381  6139  G ZAS N 262144 + 8 [dd]
252,0 15  3 92.785498517  6139  I ZAS N 262144 + 8 [dd]
252,0 15  4 92.785519065   804  D ZAS N 262144 + 8 [kworker/15:1H]
252,0 15  5 92.785541527    86  C ZAS N 262144 + 8 [0] <262144>

252,0 15  6 92.785561936  6139  Q ZAS N 262144 + 8 [dd]
252,0 15  7 92.785568368  6139  G ZAS N 262144 + 8 [dd]
252,0 15  8 92.785574820  6139  I ZAS N 262144 + 8 [dd]
252,0 15  9 92.785587754   804  D ZAS N 262144 + 8 [kworker/15:1H]
252,0 15 10 92.785602802    86  C ZAS N 262144 + 8 [0] <262152>

252,0 15 11 92.785619704  6139  Q ZAS N 262144 + 8 [dd]
252,0 15 12 92.785626076  6139  G ZAS N 262144 + 8 [dd]
252,0 15 13 92.785632438  6139  I ZAS N 262144 + 8 [dd]
252,0 15 14 92.785644801   804  D ZAS N 262144 + 8 [kworker/15:1H]
252,0 15 15 92.785659939    86  C ZAS N 262144 + 8 [0] <262160>

252,0 15 16 92.785676460  6139  Q ZAS N 262144 + 8 [dd]
252,0 15 17 92.785682872  6139  G ZAS N 262144 + 8 [dd]
252,0 15 18 92.785689294  6139  I ZAS N 262144 + 8 [dd]
252,0 15 19 92.785701487   804  D ZAS N 262144 + 8 [kworker/15:1H]
252,0 15 20 92.785716024    86  C ZAS N 262144 + 8 [0] <262168>

252,0 15 21 92.785732335  6139  Q ZAS N 262144 + 8 [dd]
252,0 15 22 92.785738687  6139  G ZAS N 262144 + 8 [dd]
252,0 15 23 92.785745019  6139  I ZAS N 262144 + 8 [dd]
252,0 15 24 92.785757843   804  D ZAS N 262144 + 8 [kworker/15:1H]
252,0 15 25 92.785772020    86  C ZAS N 262144 + 8 [0] <262176>

252,0 15 26 92.785788180  6139  Q ZAS N 262144 + 8 [dd]
252,0 15 27 92.785794492  6139  G ZAS N 262144 + 8 [dd]
252,0 15 28 92.785800763  6139  I ZAS N 262144 + 8 [dd]
252,0 15 29 92.785812696   804  D ZAS N 262144 + 8 [kworker/15:1H]
252,0 15 30 92.785826762    86  C ZAS N 262144 + 8 [0] <262184>

252,0 15 31 92.785842852  6139  Q ZAS N 262144 + 8 [dd]
252,0 15 32 92.785849104  6139  G ZAS N 262144 + 8 [dd]
252,0 15 33 92.785855346  6139  I ZAS N 262144 + 8 [dd]
252,0 15 34 92.785867599   804  D ZAS N 262144 + 8 [kworker/15:1H]
252,0 15 35 92.785881835    86  C ZAS N 262144 + 8 [0] <262192>

252,0 15 36 92.785897845  6139  Q ZAS N 262144 + 8 [dd]
252,0 15 37 92.785904107  6139  G ZAS N 262144 + 8 [dd]
252,0 15 38 92.785910329  6139  I ZAS N 262144 + 8 [dd]
252,0 15 39 92.785922181   804  D ZAS N 262144 + 8 [kworker/15:1H]
252,0 15 40 92.785936237    86  C ZAS N 262144 + 8 [0] <262200>

252,0 15 41 92.785952037  6139  Q ZAS N 262144 + 8 [dd]
252,0 15 42 92.785958289  6139  G ZAS N 262144 + 8 [dd]
252,0 15 43 92.785964651  6139  I ZAS N 262144 + 8 [dd]
252,0 15 44 92.785976373   804  D ZAS N 262144 + 8 [kworker/15:1H]
252,0 15 45 92.785990419    86  C ZAS N 262144 + 8 [0] <262208>

252,0 15 46 92.786006339  6139  Q ZAS N 262144 + 8 [dd]
252,0 15 47 92.786025204  6139  G ZAS N 262144 + 8 [dd]
252,0 15 48 92.786031566  6139  I ZAS N 262144 + 8 [dd]
252,0 15 49 92.786043869   804  D ZAS N 262144 + 8 [kworker/15:1H]
252,0 15 50 92.786058216    86  C ZAS N 262144 + 8 [0] <262216>

252,0 10  1 92.783369654  6138  Q ZRS N 262144 + 0 [truncate]
252,0 10  2 92.783384813  6138  G ZRS N 262144 + 0 [truncate]
252,0 10  3 92.783395182  6138  I ZRS N 262144 + 0 [truncate]
252,0 10  4 92.783419628   782  D ZRS N 262144 + 0 [kworker/10:1H]
252,0 10  5 92.783460895    61  C ZRS N 262144 + 0 [0]
252,0  8  1 92.788546342  6140  Q ZRAS N 0 + 0 [blkzone]
252,0  8  2 92.788554628  6140  G ZRAS N 0 + 0 [blkzone]
252,0  8  3 92.788562232  6140  I ZRAS N 0 + 0 [blkzone]
252,0  8  4 92.788580977   934  D ZRAS N 0 + 0 [kworker/8:1H]
252,0  8  5 92.788597268    51  C ZRAS N 0 + 0 [0]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 include/uapi/linux/blktrace_api.h |  1 +
 kernel/trace/blktrace.c           | 31 ++++++++++++++++++++++---------
 2 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/include/uapi/linux/blktrace_api.h b/include/uapi/linux/blktrace_api.h
index ac533a0b0928..ebfe3029cd10 100644
--- a/include/uapi/linux/blktrace_api.h
+++ b/include/uapi/linux/blktrace_api.h
@@ -155,6 +155,7 @@ struct blk_io_trace_ext {
 	__u32 sequence;		/* event number */
 	__u64 time;		/* in nanoseconds */
 	__u64 sector;		/* disk offset */
+	__u64 completion_sector;/* zone append completion sector */
 	__u32 bytes;		/* transfer length */
 	__u64 action;		/* what happened */
 	__u32 ioprio;		/* I/O priority */
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 32100c5db7a6..59bf99b4106a 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -502,7 +502,8 @@ static const u64 ddir_act_ext[2] = { BLK_TC_ACT_EXT(BLK_TC_READ),
  */
 static void __blk_add_trace_ext(struct blk_trace_ext *bt, sector_t sector, int bytes,
 		     int op, int op_flags, u64 what, int error, int pdu_len,
-		     void *pdu_data, u64 cgid, u32 ioprio, void *bip)
+		     void *pdu_data, u64 cgid, u32 ioprio, void *bip,
+		     sector_t blk_queue_zone_sectors)
 {
 	struct task_struct *tsk = current;
 	struct ring_buffer_event *event = NULL;
@@ -595,6 +596,16 @@ static void __blk_add_trace_ext(struct blk_trace_ext *bt, sector_t sector, int b
 		t->pid = pid;
 
 		t->sector = sector;
+		if (op == REQ_OP_ZONE_APPEND) {
+			sector_t zno = sector >> ilog2(blk_queue_zone_sectors);
+
+			t->completion_sector = sector;
+			/*
+			*  Start of the zone sector in which this completion
+			*  sector belongs to.
+			*/
+			sector = zno * blk_queue_zone_sectors;
+		}
 		t->bytes = bytes;
 		t->action = what;
 		t->ioprio = ioprio;
@@ -1445,7 +1456,8 @@ static void blk_add_trace_rq(struct request *rq, int error,
 			what |= BLK_TC_ACT_EXT(BLK_TC_FS);
 		__blk_add_trace_ext(bte, blk_rq_trace_sector(rq), nr_bytes,
 				    req_op(rq), rq->cmd_flags, what, error, 0,
-				    NULL, cgid, req_get_ioprio(rq), NULL);
+				    NULL, cgid, req_get_ioprio(rq), NULL,
+				    blk_queue_zone_sectors(rq->q));
 	}
 	rcu_read_unlock();
 }
@@ -1588,7 +1600,8 @@ static void blk_add_trace_bio(struct request_queue *q, struct bio *bio,
 				    bio->bi_iter.bi_size, bio_op(bio),
 				    bio->bi_opf, what, error, 0, NULL,
 				    blk_trace_bio_get_cgid(q, bio),
-				    bio_prio(bio), bio_integrity(bio));
+				    bio_prio(bio), bio_integrity(bio),
+				    blk_queue_zone_sectors(q));
 	}
 	rcu_read_unlock();
 }
@@ -1748,7 +1761,7 @@ static void blk_add_trace_plug(void *ignore, struct request_queue *q)
 		__blk_add_trace(bt, 0, 0, 0, 0, BLK_TA_PLUG, 0, 0, NULL, 0);
 	else if (bte)
 		__blk_add_trace_ext(bte, 0, 0, 0, 0, BLK_TA_PLUG_EXT, 0, 0,
-				    NULL, 0, 0, NULL);
+				    NULL, 0, 0, NULL, 0);
 	rcu_read_unlock();
 }
 
@@ -1780,7 +1793,7 @@ static void blk_add_trace_unplug(void *ignore, struct request_queue *q,
 		else
 			what = BLK_TA_UNPLUG_TIMER_EXT;
 		__blk_add_trace_ext(bte, 0, 0, 0, 0, what, 0, sizeof(rpdu),
-				&rpdu, 0, 0, NULL);
+				&rpdu, 0, 0, NULL, 0);
 	}
 	rcu_read_unlock();
 }
@@ -1813,7 +1826,7 @@ static void blk_add_trace_split(void *ignore, struct bio *bio, unsigned int pdu)
 				    bio->bi_status, sizeof(rpdu), &rpdu,
 				    blk_trace_bio_get_cgid(q, bio),
 				    bio_prio(bio),
-				    bio_integrity(bio));
+				    bio_integrity(bio), 0);
 	}
 	rcu_read_unlock();
 }
@@ -1859,7 +1872,7 @@ static void blk_add_trace_bio_remap(void *ignore, struct bio *bio, dev_t dev,
 				    sizeof(r), &r,
 				    blk_trace_bio_get_cgid(q, bio),
 				    bio_prio(bio),
-				    bio_integrity(bio));
+				    bio_integrity(bio), 0);
 	}
 	rcu_read_unlock();
 }
@@ -1904,7 +1917,7 @@ static void blk_add_trace_rq_remap(void *ignore, struct request *rq, dev_t dev,
 		__blk_add_trace_ext(bte, blk_rq_pos(rq), blk_rq_bytes(rq),
 				    rq_data_dir(rq), 0, BLK_TA_REMAP_EXT, 0,
 				    sizeof(r), &r,
-				    blk_trace_request_get_cgid(rq), 0, NULL);
+				    blk_trace_request_get_cgid(rq), 0, NULL, 0);
 	}
 	rcu_read_unlock();
 }
@@ -1940,7 +1953,7 @@ void blk_add_driver_data(struct request *rq, void *data, size_t len)
 		__blk_add_trace_ext(bte, blk_rq_trace_sector(rq),
 				blk_rq_bytes(rq), 0, 0, BLK_TA_DRV_DATA_EXT, 0,
 				len, data, blk_trace_request_get_cgid(rq),
-				req_get_ioprio(rq), NULL);
+				req_get_ioprio(rq), NULL, 0);
 	}
 	rcu_read_unlock();
 }
-- 
2.22.1

[RFC PATCH 39/39] blktrace: debug patch for the demo

[Chaitanya Kulkarni]

Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
---
 block/blk-lib.c                   |  4 ++++
 block/blk-zoned.c                 |  1 +
 drivers/block/null_blk/main.c     | 32 ++++++++++++++++++++++++-------
 drivers/block/null_blk/null_blk.h |  1 +
 4 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/block/blk-lib.c b/block/blk-lib.c
index 752f9c722062..dd8854341bf6 100644
--- a/block/blk-lib.c
+++ b/block/blk-lib.c
@@ -98,6 +98,7 @@ int __blkdev_issue_discard(struct block_device *bdev, sector_t sector,
 		bio->bi_iter.bi_sector = sector;
 		bio_set_dev(bio, bdev);
 		bio_set_op_attrs(bio, op, 0);
+		bio_set_prio(bio, get_current_ioprio());
 
 		bio->bi_iter.bi_size = req_sects << 9;
 		sector += req_sects;
@@ -191,6 +192,7 @@ static int __blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
 		bio = blk_next_bio(bio, 1, gfp_mask);
 		bio->bi_iter.bi_sector = sector;
 		bio_set_dev(bio, bdev);
+		bio_set_prio(bio, get_current_ioprio());
 		bio->bi_vcnt = 1;
 		bio->bi_io_vec->bv_page = page;
 		bio->bi_io_vec->bv_offset = 0;
@@ -267,6 +269,7 @@ static int __blkdev_issue_write_zeroes(struct block_device *bdev,
 		bio = blk_next_bio(bio, 0, gfp_mask);
 		bio->bi_iter.bi_sector = sector;
 		bio_set_dev(bio, bdev);
+		bio_set_prio(bio, get_current_ioprio());
 		bio->bi_opf = REQ_OP_WRITE_ZEROES;
 		if (flags & BLKDEV_ZERO_NOUNMAP)
 			bio->bi_opf |= REQ_NOUNMAP;
@@ -319,6 +322,7 @@ static int __blkdev_issue_zero_pages(struct block_device *bdev,
 				   gfp_mask);
 		bio->bi_iter.bi_sector = sector;
 		bio_set_dev(bio, bdev);
+		bio_set_prio(bio, get_current_ioprio());
 		bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
 
 		while (nr_sects != 0) {
diff --git a/block/blk-zoned.c b/block/blk-zoned.c
index 833978c02e60..3df0f22cbc54 100644
--- a/block/blk-zoned.c
+++ b/block/blk-zoned.c
@@ -233,6 +233,7 @@ int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,
 	while (sector < end_sector) {
 		bio = blk_next_bio(bio, 0, gfp_mask);
 		bio_set_dev(bio, bdev);
+		bio_set_prio(bio, get_current_ioprio());
 
 		/*
 		 * Special case for the zone reset operation that reset all
diff --git a/drivers/block/null_blk/main.c b/drivers/block/null_blk/main.c
index d6c821d48090..0c2bc7188d27 100644
--- a/drivers/block/null_blk/main.c
+++ b/drivers/block/null_blk/main.c
@@ -84,6 +84,10 @@ enum {
 	NULL_Q_MQ		= 2,
 };
 
+static bool g_discard;
+module_param_named(discard, g_discard, bool, 0444);
+MODULE_PARM_DESC(discard, "Enable queue discard (default: false)");
+
 static int g_no_sched;
 module_param_named(no_sched, g_no_sched, int, 0444);
 MODULE_PARM_DESC(no_sched, "No io scheduler");
@@ -156,6 +160,10 @@ static int g_max_sectors;
 module_param_named(max_sectors, g_max_sectors, int, 0444);
 MODULE_PARM_DESC(max_sectors, "Maximum size of a command (in 512B sectors)");
 
+static unsigned int g_bounce_pfn;
+module_param_named(bounce_pfn, g_bounce_pfn, int, 0444);
+MODULE_PARM_DESC(bounce_pfn, "Queue Bounce limit (default: 0)");
+
 static unsigned int nr_devices = 1;
 module_param(nr_devices, uint, 0444);
 MODULE_PARM_DESC(nr_devices, "Number of devices to register");
@@ -350,6 +358,7 @@ NULLB_DEVICE_ATTR(submit_queues, uint, nullb_apply_submit_queues);
 NULLB_DEVICE_ATTR(home_node, uint, NULL);
 NULLB_DEVICE_ATTR(queue_mode, uint, NULL);
 NULLB_DEVICE_ATTR(blocksize, uint, NULL);
+NULLB_DEVICE_ATTR(bounce_pfn, uint, NULL);
 NULLB_DEVICE_ATTR(max_sectors, uint, NULL);
 NULLB_DEVICE_ATTR(irqmode, uint, NULL);
 NULLB_DEVICE_ATTR(hw_queue_depth, uint, NULL);
@@ -468,6 +477,7 @@ static struct configfs_attribute *nullb_device_attrs[] = {
 	&nullb_device_attr_home_node,
 	&nullb_device_attr_queue_mode,
 	&nullb_device_attr_blocksize,
+	&nullb_device_attr_bounce_pfn,
 	&nullb_device_attr_max_sectors,
 	&nullb_device_attr_irqmode,
 	&nullb_device_attr_hw_queue_depth,
@@ -539,7 +549,7 @@ nullb_group_drop_item(struct config_group *group, struct config_item *item)
 static ssize_t memb_group_features_show(struct config_item *item, char *page)
 {
 	return snprintf(page, PAGE_SIZE,
-			"memory_backed,discard,bandwidth,cache,badblocks,zoned,zone_size,zone_capacity,zone_nr_conv,zone_max_open,zone_max_active,blocksize,max_sectors\n");
+			"memory_backed,discard,bounce_pfn,bandwidth,cache,badblocks,zoned,zone_size,zone_capacity,zone_nr_conv\n");
 }
 
 CONFIGFS_ATTR_RO(memb_group_, features);
@@ -600,6 +610,7 @@ static struct nullb_device *null_alloc_dev(void)
 	dev->blocking = g_blocking;
 	dev->use_per_node_hctx = g_use_per_node_hctx;
 	dev->zoned = g_zoned;
+	dev->discard = g_discard;
 	dev->zone_size = g_zone_size;
 	dev->zone_capacity = g_zone_capacity;
 	dev->zone_nr_conv = g_zone_nr_conv;
@@ -1588,15 +1599,10 @@ static void null_del_dev(struct nullb *nullb)
 
 static void null_config_discard(struct nullb *nullb)
 {
+	blk_queue_max_write_zeroes_sectors(nullb->q, UINT_MAX >> 9);
 	if (nullb->dev->discard == false)
 		return;
 
-	if (!nullb->dev->memory_backed) {
-		nullb->dev->discard = false;
-		pr_info("discard option is ignored without memory backing\n");
-		return;
-	}
-
 	if (nullb->dev->zoned) {
 		nullb->dev->discard = false;
 		pr_info("discard option is ignored in zoned mode\n");
@@ -1609,6 +1615,17 @@ static void null_config_discard(struct nullb *nullb)
 	blk_queue_flag_set(QUEUE_FLAG_DISCARD, nullb->q);
 }
 
+static void null_config_bounce_pfn(struct nullb *nullb)
+{
+	if (nullb->dev->memory_backed && nullb->dev->bounce_pfn == false)
+		return;
+
+	if (!nullb->dev->memory_backed && !g_bounce_pfn)
+		return;
+
+	blk_queue_bounce_limit(nullb->q, nullb->dev->bounce_pfn);
+}
+
 static const struct block_device_operations null_bio_ops = {
 	.owner		= THIS_MODULE,
 	.submit_bio	= null_submit_bio,
@@ -1881,6 +1898,7 @@ static int null_add_dev(struct nullb_device *dev)
 	blk_queue_max_hw_sectors(nullb->q, dev->max_sectors);
 
 	null_config_discard(nullb);
+	null_config_bounce_pfn(nullb);
 
 	sprintf(nullb->disk_name, "nullb%d", nullb->index);
 
diff --git a/drivers/block/null_blk/null_blk.h b/drivers/block/null_blk/null_blk.h
index 83504f3cc9d6..cd55f99118bf 100644
--- a/drivers/block/null_blk/null_blk.h
+++ b/drivers/block/null_blk/null_blk.h
@@ -86,6 +86,7 @@ struct nullb_device {
 	unsigned int queue_mode; /* block interface */
 	unsigned int blocksize; /* block size */
 	unsigned int max_sectors; /* Max sectors per command */
+	unsigned int bounce_pfn; /* bounce page frame number */
 	unsigned int irqmode; /* IRQ completion handler */
 	unsigned int hw_queue_depth; /* queue depth */
 	unsigned int index; /* index of the disk, only valid with a disk */
-- 
2.22.1