include/trace/events/block.h

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