[lttng-modules.git] / instrumentation / events / mainline / block.h

#undef TRACE_SYSTEM
#define TRACE_SYSTEM block

#if !defined(_TRACE_BLOCK_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_BLOCK_H

#include <linux/blktrace_api.h>
#include <linux/blkdev.h>
#include <linux/tracepoint.h>

#define RWBS_LEN	8

DECLARE_EVENT_CLASS(block_rq_with_error,

	TP_PROTO(struct request_queue *q, struct request *rq),

	TP_ARGS(q, rq),

	TP_STRUCT__entry(
		__field(  dev_t,	dev			)
		__field(  sector_t,	sector			)
		__field(  unsigned int,	nr_sector		)
		__field(  int,		errors			)
		__array(  char,		rwbs,	RWBS_LEN	)
		__dynamic_array( char,	cmd,	blk_cmd_buf_len(rq)	)
	),

	TP_fast_assign(
		__entry->dev	   = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
		__entry->sector    = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
					0 : blk_rq_pos(rq);
		__entry->nr_sector = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
					0 : blk_rq_sectors(rq);
		__entry->errors    = rq->errors;

		blk_fill_rwbs(__entry->rwbs, rq->cmd_flags, blk_rq_bytes(rq));
		blk_dump_cmd(__get_str(cmd), rq);
	),

	TP_printk("%d,%d %s (%s) %llu + %u [%d]",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->rwbs, __get_str(cmd),
		  (unsigned long long)__entry->sector,
		  __entry->nr_sector, __entry->errors)
);

/**
 * block_rq_abort - abort block operation request
 * @q: queue containing the block operation request
 * @rq: block IO operation request
 *
 * Called immediately after pending block IO operation request @rq in
 * queue @q is aborted. The fields in the operation request @rq
 * can be examined to determine which device and sectors the pending
 * operation would access.
 */
DEFINE_EVENT(block_rq_with_error, block_rq_abort,

	TP_PROTO(struct request_queue *q, struct request *rq),

	TP_ARGS(q, rq)
);

/**
 * block_rq_requeue - place block IO request back on a queue
 * @q: queue holding operation
 * @rq: block IO operation request
 *
 * The block operation request @rq is being placed back into queue
 * @q.  For some reason the request was not completed and needs to be
 * put back in the queue.
 */
DEFINE_EVENT(block_rq_with_error, block_rq_requeue,

	TP_PROTO(struct request_queue *q, struct request *rq),

	TP_ARGS(q, rq)
);

/**
 * block_rq_complete - block IO operation completed by device driver
 * @q: queue containing the block operation request
 * @rq: block operations request
 *
 * The block_rq_complete tracepoint event indicates that some portion
 * of operation request has been completed by the device driver.  If
 * the @rq->bio is %NULL, then there is absolutely no additional work to
 * do for the request. If @rq->bio is non-NULL then there is
 * additional work required to complete the request.
 */
DEFINE_EVENT(block_rq_with_error, block_rq_complete,

	TP_PROTO(struct request_queue *q, struct request *rq),

	TP_ARGS(q, rq)
);

DECLARE_EVENT_CLASS(block_rq,

	TP_PROTO(struct request_queue *q, struct request *rq),

	TP_ARGS(q, rq),

	TP_STRUCT__entry(
		__field(  dev_t,	dev			)
		__field(  sector_t,	sector			)
		__field(  unsigned int,	nr_sector		)
		__field(  unsigned int,	bytes			)
		__array(  char,		rwbs,	RWBS_LEN	)
		__array(  char,         comm,   TASK_COMM_LEN   )
		__dynamic_array( char,	cmd,	blk_cmd_buf_len(rq)	)
	),

	TP_fast_assign(
		__entry->dev	   = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
		__entry->sector    = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
					0 : blk_rq_pos(rq);
		__entry->nr_sector = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
					0 : blk_rq_sectors(rq);
		__entry->bytes     = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
					blk_rq_bytes(rq) : 0;

		blk_fill_rwbs(__entry->rwbs, rq->cmd_flags, blk_rq_bytes(rq));
		blk_dump_cmd(__get_str(cmd), rq);
		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	),

	TP_printk("%d,%d %s %u (%s) %llu + %u [%s]",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->rwbs, __entry->bytes, __get_str(cmd),
		  (unsigned long long)__entry->sector,
		  __entry->nr_sector, __entry->comm)
);

/**
 * block_rq_insert - insert block operation request into queue
 * @q: target queue
 * @rq: block IO operation request
 *
 * Called immediately before block operation request @rq is inserted
 * into queue @q.  The fields in the operation request @rq struct can
 * be examined to determine which device and sectors the pending
 * operation would access.
 */
