1 #ifndef BLKTRACE_H

     2 #define BLKTRACE_H

     3 

     4 #ifdef __KERNEL__

     5 #include <linux/blkdev.h>

     6 #include <linux/relay.h>

     7 #endif

     8 

     9 /*

    10  * Trace categories

    11  */

    12 enum blktrace_cat {

    13 	BLK_TC_READ	= 1 << 0,	/* reads */

    14 	BLK_TC_WRITE	= 1 << 1,	/* writes */

    15 	BLK_TC_BARRIER	= 1 << 2,	/* barrier */

    16 	BLK_TC_SYNC	= 1 << 3,	/* sync IO */

    17 	BLK_TC_QUEUE	= 1 << 4,	/* queueing/merging */

    18 	BLK_TC_REQUEUE	= 1 << 5,	/* requeueing */

    19 	BLK_TC_ISSUE	= 1 << 6,	/* issue */

    20 	BLK_TC_COMPLETE	= 1 << 7,	/* completions */

    21 	BLK_TC_FS	= 1 << 8,	/* fs requests */

    22 	BLK_TC_PC	= 1 << 9,	/* pc requests */

    23 	BLK_TC_NOTIFY	= 1 << 10,	/* special message */

    24 	BLK_TC_AHEAD	= 1 << 11,	/* readahead */

    25 	BLK_TC_META	= 1 << 12,	/* metadata */

    26 	BLK_TC_DISCARD	= 1 << 13,	/* discard requests */

    27 	BLK_TC_DRV_DATA	= 1 << 14,	/* binary per-driver data */

    28 

    29 	BLK_TC_END	= 1 << 15,	/* only 16-bits, reminder */

    30 };

    31 

    32 #define BLK_TC_SHIFT		(16)

    33 #define BLK_TC_ACT(act)		((act) << BLK_TC_SHIFT)

    34 

    35 /*

    36  * Basic trace actions

    37  */

    38 enum blktrace_act {

    39 	__BLK_TA_QUEUE = 1,		/* queued */

    40 	__BLK_TA_BACKMERGE,		/* back merged to existing rq */

    41 	__BLK_TA_FRONTMERGE,		/* front merge to existing rq */

    42 	__BLK_TA_GETRQ,			/* allocated new request */

    43 	__BLK_TA_SLEEPRQ,		/* sleeping on rq allocation */

    44 	__BLK_TA_REQUEUE,		/* request requeued */

    45 	__BLK_TA_ISSUE,			/* sent to driver */

    46 	__BLK_TA_COMPLETE,		/* completed by driver */

    47 	__BLK_TA_PLUG,			/* queue was plugged */

    48 	__BLK_TA_UNPLUG_IO,		/* queue was unplugged by io */

    49 	__BLK_TA_UNPLUG_TIMER,		/* queue was unplugged by timer */

    50 	__BLK_TA_INSERT,		/* insert request */

    51 	__BLK_TA_SPLIT,			/* bio was split */

    52 	__BLK_TA_BOUNCE,		/* bio was bounced */

    53 	__BLK_TA_REMAP,			/* bio was remapped */

    54 	__BLK_TA_ABORT,			/* request aborted */

    55 	__BLK_TA_DRV_DATA,		/* driver-specific binary data */

    56 };

    57 

    58 /*

    59  * Notify events.

    60  */

    61 enum blktrace_notify {

    62 	__BLK_TN_PROCESS = 0,		/* establish pid/name mapping */

    63 	__BLK_TN_TIMESTAMP,		/* include system clock */

    64 	__BLK_TN_MESSAGE,		/* Character string message */

    65 };

    66 

    67 

    68 /*

    69  * Trace actions in full. Additionally, read or write is masked

    70  */

    71 #define BLK_TA_QUEUE		(__BLK_TA_QUEUE | BLK_TC_ACT(BLK_TC_QUEUE))

    72 #define BLK_TA_BACKMERGE	(__BLK_TA_BACKMERGE | BLK_TC_ACT(BLK_TC_QUEUE))

    73 #define BLK_TA_FRONTMERGE	(__BLK_TA_FRONTMERGE | BLK_TC_ACT(BLK_TC_QUEUE))

    74 #define	BLK_TA_GETRQ		(__BLK_TA_GETRQ | BLK_TC_ACT(BLK_TC_QUEUE))

    75 #define	BLK_TA_SLEEPRQ		(__BLK_TA_SLEEPRQ | BLK_TC_ACT(BLK_TC_QUEUE))

    76 #define	BLK_TA_REQUEUE		(__BLK_TA_REQUEUE | BLK_TC_ACT(BLK_TC_REQUEUE))

    77 #define BLK_TA_ISSUE		(__BLK_TA_ISSUE | BLK_TC_ACT(BLK_TC_ISSUE))

    78 #define BLK_TA_COMPLETE		(__BLK_TA_COMPLETE| BLK_TC_ACT(BLK_TC_COMPLETE))

    79 #define BLK_TA_PLUG		(__BLK_TA_PLUG | BLK_TC_ACT(BLK_TC_QUEUE))

    80 #define BLK_TA_UNPLUG_IO	(__BLK_TA_UNPLUG_IO | BLK_TC_ACT(BLK_TC_QUEUE))

    81 #define BLK_TA_UNPLUG_TIMER	(__BLK_TA_UNPLUG_TIMER | BLK_TC_ACT(BLK_TC_QUEUE))

    82 #define BLK_TA_INSERT		(__BLK_TA_INSERT | BLK_TC_ACT(BLK_TC_QUEUE))

    83 #define BLK_TA_SPLIT		(__BLK_TA_SPLIT)

    84 #define BLK_TA_BOUNCE		(__BLK_TA_BOUNCE)

    85 #define BLK_TA_REMAP		(__BLK_TA_REMAP | BLK_TC_ACT(BLK_TC_QUEUE))

    86 #define BLK_TA_ABORT		(__BLK_TA_ABORT | BLK_TC_ACT(BLK_TC_QUEUE))

    87 #define BLK_TA_DRV_DATA	(__BLK_TA_DRV_DATA | BLK_TC_ACT(BLK_TC_DRV_DATA))

    88 

    89 #define BLK_TN_PROCESS		(__BLK_TN_PROCESS | BLK_TC_ACT(BLK_TC_NOTIFY))

    90 #define BLK_TN_TIMESTAMP	(__BLK_TN_TIMESTAMP | BLK_TC_ACT(BLK_TC_NOTIFY))

    91 #define BLK_TN_MESSAGE		(__BLK_TN_MESSAGE | BLK_TC_ACT(BLK_TC_NOTIFY))

    92 

    93 #define BLK_IO_TRACE_MAGIC	0x65617400

    94 #define BLK_IO_TRACE_VERSION	0x07

    95 

    96 /*

    97  * The trace itself

    98  */

    99 struct blk_io_trace {

   100 	__u32 magic;		/* MAGIC << 8 | version */

   101 	__u32 sequence;		/* event number */

   102 	__u64 time;		/* in microseconds */

   103 	__u64 sector;		/* disk offset */

   104 	__u32 bytes;		/* transfer length */

   105 	__u32 action;		/* what happened */

   106 	__u32 pid;		/* who did it */

   107 	__u32 device;		/* device number */

   108 	__u32 cpu;		/* on what cpu did it happen */

   109 	__u16 error;		/* completion error */

   110 	__u16 pdu_len;		/* length of data after this trace */

   111 };

   112 

   113 /*

   114  * The remap event

   115  */

   116 struct blk_io_trace_remap {

   117 	__be32 device;

   118 	__be32 device_from;

   119 	__be64 sector;

   120 };

   121 

   122 enum {

   123 	Blktrace_setup = 1,

   124 	Blktrace_running,

   125 	Blktrace_stopped,

   126 };

   127 

   128 #define BLKTRACE_BDEV_SIZE	32

   129 

   130 /*

   131  * User setup structure passed with BLKTRACESTART

   132  */

   133 struct blk_user_trace_setup {

   134 	char name[BLKTRACE_BDEV_SIZE];	/* output */

   135 	__u16 act_mask;			/* input */

   136 	__u32 buf_size;			/* input */

   137 	__u32 buf_nr;			/* input */

   138 	__u64 start_lba;

   139 	__u64 end_lba;

   140 	__u32 pid;

   141 };

   142 

   143 #ifdef __KERNEL__

   144 #if defined(CONFIG_BLK_DEV_IO_TRACE)

   145 struct blk_trace {

   146 	int trace_state;

   147 	struct rchan *rchan;

   148 	unsigned long *sequence;

   149 	unsigned char *msg_data;

   150 	u16 act_mask;

   151 	u64 start_lba;

   152 	u64 end_lba;

   153 	u32 pid;

   154 	u32 dev;

   155 	struct dentry *dir;

   156 	struct dentry *dropped_file;

   157 	struct dentry *msg_file;

   158 	atomic_t dropped;

   159 };

   160 

   161 extern int blk_trace_ioctl(struct block_device *, unsigned, char __user *);

   162 extern void blk_trace_shutdown(struct request_queue *);

   163 extern void __blk_add_trace(struct blk_trace *, sector_t, int, int, u32, int, int, void *);

   164 extern int do_blk_trace_setup(struct request_queue *q,

   165 	char *name, dev_t dev, struct blk_user_trace_setup *buts);

   166 extern void __trace_note_message(struct blk_trace *, const char *fmt, ...);

   167 

   168 /**

   169  * blk_add_trace_msg - Add a (simple) message to the blktrace stream

   170  * @q:		queue the io is for

   171  * @fmt:	format to print message in

   172  * args...	Variable argument list for format

   173  *

   174  * Description:

   175  *     Records a (simple) message onto the blktrace stream.

   176  *

   177  *     NOTE: BLK_TN_MAX_MSG characters are output at most.

   178  *     NOTE: Can not use 'static inline' due to presence of var args...

   179  *

   180  **/

   181 #define blk_add_trace_msg(q, fmt, ...)					\

   182 	do {								\

   183 		struct blk_trace *bt = (q)->blk_trace;			\

   184 		if (unlikely(bt))					\

   185 			__trace_note_message(bt, fmt, ##__VA_ARGS__);	\

   186 	} while (0)

   187 #define BLK_TN_MAX_MSG		128

   188 

   189 /**

   190  * blk_add_trace_rq - Add a trace for a request oriented action

   191  * @q:		queue the io is for

   192  * @rq:		the source request

   193  * @what:	the action

   194  *

   195  * Description:

   196  *     Records an action against a request. Will log the bio offset + size.

   197  *

   198  **/

   199 static inline void blk_add_trace_rq(struct request_queue *q, struct request *rq,

   200 				    u32 what)

   201 {

   202 	struct blk_trace *bt = q->blk_trace;

   203 	int rw = rq->cmd_flags & 0x03;

   204 

   205 	if (likely(!bt))

   206 		return;

   207 

   208 	if (blk_discard_rq(rq))

   209 		rw |= (1 << BIO_RW_DISCARD);

   210 

   211 	if (blk_pc_request(rq)) {

   212 		what |= BLK_TC_ACT(BLK_TC_PC);

   213 		__blk_add_trace(bt, 0, rq->data_len, rw, what, rq->errors, sizeof(rq->cmd), rq->cmd);

   214 	} else  {

   215 		what |= BLK_TC_ACT(BLK_TC_FS);

   216 		__blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9, rw, what, rq->errors, 0, NULL);

   217 	}

   218 }

   219 

   220 /**

   221  * blk_add_trace_bio - Add a trace for a bio oriented action

   222  * @q:		queue the io is for

   223  * @bio:	the source bio

   224  * @what:	the action

   225  *

   226  * Description:

   227  *     Records an action against a bio. Will log the bio offset + size.

   228  *

   229  **/

   230 static inline void blk_add_trace_bio(struct request_queue *q, struct bio *bio,

   231 				     u32 what)

   232 {

   233 	struct blk_trace *bt = q->blk_trace;

   234 

   235 	if (likely(!bt))

   236 		return;

   237 

   238 	__blk_add_trace(bt, bio->bi_sector, bio->bi_size, bio->bi_rw, what, !bio_flagged(bio, BIO_UPTODATE), 0, NULL);

   239 }

   240 

   241 /**

   242  * blk_add_trace_generic - Add a trace for a generic action

   243  * @q:		queue the io is for

   244  * @bio:	the source bio

   245  * @rw:		the data direction

   246  * @what:	the action

   247  *

   248  * Description:

   249  *     Records a simple trace

   250  *

   251  **/

   252 static inline void blk_add_trace_generic(struct request_queue *q,

   253 					 struct bio *bio, int rw, u32 what)

   254 {

   255 	struct blk_trace *bt = q->blk_trace;

   256 

   257 	if (likely(!bt))

   258 		return;

   259 

   260 	if (bio)

   261 		blk_add_trace_bio(q, bio, what);

   262 	else

   263 		__blk_add_trace(bt, 0, 0, rw, what, 0, 0, NULL);

   264 }

   265 

   266 /**

   267  * blk_add_trace_pdu_int - Add a trace for a bio with an integer payload

   268  * @q:		queue the io is for

   269  * @what:	the action

   270  * @bio:	the source bio

   271  * @pdu:	the integer payload

   272  *

   273  * Description:

   274  *     Adds a trace with some integer payload. This might be an unplug

   275  *     option given as the action, with the depth at unplug time given

   276  *     as the payload

   277  *

   278  **/

   279 static inline void blk_add_trace_pdu_int(struct request_queue *q, u32 what,

   280 					 struct bio *bio, unsigned int pdu)

   281 {

   282 	struct blk_trace *bt = q->blk_trace;

   283 	__be64 rpdu = cpu_to_be64(pdu);

   284 

   285 	if (likely(!bt))

   286 		return;

   287 

   288 	if (bio)

   289 		__blk_add_trace(bt, bio->bi_sector, bio->bi_size, bio->bi_rw, what, !bio_flagged(bio, BIO_UPTODATE), sizeof(rpdu), &rpdu);

   290 	else

   291 		__blk_add_trace(bt, 0, 0, 0, what, 0, sizeof(rpdu), &rpdu);

   292 }

   293 

   294 /**

   295  * blk_add_trace_remap - Add a trace for a remap operation

   296  * @q:		queue the io is for

   297  * @bio:	the source bio

   298  * @dev:	target device

   299  * @from:	source sector

   300  * @to:		target sector

   301  *

   302  * Description:

   303  *     Device mapper or raid target sometimes need to split a bio because

   304  *     it spans a stripe (or similar). Add a trace for that action.

   305  *

   306  **/

   307 static inline void blk_add_trace_remap(struct request_queue *q, struct bio *bio,

   308 				       dev_t dev, sector_t from, sector_t to)

   309 {

   310 	struct blk_trace *bt = q->blk_trace;

   311 	struct blk_io_trace_remap r;

   312 

   313 	if (likely(!bt))

   314 		return;

   315 

   316 	r.device = cpu_to_be32(dev);

   317 	r.device_from = cpu_to_be32(bio->bi_bdev->bd_dev);

   318 	r.sector = cpu_to_be64(to);

   319 

   320 	__blk_add_trace(bt, from, bio->bi_size, bio->bi_rw, BLK_TA_REMAP, !bio_flagged(bio, BIO_UPTODATE), sizeof(r), &r);

   321 }

   322 

   323 /**

   324  * blk_add_driver_data - Add binary message with driver-specific data

   325  * @q:		queue the io is for

   326  * @rq:		io request

   327  * @data:	driver-specific data

   328  * @len:	length of driver-specific data

   329  *

   330  * Description:

   331  *     Some drivers might want to write driver-specific data per request.

   332  *

   333  **/

   334 static inline void blk_add_driver_data(struct request_queue *q,

   335 				       struct request *rq,

   336 				       void *data, size_t len)

   337 {

   338 	struct blk_trace *bt = q->blk_trace;

   339 

   340 	if (likely(!bt))

   341 		return;

   342 

   343 	if (blk_pc_request(rq))

   344 		__blk_add_trace(bt, 0, rq->data_len, 0, BLK_TA_DRV_DATA,

   345 				rq->errors, len, data);

   346 	else

   347 		__blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9,

   348 				0, BLK_TA_DRV_DATA, rq->errors, len, data);

   349 }

   350 

   351 extern int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,

   352 			   char __user *arg);

   353 extern int blk_trace_startstop(struct request_queue *q, int start);

   354 extern int blk_trace_remove(struct request_queue *q);

   355 

   356 #else /* !CONFIG_BLK_DEV_IO_TRACE */

   357 #define blk_trace_ioctl(bdev, cmd, arg)		(-ENOTTY)

   358 #define blk_trace_shutdown(q)			do { } while (0)

   359 #define blk_add_trace_rq(q, rq, what)		do { } while (0)

   360 #define blk_add_trace_bio(q, rq, what)		do { } while (0)

   361 #define blk_add_trace_generic(q, rq, rw, what)	do { } while (0)

   362 #define blk_add_trace_pdu_int(q, what, bio, pdu)	do { } while (0)

   363 #define blk_add_trace_remap(q, bio, dev, f, t)	do {} while (0)

   364 #define blk_add_driver_data(q, rq, data, len)	do {} while (0)

   365 #define do_blk_trace_setup(q, name, dev, buts)	(-ENOTTY)

   366 #define blk_trace_setup(q, name, dev, arg)	(-ENOTTY)

   367 #define blk_trace_startstop(q, start)		(-ENOTTY)

   368 #define blk_trace_remove(q)			(-ENOTTY)

   369 #define blk_add_trace_msg(q, fmt, ...)		do { } while (0)

   370 

   371 #endif /* CONFIG_BLK_DEV_IO_TRACE */

   372 #endif /* __KERNEL__ */

   373 #endif