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