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