DEFINE_EVENT(block_rq, block_rq_insert,

	TP_PROTO(struct request_queue *q, struct request *rq),

	TP_ARGS(q, rq)
);

/**
 * block_rq_issue - issue pending block IO request operation to device driver
 * @q: queue holding operation
 * @rq: block IO operation operation request
 *
 * Called when block operation request @rq from queue @q is sent to a
 * device driver for processing.
 */
DEFINE_EVENT(block_rq, block_rq_issue,

	TP_PROTO(struct request_queue *q, struct request *rq),

	TP_ARGS(q, rq)
);

/**
 * block_bio_bounce - used bounce buffer when processing block operation
 * @q: queue holding the block operation
 * @bio: block operation
 *
 * A bounce buffer was used to handle the block operation @bio in @q.
 * This occurs when hardware limitations prevent a direct transfer of
 * data between the @bio data memory area and the IO device.  Use of a
 * bounce buffer requires extra copying of data and decreases
 * performance.
 */
TRACE_EVENT(block_bio_bounce,

	TP_PROTO(struct request_queue *q, struct bio *bio),

	TP_ARGS(q, bio),

	TP_STRUCT__entry(
		__field( dev_t,		dev			)
		__field( sector_t,	sector			)
		__field( unsigned int,	nr_sector		)
		__array( char,		rwbs,	RWBS_LEN	)
		__array( char,		comm,	TASK_COMM_LEN	)
	),

	TP_fast_assign(
		__entry->dev		= bio->bi_bdev ?
					  bio->bi_bdev->bd_dev : 0;
		__entry->sector		= bio->bi_sector;
		__entry->nr_sector	= bio->bi_size >> 9;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	),

	TP_printk("%d,%d %s %llu + %u [%s]",
		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
		  (unsigned long long)__entry->sector,
		  __entry->nr_sector, __entry->comm)
);

/**
 * block_bio_complete - completed all work on the block operation
 * @q: queue holding the block operation
 * @bio: block operation completed
 * @error: io error value
 *
 * This tracepoint indicates there is no further work to do on this
 * block IO operation @bio.
 */
TRACE_EVENT(block_bio_complete,

	TP_PROTO(struct request_queue *q, struct bio *bio, int error),

	TP_ARGS(q, bio, error),

	TP_STRUCT__entry(
		__field( dev_t,		dev		)
		__field( sector_t,	sector		)
		__field( unsigned,	nr_sector	)
		__field( int,		error		)
		__array( char,		rwbs,	RWBS_LEN)
	),

	TP_fast_assign(
		__entry->dev		= bio->bi_bdev->bd_dev;
		__entry->sector		= bio->bi_sector;
		__entry->nr_sector	= bio->bi_size >> 9;
		__entry->error		= error;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
	),

	TP_printk("%d,%d %s %llu + %u [%d]",
		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
		  (unsigned long long)__entry->sector,
		  __entry->nr_sector, __entry->error)
);

DECLARE_EVENT_CLASS(block_bio,

	TP_PROTO(struct request_queue *q, struct bio *bio),

	TP_ARGS(q, bio),

	TP_STRUCT__entry(
		__field( dev_t,		dev			)
		__field( sector_t,	sector			)
		__field( unsigned int,	nr_sector		)
		__array( char,		rwbs,	RWBS_LEN	)
		__array( char,		comm,	TASK_COMM_LEN	)
	),

	TP_fast_assign(
		__entry->dev		= bio->bi_bdev->bd_dev;
		__entry->sector		= bio->bi_sector;
		__entry->nr_sector	= bio->bi_size >> 9;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	),

	TP_printk("%d,%d %s %llu + %u [%s]",
		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
		  (unsigned long long)__entry->sector,
		  __entry->nr_sector, __entry->comm)
);

/**
 * block_bio_backmerge - merging block operation to the end of an existing operation
 * @q: queue holding operation
 * @bio: new block operation to merge
 *
 * Merging block request @bio to the end of an existing block request
 * in queue @q.
 */
DEFINE_EVENT(block_bio, block_bio_backmerge,

	TP_PROTO(struct request_queue *q, struct bio *bio),

	TP_ARGS(q, bio)
);

/**
 * block_bio_frontmerge - merging block operation to the beginning of an existing operation
 * @q: queue holding operation
 * @bio: new block operation to merge
 *
 * Merging block IO operation @bio to the beginning of an existing block
 * operation in queue @q.
 */
DEFINE_EVENT(block_bio, block_bio_frontmerge,

	TP_PROTO(struct request_queue *q, struct bio *bio),

	TP_ARGS(q, bio)
);

/**
 * block_bio_queue - putting new block IO operation in queue
 * @q: queue holding operation
 * @bio: new block operation
 *
 * About to place the block IO operation @bio into queue @q.
 */
