← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to include/trace/events/block.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

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