drivers/staging/lttng/instrumentation/events/lttng-module/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 #include <linux/trace_seq.h>
  11 #include <linux/version.h>
  12
  13 #define RWBS_LEN        8
  14
  15 #ifndef _TRACE_BLOCK_DEF_
  16 #define _TRACE_BLOCK_DEF_
  17
  18 #define __blk_dump_cmd(cmd, len)        "<unknown>"
  19
  20 enum {
  21         RWBS_FLAG_WRITE         = (1 << 0),
  22         RWBS_FLAG_DISCARD       = (1 << 1),
  23         RWBS_FLAG_READ          = (1 << 2),
  24         RWBS_FLAG_RAHEAD        = (1 << 3),
  25         RWBS_FLAG_BARRIER       = (1 << 4),
  26         RWBS_FLAG_SYNC          = (1 << 5),
  27         RWBS_FLAG_META          = (1 << 6),
  28         RWBS_FLAG_SECURE        = (1 << 7),
  29         RWBS_FLAG_FLUSH         = (1 << 8),
  30         RWBS_FLAG_FUA           = (1 << 9),
  31 };
  32
  33 #endif /* _TRACE_BLOCK_DEF_ */
  34
  35 #define __print_rwbs_flags(rwbs)                \
  36         __print_flags(rwbs, "",                 \
  37                 { RWBS_FLAG_FLUSH, "F" },       \
  38                 { RWBS_FLAG_WRITE, "W" },       \
  39                 { RWBS_FLAG_DISCARD, "D" },     \
  40                 { RWBS_FLAG_READ, "R" },        \
  41                 { RWBS_FLAG_FUA, "F" },         \
  42                 { RWBS_FLAG_RAHEAD, "A" },      \
  43                 { RWBS_FLAG_BARRIER, "B" },     \
  44                 { RWBS_FLAG_SYNC, "S" },        \
  45                 { RWBS_FLAG_META, "M" },        \
  46                 { RWBS_FLAG_SECURE, "E" })
  47
  48 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
  49
  50 #define blk_fill_rwbs(rwbs, rw, bytes)                                        \
  51                 tp_assign(rwbs, ((rw) & WRITE ? RWBS_FLAG_WRITE :             \
  52                         ( (rw) & REQ_DISCARD ? RWBS_FLAG_DISCARD :            \
  53                         ( (bytes) ? RWBS_FLAG_READ :                          \
  54                         ( 0 ))))                                              \
  55                         | ((rw) & REQ_RAHEAD ? RWBS_FLAG_RAHEAD : 0)          \
  56                         | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0)              \
  57                         | ((rw) & REQ_META ? RWBS_FLAG_META : 0)              \
  58                         | ((rw) & REQ_SECURE ? RWBS_FLAG_SECURE : 0)          \
  59                         | ((rw) & REQ_FLUSH ? RWBS_FLAG_FLUSH : 0)            \
  60                         | ((rw) & REQ_FUA ? RWBS_FLAG_FUA : 0))
  61
  62 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
  63
  64 #define blk_fill_rwbs(rwbs, rw, bytes)                                        \
  65                 tp_assign(rwbs, ((rw) & WRITE ? RWBS_FLAG_WRITE :             \
  66                         ( (rw) & REQ_DISCARD ? RWBS_FLAG_DISCARD :            \
  67                         ( (bytes) ? RWBS_FLAG_READ :                          \
  68                         ( 0 ))))                                              \
  69                         | ((rw) & REQ_RAHEAD ? RWBS_FLAG_RAHEAD : 0)          \
  70                         | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0)              \
  71                         | ((rw) & REQ_META ? RWBS_FLAG_META : 0)              \
  72                         | ((rw) & REQ_SECURE ? RWBS_FLAG_SECURE : 0))
  73
  74 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
  75
  76 #define blk_fill_rwbs(rwbs, rw, bytes)                                        \
  77                 tp_assign(rwbs, ((rw) & WRITE ? RWBS_FLAG_WRITE :             \
  78                         ( (rw) & REQ_DISCARD ? RWBS_FLAG_DISCARD :            \
  79                         ( (bytes) ? RWBS_FLAG_READ :                          \
  80                         ( 0 ))))                                              \
  81                         | ((rw) & REQ_RAHEAD ? RWBS_FLAG_RAHEAD : 0)          \
  82                         | ((rw) & REQ_HARDBARRIER ? RWBS_FLAG_BARRIER : 0)    \
  83                         | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0)              \
  84                         | ((rw) & REQ_META ? RWBS_FLAG_META : 0)              \
  85                         | ((rw) & REQ_SECURE ? RWBS_FLAG_SECURE : 0))
  86
  87 #else
  88
  89 #define blk_fill_rwbs(rwbs, rw, bytes)                                        \
  90                 tp_assign(rwbs, ((rw) & WRITE ? RWBS_FLAG_WRITE :             \
  91                         ( (rw) & (1 << BIO_RW_DISCARD) ? RWBS_FLAG_DISCARD :  \
  92                         ( (bytes) ? RWBS_FLAG_READ :                          \
  93                         ( 0 ))))                                              \
  94                         | ((rw) & (1 << BIO_RW_AHEAD) ? RWBS_FLAG_RAHEAD : 0) \
  95                         | ((rw) & (1 << BIO_RW_SYNCIO) ? RWBS_FLAG_SYNC : 0)  \
  96                         | ((rw) & (1 << BIO_RW_META) ? RWBS_FLAG_META : 0)    \
  97                         | ((rw) & (1 << BIO_RW_BARRIER) ? RWBS_FLAG_BARRIER : 0))
  98
  99 #endif
 100
 101 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
 102 DECLARE_EVENT_CLASS(block_buffer,
 103
 104         TP_PROTO(struct buffer_head *bh),
 105
 106         TP_ARGS(bh),
 107
 108         TP_STRUCT__entry (
 109                 __field(  dev_t,        dev                     )
 110                 __field(  sector_t,     sector                  )
 111                 __field(  size_t,       size                    )
 112         ),
 113
 114         TP_fast_assign(
 115                 tp_assign(dev, bh->b_bdev->bd_dev)
 116                 tp_assign(sector, bh->b_blocknr)
 117                 tp_assign(size, bh->b_size)
 118         ),
 119
 120         TP_printk("%d,%d sector=%llu size=%zu",
 121                 MAJOR(__entry->dev), MINOR(__entry->dev),
 122                 (unsigned long long)__entry->sector, __entry->size
 123         )
 124 )
 125
 126 /**
 127  * block_touch_buffer - mark a buffer accessed
 128  * @bh: buffer_head being touched
 129  *
 130  * Called from touch_buffer().
 131  */
 132 DEFINE_EVENT(block_buffer, block_touch_buffer,
 133
 134         TP_PROTO(struct buffer_head *bh),
 135
 136         TP_ARGS(bh)
 137 )
 138
 139 /**
 140  * block_dirty_buffer - mark a buffer dirty
 141  * @bh: buffer_head being dirtied
 142  *
 143  * Called from mark_buffer_dirty().
 144  */
 145 DEFINE_EVENT(block_buffer, block_dirty_buffer,
 146
 147         TP_PROTO(struct buffer_head *bh),
 148
 149         TP_ARGS(bh)
 150 )
 151 #endif
 152
 153 DECLARE_EVENT_CLASS(block_rq_with_error,
 154
 155         TP_PROTO(struct request_queue *q, struct request *rq),
 156
 157         TP_ARGS(q, rq),
 158
 159         TP_STRUCT__entry(
 160                 __field(  dev_t,        dev                     )
 161                 __field(  sector_t,     sector                  )
 162                 __field(  unsigned int, nr_sector               )
 163                 __field(  int,          errors                  )
 164                 __field(  unsigned int, rwbs                    )
 165                 __dynamic_array_hex( unsigned char,     cmd,
 166                         (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
 167                                 rq->cmd_len : 0)
 168         ),
 169
 170         TP_fast_assign(
 171                 tp_assign(dev, rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 172                 tp_assign(sector, (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
 173                                         0 : blk_rq_pos(rq))
 174                 tp_assign(nr_sector, (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
 175                                         0 : blk_rq_sectors(rq))
 176                 tp_assign(errors, rq->errors)
 177                 blk_fill_rwbs(rwbs, rq->cmd_flags, blk_rq_bytes(rq))
 178                 tp_memcpy_dyn(cmd, (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
 179                                         rq->cmd : NULL)
 180         ),
 181
 182         TP_printk("%d,%d %s (%s) %llu + %u [%d]",
 183                   MAJOR(__entry->dev), MINOR(__entry->dev),
 184                   __print_rwbs_flags(__entry->rwbs),
 185                   __blk_dump_cmd(__get_dynamic_array(cmd),
 186                                  __get_dynamic_array_len(cmd)),
 187                   (unsigned long long)__entry->sector,
 188                   __entry->nr_sector, __entry->errors)
 189 )
 190
 191 /**
 192  * block_rq_abort - abort block operation request
 193  * @q: queue containing the block operation request
 194  * @rq: block IO operation request
 195  *
 196  * Called immediately after pending block IO operation request @rq in
 197  * queue @q is aborted. The fields in the operation request @rq
 198  * can be examined to determine which device and sectors the pending
 199  * operation would access.
 200  */
 201 DEFINE_EVENT(block_rq_with_error, block_rq_abort,
 202
 203         TP_PROTO(struct request_queue *q, struct request *rq),
 204
 205         TP_ARGS(q, rq)
 206 )
 207
 208 /**
 209  * block_rq_requeue - place block IO request back on a queue
 210  * @q: queue holding operation
 211  * @rq: block IO operation request
 212  *
 213  * The block operation request @rq is being placed back into queue
 214  * @q.  For some reason the request was not completed and needs to be
 215  * put back in the queue.
 216  */
 217 DEFINE_EVENT(block_rq_with_error, block_rq_requeue,
 218
 219         TP_PROTO(struct request_queue *q, struct request *rq),
 220
 221         TP_ARGS(q, rq)
 222 )
 223
 224 /**
 225  * block_rq_complete - block IO operation completed by device driver
 226  * @q: queue containing the block operation request
 227  * @rq: block operations request
 228  *
 229  * The block_rq_complete tracepoint event indicates that some portion
 230  * of operation request has been completed by the device driver.  If
 231  * the @rq->bio is %NULL, then there is absolutely no additional work to
 232  * do for the request. If @rq->bio is non-NULL then there is
 233  * additional work required to complete the request.
 234  */
 235 DEFINE_EVENT(block_rq_with_error, block_rq_complete,
 236
 237         TP_PROTO(struct request_queue *q, struct request *rq),
 238
 239         TP_ARGS(q, rq)
 240 )
 241
 242 DECLARE_EVENT_CLASS(block_rq,
 243
 244         TP_PROTO(struct request_queue *q, struct request *rq),
 245
 246         TP_ARGS(q, rq),
 247
 248         TP_STRUCT__entry(
 249                 __field(  dev_t,        dev                     )
 250                 __field(  sector_t,     sector                  )
 251                 __field(  unsigned int, nr_sector               )
 252                 __field(  unsigned int, bytes                   )
 253                 __field(  unsigned int, rwbs                    )
 254                 __array_text(  char,         comm,   TASK_COMM_LEN   )
 255                 __dynamic_array_hex( unsigned char,     cmd,
 256                         (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
 257                                 rq->cmd_len : 0)
 258         ),
 259
 260         TP_fast_assign(
 261                 tp_assign(dev, rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 262                 tp_assign(sector, (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
 263                                         0 : blk_rq_pos(rq))
 264                 tp_assign(nr_sector, (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
 265                                         0 : blk_rq_sectors(rq))
 266                 tp_assign(bytes, (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
 267                                         blk_rq_bytes(rq) : 0)
 268                 blk_fill_rwbs(rwbs, rq->cmd_flags, blk_rq_bytes(rq))
 269                 tp_memcpy_dyn(cmd, (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
 270                                         rq->cmd : NULL)
 271                 tp_memcpy(comm, current->comm, TASK_COMM_LEN)
 272         ),
 273
 274         TP_printk("%d,%d %s %u (%s) %llu + %u [%s]",
 275                   MAJOR(__entry->dev), MINOR(__entry->dev),
 276                   __print_rwbs_flags(__entry->rwbs),
 277                   __entry->bytes,
 278                   __blk_dump_cmd(__get_dynamic_array(cmd),
 279                                  __get_dynamic_array_len(cmd)),
 280                   (unsigned long long)__entry->sector,
 281                   __entry->nr_sector, __entry->comm)
 282 )
 283
 284 /**
 285  * block_rq_insert - insert block operation request into queue
 286  * @q: target queue
 287  * @rq: block IO operation request
 288  *
 289  * Called immediately before block operation request @rq is inserted
 290  * into queue @q.  The fields in the operation request @rq struct can
 291  * be examined to determine which device and sectors the pending
 292  * operation would access.
 293  */
 294 DEFINE_EVENT(block_rq, block_rq_insert,
 295
 296         TP_PROTO(struct request_queue *q, struct request *rq),
 297
 298         TP_ARGS(q, rq)
 299 )
 300
 301 /**
 302  * block_rq_issue - issue pending block IO request operation to device driver
 303  * @q: queue holding operation
 304  * @rq: block IO operation operation request
 305  *
 306  * Called when block operation request @rq from queue @q is sent to a
 307  * device driver for processing.
 308  */
 309 DEFINE_EVENT(block_rq, block_rq_issue,
 310
 311         TP_PROTO(struct request_queue *q, struct request *rq),
 312
 313         TP_ARGS(q, rq)
 314 )
 315
 316 /**
 317  * block_bio_bounce - used bounce buffer when processing block operation
 318  * @q: queue holding the block operation
 319  * @bio: block operation
 320  *
 321  * A bounce buffer was used to handle the block operation @bio in @q.
 322  * This occurs when hardware limitations prevent a direct transfer of
 323  * data between the @bio data memory area and the IO device.  Use of a
 324  * bounce buffer requires extra copying of data and decreases
 325  * performance.
 326  */
 327 TRACE_EVENT(block_bio_bounce,
 328
 329         TP_PROTO(struct request_queue *q, struct bio *bio),
 330
 331         TP_ARGS(q, bio),
 332
 333         TP_STRUCT__entry(
 334                 __field( dev_t,         dev                     )
 335                 __field( sector_t,      sector                  )
 336                 __field( unsigned int,  nr_sector               )
 337                 __field( unsigned int,  rwbs                    )
 338                 __array_text( char,             comm,   TASK_COMM_LEN   )
 339         ),
 340
 341         TP_fast_assign(
 342                 tp_assign(dev, bio->bi_bdev ?
 343                                           bio->bi_bdev->bd_dev : 0)
 344                 tp_assign(sector, bio->bi_sector)
 345                 tp_assign(nr_sector, bio->bi_size >> 9)
 346                 blk_fill_rwbs(rwbs, bio->bi_rw, bio->bi_size)
 347                 tp_memcpy(comm, current->comm, TASK_COMM_LEN)
 348         ),
 349
 350         TP_printk("%d,%d %s %llu + %u [%s]",
 351                   MAJOR(__entry->dev), MINOR(__entry->dev),
 352                   __print_rwbs_flags(__entry->rwbs),
 353                   (unsigned long long)__entry->sector,
 354                   __entry->nr_sector, __entry->comm)
 355 )
 356
 357 /**
 358  * block_bio_complete - completed all work on the block operation
 359  * @q: queue holding the block operation
 360  * @bio: block operation completed
 361  * @error: io error value
 362  *
 363  * This tracepoint indicates there is no further work to do on this
 364  * block IO operation @bio.
 365  */
 366 TRACE_EVENT(block_bio_complete,
 367
 368 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
 369         TP_PROTO(struct request_queue *q, struct bio *bio, int error),
 370
 371         TP_ARGS(q, bio, error),
 372 #else
 373         TP_PROTO(struct request_queue *q, struct bio *bio),
 374
 375         TP_ARGS(q, bio),
 376 #endif
 377
 378         TP_STRUCT__entry(
 379                 __field( dev_t,         dev             )
 380                 __field( sector_t,      sector          )
 381                 __field( unsigned,      nr_sector       )
 382                 __field( int,           error           )
 383                 __field( unsigned int,  rwbs            )
 384         ),
 385
 386         TP_fast_assign(
 387                 tp_assign(dev, bio->bi_bdev->bd_dev)
 388                 tp_assign(sector, bio->bi_sector)
 389                 tp_assign(nr_sector, bio->bi_size >> 9)
 390 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
 391                 tp_assign(error, error)
 392 #else
 393                 tp_assign(error, 0)
 394 #endif
 395                 blk_fill_rwbs(rwbs, bio->bi_rw, bio->bi_size)
 396         ),
 397
 398         TP_printk("%d,%d %s %llu + %u [%d]",
 399                   MAJOR(__entry->dev), MINOR(__entry->dev),
 400                   __print_rwbs_flags(__entry->rwbs),
 401                   (unsigned long long)__entry->sector,
 402                   __entry->nr_sector, __entry->error)
 403 )
 404
 405 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
 406 DECLARE_EVENT_CLASS(block_bio_merge,
 407
 408         TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
 409
 410         TP_ARGS(q, rq, bio),
 411
 412         TP_STRUCT__entry(
 413                 __field( dev_t,         dev                     )
 414                 __field( sector_t,      sector                  )
 415                 __field( unsigned int,  nr_sector               )
 416                 __field( unsigned int,  rwbs                    )
 417                 __array_text( char,             comm,   TASK_COMM_LEN   )
 418         ),
 419
 420         TP_fast_assign(
 421                 tp_assign(dev, bio->bi_bdev->bd_dev)
 422                 tp_assign(sector, bio->bi_sector)
 423                 tp_assign(nr_sector, bio->bi_size >> 9)
 424                 blk_fill_rwbs(rwbs, bio->bi_rw, bio->bi_size)
 425                 tp_memcpy(comm, current->comm, TASK_COMM_LEN)
 426         ),
 427
 428         TP_printk("%d,%d %s %llu + %u [%s]",
 429                   MAJOR(__entry->dev), MINOR(__entry->dev),
 430                   __print_rwbs_flags(__entry->rwbs),
 431                   (unsigned long long)__entry->sector,
 432                   __entry->nr_sector, __entry->comm)
 433 )
 434
 435 /**
 436  * block_bio_backmerge - merging block operation to the end of an existing operation
 437  * @q: queue holding operation
 438  * @bio: new block operation to merge
 439  *
 440  * Merging block request @bio to the end of an existing block request
 441  * in queue @q.
 442  */
 443 DEFINE_EVENT(block_bio_merge, block_bio_backmerge,
 444
 445         TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
 446
 447         TP_ARGS(q, rq, bio)
 448 )
 449
 450 /**
 451  * block_bio_frontmerge - merging block operation to the beginning of an existing operation
 452  * @q: queue holding operation
 453  * @bio: new block operation to merge
 454  *
 455  * Merging block IO operation @bio to the beginning of an existing block
 456  * operation in queue @q.
 457  */
 458 DEFINE_EVENT(block_bio_merge, block_bio_frontmerge,
 459
 460         TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
 461
 462         TP_ARGS(q, rq, bio)
 463 )
 464
 465 /**
 466  * block_bio_queue - putting new block IO operation in queue
 467  * @q: queue holding operation
 468  * @bio: new block operation
 469  *
 470  * About to place the block IO operation @bio into queue @q.
 471  */
 472 TRACE_EVENT(block_bio_queue,
 473
 474         TP_PROTO(struct request_queue *q, struct bio *bio),
 475
 476         TP_ARGS(q, bio),
 477
 478         TP_STRUCT__entry(
 479                 __field( dev_t,         dev                     )
 480                 __field( sector_t,      sector                  )
 481                 __field( unsigned int,  nr_sector               )
 482                 __array( char,          rwbs,   RWBS_LEN        )
 483                 __array( char,          comm,   TASK_COMM_LEN   )
 484         ),
 485
 486         TP_fast_assign(
 487                 tp_assign(dev, bio->bi_bdev->bd_dev)
 488                 tp_assign(sector, bio->bi_sector)
 489                 tp_assign(nr_sector, bio->bi_size >> 9)
 490                 blk_fill_rwbs(rwbs, bio->bi_rw, bio->bi_size)
 491                 tp_memcpy(comm, current->comm, TASK_COMM_LEN)
 492         ),
 493
 494         TP_printk("%d,%d %s %llu + %u [%s]",
 495                   MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
 496                   (unsigned long long)__entry->sector,
 497                   __entry->nr_sector, __entry->comm)
 498 )
 499 #else
 500 DECLARE_EVENT_CLASS(block_bio,
 501
 502         TP_PROTO(struct request_queue *q, struct bio *bio),
 503
 504         TP_ARGS(q, bio),
 505
 506         TP_STRUCT__entry(
 507                 __field( dev_t,         dev                     )
 508                 __field( sector_t,      sector                  )
 509                 __field( unsigned int,  nr_sector               )
 510                 __field( unsigned int,  rwbs                    )
 511                 __array_text( char,             comm,   TASK_COMM_LEN   )
 512         ),
 513
 514         TP_fast_assign(
 515                 tp_assign(dev, bio->bi_bdev ? bio->bi_bdev->bd_dev : 0)
 516                 tp_assign(sector, bio->bi_sector)
 517                 tp_assign(nr_sector, bio->bi_size >> 9)
 518                 blk_fill_rwbs(rwbs, bio->bi_rw, bio->bi_size)
 519                 tp_memcpy(comm, current->comm, TASK_COMM_LEN)
 520         ),
 521
 522         TP_printk("%d,%d %s %llu + %u [%s]",
 523                   MAJOR(__entry->dev), MINOR(__entry->dev),
 524                   __print_rwbs_flags(__entry->rwbs),
 525                   (unsigned long long)__entry->sector,
 526                   __entry->nr_sector, __entry->comm)
 527 )
 528
 529 /**
 530  * block_bio_backmerge - merging block operation to the end of an existing operation
 531  * @q: queue holding operation
 532  * @bio: new block operation to merge
 533  *
 534  * Merging block request @bio to the end of an existing block request
 535  * in queue @q.
 536  */
 537 DEFINE_EVENT(block_bio, block_bio_backmerge,
 538
 539         TP_PROTO(struct request_queue *q, struct bio *bio),
 540
 541         TP_ARGS(q, bio)
 542 )
 543
 544 /**
 545  * block_bio_frontmerge - merging block operation to the beginning of an existing operation
 546  * @q: queue holding operation
 547  * @bio: new block operation to merge
 548  *
 549  * Merging block IO operation @bio to the beginning of an existing block
 550  * operation in queue @q.
 551  */
 552 DEFINE_EVENT(block_bio, block_bio_frontmerge,
 553
 554         TP_PROTO(struct request_queue *q, struct bio *bio),
 555
 556         TP_ARGS(q, bio)
 557 )
 558
 559 /**
 560  * block_bio_queue - putting new block IO operation in queue
 561  * @q: queue holding operation
 562  * @bio: new block operation
 563  *
 564  * About to place the block IO operation @bio into queue @q.
 565  */
 566 DEFINE_EVENT(block_bio, block_bio_queue,
 567
 568         TP_PROTO(struct request_queue *q, struct bio *bio),
 569
 570         TP_ARGS(q, bio)
 571 )
 572 #endif
 573
 574 DECLARE_EVENT_CLASS(block_get_rq,
 575
 576         TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
 577
 578         TP_ARGS(q, bio, rw),
 579
 580         TP_STRUCT__entry(
 581                 __field( dev_t,         dev                     )
 582                 __field( sector_t,      sector                  )
 583                 __field( unsigned int,  nr_sector               )
 584                 __field( unsigned int,  rwbs                    )
 585                 __array_text( char,             comm,   TASK_COMM_LEN   )
 586         ),
 587
 588         TP_fast_assign(
 589                 tp_assign(dev, bio ? bio->bi_bdev->bd_dev : 0)
 590                 tp_assign(sector, bio ? bio->bi_sector : 0)
 591                 tp_assign(nr_sector, bio ? bio->bi_size >> 9 : 0)
 592                 blk_fill_rwbs(rwbs, bio ? bio->bi_rw : 0,
 593                               bio ? bio->bi_size >> 9 : 0)
 594                 tp_memcpy(comm, current->comm, TASK_COMM_LEN)
 595         ),
 596
 597         TP_printk("%d,%d %s %llu + %u [%s]",
 598                   MAJOR(__entry->dev), MINOR(__entry->dev),
 599                   __print_rwbs_flags(__entry->rwbs),
 600                   (unsigned long long)__entry->sector,
 601                   __entry->nr_sector, __entry->comm)
 602 )
 603
 604 /**
 605  * block_getrq - get a free request entry in queue for block IO operations
 606  * @q: queue for operations
 607  * @bio: pending block IO operation
 608  * @rw: low bit indicates a read (%0) or a write (%1)
 609  *
 610  * A request struct for queue @q has been allocated to handle the
 611  * block IO operation @bio.
 612  */
 613 DEFINE_EVENT(block_get_rq, block_getrq,
 614
 615         TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
 616
 617         TP_ARGS(q, bio, rw)
 618 )
 619
 620 /**
 621  * block_sleeprq - waiting to get a free request entry in queue for block IO operation
 622  * @q: queue for operation
 623  * @bio: pending block IO operation
 624  * @rw: low bit indicates a read (%0) or a write (%1)
 625  *
 626  * In the case where a request struct cannot be provided for queue @q
 627  * the process needs to wait for an request struct to become
 628  * available.  This tracepoint event is generated each time the
 629  * process goes to sleep waiting for request struct become available.
 630  */
 631 DEFINE_EVENT(block_get_rq, block_sleeprq,
 632
 633         TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
 634
 635         TP_ARGS(q, bio, rw)
 636 )
 637
 638 /**
 639  * block_plug - keep operations requests in request queue
 640  * @q: request queue to plug
 641  *
 642  * Plug the request queue @q.  Do not allow block operation requests
 643  * to be sent to the device driver. Instead, accumulate requests in
 644  * the queue to improve throughput performance of the block device.
 645  */
 646 TRACE_EVENT(block_plug,
 647
 648         TP_PROTO(struct request_queue *q),
 649
 650         TP_ARGS(q),
 651
 652         TP_STRUCT__entry(
 653                 __array_text( char,             comm,   TASK_COMM_LEN   )
 654         ),
 655
 656         TP_fast_assign(
 657                 tp_memcpy(comm, current->comm, TASK_COMM_LEN)
 658         ),
 659
 660         TP_printk("[%s]", __entry->comm)
 661 )
 662
 663 DECLARE_EVENT_CLASS(block_unplug,
 664
 665 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 666         TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),
 667
 668         TP_ARGS(q, depth, explicit),
 669 #else
 670         TP_PROTO(struct request_queue *q),
 671
 672         TP_ARGS(q),
 673 #endif
 674
 675         TP_STRUCT__entry(
 676                 __field( int,           nr_rq                   )
 677                 __array_text( char,             comm,   TASK_COMM_LEN   )
 678         ),
 679
 680         TP_fast_assign(
 681 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 682                 tp_assign(nr_rq, depth)
 683 #else
 684                 tp_assign(nr_rq, q->rq.count[READ] + q->rq.count[WRITE])
 685 #endif
 686                 tp_memcpy(comm, current->comm, TASK_COMM_LEN)
 687         ),
 688
 689         TP_printk("[%s] %d", __entry->comm, __entry->nr_rq)
 690 )
 691
 692 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
 693 /**
 694  * block_unplug_timer - timed release of operations requests in queue to device driver
 695  * @q: request queue to unplug
 696  *
 697  * Unplug the request queue @q because a timer expired and allow block
 698  * operation requests to be sent to the device driver.
 699  */
 700 DEFINE_EVENT(block_unplug, block_unplug_timer,
 701
 702         TP_PROTO(struct request_queue *q),
 703
 704         TP_ARGS(q)
 705 )
 706 #endif
 707
 708 /**
 709  * block_unplug - release of operations requests in request queue
 710  * @q: request queue to unplug
 711  * @depth: number of requests just added to the queue
 712  * @explicit: whether this was an explicit unplug, or one from schedule()
 713  *
 714  * Unplug request queue @q because device driver is scheduled to work
 715  * on elements in the request queue.
 716  */
 717 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 718 DEFINE_EVENT(block_unplug, block_unplug,
 719 #else
 720 DEFINE_EVENT(block_unplug, block_unplug_io,
 721 #endif
 722
 723 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 724         TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),
 725
 726         TP_ARGS(q, depth, explicit)
 727 #else
 728         TP_PROTO(struct request_queue *q),
 729
 730         TP_ARGS(q)
 731 #endif
 732 )
 733
 734 /**
 735  * block_split - split a single bio struct into two bio structs
 736  * @q: queue containing the bio
 737  * @bio: block operation being split
 738  * @new_sector: The starting sector for the new bio
 739  *
 740  * The bio request @bio in request queue @q needs to be split into two
 741  * bio requests. The newly created @bio request starts at
 742  * @new_sector. This split may be required due to hardware limitation
 743  * such as operation crossing device boundaries in a RAID system.
 744  */
 745 TRACE_EVENT(block_split,
 746
 747         TP_PROTO(struct request_queue *q, struct bio *bio,
 748                  unsigned int new_sector),
 749
 750         TP_ARGS(q, bio, new_sector),
 751
 752         TP_STRUCT__entry(
 753                 __field( dev_t,         dev                             )
 754                 __field( sector_t,      sector                          )
 755                 __field( sector_t,      new_sector                      )
 756                 __field( unsigned int,  rwbs            )
 757                 __array_text( char,             comm,           TASK_COMM_LEN   )
 758         ),
 759
 760         TP_fast_assign(
 761                 tp_assign(dev, bio->bi_bdev->bd_dev)
 762                 tp_assign(sector, bio->bi_sector)
 763                 tp_assign(new_sector, new_sector)
 764                 blk_fill_rwbs(rwbs, bio->bi_rw, bio->bi_size)
 765                 tp_memcpy(comm, current->comm, TASK_COMM_LEN)
 766         ),
 767
 768         TP_printk("%d,%d %s %llu / %llu [%s]",
 769                   MAJOR(__entry->dev), MINOR(__entry->dev),
 770                   __print_rwbs_flags(__entry->rwbs),
 771                   (unsigned long long)__entry->sector,
 772                   (unsigned long long)__entry->new_sector,
 773                   __entry->comm)
 774 )
 775
 776 /**
 777  * block_bio_remap - map request for a logical device to the raw device
 778  * @q: queue holding the operation
 779  * @bio: revised operation
 780  * @dev: device for the operation
 781  * @from: original sector for the operation
 782  *
 783  * An operation for a logical device has been mapped to the
 784  * raw block device.
 785  */
 786 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
 787 TRACE_EVENT(block_bio_remap,
 788 #else
 789 TRACE_EVENT(block_remap,
 790 #endif
 791
 792         TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
 793                  sector_t from),
 794
 795         TP_ARGS(q, bio, dev, from),
 796
 797         TP_STRUCT__entry(
 798                 __field( dev_t,         dev             )
 799                 __field( sector_t,      sector          )
 800                 __field( unsigned int,  nr_sector       )
 801                 __field( dev_t,         old_dev         )
 802                 __field( sector_t,      old_sector      )
 803                 __field( unsigned int,  rwbs            )
 804         ),
 805
 806         TP_fast_assign(
 807                 tp_assign(dev, bio->bi_bdev->bd_dev)
 808                 tp_assign(sector, bio->bi_sector)
 809                 tp_assign(nr_sector, bio->bi_size >> 9)
 810                 tp_assign(old_dev, dev)
 811                 tp_assign(old_sector, from)
 812                 blk_fill_rwbs(rwbs, bio->bi_rw, bio->bi_size)
 813         ),
 814
 815         TP_printk("%d,%d %s %llu + %u <- (%d,%d) %llu",
 816                   MAJOR(__entry->dev), MINOR(__entry->dev),
 817                   __print_rwbs_flags(__entry->rwbs),
 818                   (unsigned long long)__entry->sector,
 819                   __entry->nr_sector,
 820                   MAJOR(__entry->old_dev), MINOR(__entry->old_dev),
 821                   (unsigned long long)__entry->old_sector)
 822 )
 823
 824 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32))
 825 /**
 826  * block_rq_remap - map request for a block operation request
 827  * @q: queue holding the operation
 828  * @rq: block IO operation request
 829  * @dev: device for the operation
 830  * @from: original sector for the operation
 831  *
 832  * The block operation request @rq in @q has been remapped.  The block
 833  * operation request @rq holds the current information and @from hold
 834  * the original sector.
 835  */
 836 TRACE_EVENT(block_rq_remap,
 837
 838         TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev,
 839                  sector_t from),
 840
 841         TP_ARGS(q, rq, dev, from),
 842
 843         TP_STRUCT__entry(
 844                 __field( dev_t,         dev             )
 845                 __field( sector_t,      sector          )
 846                 __field( unsigned int,  nr_sector       )
 847                 __field( dev_t,         old_dev         )
 848                 __field( sector_t,      old_sector      )
 849                 __field( unsigned int,  rwbs            )
 850         ),
 851
 852         TP_fast_assign(
 853                 tp_assign(dev, disk_devt(rq->rq_disk))
 854                 tp_assign(sector, blk_rq_pos(rq))
 855                 tp_assign(nr_sector, blk_rq_sectors(rq))
 856                 tp_assign(old_dev, dev)
 857                 tp_assign(old_sector, from)
 858                 blk_fill_rwbs(rwbs, rq->cmd_flags, blk_rq_bytes(rq))
 859         ),
 860
 861         TP_printk("%d,%d %s %llu + %u <- (%d,%d) %llu",
 862                   MAJOR(__entry->dev), MINOR(__entry->dev),
 863                   __print_rwbs_flags(__entry->rwbs),
 864                   (unsigned long long)__entry->sector,
 865                   __entry->nr_sector,
 866                   MAJOR(__entry->old_dev), MINOR(__entry->old_dev),
 867                   (unsigned long long)__entry->old_sector)
 868 )
 869 #endif
 870
 871 #undef __print_rwbs_flags
 872 #undef blk_fill_rwbs
 873
 874 #endif /* _TRACE_BLOCK_H */
 875
 876 /* This part must be outside protection */
 877 #include "../../../probes/define_trace.h"
 878