DEFINE_EVENT(block_bio, block_bio_queue,

	TP_PROTO(struct request_queue *q, struct bio *bio),

	TP_ARGS(q, bio)
);

DECLARE_EVENT_CLASS(block_get_rq,

	TP_PROTO(struct request_queue *q, struct bio *bio, int rw),

	TP_ARGS(q, bio, rw),

	TP_STRUCT__entry(
		__field( dev_t,		dev			)
		__field( sector_t,	sector			)
		__field( unsigned int,	nr_sector		)
		__array( char,		rwbs,	RWBS_LEN	)
		__array( char,		comm,	TASK_COMM_LEN	)
        ),

	TP_fast_assign(
		__entry->dev		= bio ? bio->bi_bdev->bd_dev : 0;
		__entry->sector		= bio ? bio->bi_sector : 0;
		__entry->nr_sector	= bio ? bio->bi_size >> 9 : 0;
		blk_fill_rwbs(__entry->rwbs,
			      bio ? bio->bi_rw : 0, __entry->nr_sector);
		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
        ),

	TP_printk("%d,%d %s %llu + %u [%s]",
		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
		  (unsigned long long)__entry->sector,
		  __entry->nr_sector, __entry->comm)
);

/**
 * block_getrq - get a free request entry in queue for block IO operations
 * @q: queue for operations
 * @bio: pending block IO operation
 * @rw: low bit indicates a read (%0) or a write (%1)
 *
 * A request struct for queue @q has been allocated to handle the
 * block IO operation @bio.
 */
DEFINE_EVENT(block_get_rq, block_getrq,

	TP_PROTO(struct request_queue *q, struct bio *bio, int rw),

	TP_ARGS(q, bio, rw)
);

/**
 * block_sleeprq - waiting to get a free request entry in queue for block IO operation
 * @q: queue for operation
 * @bio: pending block IO operation
 * @rw: low bit indicates a read (%0) or a write (%1)
 *
 * In the case where a request struct cannot be provided for queue @q
 * the process needs to wait for an request struct to become
 * available.  This tracepoint event is generated each time the
 * process goes to sleep waiting for request struct become available.
 */
DEFINE_EVENT(block_get_rq, block_sleeprq,

	TP_PROTO(struct request_queue *q, struct bio *bio, int rw),

	TP_ARGS(q, bio, rw)
);

/**
 * block_plug - keep operations requests in request queue
 * @q: request queue to plug
 *
 * Plug the request queue @q.  Do not allow block operation requests
 * to be sent to the device driver. Instead, accumulate requests in
 * the queue to improve throughput performance of the block device.
 */
TRACE_EVENT(block_plug,

	TP_PROTO(struct request_queue *q),

	TP_ARGS(q),

	TP_STRUCT__entry(
		__array( char,		comm,	TASK_COMM_LEN	)
	),

	TP_fast_assign(
		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	),

	TP_printk("[%s]", __entry->comm)
);

DECLARE_EVENT_CLASS(block_unplug,

	TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),

	TP_ARGS(q, depth, explicit),

	TP_STRUCT__entry(
		__field( int,		nr_rq			)
		__array( char,		comm,	TASK_COMM_LEN	)
	),

	TP_fast_assign(
		__entry->nr_rq = depth;
		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	),

	TP_printk("[%s] %d", __entry->comm, __entry->nr_rq)
);

/**
 * block_unplug - release of operations requests in request queue
 * @q: request queue to unplug
 * @depth: number of requests just added to the queue
 * @explicit: whether this was an explicit unplug, or one from schedule()
 *
 * Unplug request queue @q because device driver is scheduled to work
 * on elements in the request queue.
 */
DEFINE_EVENT(block_unplug, block_unplug,

	TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),

	TP_ARGS(q, depth, explicit)
);

/**
 * block_split - split a single bio struct into two bio structs
 * @q: queue containing the bio
 * @bio: block operation being split
 * @new_sector: The starting sector for the new bio
 *
 * The bio request @bio in request queue @q needs to be split into two
 * bio requests. The newly created @bio request starts at
 * @new_sector. This split may be required due to hardware limitation
 * such as operation crossing device boundaries in a RAID system.
 */
TRACE_EVENT(block_split,

	TP_PROTO(struct request_queue *q, struct bio *bio,
		 unsigned int new_sector),

	TP_ARGS(q, bio, new_sector),

	TP_STRUCT__entry(
		__field( dev_t,		dev				)
		__field( sector_t,	sector				)
		__field( sector_t,	new_sector			)
		__array( char,		rwbs,		RWBS_LEN	)
		__array( char,		comm,		TASK_COMM_LEN	)
	),

	TP_fast_assign(
		__entry->dev		= bio->bi_bdev->bd_dev;
		__entry->sector		= bio->bi_sector;
		__entry->new_sector	= new_sector;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	),

	TP_printk("%d,%d %s %llu / %llu [%s]",
		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
		  (unsigned long long)__entry->sector,
		  (unsigned long long)__entry->new_sector,
		  __entry->comm)
);

