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 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 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_bio_complete - completed all work on the block operation
250  * @q: queue holding the block operation
251  * @bio: block operation completed
252  *
253  * This tracepoint indicates there is no further work to do on this
254  * block IO operation @bio.
255  */
256 TRACE_EVENT(block_bio_complete,
257 
258 	TP_PROTO(struct request_queue *q, struct bio *bio),
259 
260 	TP_ARGS(q, bio),
261 
262 	TP_STRUCT__entry(
263 		__field( dev_t,		dev		)
264 		__field( sector_t,	sector		)
265 		__field( unsigned,	nr_sector	)
266 		__field( int,		error		)
267 		__array( char,		rwbs,	RWBS_LEN)
268 	),
269 
270 	TP_fast_assign(
271 		__entry->dev		= bio_dev(bio);
272 		__entry->sector		= bio->bi_iter.bi_sector;
273 		__entry->nr_sector	= bio_sectors(bio);
274 		__entry->error		= blk_status_to_errno(bio->bi_status);
275 		blk_fill_rwbs(__entry->rwbs, bio->bi_opf);
276 	),
277 
278 	TP_printk("%d,%d %s %llu + %u [%d]",
279 		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
280 		  (unsigned long long)__entry->sector,
281 		  __entry->nr_sector, __entry->error)
282 );
283 
284 DECLARE_EVENT_CLASS(block_bio,
285 
286 	TP_PROTO(struct bio *bio),
287 
288 	TP_ARGS(bio),
289 
290 	TP_STRUCT__entry(
291 		__field( dev_t,		dev			)
292 		__field( sector_t,	sector			)
293 		__field( unsigned int,	nr_sector		)
294 		__array( char,		rwbs,	RWBS_LEN	)
295 		__array( char,		comm,	TASK_COMM_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 		blk_fill_rwbs(__entry->rwbs, bio->bi_opf);
303 		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
304 	),
305 
306 	TP_printk("%d,%d %s %llu + %u [%s]",
307 		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
308 		  (unsigned long long)__entry->sector,
309 		  __entry->nr_sector, __entry->comm)
310 );
311 
312 /**
313  * block_bio_bounce - used bounce buffer when processing block operation
314  * @bio: block operation
315  *
316  * A bounce buffer was used to handle the block operation @bio in @q.
317  * This occurs when hardware limitations prevent a direct transfer of
318  * data between the @bio data memory area and the IO device.  Use of a
319  * bounce buffer requires extra copying of data and decreases
320  * performance.
321  */
322 DEFINE_EVENT(block_bio, block_bio_bounce,
323 	TP_PROTO(struct bio *bio),
324 	TP_ARGS(bio)
325 );
326 
327 /**
328  * block_bio_backmerge - merging block operation to the end of an existing operation
329  * @bio: new block operation to merge
330  *
331  * Merging block request @bio to the end of an existing block request.
332  */
333 DEFINE_EVENT(block_bio, block_bio_backmerge,
334 	TP_PROTO(struct bio *bio),
335 	TP_ARGS(bio)
336 );
337 
338 /**
339  * block_bio_frontmerge - merging block operation to the beginning of an existing operation
340  * @bio: new block operation to merge
341  *
342  * Merging block IO operation @bio to the beginning of an existing block request.
343  */
344 DEFINE_EVENT(block_bio, block_bio_frontmerge,
345 	TP_PROTO(struct bio *bio),
346 	TP_ARGS(bio)
347 );
348 
349 /**
350  * block_bio_queue - putting new block IO operation in queue
351  * @bio: new block operation
352  *
353  * About to place the block IO operation @bio into queue @q.
354  */
355 DEFINE_EVENT(block_bio, block_bio_queue,
356 	TP_PROTO(struct bio *bio),
357 	TP_ARGS(bio)
358 );
359 
360 /**
361  * block_getrq - get a free request entry in queue for block IO operations
362  * @bio: pending block IO operation (can be %NULL)
363  *
364  * A request struct has been allocated to handle the block IO operation @bio.
365  */
366 DEFINE_EVENT(block_bio, block_getrq,
367 	TP_PROTO(struct bio *bio),
368 	TP_ARGS(bio)
369 );
370 
371 /**
372  * block_plug - keep operations requests in request queue
373  * @q: request queue to plug
374  *
375  * Plug the request queue @q.  Do not allow block operation requests
376  * to be sent to the device driver. Instead, accumulate requests in
377  * the queue to improve throughput performance of the block device.
378  */
379 TRACE_EVENT(block_plug,
380 
381 	TP_PROTO(struct request_queue *q),
382 
383 	TP_ARGS(q),
384 
385 	TP_STRUCT__entry(
386 		__array( char,		comm,	TASK_COMM_LEN	)
387 	),
388 
389 	TP_fast_assign(
390 		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
391 	),
392 
393 	TP_printk("[%s]", __entry->comm)
394 );
395 
396 DECLARE_EVENT_CLASS(block_unplug,
397 
398 	TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),
399 
400 	TP_ARGS(q, depth, explicit),
401 
402 	TP_STRUCT__entry(
403 		__field( int,		nr_rq			)
404 		__array( char,		comm,	TASK_COMM_LEN	)
405 	),
406 
407 	TP_fast_assign(
408 		__entry->nr_rq = depth;
409 		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
410 	),
411 
412 	TP_printk("[%s] %d", __entry->comm, __entry->nr_rq)
413 );
414 
415 /**
416  * block_unplug - release of operations requests in request queue
417  * @q: request queue to unplug
418  * @depth: number of requests just added to the queue
419  * @explicit: whether this was an explicit unplug, or one from schedule()
420  *
421  * Unplug request queue @q because device driver is scheduled to work
422  * on elements in the request queue.
423  */
424 DEFINE_EVENT(block_unplug, block_unplug,
425 
426 	TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),
427 
428 	TP_ARGS(q, depth, explicit)
429 );
430 
431 /**
432  * block_split - split a single bio struct into two bio structs
433  * @bio: block operation being split
434  * @new_sector: The starting sector for the new bio
435  *
436  * The bio request @bio needs to be split into two bio requests.  The newly
437  * created @bio request starts at @new_sector. This split may be required due to
438  * hardware limitations such as operation crossing device boundaries in a RAID
439  * system.
440  */
441 TRACE_EVENT(block_split,
442 
443 	TP_PROTO(struct bio *bio, unsigned int new_sector),
444 
445 	TP_ARGS(bio, new_sector),
446 
447 	TP_STRUCT__entry(
448 		__field( dev_t,		dev				)
449 		__field( sector_t,	sector				)
450 		__field( sector_t,	new_sector			)
451 		__array( char,		rwbs,		RWBS_LEN	)
452 		__array( char,		comm,		TASK_COMM_LEN	)
453 	),
454 
455 	TP_fast_assign(
456 		__entry->dev		= bio_dev(bio);
457 		__entry->sector		= bio->bi_iter.bi_sector;
458 		__entry->new_sector	= new_sector;
459 		blk_fill_rwbs(__entry->rwbs, bio->bi_opf);
460 		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
461 	),
462 
463 	TP_printk("%d,%d %s %llu / %llu [%s]",
464 		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
465 		  (unsigned long long)__entry->sector,
466 		  (unsigned long long)__entry->new_sector,
467 		  __entry->comm)
468 );
469 
470 /**
471  * block_bio_remap - map request for a logical device to the raw device
472  * @bio: revised operation
473  * @dev: original device for the operation
474  * @from: original sector for the operation
475  *
476  * An operation for a logical device has been mapped to the
477  * raw block device.
478  */
479 TRACE_EVENT(block_bio_remap,
480 
481 	TP_PROTO(struct bio *bio, dev_t dev, sector_t from),
482 
483 	TP_ARGS(bio, dev, from),
484 
485 	TP_STRUCT__entry(
486 		__field( dev_t,		dev		)
487 		__field( sector_t,	sector		)
488 		__field( unsigned int,	nr_sector	)
489 		__field( dev_t,		old_dev		)
490 		__field( sector_t,	old_sector	)
491 		__array( char,		rwbs,	RWBS_LEN)
492 	),
493 
494 	TP_fast_assign(
495 		__entry->dev		= bio_dev(bio);
496 		__entry->sector		= bio->bi_iter.bi_sector;
497 		__entry->nr_sector	= bio_sectors(bio);
498 		__entry->old_dev	= dev;
499 		__entry->old_sector	= from;
500 		blk_fill_rwbs(__entry->rwbs, bio->bi_opf);
501 	),
502 
503 	TP_printk("%d,%d %s %llu + %u <- (%d,%d) %llu",
504 		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
505 		  (unsigned long long)__entry->sector,
506 		  __entry->nr_sector,
507 		  MAJOR(__entry->old_dev), MINOR(__entry->old_dev),
508 		  (unsigned long long)__entry->old_sector)
509 );
510 
511 /**
512  * block_rq_remap - map request for a block operation request
513  * @rq: block IO operation request
514  * @dev: device for the operation
515  * @from: original sector for the operation
516  *
517  * The block operation request @rq in @q has been remapped.  The block
518  * operation request @rq holds the current information and @from hold
519  * the original sector.
520  */
521 TRACE_EVENT(block_rq_remap,
522 
523 	TP_PROTO(struct request *rq, dev_t dev, sector_t from),
524 
525 	TP_ARGS(rq, dev, from),
526 
527 	TP_STRUCT__entry(
528 		__field( dev_t,		dev		)
529 		__field( sector_t,	sector		)
530 		__field( unsigned int,	nr_sector	)
531 		__field( dev_t,		old_dev		)
532 		__field( sector_t,	old_sector	)
533 		__field( unsigned int,	nr_bios		)
534 		__array( char,		rwbs,	RWBS_LEN)
535 	),
536 
537 	TP_fast_assign(
538 		__entry->dev		= disk_devt(rq->q->disk);
539 		__entry->sector		= blk_rq_pos(rq);
540 		__entry->nr_sector	= blk_rq_sectors(rq);
541 		__entry->old_dev	= dev;
542 		__entry->old_sector	= from;
543 		__entry->nr_bios	= blk_rq_count_bios(rq);
544 		blk_fill_rwbs(__entry->rwbs, rq->cmd_flags);
545 	),
546 
547 	TP_printk("%d,%d %s %llu + %u <- (%d,%d) %llu %u",
548 		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
549 		  (unsigned long long)__entry->sector,
550 		  __entry->nr_sector,
551 		  MAJOR(__entry->old_dev), MINOR(__entry->old_dev),
552 		  (unsigned long long)__entry->old_sector, __entry->nr_bios)
553 );
554 
555 #endif /* _TRACE_BLOCK_H */
556 
557 /* This part must be outside protection */
558 #include <trace/define_trace.h>
559 
560