block.h File Reference

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

Go to the source code of this file.

Macros
#define	TRACE_SYSTEM   block
#define	_TRACE_BLOCK_H
#define	RWBS_LEN   8

Functions
	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))
	DEFINE_EVENT (block_rq_with_error, block_rq_abort, TP_PROTO(struct request_queue *q, struct request *rq),)
	DEFINE_EVENT (block_rq_with_error, block_rq_requeue, TP_PROTO(struct request_queue *q, struct request *rq),)
	DEFINE_EVENT (block_rq_with_error, block_rq_complete, TP_PROTO(struct request_queue *q, struct request *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))
	DEFINE_EVENT (block_rq, block_rq_insert, TP_PROTO(struct request_queue *q, struct request *rq),)
	DEFINE_EVENT (block_rq, block_rq_issue, TP_PROTO(struct request_queue *q, struct request *rq),)
	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))
	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))
	DEFINE_EVENT (block_bio, block_bio_backmerge, TP_PROTO(struct request_queue *q, struct bio *bio),)
	DEFINE_EVENT (block_bio, block_bio_frontmerge, TP_PROTO(struct request_queue *q, struct bio *bio),)
	DEFINE_EVENT (block_bio, block_bio_queue, TP_PROTO(struct request_queue *q, struct bio *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))
	DEFINE_EVENT (block_get_rq, block_getrq, TP_PROTO(struct request_queue *q, struct bio *bio, int rw),)
	DEFINE_EVENT (block_get_rq, block_sleeprq, TP_PROTO(struct request_queue *q, struct bio *bio, int rw),)
	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))
	DEFINE_EVENT (block_unplug, block_unplug, TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),)
	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))
	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))
	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))

Macro Definition Documentation

#define _TRACE_BLOCK_H

Definition at line 5 of file block.h.

#define RWBS_LEN   8

Definition at line 11 of file block.h.

#define TRACE_SYSTEM   block

Definition at line 2 of file block.h.

Function Documentation

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)
	)

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)
	)

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)
	)

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)
	)

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)
	)

DEFINE_EVENT	(	block_rq_with_error	,
		block_rq_abort	,
		TP_PROTO(struct request_queue *q, struct request *rq)
	)

block_rq_abort - abort block operation request : queue containing the block operation request : block IO operation request

Called immediately after pending block IO operation request in queue is aborted. The fields in the operation request can be examined to determine which device and sectors the pending operation would access.

DEFINE_EVENT	(	block_rq_with_error	,
		block_rq_requeue	,
		TP_PROTO(struct request_queue *q, struct request *rq)
	)

block_rq_requeue - place block IO request back on a queue : queue holding operation : block IO operation request

The block operation request is being placed back into queue . 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_complete	,
		TP_PROTO(struct request_queue *q, struct request *rq)
	)

block_rq_complete - block IO operation completed by device driver : queue containing the block operation request : 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 ->bio is NULL, then there is absolutely no additional work to do for the request. If ->bio is non-NULL then there is additional work required to complete the request.

DEFINE_EVENT	(	block_rq	,
		block_rq_insert	,
		TP_PROTO(struct request_queue *q, struct request *rq)
	)

block_rq_insert - insert block operation request into queue : target queue : block IO operation request

Called immediately before block operation request is inserted into queue . The fields in the operation request struct can be examined to determine which device and sectors the pending operation would access.

DEFINE_EVENT	(	block_rq	,
		block_rq_issue	,
		TP_PROTO(struct request_queue *q, struct request *rq)
	)

block_rq_issue - issue pending block IO request operation to device driver : queue holding operation : block IO operation operation request

Called when block operation request from queue is sent to a device driver for processing.

DEFINE_EVENT	(	block_bio	,
		block_bio_backmerge	,
		TP_PROTO(struct request_queue *q, struct bio *bio)
	)

block_bio_backmerge - merging block operation to the end of an existing operation : queue holding operation : new block operation to merge

Merging block request to the end of an existing block request in queue .

DEFINE_EVENT	(	block_bio	,
		block_bio_frontmerge	,
		TP_PROTO(struct request_queue *q, struct bio *bio)
	)

block_bio_frontmerge - merging block operation to the beginning of an existing operation : queue holding operation : new block operation to merge

Merging block IO operation to the beginning of an existing block operation in queue .

DEFINE_EVENT	(	block_bio	,
		block_bio_queue	,
		TP_PROTO(struct request_queue *q, struct bio *bio)
	)

block_bio_queue - putting new block IO operation in queue : queue holding operation : new block operation

About to place the block IO operation into queue .

DEFINE_EVENT	(	block_get_rq	,
		block_getrq	,
		TP_PROTO(struct request_queue *q, struct bio *bio, int rw)
	)

block_getrq - get a free request entry in queue for block IO operations : queue for operations : pending block IO operation : low bit indicates a read (%0) or a write (%1)

A request struct for queue has been allocated to handle the block IO operation .

DEFINE_EVENT	(	block_get_rq	,
		block_sleeprq	,
		TP_PROTO(struct request_queue *q, struct bio *bio, int rw)
	)

block_sleeprq - waiting to get a free request entry in queue for block IO operation : queue for operation : pending block IO operation : low bit indicates a read (%0) or a write (%1)

In the case where a request struct cannot be provided for queue 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_unplug	,
		block_unplug	,
		TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit)
	)

block_unplug - release of operations requests in request queue : request queue to unplug : number of requests just added to the queue : whether this was an explicit unplug, or one from schedule()

Unplug request queue because device driver is scheduled to work on elements in the request queue.

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_bounce - used bounce buffer when processing block operation : queue holding the block operation : block operation

A bounce buffer was used to handle the block operation in . This occurs when hardware limitations prevent a direct transfer of data between the data memory area and the IO device. Use of a bounce buffer requires extra copying of data and decreases performance.

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)
	)

block_bio_complete - completed all work on the block operation : queue holding the block operation : block operation completed : io error value

This tracepoint indicates there is no further work to do on this block IO operation .

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)
	)

block_plug - keep operations requests in request queue : request queue to plug

Plug the request queue . 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_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_split - split a single bio struct into two bio structs : queue containing the bio : block operation being split : The starting sector for the new bio

The bio request in request queue needs to be split into two bio requests. The newly created request starts at . This split may be required due to hardware limitation such as operation crossing device boundaries in a RAID system.

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_bio_remap - map request for a logical device to the raw device : queue holding the operation : revised operation : device for the operation : original sector for the operation

An operation for a logical device has been mapped to the raw block device.

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)
	)

block_rq_remap - map request for a block operation request : queue holding the operation : block IO operation request : device for the operation : original sector for the operation

The block operation request in has been remapped. The block operation request holds the current information and hold the original sector.