/**
 * block_bio_remap - map request for a logical device to the raw device
 * @q: queue holding the operation
 * @bio: revised operation
 * @dev: device for the operation
 * @from: original sector for the operation
 *
 * An operation for a logical device has been mapped to the
 * raw block device.
 */
TRACE_EVENT(block_bio_remap,

	TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
		 sector_t from),

	TP_ARGS(q, bio, dev, from),

	TP_STRUCT__entry(
		__field( dev_t,		dev		)
		__field( sector_t,	sector		)
		__field( unsigned int,	nr_sector	)
		__field( dev_t,		old_dev		)
		__field( sector_t,	old_sector	)
		__array( char,		rwbs,	RWBS_LEN)
	),

	TP_fast_assign(
		__entry->dev		= bio->bi_bdev->bd_dev;
		__entry->sector		= bio->bi_sector;
		__entry->nr_sector	= bio->bi_size >> 9;
		__entry->old_dev	= dev;
		__entry->old_sector	= from;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
	),

	TP_printk("%d,%d %s %llu + %u <- (%d,%d) %llu",
		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
		  (unsigned long long)__entry->sector,
		  __entry->nr_sector,
		  MAJOR(__entry->old_dev), MINOR(__entry->old_dev),
		  (unsigned long long)__entry->old_sector)
);

/**
 * block_rq_remap - map request for a block operation request
 * @q: queue holding the operation
 * @rq: block IO operation request
 * @dev: device for the operation
 * @from: original sector for the operation
 *
 * The block operation request @rq in @q has been remapped.  The block
 * operation request @rq holds the current information and @from hold
 * the original sector.
 */
TRACE_EVENT(block_rq_remap,

	TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev,
		 sector_t from),

	TP_ARGS(q, rq, dev, from),

	TP_STRUCT__entry(
		__field( dev_t,		dev		)
		__field( sector_t,	sector		)
		__field( unsigned int,	nr_sector	)
		__field( dev_t,		old_dev		)
		__field( sector_t,	old_sector	)
		__array( char,		rwbs,	RWBS_LEN)
	),

	TP_fast_assign(
		__entry->dev		= disk_devt(rq->rq_disk);
		__entry->sector		= blk_rq_pos(rq);
		__entry->nr_sector	= blk_rq_sectors(rq);
		__entry->old_dev	= dev;
		__entry->old_sector	= from;
		blk_fill_rwbs(__entry->rwbs, rq->cmd_flags, blk_rq_bytes(rq));
	),

	TP_printk("%d,%d %s %llu + %u <- (%d,%d) %llu",
		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
		  (unsigned long long)__entry->sector,
		  __entry->nr_sector,
		  MAJOR(__entry->old_dev), MINOR(__entry->old_dev),
		  (unsigned long long)__entry->old_sector)
);

#endif /* _TRACE_BLOCK_H */

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
f62b389e MD	1	#undef TRACE_SYSTEM
	2	#define TRACE_SYSTEM block
	3
	4	#if !defined(_TRACE_BLOCK_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	5	#define _TRACE_BLOCK_H
	6
	7	#include <linux/blktrace_api.h>
	8	#include <linux/blkdev.h>
	9	#include <linux/tracepoint.h>
	10
