611 lines · c
1/* SPDX-License-Identifier: GPL-2.0 */2#undef TRACE_SYSTEM3#define TRACE_SYSTEM block4 5#if !defined(_TRACE_BLOCK_H) || defined(TRACE_HEADER_MULTI_READ)6#define _TRACE_BLOCK_H7 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 815 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_HEAD24DECLARE_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->size45 )46);47 48/**49 * block_touch_buffer - mark a buffer accessed50 * @bh: buffer_head being touched51 *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 dirty63 * @bh: buffer_head being dirtied64 *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 queue77 * @rq: block IO operation request78 *79 * The block operation request @rq is being placed back into queue80 * @q. For some reason the request was not completed and needs to be81 * 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 = rq->ioprio;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 = rq->ioprio;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 driver157 * @rq: block operations request158 * @error: status code159 * @nr_bytes: number of completed bytes160 *161 * The block_rq_complete tracepoint event indicates that some portion162 * of operation request has been completed by the device driver. If163 * the @rq->bio is %NULL, then there is absolutely no additional work to164 * do for the request. If @rq->bio is non-NULL then there is165 * 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 driver176 * @rq: block operations request177 * @error: status code178 * @nr_bytes: number of completed bytes179 *180 * The block_rq_error tracepoint event indicates that some portion181 * 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 = rq->ioprio;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 queue231 * @rq: block IO operation request232 *233 * Called immediately before block operation request @rq is inserted234 * into queue @q. The fields in the operation request @rq struct can235 * be examined to determine which device and sectors the pending236 * 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 driver247 * @rq: block IO operation request248 *249 * Called when block operation request @rq from queue @q is sent to a250 * 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 elevator261 * @rq: block IO operation request262 *263 * Called when block operation request @rq from queue @q is merged to another264 * 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 execution275 * @rq: block IO operation request276 *277 * Called when block operation request @rq is queued for execution278 */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 completed288 * @rq: block IO operation request289 *290 * Called when block operation request @rq is completed291 */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 operation301 * @q: queue holding the block operation302 * @bio: block operation completed303 *304 * This tracepoint indicates there is no further work to do on this305 * 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_bounce - used bounce buffer when processing block operation365 * @bio: block operation366 *367 * A bounce buffer was used to handle the block operation @bio in @q.368 * This occurs when hardware limitations prevent a direct transfer of369 * data between the @bio data memory area and the IO device. Use of a370 * bounce buffer requires extra copying of data and decreases371 * performance.372 */373DEFINE_EVENT(block_bio, block_bio_bounce,374 TP_PROTO(struct bio *bio),375 TP_ARGS(bio)376);377 378/**379 * block_bio_backmerge - merging block operation to the end of an existing operation380 * @bio: new block operation to merge381 *382 * Merging block request @bio to the end of an existing block request.383 */384DEFINE_EVENT(block_bio, block_bio_backmerge,385 TP_PROTO(struct bio *bio),386 TP_ARGS(bio)387);388 389/**390 * block_bio_frontmerge - merging block operation to the beginning of an existing operation391 * @bio: new block operation to merge392 *393 * Merging block IO operation @bio to the beginning of an existing block request.394 */395DEFINE_EVENT(block_bio, block_bio_frontmerge,396 TP_PROTO(struct bio *bio),397 TP_ARGS(bio)398);399 400/**401 * block_bio_queue - putting new block IO operation in queue402 * @bio: new block operation403 *404 * About to place the block IO operation @bio into queue @q.405 */406DEFINE_EVENT(block_bio, block_bio_queue,407 TP_PROTO(struct bio *bio),408 TP_ARGS(bio)409);410 411/**412 * block_getrq - get a free request entry in queue for block IO operations413 * @bio: pending block IO operation (can be %NULL)414 *415 * A request struct has been allocated to handle the block IO operation @bio.416 */417DEFINE_EVENT(block_bio, block_getrq,418 TP_PROTO(struct bio *bio),419 TP_ARGS(bio)420);421 422/**423 * block_plug - keep operations requests in request queue424 * @q: request queue to plug425 *426 * Plug the request queue @q. Do not allow block operation requests427 * to be sent to the device driver. Instead, accumulate requests in428 * the queue to improve throughput performance of the block device.429 */430TRACE_EVENT(block_plug,431 432 TP_PROTO(struct request_queue *q),433 434 TP_ARGS(q),435 436 TP_STRUCT__entry(437 __array( char, comm, TASK_COMM_LEN )438 ),439 440 TP_fast_assign(441 memcpy(__entry->comm, current->comm, TASK_COMM_LEN);442 ),443 444 TP_printk("[%s]", __entry->comm)445);446 447DECLARE_EVENT_CLASS(block_unplug,448 449 TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),450 451 TP_ARGS(q, depth, explicit),452 453 TP_STRUCT__entry(454 __field( int, nr_rq )455 __array( char, comm, TASK_COMM_LEN )456 ),457 458 TP_fast_assign(459 __entry->nr_rq = depth;460 memcpy(__entry->comm, current->comm, TASK_COMM_LEN);461 ),462 463 TP_printk("[%s] %d", __entry->comm, __entry->nr_rq)464);465 466/**467 * block_unplug - release of operations requests in request queue468 * @q: request queue to unplug469 * @depth: number of requests just added to the queue470 * @explicit: whether this was an explicit unplug, or one from schedule()471 *472 * Unplug request queue @q because device driver is scheduled to work473 * on elements in the request queue.474 */475DEFINE_EVENT(block_unplug, block_unplug,476 477 TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),478 479 TP_ARGS(q, depth, explicit)480);481 482/**483 * block_split - split a single bio struct into two bio structs484 * @bio: block operation being split485 * @new_sector: The starting sector for the new bio486 *487 * The bio request @bio needs to be split into two bio requests. The newly488 * created @bio request starts at @new_sector. This split may be required due to489 * hardware limitations such as operation crossing device boundaries in a RAID490 * system.491 */492TRACE_EVENT(block_split,493 494 TP_PROTO(struct bio *bio, unsigned int new_sector),495 496 TP_ARGS(bio, new_sector),497 498 TP_STRUCT__entry(499 __field( dev_t, dev )500 __field( sector_t, sector )501 __field( sector_t, new_sector )502 __array( char, rwbs, RWBS_LEN )503 __array( char, comm, TASK_COMM_LEN )504 ),505 506 TP_fast_assign(507 __entry->dev = bio_dev(bio);508 __entry->sector = bio->bi_iter.bi_sector;509 __entry->new_sector = new_sector;510 blk_fill_rwbs(__entry->rwbs, bio->bi_opf);511 memcpy(__entry->comm, current->comm, TASK_COMM_LEN);512 ),513 514 TP_printk("%d,%d %s %llu / %llu [%s]",515 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,516 (unsigned long long)__entry->sector,517 (unsigned long long)__entry->new_sector,518 __entry->comm)519);520 521/**522 * block_bio_remap - map request for a logical device to the raw device523 * @bio: revised operation524 * @dev: original device for the operation525 * @from: original sector for the operation526 *527 * An operation for a logical device has been mapped to the528 * raw block device.529 */530TRACE_EVENT(block_bio_remap,531 532 TP_PROTO(struct bio *bio, dev_t dev, sector_t from),533 534 TP_ARGS(bio, dev, from),535 536 TP_STRUCT__entry(537 __field( dev_t, dev )538 __field( sector_t, sector )539 __field( unsigned int, nr_sector )540 __field( dev_t, old_dev )541 __field( sector_t, old_sector )542 __array( char, rwbs, RWBS_LEN)543 ),544 545 TP_fast_assign(546 __entry->dev = bio_dev(bio);547 __entry->sector = bio->bi_iter.bi_sector;548 __entry->nr_sector = bio_sectors(bio);549 __entry->old_dev = dev;550 __entry->old_sector = from;551 blk_fill_rwbs(__entry->rwbs, bio->bi_opf);552 ),553 554 TP_printk("%d,%d %s %llu + %u <- (%d,%d) %llu",555 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,556 (unsigned long long)__entry->sector,557 __entry->nr_sector,558 MAJOR(__entry->old_dev), MINOR(__entry->old_dev),559 (unsigned long long)__entry->old_sector)560);561 562/**563 * block_rq_remap - map request for a block operation request564 * @rq: block IO operation request565 * @dev: device for the operation566 * @from: original sector for the operation567 *568 * The block operation request @rq in @q has been remapped. The block569 * operation request @rq holds the current information and @from hold570 * the original sector.571 */572TRACE_EVENT(block_rq_remap,573 574 TP_PROTO(struct request *rq, dev_t dev, sector_t from),575 576 TP_ARGS(rq, dev, from),577 578 TP_STRUCT__entry(579 __field( dev_t, dev )580 __field( sector_t, sector )581 __field( unsigned int, nr_sector )582 __field( dev_t, old_dev )583 __field( sector_t, old_sector )584 __field( unsigned int, nr_bios )585 __array( char, rwbs, RWBS_LEN)586 ),587 588 TP_fast_assign(589 __entry->dev = disk_devt(rq->q->disk);590 __entry->sector = blk_rq_pos(rq);591 __entry->nr_sector = blk_rq_sectors(rq);592 __entry->old_dev = dev;593 __entry->old_sector = from;594 __entry->nr_bios = blk_rq_count_bios(rq);595 blk_fill_rwbs(__entry->rwbs, rq->cmd_flags);596 ),597 598 TP_printk("%d,%d %s %llu + %u <- (%d,%d) %llu %u",599 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,600 (unsigned long long)__entry->sector,601 __entry->nr_sector,602 MAJOR(__entry->old_dev), MINOR(__entry->old_dev),603 (unsigned long long)__entry->old_sector, __entry->nr_bios)604);605 606#endif /* _TRACE_BLOCK_H */607 608/* This part must be outside protection */609#include <trace/define_trace.h>610 611