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 588