01696d4d MD	11	#define RWBS_LEN 8
01696d4d MD	12
f62b389e MD	13	DECLARE_EVENT_CLASS(block_rq_with_error,
	14
	15	TP_PROTO(struct request_queue q, struct request rq),
	16
	17	TP_ARGS(q, rq),
	18
	19	TP_STRUCT__entry(
	20	__field( dev_t, dev )
	21	__field( sector_t, sector )
	22	__field( unsigned int, nr_sector )
	23	__field( int, errors )
01696d4d	24	__array( char, rwbs, RWBS_LEN )
f62b389e MD	25	__dynamic_array( char, cmd, blk_cmd_buf_len(rq) )
	26	),
	27
	28	TP_fast_assign(
	29	__entry->dev = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
	30	__entry->sector = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
	31	0 : blk_rq_pos(rq);
	32	__entry->nr_sector = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
	33	0 : blk_rq_sectors(rq);
	34	__entry->errors = rq->errors;
	35
	36	blk_fill_rwbs(__entry->rwbs, rq->cmd_flags, blk_rq_bytes(rq));
	37	blk_dump_cmd(__get_str(cmd), rq);
	38	),
	39
	40	TP_printk("%d,%d %s (%s) %llu + %u [%d]",
	41	MAJOR(__entry->dev), MINOR(__entry->dev),
	42	__entry->rwbs, __get_str(cmd),
	43	(unsigned long long)__entry->sector,
	44	__entry->nr_sector, __entry->errors)
	45	);
	46
	47	/**
	48	* block_rq_abort - abort block operation request
	49	* @q: queue containing the block operation request
	50	* @rq: block IO operation request
	51	*
	52	* Called immediately after pending block IO operation request @rq in
	53	* queue @q is aborted. The fields in the operation request @rq
	54	* can be examined to determine which device and sectors the pending
	55	* operation would access.
	56	*/
	57	DEFINE_EVENT(block_rq_with_error, block_rq_abort,
	58
	59	TP_PROTO(struct request_queue q, struct request rq),
	60
	61	TP_ARGS(q, rq)
	62	);
	63
	64	/**
	65	* block_rq_requeue - place block IO request back on a queue
	66	* @q: queue holding operation
	67	* @rq: block IO operation request
	68	*
	69	* The block operation request @rq is being placed back into queue
	70	* @q. For some reason the request was not completed and needs to be
	71	* put back in the queue.
	72	*/
	73	DEFINE_EVENT(block_rq_with_error, block_rq_requeue,
	74
	75	TP_PROTO(struct request_queue q, struct request rq),
	76
	77	TP_ARGS(q, rq)
	78	);
	79
	80	/**
	81	* block_rq_complete - block IO operation completed by device driver
	82	* @q: queue containing the block operation request
	83	* @rq: block operations request
	84	*
	85	* The block_rq_complete tracepoint event indicates that some portion
	86	* of operation request has been completed by the device driver. If
	87	* the @rq->bio is %NULL, then there is absolutely no additional work to
	88	* do for the request. If @rq->bio is non-NULL then there is
89	* additional work required to complete the request.
90	*/
91	DEFINE_EVENT(block_rq_with_error, block_rq_complete,
92
93	TP_PROTO(struct request_queue q, struct request rq),
94
95	TP_ARGS(q, rq)
96	);
97
98	DECLARE_EVENT_CLASS(block_rq,
99
100	TP_PROTO(struct request_queue q, struct request rq),
101
102	TP_ARGS(q, rq),
103
104	TP_STRUCT__entry(
105	__field( dev_t, dev )
106	__field( sector_t, sector )
107	__field( unsigned int, nr_sector )
108	__field( unsigned int, bytes )
01696d4d	109	__array( char, rwbs, RWBS_LEN )
f62b389e MD	110	__array( char, comm, TASK_COMM_LEN )
	111	__dynamic_array( char, cmd, blk_cmd_buf_len(rq) )
	112	),
	113
	114	TP_fast_assign(
	115	__entry->dev = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
	116	__entry->sector = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
	117	0 : blk_rq_pos(rq);
	118	__entry->nr_sector = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
	119	0 : blk_rq_sectors(rq);
	120	__entry->bytes = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
	121	blk_rq_bytes(rq) : 0;
	122
	123	blk_fill_rwbs(__entry->rwbs, rq->cmd_flags, blk_rq_bytes(rq));
	124	blk_dump_cmd(__get_str(cmd), rq);
	125	memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	126	),
	127
	128	TP_printk("%d,%d %s %u (%s) %llu + %u [%s]",
	129	MAJOR(__entry->dev), MINOR(__entry->dev),
	130	__entry->rwbs, __entry->bytes, __get_str(cmd),
	131	(unsigned long long)__entry->sector,
	132	__entry->nr_sector, __entry->comm)
	133	);
	134
	135	/**
	136	* block_rq_insert - insert block operation request into queue
	137	* @q: target queue
	138	* @rq: block IO operation request
	139	*
	140	* Called immediately before block operation request @rq is inserted
	141	* into queue @q. The fields in the operation request @rq struct can
	142	* be examined to determine which device and sectors the pending
	143	* operation would access.
	144	*/
	145	DEFINE_EVENT(block_rq, block_rq_insert,
	146
	147	TP_PROTO(struct request_queue q, struct request rq),
	148
	149	TP_ARGS(q, rq)
	150	);
	151
	152	/**
	153	* block_rq_issue - issue pending block IO request operation to device driver
	154	* @q: queue holding operation
	155	* @rq: block IO operation operation request
	156	*
	157	* Called when block operation request @rq from queue @q is sent to a
	158	* device driver for processing.
	159	*/
	160	DEFINE_EVENT(block_rq, block_rq_issue,
	161
	162	TP_PROTO(struct request_queue q, struct request rq),
	163
	164	TP_ARGS(q, rq)
	165	);
	166
	167	/**
	168	* block_bio_bounce - used bounce buffer when processing block operation
	169	* @q: queue holding the block operation
	170	* @bio: block operation
	171	*
	172	* A bounce buffer was used to handle the block operation @bio in @q.
	173	* This occurs when hardware limitations prevent a direct transfer of
174	* data between the @bio data memory area and the IO device. Use of a
175	* bounce buffer requires extra copying of data and decreases
176	* performance.
177	*/
178	TRACE_EVENT(block_bio_bounce,
179
180	TP_PROTO(struct request_queue q, struct bio bio),
181
182	TP_ARGS(q, bio),
183
184	TP_STRUCT__entry(
185	__field( dev_t, dev )
186	__field( sector_t, sector )
187	__field( unsigned int, nr_sector )
01696d4d	188	__array( char, rwbs, RWBS_LEN )
f62b389e MD	189	__array( char, comm, TASK_COMM_LEN )
	190	),
	191
	192	TP_fast_assign(
	193	__entry->dev = bio->bi_bdev ?
	194	bio->bi_bdev->bd_dev : 0;
	195	__entry->sector = bio->bi_sector;
	196	__entry->nr_sector = bio->bi_size >> 9;
	197	blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
	198	memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	199	),
	200
	201	TP_printk("%d,%d %s %llu + %u [%s]",
	202	MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
	203	(unsigned long long)__entry->sector,
	204	__entry->nr_sector, __entry->comm)
	205	);
	206
	207	/**
	208	* block_bio_complete - completed all work on the block operation
	209	* @q: queue holding the block operation
	210	* @bio: block operation completed
	211	* @error: io error value
	212	*
	213	* This tracepoint indicates there is no further work to do on this
	214	* block IO operation @bio.
	215	*/
	216	TRACE_EVENT(block_bio_complete,
	217
	218	TP_PROTO(struct request_queue q, struct bio bio, int error),
	219
	220	TP_ARGS(q, bio, error),
	221
	222	TP_STRUCT__entry(
	223	__field( dev_t, dev )
	224	__field( sector_t, sector )
	225	__field( unsigned, nr_sector )
	226	__field( int, error )
01696d4d	227	__array( char, rwbs, RWBS_LEN)
f62b389e MD	228	),
	229
	230	TP_fast_assign(
	231	__entry->dev = bio->bi_bdev->bd_dev;
	232	__entry->sector = bio->bi_sector;
	233	__entry->nr_sector = bio->bi_size >> 9;
	234	__entry->error = error;
	235	blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
	236	),
	237
	238	TP_printk("%d,%d %s %llu + %u [%d]",
	239	MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
	240	(unsigned long long)__entry->sector,
	241	__entry->nr_sector, __entry->error)
	242	);
	243
	244	DECLARE_EVENT_CLASS(block_bio,
	245
	246	TP_PROTO(struct request_queue q, struct bio bio),
	247
	248	TP_ARGS(q, bio),
	249
	250	TP_STRUCT__entry(
	251	__field( dev_t, dev )
	252	__field( sector_t, sector )
	253	__field( unsigned int, nr_sector )
01696d4d	254	__array( char, rwbs, RWBS_LEN )
f62b389e MD	255	__array( char, comm, TASK_COMM_LEN )
	256	),
	257
	258	TP_fast_assign(
	259	__entry->dev = bio->bi_bdev->bd_dev;
	260	__entry->sector = bio->bi_sector;
	261	__entry->nr_sector = bio->bi_size >> 9;
	262	blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
	263	memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	264	),
	265
	266	TP_printk("%d,%d %s %llu + %u [%s]",
	267	MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
	268	(unsigned long long)__entry->sector,
	269	__entry->nr_sector, __entry->comm)
	270	);
	271
	272	/**
	273	* block_bio_backmerge - merging block operation to the end of an existing operation
	274	* @q: queue holding operation
	275	* @bio: new block operation to merge
	276	*
	277	* Merging block request @bio to the end of an existing block request
	278	* in queue @q.
	279	*/
	280	DEFINE_EVENT(block_bio, block_bio_backmerge,
	281
	282	TP_PROTO(struct request_queue q, struct bio bio),
	283
	284	TP_ARGS(q, bio)
	285	);
	286
	287	/**
	288	* block_bio_frontmerge - merging block operation to the beginning of an existing operation
	289	* @q: queue holding operation
	290	* @bio: new block operation to merge
	291	*
	292	* Merging block IO operation @bio to the beginning of an existing block
	293	* operation in queue @q.
	294	*/
	295	DEFINE_EVENT(block_bio, block_bio_frontmerge,
	296
	297	TP_PROTO(struct request_queue q, struct bio bio),
	298
	299	TP_ARGS(q, bio)
	300	);
	301
	302	/**
	303	* block_bio_queue - putting new block IO operation in queue
	304	* @q: queue holding operation
	305	* @bio: new block operation
	306	*
	307	* About to place the block IO operation @bio into queue @q.
	308	*/
	309	DEFINE_EVENT(block_bio, block_bio_queue,
	310
	311	TP_PROTO(struct request_queue q, struct bio bio),
	312
	313	TP_ARGS(q, bio)
	314	);
	315
	316	DECLARE_EVENT_CLASS(block_get_rq,
	317
	318	TP_PROTO(struct request_queue q, struct bio bio, int rw),
319
320	TP_ARGS(q, bio, rw),
321
322	TP_STRUCT__entry(
323	__field( dev_t, dev )
324	__field( sector_t, sector )
325	__field( unsigned int, nr_sector )
01696d4d	326	__array( char, rwbs, RWBS_LEN )
f62b389e MD	327	__array( char, comm, TASK_COMM_LEN )
	328	),
	329
	330	TP_fast_assign(
	331	__entry->dev = bio ? bio->bi_bdev->bd_dev : 0;
	332	__entry->sector = bio ? bio->bi_sector : 0;
	333	__entry->nr_sector = bio ? bio->bi_size >> 9 : 0;
	334	blk_fill_rwbs(__entry->rwbs,
	335	bio ? bio->bi_rw : 0, __entry->nr_sector);
	336	memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	337	),
	338
	339	TP_printk("%d,%d %s %llu + %u [%s]",
	340	MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
	341	(unsigned long long)__entry->sector,
	342	__entry->nr_sector, __entry->comm)
	343	);
	344
	345	/**
	346	* block_getrq - get a free request entry in queue for block IO operations
	347	* @q: queue for operations
	348	* @bio: pending block IO operation
	349	* @rw: low bit indicates a read (%0) or a write (%1)
	350	*
	351	* A request struct for queue @q has been allocated to handle the
	352	* block IO operation @bio.
	353	*/
	354	DEFINE_EVENT(block_get_rq, block_getrq,
	355
	356	TP_PROTO(struct request_queue q, struct bio bio, int rw),
	357
	358	TP_ARGS(q, bio, rw)
	359	);
	360
	361	/**
	362	* block_sleeprq - waiting to get a free request entry in queue for block IO operation
	363	* @q: queue for operation
	364	* @bio: pending block IO operation
	365	* @rw: low bit indicates a read (%0) or a write (%1)
	366	*
	367	* In the case where a request struct cannot be provided for queue @q
	368	* the process needs to wait for an request struct to become
	369	* available. This tracepoint event is generated each time the
	370	* process goes to sleep waiting for request struct become available.
	371	*/
	372	DEFINE_EVENT(block_get_rq, block_sleeprq,
	373
	374	TP_PROTO(struct request_queue q, struct bio bio, int rw),
	375
	376	TP_ARGS(q, bio, rw)
	377	);
	378
	379	/**
	380	* block_plug - keep operations requests in request queue
	381	* @q: request queue to plug
	382	*
	383	* Plug the request queue @q. Do not allow block operation requests
	384	* to be sent to the device driver. Instead, accumulate requests in
	385	* the queue to improve throughput performance of the block device.
	386	*/
	387	TRACE_EVENT(block_plug,
	388
	389	TP_PROTO(struct request_queue *q),
	390
391	TP_ARGS(q),
392
393	TP_STRUCT__entry(
394	__array( char, comm, TASK_COMM_LEN )
395	),
396
397	TP_fast_assign(
398	memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
399	),
400
401	TP_printk("[%s]", __entry->comm)
402	);
403
404	DECLARE_EVENT_CLASS(block_unplug,
405
406	TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),
407
408	TP_ARGS(q, depth, explicit),
409
410	TP_STRUCT__entry(
411	__field( int, nr_rq )
412	__array( char, comm, TASK_COMM_LEN )
413	),
414
415	TP_fast_assign(
416	__entry->nr_rq = depth;
417	memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
418	),
419
420	TP_printk("[%s] %d", __entry->comm, __entry->nr_rq)
421	);
422
423	/**
424	* block_unplug - release of operations requests in request queue
425	* @q: request queue to unplug
426	* @depth: number of requests just added to the queue
427	* @explicit: whether this was an explicit unplug, or one from schedule()
428	*
429	* Unplug request queue @q because device driver is scheduled to work
430	* on elements in the request queue.
431	*/
432	DEFINE_EVENT(block_unplug, block_unplug,
433
434	TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),
435
436	TP_ARGS(q, depth, explicit)
437	);
438
439	/**
440	* block_split - split a single bio struct into two bio structs
441	* @q: queue containing the bio
442	* @bio: block operation being split
443	* @new_sector: The starting sector for the new bio
444	*
445	* The bio request @bio in request queue @q needs to be split into two
446	* bio requests. The newly created @bio request starts at
447	* @new_sector. This split may be required due to hardware limitation
448	* such as operation crossing device boundaries in a RAID system.
449	*/
450	TRACE_EVENT(block_split,
451
452	TP_PROTO(struct request_queue q, struct bio bio,
453	unsigned int new_sector),
454
455	TP_ARGS(q, bio, new_sector),
456
457	TP_STRUCT__entry(
458	__field( dev_t, dev )
459	__field( sector_t, sector )
460	__field( sector_t, new_sector )
01696d4d	461	__array( char, rwbs, RWBS_LEN )
f62b389e MD	462	__array( char, comm, TASK_COMM_LEN )
	463	),
	464
	465	TP_fast_assign(
	466	__entry->dev = bio->bi_bdev->bd_dev;
	467	__entry->sector = bio->bi_sector;
	468	__entry->new_sector = new_sector;
	469	blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
	470	memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	471	),
	472
	473	TP_printk("%d,%d %s %llu / %llu [%s]",
	474	MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
	475	(unsigned long long)__entry->sector,
	476	(unsigned long long)__entry->new_sector,
	477	__entry->comm)
	478	);
	479
	480	/**
	481	* block_bio_remap - map request for a logical device to the raw device
	482	* @q: queue holding the operation
	483	* @bio: revised operation
	484	* @dev: device for the operation
	485	* @from: original sector for the operation
	486	*
	487	* An operation for a logical device has been mapped to the
	488	* raw block device.
	489	*/
	490	TRACE_EVENT(block_bio_remap,
	491
	492	TP_PROTO(struct request_queue q, struct bio bio, dev_t dev,
	493	sector_t from),
	494
	495	TP_ARGS(q, bio, dev, from),
	496
	497	TP_STRUCT__entry(
	498	__field( dev_t, dev )
	499	__field( sector_t, sector )
	500	__field( unsigned int, nr_sector )
	501	__field( dev_t, old_dev )
	502	__field( sector_t, old_sector )
01696d4d	503	__array( char, rwbs, RWBS_LEN)
f62b389e MD	504	),
	505
	506	TP_fast_assign(
	507	__entry->dev = bio->bi_bdev->bd_dev;
	508	__entry->sector = bio->bi_sector;
	509	__entry->nr_sector = bio->bi_size >> 9;
	510	__entry->old_dev = dev;
	511	__entry->old_sector = from;
	512	blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
	513	),
	514
	515	TP_printk("%d,%d %s %llu + %u <- (%d,%d) %llu",
	516	MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
	517	(unsigned long long)__entry->sector,
	518	__entry->nr_sector,
	519	MAJOR(__entry->old_dev), MINOR(__entry->old_dev),
	520	(unsigned long long)__entry->old_sector)
	521	);
	522
	523	/**
	524	* block_rq_remap - map request for a block operation request
	525	* @q: queue holding the operation
	526	* @rq: block IO operation request
	527	* @dev: device for the operation
	528	* @from: original sector for the operation
	529	*
	530	* The block operation request @rq in @q has been remapped. The block
	531	* operation request @rq holds the current information and @from hold
	532	* the original sector.
	533	*/
	534	TRACE_EVENT(block_rq_remap,
	535
	536	TP_PROTO(struct request_queue q, struct request rq, dev_t dev,
	537	sector_t from),
	538
	539	TP_ARGS(q, rq, dev, from),
	540
	541	TP_STRUCT__entry(
	542	__field( dev_t, dev )
	543	__field( sector_t, sector )
	544	__field( unsigned int, nr_sector )
	545	__field( dev_t, old_dev )
	546	__field( sector_t, old_sector )
01696d4d	547	__array( char, rwbs, RWBS_LEN)
f62b389e MD	548	),
	549
	550	TP_fast_assign(
	551	__entry->dev = disk_devt(rq->rq_disk);
	552	__entry->sector = blk_rq_pos(rq);
	553	__entry->nr_sector = blk_rq_sectors(rq);
	554	__entry->old_dev = dev;
	555	__entry->old_sector = from;
	556	blk_fill_rwbs(__entry->rwbs, rq->cmd_flags, blk_rq_bytes(rq));
	557	),
	558
	559	TP_printk("%d,%d %s %llu + %u <- (%d,%d) %llu",
	560	MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
	561	(unsigned long long)__entry->sector,
	562	__entry->nr_sector,
	563	MAJOR(__entry->old_dev), MINOR(__entry->old_dev),
	564	(unsigned long long)__entry->old_sector)
	565	);
	566
	567	#endif /* _TRACE_BLOCK_H */
	568
	569	/* This part must be outside protection */
	570	#include <trace/define_trace.h>
	571