include/trace/events/block.h

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