instrumentation/events/lttng-module/block.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM block
   4
   5 #if !defined(LTTNG_TRACE_BLOCK_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define LTTNG_TRACE_BLOCK_H
   7
   8 #include <probes/lttng-tracepoint-event.h>
   9 #include <linux/blktrace_api.h>
  10 #include <linux/blkdev.h>
  11 #include <linux/trace_seq.h>
  12 #include <linux/version.h>
  13
  14 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0))
  15 #include <scsi/scsi_request.h>
  16 #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */
  17
  18 #ifndef _TRACE_BLOCK_DEF_
  19 #define _TRACE_BLOCK_DEF_
  20
  21 enum {
  22         RWBS_FLAG_WRITE         = (1 << 0),
  23         RWBS_FLAG_DISCARD       = (1 << 1),
  24         RWBS_FLAG_READ          = (1 << 2),
  25         RWBS_FLAG_RAHEAD        = (1 << 3),
  26         RWBS_FLAG_BARRIER       = (1 << 4),
  27         RWBS_FLAG_SYNC          = (1 << 5),
  28         RWBS_FLAG_META          = (1 << 6),
  29         RWBS_FLAG_SECURE        = (1 << 7),
  30         RWBS_FLAG_FLUSH         = (1 << 8),
  31         RWBS_FLAG_FUA           = (1 << 9),
  32         RWBS_FLAG_PREFLUSH      = (1 << 10),
  33 };
  34
  35 #endif /* _TRACE_BLOCK_DEF_ */
  36
  37 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0) || \
  38         LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
  39         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
  40         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
  41         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,4,103,7,0,0) || \
  42         LTTNG_SLE_KERNEL_RANGE(4,4,114,94,0,0, 4,4,114,95,0,0) || \
  43         LTTNG_SLE_KERNEL_RANGE(4,4,120,94,0,0, 4,4,120,95,0,0) || \
  44         LTTNG_SLE_KERNEL_RANGE(4,4,126,94,0,0, 4,5,0,0,0,0))
  45
  46 #define lttng_req_op(rq)        req_op(rq)
  47 #define lttng_req_rw(rq)        ((rq)->cmd_flags)
  48 #define lttng_bio_op(bio)       bio_op(bio)
  49 #define lttng_bio_rw(bio)       ((bio)->bi_opf)
  50
  51 #define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes)                       \
  52                 ctf_integer(type, rwbs,                                       \
  53                         (((op) == REQ_OP_WRITE || (op) == REQ_OP_WRITE_SAME) ? RWBS_FLAG_WRITE : \
  54                         ( (op) == REQ_OP_DISCARD ? RWBS_FLAG_DISCARD :        \
  55                         ( (op) == REQ_OP_SECURE_ERASE ? (RWBS_FLAG_DISCARD | RWBS_FLAG_SECURE) : \
  56                         ( (op) == REQ_OP_FLUSH ? RWBS_FLAG_FLUSH :            \
  57                         ( (op) == REQ_OP_READ ? RWBS_FLAG_READ :              \
  58                         ( 0 ))))))                                            \
  59                         | ((rw) & REQ_RAHEAD ? RWBS_FLAG_RAHEAD : 0)          \
  60                         | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0)              \
  61                         | ((rw) & REQ_META ? RWBS_FLAG_META : 0)              \
  62                         | ((rw) & REQ_PREFLUSH ? RWBS_FLAG_PREFLUSH : 0)      \
  63                         | ((rw) & REQ_FUA ? RWBS_FLAG_FUA : 0))
  64
  65 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
  66
  67 #define lttng_req_op(rq)
  68 #define lttng_req_rw(rq)        ((rq)->cmd_flags)
  69 #define lttng_bio_op(bio)
  70 #define lttng_bio_rw(bio)       ((bio)->bi_rw)
  71
  72 #define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes)                       \
  73                 ctf_integer(type, rwbs, ((rw) & WRITE ? RWBS_FLAG_WRITE :     \
  74                         ( (rw) & REQ_DISCARD ? RWBS_FLAG_DISCARD :            \
  75                         ( (bytes) ? RWBS_FLAG_READ :                          \
  76                         ( 0 ))))                                              \
  77                         | ((rw) & REQ_RAHEAD ? RWBS_FLAG_RAHEAD : 0)          \
  78                         | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0)              \
  79                         | ((rw) & REQ_META ? RWBS_FLAG_META : 0)              \
  80                         | ((rw) & REQ_SECURE ? RWBS_FLAG_SECURE : 0)          \
  81                         | ((rw) & REQ_FLUSH ? RWBS_FLAG_FLUSH : 0)            \
  82                         | ((rw) & REQ_FUA ? RWBS_FLAG_FUA : 0))
  83
  84 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
  85
  86 #define lttng_req_op(rq)
  87 #define lttng_req_rw(rq)        ((rq)->cmd_flags)
  88 #define lttng_bio_op(bio)
  89 #define lttng_bio_rw(bio)       ((bio)->bi_rw)
  90
  91 #define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes)                       \
  92                 ctf_integer(type, rwbs, ((rw) & WRITE ? RWBS_FLAG_WRITE :     \
  93                         ( (rw) & REQ_DISCARD ? RWBS_FLAG_DISCARD :            \
  94                         ( (bytes) ? RWBS_FLAG_READ :                          \
  95                         ( 0 ))))                                              \
  96                         | ((rw) & REQ_RAHEAD ? RWBS_FLAG_RAHEAD : 0)          \
  97                         | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0)              \
  98                         | ((rw) & REQ_META ? RWBS_FLAG_META : 0)              \
  99                         | ((rw) & REQ_SECURE ? RWBS_FLAG_SECURE : 0))
 100
 101 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
 102
 103 #define lttng_req_op(rq)
 104 #define lttng_req_rw(rq)        ((rq)->cmd_flags)
 105 #define lttng_bio_op(bio)
 106 #define lttng_bio_rw(bio)       ((bio)->bi_rw)
 107
 108 #define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes)                       \
 109                 ctf_integer(type, rwbs, ((rw) & WRITE ? RWBS_FLAG_WRITE :     \
 110                         ( (rw) & REQ_DISCARD ? RWBS_FLAG_DISCARD :            \
 111                         ( (bytes) ? RWBS_FLAG_READ :                          \
 112                         ( 0 ))))                                              \
 113                         | ((rw) & REQ_RAHEAD ? RWBS_FLAG_RAHEAD : 0)          \
 114                         | ((rw) & REQ_HARDBARRIER ? RWBS_FLAG_BARRIER : 0)    \
 115                         | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0)              \
 116                         | ((rw) & REQ_META ? RWBS_FLAG_META : 0)              \
 117                         | ((rw) & REQ_SECURE ? RWBS_FLAG_SECURE : 0))
 118
 119 #else
 120
 121 #define lttng_req_op(rq)
 122 #define lttng_req_rw(rq)        ((rq)->cmd_flags)
 123 #define lttng_bio_op(bio)
 124 #define lttng_bio_rw(bio)       ((bio)->bi_rw)
 125
 126 #define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes)                       \
 127                 ctf_integer(type, rwbs, ((rw) & WRITE ? RWBS_FLAG_WRITE :     \
 128                         ( (rw) & (1 << BIO_RW_DISCARD) ? RWBS_FLAG_DISCARD :  \
 129                         ( (bytes) ? RWBS_FLAG_READ :                          \
 130                         ( 0 ))))                                              \
 131                         | ((rw) & (1 << BIO_RW_AHEAD) ? RWBS_FLAG_RAHEAD : 0) \
 132                         | ((rw) & (1 << BIO_RW_SYNCIO) ? RWBS_FLAG_SYNC : 0)  \
 133                         | ((rw) & (1 << BIO_RW_META) ? RWBS_FLAG_META : 0)    \
 134                         | ((rw) & (1 << BIO_RW_BARRIER) ? RWBS_FLAG_BARRIER : 0))
 135
 136 #endif
 137
 138 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
 139 LTTNG_TRACEPOINT_EVENT_CLASS(block_buffer,
 140
 141         TP_PROTO(struct buffer_head *bh),
 142
 143         TP_ARGS(bh),
 144
 145         TP_FIELDS (
 146                 ctf_integer(dev_t, dev, bh->b_bdev->bd_dev)
 147                 ctf_integer(sector_t, sector, bh->b_blocknr)
 148                 ctf_integer(size_t, size, bh->b_size)
 149         )
 150 )
 151
 152 /**
 153  * block_touch_buffer - mark a buffer accessed
 154  * @bh: buffer_head being touched
 155  *
 156  * Called from touch_buffer().
 157  */
 158 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_buffer, block_touch_buffer,
 159
 160         TP_PROTO(struct buffer_head *bh),
 161
 162         TP_ARGS(bh)
 163 )
 164
 165 /**
 166  * block_dirty_buffer - mark a buffer dirty
 167  * @bh: buffer_head being dirtied
 168  *
 169  * Called from mark_buffer_dirty().
 170  */
 171 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_buffer, block_dirty_buffer,
 172
 173         TP_PROTO(struct buffer_head *bh),
 174
 175         TP_ARGS(bh)
 176 )
 177 #endif
 178
 179 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
 180 /* block_rq_with_error event class removed in kernel 4.12 */
 181 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0))
 182 LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_rq_with_error,
 183
 184         TP_PROTO(struct request_queue *q, struct request *rq),
 185
 186         TP_ARGS(q, rq),
 187
 188         TP_locvar(
 189                 sector_t sector;
 190                 unsigned int nr_sector;
 191                 unsigned char *cmd;
 192                 size_t cmd_len;
 193         ),
 194
 195         TP_code_pre(
 196                 if (blk_rq_is_scsi(rq)) {
 197                         struct scsi_request *scsi_rq = scsi_req(rq);
 198                         tp_locvar->sector = 0;
 199                         tp_locvar->nr_sector = 0;
 200                         tp_locvar->cmd = scsi_rq->cmd;
 201                         tp_locvar->cmd_len = scsi_rq->cmd_len;
 202                 } else {
 203                         tp_locvar->sector = blk_rq_pos(rq);
 204                         tp_locvar->nr_sector = blk_rq_sectors(rq);
 205                         tp_locvar->cmd = NULL;
 206                         tp_locvar->cmd_len = 0;
 207                 }
 208         ),
 209
 210         TP_FIELDS(
 211                 ctf_integer(dev_t, dev,
 212                         rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 213                 ctf_integer(sector_t, sector, tp_locvar->sector)
 214                 ctf_integer(unsigned int, nr_sector, tp_locvar->nr_sector)
 215                 ctf_integer(int, errors, rq->errors)
 216                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 217                         lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq))
 218                 ctf_sequence_hex(unsigned char, cmd,
 219                         tp_locvar->cmd, size_t, tp_locvar->cmd_len)
 220         ),
 221
 222         TP_code_post()
 223 )
 224 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */
 225 LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_rq_with_error,
 226
 227         TP_PROTO(struct request_queue *q, struct request *rq),
 228
 229         TP_ARGS(q, rq),
 230
 231         TP_locvar(
 232                 sector_t sector;
 233                 unsigned int nr_sector;
 234                 unsigned char *cmd;
 235                 size_t cmd_len;
 236         ),
 237
 238         TP_code_pre(
 239
 240                 if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
 241                         tp_locvar->sector = 0;
 242                         tp_locvar->nr_sector = 0;
 243                         tp_locvar->cmd = rq->cmd;
 244                         tp_locvar->cmd_len = rq->cmd_len;
 245                 } else {
 246                         tp_locvar->sector = blk_rq_pos(rq);
 247                         tp_locvar->nr_sector = blk_rq_sectors(rq);
 248                         tp_locvar->cmd = NULL;
 249                         tp_locvar->cmd_len = 0;
 250                 }
 251         ),
 252
 253         TP_FIELDS(
 254                 ctf_integer(dev_t, dev,
 255                         rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 256                 ctf_integer(sector_t, sector, tp_locvar->sector)
 257                 ctf_integer(unsigned int, nr_sector, tp_locvar->nr_sector)
 258                 ctf_integer(int, errors, rq->errors)
 259                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 260                         lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq))
 261                 ctf_sequence_hex(unsigned char, cmd,
 262                         tp_locvar->cmd, size_t, tp_locvar->cmd_len)
 263         ),
 264
 265         TP_code_post()
 266 )
 267 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */
 268
 269 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,12,0))
 270 /**
 271  * block_rq_abort - abort block operation request
 272  * @q: queue containing the block operation request
 273  * @rq: block IO operation request
 274  *
 275  * Called immediately after pending block IO operation request @rq in
 276  * queue @q is aborted. The fields in the operation request @rq
 277  * can be examined to determine which device and sectors the pending
 278  * operation would access.
 279  */
 280 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq_with_error, block_rq_abort,
 281
 282         TP_PROTO(struct request_queue *q, struct request *rq),
 283
 284         TP_ARGS(q, rq)
 285 )
 286 #endif
 287
 288 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
 289 /**
 290  * block_rq_requeue - place block IO request back on a queue
 291  * @rq: block IO operation request
 292  *
 293  * The block operation request @rq is being placed back into queue
 294  * @q.  For some reason the request was not completed and needs to be
 295  * put back in the queue.
 296  */
 297 LTTNG_TRACEPOINT_EVENT(block_rq_requeue,
 298
 299         TP_PROTO(struct request *rq),
 300
 301         TP_ARGS(rq),
 302
 303         TP_FIELDS(
 304                 ctf_integer(dev_t, dev,
 305                         rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 306                 ctf_integer(sector_t, sector, blk_rq_trace_sector(rq))
 307                 ctf_integer(unsigned int, nr_sector, blk_rq_trace_nr_sectors(rq))
 308                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 309                         lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq))
 310         )
 311 )
 312 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
 313 /**
 314  * block_rq_requeue - place block IO request back on a queue
 315  * @q: queue holding operation
 316  * @rq: block IO operation request
 317  *
 318  * The block operation request @rq is being placed back into queue
 319  * @q.  For some reason the request was not completed and needs to be
 320  * put back in the queue.
 321  */
 322 LTTNG_TRACEPOINT_EVENT(block_rq_requeue,
 323
 324         TP_PROTO(struct request_queue *q, struct request *rq),
 325
 326         TP_ARGS(q, rq),
 327
 328         TP_FIELDS(
 329                 ctf_integer(dev_t, dev,
 330                         rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 331                 ctf_integer(sector_t, sector, blk_rq_trace_sector(rq))
 332                 ctf_integer(unsigned int, nr_sector, blk_rq_trace_nr_sectors(rq))
 333                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 334                         lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq))
 335         )
 336 )
 337 #else
 338 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq_with_error, block_rq_requeue,
 339
 340         TP_PROTO(struct request_queue *q, struct request *rq),
 341
 342         TP_ARGS(q, rq)
 343 )
 344 #endif
 345
 346 /**
 347  * block_rq_complete - block IO operation completed by device driver
 348  * @q: queue containing the block operation request
 349  * @rq: block operations request
 350  * @nr_bytes: number of completed bytes
 351  *
 352  * The block_rq_complete tracepoint event indicates that some portion
 353  * of operation request has been completed by the device driver.  If
 354  * the @rq->bio is %NULL, then there is absolutely no additional work to
 355  * do for the request. If @rq->bio is non-NULL then there is
 356  * additional work required to complete the request.
 357  */
 358 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
 359 LTTNG_TRACEPOINT_EVENT(block_rq_complete,
 360
 361         TP_PROTO(struct request *rq, int error, unsigned int nr_bytes),
 362
 363         TP_ARGS(rq, error, nr_bytes),
 364
 365         TP_FIELDS(
 366                 ctf_integer(dev_t, dev,
 367                         rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 368                 ctf_integer(sector_t, sector, blk_rq_pos(rq))
 369                 ctf_integer(unsigned int, nr_sector, nr_bytes >> 9)
 370                 ctf_integer(int, error, error)
 371                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 372                         lttng_req_op(rq), lttng_req_rw(rq), nr_bytes)
 373         )
 374 )
 375 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0))
 376 LTTNG_TRACEPOINT_EVENT_CODE(block_rq_complete,
 377
 378         TP_PROTO(struct request_queue *q, struct request *rq,
 379                  unsigned int nr_bytes),
 380
 381         TP_ARGS(q, rq, nr_bytes),
 382
 383         TP_locvar(
 384                 unsigned char *cmd;
 385                 size_t cmd_len;
 386         ),
 387
 388         TP_code_pre(
 389                 if (blk_rq_is_scsi(rq)) {
 390                         struct scsi_request *scsi_rq = scsi_req(rq);
 391                         tp_locvar->cmd = scsi_rq->cmd;
 392                         tp_locvar->cmd_len = scsi_rq->cmd_len;
 393                 } else {
 394                         tp_locvar->cmd = NULL;
 395                         tp_locvar->cmd_len = 0;
 396                 }
 397         ),
 398
 399         TP_FIELDS(
 400                 ctf_integer(dev_t, dev,
 401                         rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 402                 ctf_integer(sector_t, sector, blk_rq_pos(rq))
 403                 ctf_integer(unsigned int, nr_sector, nr_bytes >> 9)
 404                 ctf_integer(int, errors, rq->errors)
 405                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 406                         lttng_req_op(rq), lttng_req_rw(rq), nr_bytes)
 407                 ctf_sequence_hex(unsigned char, cmd,
 408                         tp_locvar->cmd, size_t, tp_locvar->cmd_len)
 409         ),
 410
 411         TP_code_post()
 412 )
 413 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,5)     \
 414         || LTTNG_KERNEL_RANGE(3,12,21, 3,13,0)          \
 415         || LTTNG_KERNEL_RANGE(3,10,41, 3,11,0)          \
 416         || LTTNG_KERNEL_RANGE(3,4,91, 3,5,0)            \
 417         || LTTNG_KERNEL_RANGE(3,2,58, 3,3,0)            \
 418         || LTTNG_UBUNTU_KERNEL_RANGE(3,13,11,28, 3,14,0,0)      \
 419         || LTTNG_RHEL_KERNEL_RANGE(3,10,0,229,0,0, 3,11,0,0,0,0))
 420
 421 LTTNG_TRACEPOINT_EVENT_CODE(block_rq_complete,
 422
 423         TP_PROTO(struct request_queue *q, struct request *rq,
 424                  unsigned int nr_bytes),
 425
 426         TP_ARGS(q, rq, nr_bytes),
 427
 428         TP_locvar(
 429                 unsigned char *cmd;
 430                 size_t cmd_len;
 431         ),
 432
 433         TP_code_pre(
 434                 if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
 435                         tp_locvar->cmd = rq->cmd;
 436                         tp_locvar->cmd_len = rq->cmd_len;
 437                 } else {
 438                         tp_locvar->cmd = NULL;
 439                         tp_locvar->cmd_len = 0;
 440                 }
 441         ),
 442
 443         TP_FIELDS(
 444                 ctf_integer(dev_t, dev,
 445                         rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 446                 ctf_integer(sector_t, sector, blk_rq_pos(rq))
 447                 ctf_integer(unsigned int, nr_sector, nr_bytes >> 9)
 448                 ctf_integer(int, errors, rq->errors)
 449                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 450                         lttng_req_op(rq), lttng_req_rw(rq), nr_bytes)
 451                 ctf_sequence_hex(unsigned char, cmd,
 452                         tp_locvar->cmd, size_t, tp_locvar->cmd_len)
 453         ),
 454
 455         TP_code_post()
 456 )
 457
 458 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0)) */
 459
 460 /**
 461  * block_rq_complete - block IO operation completed by device driver
 462  * @q: queue containing the block operation request
 463  * @rq: block operations request
 464  *
 465  * The block_rq_complete tracepoint event indicates that some portion
 466  * of operation request has been completed by the device driver.  If
 467  * the @rq->bio is %NULL, then there is absolutely no additional work to
 468  * do for the request. If @rq->bio is non-NULL then there is
 469  * additional work required to complete the request.
 470  */
 471 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq_with_error, block_rq_complete,
 472
 473         TP_PROTO(struct request_queue *q, struct request *rq),
 474
 475         TP_ARGS(q, rq)
 476 )
 477
 478 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0)) */
 479
 480 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
 481 LTTNG_TRACEPOINT_EVENT_CLASS(block_rq,
 482
 483         TP_PROTO(struct request *rq),
 484
 485         TP_ARGS(rq),
 486
 487         TP_FIELDS(
 488                 ctf_integer(dev_t, dev,
 489                         rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 490                 ctf_integer(sector_t, sector, blk_rq_trace_sector(rq))
 491                 ctf_integer(unsigned int, nr_sector, blk_rq_trace_nr_sectors(rq))
 492                 ctf_integer(unsigned int, bytes, blk_rq_bytes(rq))
 493                 ctf_integer(pid_t, tid, current->pid)
 494                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 495                         lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq))
 496                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
 497         )
 498 )
 499 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
 500 LTTNG_TRACEPOINT_EVENT_CLASS(block_rq,
 501
 502         TP_PROTO(struct request_queue *q, struct request *rq),
 503
 504         TP_ARGS(q, rq),
 505
 506         TP_FIELDS(
 507                 ctf_integer(dev_t, dev,
 508                         rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 509                 ctf_integer(sector_t, sector, blk_rq_trace_sector(rq))
 510                 ctf_integer(unsigned int, nr_sector, blk_rq_trace_nr_sectors(rq))
 511                 ctf_integer(unsigned int, bytes, blk_rq_bytes(rq))
 512                 ctf_integer(pid_t, tid, current->pid)
 513                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 514                         lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq))
 515                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
 516         )
 517 )
 518 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0))
 519 LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_rq,
 520
 521         TP_PROTO(struct request_queue *q, struct request *rq),
 522
 523         TP_ARGS(q, rq),
 524
 525         TP_locvar(
 526                 sector_t sector;
 527                 unsigned int nr_sector;
 528                 unsigned int bytes;
 529                 unsigned char *cmd;
 530                 size_t cmd_len;
 531         ),
 532
 533         TP_code_pre(
 534                 if (blk_rq_is_scsi(rq)) {
 535                         struct scsi_request *scsi_rq = scsi_req(rq);
 536                         tp_locvar->sector = 0;
 537                         tp_locvar->nr_sector = 0;
 538                         tp_locvar->bytes = scsi_rq->resid_len;
 539                         tp_locvar->cmd = scsi_rq->cmd;
 540                         tp_locvar->cmd_len = scsi_rq->cmd_len;
 541                 } else {
 542                         tp_locvar->sector = blk_rq_pos(rq);
 543                         tp_locvar->nr_sector = blk_rq_sectors(rq);
 544                         tp_locvar->bytes = 0;
 545                         tp_locvar->cmd = NULL;
 546                         tp_locvar->cmd_len = 0;
 547                 }
 548         ),
 549
 550         TP_FIELDS(
 551                 ctf_integer(dev_t, dev,
 552                         rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 553                 ctf_integer(sector_t, sector, tp_locvar->sector)
 554                 ctf_integer(unsigned int, nr_sector, tp_locvar->nr_sector)
 555                 ctf_integer(unsigned int, bytes, tp_locvar->bytes)
 556                 ctf_integer(pid_t, tid, current->pid)
 557                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 558                         lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq))
 559                 ctf_sequence_hex(unsigned char, cmd,
 560                         tp_locvar->cmd, size_t, tp_locvar->cmd_len)
 561                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
 562         ),
 563
 564         TP_code_post()
 565 )
 566 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */
 567 LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_rq,
 568
 569         TP_PROTO(struct request_queue *q, struct request *rq),
 570
 571         TP_ARGS(q, rq),
 572
 573         TP_locvar(
 574                 sector_t sector;
 575                 unsigned int nr_sector;
 576                 unsigned int bytes;
 577                 unsigned char *cmd;
 578                 size_t cmd_len;
 579         ),
 580
 581         TP_code_pre(
 582                 if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
 583                         tp_locvar->sector = 0;
 584                         tp_locvar->nr_sector = 0;
 585                         tp_locvar->bytes = blk_rq_bytes(rq);
 586                         tp_locvar->cmd = rq->cmd;
 587                         tp_locvar->cmd_len = rq->cmd_len;
 588                 } else {
 589                         tp_locvar->sector = blk_rq_pos(rq);
 590                         tp_locvar->nr_sector = blk_rq_sectors(rq);
 591                         tp_locvar->bytes = 0;
 592                         tp_locvar->cmd = NULL;
 593                         tp_locvar->cmd_len = 0;
 594                 }
 595         ),
 596
 597         TP_FIELDS(
 598                 ctf_integer(dev_t, dev,
 599                         rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
 600                 ctf_integer(sector_t, sector, tp_locvar->sector)
 601                 ctf_integer(unsigned int, nr_sector, tp_locvar->nr_sector)
 602                 ctf_integer(unsigned int, bytes, tp_locvar->bytes)
 603                 ctf_integer(pid_t, tid, current->pid)
 604                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 605                         lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq))
 606                 ctf_sequence_hex(unsigned char, cmd,
 607                         tp_locvar->cmd, size_t, tp_locvar->cmd_len)
 608                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
 609         ),
 610
 611         TP_code_post()
 612 )
 613 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */
 614
 615 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
 616 /**
 617  * block_rq_insert - insert block operation request into queue
 618  * @rq: block IO operation request
 619  *
 620  * Called immediately before block operation request @rq is inserted
 621  * into queue @q.  The fields in the operation request @rq struct can
 622  * be examined to determine which device and sectors the pending
 623  * operation would access.
 624  */
 625 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_insert,
 626
 627         TP_PROTO(struct request *rq),
 628
 629         TP_ARGS(rq)
 630 )
 631 #else
 632 /**
 633  * block_rq_insert - insert block operation request into queue
 634  * @q: target queue
 635  * @rq: block IO operation request
 636  *
 637  * Called immediately before block operation request @rq is inserted
 638  * into queue @q.  The fields in the operation request @rq struct can
 639  * be examined to determine which device and sectors the pending
 640  * operation would access.
 641  */
 642 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_insert,
 643
 644         TP_PROTO(struct request_queue *q, struct request *rq),
 645
 646         TP_ARGS(q, rq)
 647 )
 648 #endif
 649
 650 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
 651 /**
 652  * block_rq_issue - issue pending block IO request operation to device driver
 653  * @rq: block IO operation operation request
 654  *
 655  * Called when block operation request @rq from queue @q is sent to a
 656  * device driver for processing.
 657  */
 658 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_issue,
 659
 660         TP_PROTO(struct request *rq),
 661
 662         TP_ARGS(rq)
 663 )
 664 #else
 665 /**
 666  * block_rq_issue - issue pending block IO request operation to device driver
 667  * @q: queue holding operation
 668  * @rq: block IO operation operation request
 669  *
 670  * Called when block operation request @rq from queue @q is sent to a
 671  * device driver for processing.
 672  */
 673 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_issue,
 674
 675         TP_PROTO(struct request_queue *q, struct request *rq),
 676
 677         TP_ARGS(q, rq)
 678 )
 679 #endif
 680
 681 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
 682 /**
 683  * block_rq_merge - merge request with another one in the elevator
 684  * @rq: block IO operation operation request
 685  *
 686  * Called when block operation request @rq from queue @q is merged to another
 687  * request queued in the elevator.
 688  */
 689 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_merge,
 690
 691         TP_PROTO(struct request *rq),
 692
 693         TP_ARGS(rq)
 694 )
 695 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(5,9,0))
 696 /**
 697  * block_rq_merge - merge request with another one in the elevator
 698  * @q: queue holding operation
 699  * @rq: block IO operation operation request
 700  *
 701  * Called when block operation request @rq from queue @q is merged to another
 702  * request queued in the elevator.
 703  */
 704 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_merge,
 705
 706         TP_PROTO(struct request_queue *q, struct request *rq),
 707
 708         TP_ARGS(q, rq)
 709 )
 710 #endif
 711
 712 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,8,0))
 713 /**
 714  * block_bio_complete - completed all work on the block operation
 715  * @q: queue holding the block operation
 716  * @bio: block operation completed
 717  * @error: io error value
 718  *
 719  * This tracepoint indicates there is no further work to do on this
 720  * block IO operation @bio.
 721  */
 722 LTTNG_TRACEPOINT_EVENT(block_bio_complete,
 723
 724         TP_PROTO(struct request_queue *q, struct bio *bio),
 725
 726         TP_ARGS(q, bio),
 727
 728         TP_FIELDS(
 729                 ctf_integer(dev_t, dev, bio_dev(bio))
 730                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 731                 ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
 732                 ctf_integer(int, error, blk_status_to_errno(bio->bi_status))
 733                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 734                         lttng_bio_op(bio), lttng_bio_rw(bio),
 735                         bio->bi_iter.bi_size)
 736         )
 737 )
 738 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
 739 /**
 740  * block_bio_complete - completed all work on the block operation
 741  * @q: queue holding the block operation
 742  * @bio: block operation completed
 743  * @error: io error value
 744  *
 745  * This tracepoint indicates there is no further work to do on this
 746  * block IO operation @bio.
 747  */
 748 LTTNG_TRACEPOINT_EVENT(block_bio_complete,
 749
 750         TP_PROTO(struct request_queue *q, struct bio *bio, int error),
 751
 752         TP_ARGS(q, bio, error),
 753
 754         TP_FIELDS(
 755                 ctf_integer(dev_t, dev, bio_dev(bio))
 756                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 757                 ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
 758                 ctf_integer(int, error, error)
 759                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 760                         lttng_bio_op(bio), lttng_bio_rw(bio),
 761                         bio->bi_iter.bi_size)
 762         )
 763 )
 764 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
 765 /**
 766  * block_bio_complete - completed all work on the block operation
 767  * @q: queue holding the block operation
 768  * @bio: block operation completed
 769  * @error: io error value
 770  *
 771  * This tracepoint indicates there is no further work to do on this
 772  * block IO operation @bio.
 773  */
 774 LTTNG_TRACEPOINT_EVENT(block_bio_complete,
 775
 776         TP_PROTO(struct request_queue *q, struct bio *bio, int error),
 777
 778         TP_ARGS(q, bio, error),
 779
 780         TP_FIELDS(
 781                 ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
 782                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 783                 ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
 784                 ctf_integer(int, error, error)
 785                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 786                         lttng_bio_op(bio), lttng_bio_rw(bio),
 787                         bio->bi_iter.bi_size)
 788         )
 789 )
 790 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
 791 /**
 792  * block_bio_complete - completed all work on the block operation
 793  * @q: queue holding the block operation
 794  * @bio: block operation completed
 795  * @error: io error value
 796  *
 797  * This tracepoint indicates there is no further work to do on this
 798  * block IO operation @bio.
 799  */
 800 LTTNG_TRACEPOINT_EVENT(block_bio_complete,
 801
 802         TP_PROTO(struct request_queue *q, struct bio *bio, int error),
 803
 804         TP_ARGS(q, bio, error),
 805
 806         TP_FIELDS(
 807                 ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
 808                 ctf_integer(sector_t, sector, bio->bi_sector)
 809                 ctf_integer(unsigned int, nr_sector, bio->bi_size >> 9)
 810                 ctf_integer(int, error, error)
 811                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 812                         lttng_bio_op(bio), lttng_bio_rw(bio), bio->bi_size)
 813         )
 814 )
 815 #else
 816 /**
 817  * block_bio_complete - completed all work on the block operation
 818  * @q: queue holding the block operation
 819  * @bio: block operation completed
 820  * @error: io error value
 821  *
 822  * This tracepoint indicates there is no further work to do on this
 823  * block IO operation @bio.
 824  */
 825 LTTNG_TRACEPOINT_EVENT(block_bio_complete,
 826
 827         TP_PROTO(struct request_queue *q, struct bio *bio),
 828
 829         TP_ARGS(q, bio),
 830
 831         TP_FIELDS(
 832                 ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
 833                 ctf_integer(sector_t, sector, bio->bi_sector)
 834                 ctf_integer(unsigned int, nr_sector, bio->bi_size >> 9)
 835                 ctf_integer(int, error, 0)
 836                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 837                         lttng_bio_op(bio), lttng_bio_rw(bio), bio->bi_size)
 838         )
 839 )
 840 #endif
 841
 842 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
 843 LTTNG_TRACEPOINT_EVENT_CLASS(block_bio,
 844
 845         TP_PROTO(struct bio *bio),
 846
 847         TP_ARGS(bio),
 848
 849         TP_FIELDS(
 850                 ctf_integer(dev_t, dev, bio_dev(bio))
 851                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 852                 ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
 853                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 854                         lttng_bio_op(bio), lttng_bio_rw(bio),
 855                         bio->bi_iter.bi_size)
 856                 ctf_integer(pid_t, tid, current->pid)
 857                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
 858         )
 859 )
 860 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
 861 LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge,
 862
 863         TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
 864
 865         TP_ARGS(q, rq, bio),
 866
 867         TP_FIELDS(
 868                 ctf_integer(dev_t, dev, bio_dev(bio))
 869                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 870                 ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
 871                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 872                         lttng_bio_op(bio), lttng_bio_rw(bio),
 873                         bio->bi_iter.bi_size)
 874                 ctf_integer(pid_t, tid, current->pid)
 875                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
 876         )
 877 )
 878 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
 879 LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge,
 880
 881         TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
 882
 883         TP_ARGS(q, rq, bio),
 884
 885         TP_FIELDS(
 886                 ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
 887                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 888                 ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
 889                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 890                         lttng_bio_op(bio), lttng_bio_rw(bio),
 891                         bio->bi_iter.bi_size)
 892                 ctf_integer(pid_t, tid, current->pid)
 893                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
 894         )
 895 )
 896 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
 897 LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge,
 898
 899         TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
 900
 901         TP_ARGS(q, rq, bio),
 902
 903         TP_FIELDS(
 904                 ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
 905                 ctf_integer(sector_t, sector, bio->bi_sector)
 906                 ctf_integer(unsigned int, nr_sector, bio->bi_size >> 9)
 907                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 908                         lttng_bio_op(bio), lttng_bio_rw(bio), bio->bi_size)
 909                 ctf_integer(pid_t, tid, current->pid)
 910                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
 911         )
 912 )
 913 #endif
 914
 915
 916
 917 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
 918 /**
 919  * block_bio_bounce - used bounce buffer when processing block operation
 920  * @bio: block operation
 921  *
 922  * A bounce buffer was used to handle the block operation @bio in @q.
 923  * This occurs when hardware limitations prevent a direct transfer of
 924  * data between the @bio data memory area and the IO device.  Use of a
 925  * bounce buffer requires extra copying of data and decreases
 926  * performance.
 927  */
 928 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_bounce,
 929
 930         TP_PROTO(struct bio *bio),
 931
 932         TP_ARGS(bio)
 933 )
 934 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
 935 /**
 936  * block_bio_bounce - used bounce buffer when processing block operation
 937  * @q: queue holding the block operation
 938  * @bio: block operation
 939  *
 940  * A bounce buffer was used to handle the block operation @bio in @q.
 941  * This occurs when hardware limitations prevent a direct transfer of
 942  * data between the @bio data memory area and the IO device.  Use of a
 943  * bounce buffer requires extra copying of data and decreases
 944  * performance.
 945  */
 946 LTTNG_TRACEPOINT_EVENT(block_bio_bounce,
 947
 948         TP_PROTO(struct request_queue *q, struct bio *bio),
 949
 950         TP_ARGS(q, bio),
 951
 952         TP_FIELDS(
 953                 ctf_integer(dev_t, dev, bio_dev(bio))
 954                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 955                 ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
 956                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 957                         lttng_bio_op(bio), lttng_bio_rw(bio),
 958                         bio->bi_iter.bi_size)
 959                 ctf_integer(pid_t, tid, current->pid)
 960                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
 961         )
 962 )
 963 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
 964 LTTNG_TRACEPOINT_EVENT(block_bio_bounce,
 965
 966         TP_PROTO(struct request_queue *q, struct bio *bio),
 967
 968         TP_ARGS(q, bio),
 969
 970         TP_FIELDS(
 971                 ctf_integer(dev_t, dev, bio->bi_bdev ? bio->bi_bdev->bd_dev : 0)
 972                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 973                 ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
 974                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 975                         lttng_bio_op(bio), lttng_bio_rw(bio),
 976                         bio->bi_iter.bi_size)
 977                 ctf_integer(pid_t, tid, current->pid)
 978                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
 979         )
 980 )
 981 #else
 982 LTTNG_TRACEPOINT_EVENT(block_bio_bounce,
 983
 984         TP_PROTO(struct request_queue *q, struct bio *bio),
 985
 986         TP_ARGS(q, bio),
 987
 988         TP_FIELDS(
 989                 ctf_integer(dev_t, dev, bio->bi_bdev ? bio->bi_bdev->bd_dev : 0)
 990                 ctf_integer(sector_t, sector, bio->bi_sector)
 991                 ctf_integer(unsigned int, nr_sector, bio->bi_size >> 9)
 992                 blk_rwbs_ctf_integer(unsigned int, rwbs,
 993                         lttng_bio_op(bio), lttng_bio_rw(bio),
 994                         bio->bi_size)
 995                 ctf_integer(pid_t, tid, current->pid)
 996                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
 997         )
 998 )
 999 #endif
1000
1001
1002 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
1003 /**
1004  * block_bio_backmerge - merging block operation to the end of an existing operation
1005  * @bio: new block operation to merge
1006  *
1007  * Merging block request @bio to the end of an existing block request.
1008  */
1009 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_backmerge,
1010
1011         TP_PROTO(struct bio *bio),
1012
1013         TP_ARGS(bio)
1014 )
1015
1016 /**
1017  * block_bio_frontmerge - merging block operation to the beginning of an existing operation
1018  * @bio: new block operation to merge
1019  *
1020  * Merging block IO operation @bio to the beginning of an existing block request.
1021  */
1022 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_frontmerge,
1023
1024         TP_PROTO(struct bio *bio),
1025
1026         TP_ARGS(bio)
1027 )
1028
1029 /**
1030  * block_bio_queue - putting new block IO operation in queue
1031  * @bio: new block operation
1032  *
1033  * About to place the block IO operation @bio into queue @q.
1034  */
1035 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_queue,
1036
1037         TP_PROTO(struct bio *bio),
1038
1039         TP_ARGS(bio)
1040 )
1041 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
1042 /**
1043  * block_bio_backmerge - merging block operation to the end of an existing operation
1044  * @q: queue holding operation
1045  * @rq: request bio is being merged into
1046  * @bio: new block operation to merge
1047  *
1048  * Merging block request @bio to the end of an existing block request
1049  * in queue @q.
1050  */
1051 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio_merge, block_bio_backmerge,
1052
1053         TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
1054
1055         TP_ARGS(q, rq, bio)
1056 )
1057
1058 /**
1059  * block_bio_frontmerge - merging block operation to the beginning of an existing operation
1060  * @q: queue holding operation
1061  * @rq: request bio is being merged into
1062  * @bio: new block operation to merge
1063  *
1064  * Merging block IO operation @bio to the beginning of an existing block
1065  * operation in queue @q.
1066  */
1067 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio_merge, block_bio_frontmerge,
1068
1069         TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
1070
1071         TP_ARGS(q, rq, bio)
1072 )
1073
1074 /**
1075  * block_bio_queue - putting new block IO operation in queue
1076  * @q: queue holding operation
1077  * @bio: new block operation
1078  *
1079  * About to place the block IO operation @bio into queue @q.
1080  */
1081 LTTNG_TRACEPOINT_EVENT(block_bio_queue,
1082
1083         TP_PROTO(struct request_queue *q, struct bio *bio),
1084
1085         TP_ARGS(q, bio),
1086
1087         TP_FIELDS(
1088 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
1089                 ctf_integer(dev_t, dev, bio_dev(bio))
1090 #else
1091                 ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
1092 #endif
1093 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
1094                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
1095                 ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
1096                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1097                         lttng_bio_op(bio), lttng_bio_rw(bio),
1098                         bio->bi_iter.bi_size)
1099 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) */
1100                 ctf_integer(sector_t, sector, bio->bi_sector)
1101                 ctf_integer(unsigned int, nr_sector, bio->bi_size >> 9)
1102                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1103                         lttng_bio_op(bio), lttng_bio_rw(bio), bio->bi_size)
1104 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) */
1105                 ctf_integer(pid_t, tid, current->pid)
1106                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
1107         )
1108 )
1109 #else /* if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)) */
1110 LTTNG_TRACEPOINT_EVENT_CLASS(block_bio,
1111
1112         TP_PROTO(struct request_queue *q, struct bio *bio),
1113
1114         TP_ARGS(q, bio),
1115
1116         TP_FIELDS(
1117                 ctf_integer(dev_t, dev, bio->bi_bdev ? bio->bi_bdev->bd_dev : 0)
1118                 ctf_integer(sector_t, sector, bio->bi_sector)
1119                 ctf_integer(unsigned int, nr_sector, bio->bi_size >> 9)
1120                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1121                         lttng_bio_op(bio), lttng_bio_rw(bio), bio->bi_size)
1122                 ctf_integer(pid_t, tid, current->pid)
1123                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
1124         )
1125 )
1126
1127 /**
1128  * block_bio_backmerge - merging block operation to the end of an existing operation
1129  * @q: queue holding operation
1130  * @bio: new block operation to merge
1131  *
1132  * Merging block request @bio to the end of an existing block request
1133  * in queue @q.
1134  */
1135 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_backmerge,
1136
1137         TP_PROTO(struct request_queue *q, struct bio *bio),
1138
1139         TP_ARGS(q, bio)
1140 )
1141
1142 /**
1143  * block_bio_frontmerge - merging block operation to the beginning of an existing operation
1144  * @q: queue holding operation
1145  * @bio: new block operation to merge
1146  *
1147  * Merging block IO operation @bio to the beginning of an existing block
1148  * operation in queue @q.
1149  */
1150 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_frontmerge,
1151
1152         TP_PROTO(struct request_queue *q, struct bio *bio),
1153
1154         TP_ARGS(q, bio)
1155 )
1156
1157 /**
1158  * block_bio_queue - putting new block IO operation in queue
1159  * @q: queue holding operation
1160  * @bio: new block operation
1161  *
1162  * About to place the block IO operation @bio into queue @q.
1163  */
1164 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_queue,
1165
1166         TP_PROTO(struct request_queue *q, struct bio *bio),
1167
1168         TP_ARGS(q, bio)
1169 )
1170 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)) */
1171
1172 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
1173 /**
1174  * block_getrq - get a free request entry in queue for block IO operations
1175  * @bio: pending block IO operation (can be %NULL)
1176  *
1177  * A request struct has been allocated to handle the block IO operation @bio.
1178  */
1179 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_getrq,
1180
1181         TP_PROTO(struct bio *bio),
1182
1183         TP_ARGS(bio)
1184 )
1185 #else
1186 LTTNG_TRACEPOINT_EVENT_CLASS(block_get_rq,
1187
1188         TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
1189
1190         TP_ARGS(q, bio, rw),
1191
1192         TP_FIELDS(
1193 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
1194                 ctf_integer(dev_t, dev, bio ? bio_dev(bio) : 0)
1195 #else
1196                 ctf_integer(dev_t, dev, bio ? bio->bi_bdev->bd_dev : 0)
1197 #endif
1198 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
1199                 ctf_integer(sector_t, sector, bio ? bio->bi_iter.bi_sector : 0)
1200                 ctf_integer(unsigned int, nr_sector,
1201                         bio ? bio_sectors(bio) : 0)
1202                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1203                         bio ? lttng_bio_op(bio) : 0,
1204                         bio ? lttng_bio_rw(bio) : 0,
1205                         bio ? bio->bi_iter.bi_size : 0)
1206 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) */
1207                 ctf_integer(sector_t, sector, bio ? bio->bi_sector : 0)
1208                 ctf_integer(unsigned int, nr_sector,
1209                         bio ? bio->bi_size >> 9 : 0)
1210                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1211                         bio ? lttng_bio_op(bio) : 0,
1212                         bio ? lttng_bio_rw(bio) : 0,
1213                         bio ? bio->bi_size : 0)
1214 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) */
1215                 ctf_integer(pid_t, tid, current->pid)
1216                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
1217         )
1218 )
1219
1220 /**
1221  * block_getrq - get a free request entry in queue for block IO operations
1222  * @q: queue for operations
1223  * @bio: pending block IO operation (can be %NULL)
1224  * @rw: low bit indicates a read (%0) or a write (%1)
1225  *
1226  * A request struct for queue @q has been allocated to handle the
1227  * block IO operation @bio.
1228  */
1229 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_get_rq, block_getrq,
1230
1231         TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
1232
1233         TP_ARGS(q, bio, rw)
1234 )
1235
1236 /**
1237  * block_sleeprq - waiting to get a free request entry in queue for block IO operation
1238  * @q: queue for operation
1239  * @bio: pending block IO operation (can be %NULL)
1240  * @rw: low bit indicates a read (%0) or a write (%1)
1241  *
1242  * In the case where a request struct cannot be provided for queue @q
1243  * the process needs to wait for an request struct to become
1244  * available.  This tracepoint event is generated each time the
1245  * process goes to sleep waiting for request struct become available.
1246  */
1247 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_get_rq, block_sleeprq,
1248
1249         TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
1250
1251         TP_ARGS(q, bio, rw)
1252 )
1253 #endif
1254
1255 /**
1256  * block_plug - keep operations requests in request queue
1257  * @q: request queue to plug
1258  *
1259  * Plug the request queue @q.  Do not allow block operation requests
1260  * to be sent to the device driver. Instead, accumulate requests in
1261  * the queue to improve throughput performance of the block device.
1262  */
1263 LTTNG_TRACEPOINT_EVENT(block_plug,
1264
1265         TP_PROTO(struct request_queue *q),
1266
1267         TP_ARGS(q),
1268
1269         TP_FIELDS(
1270                 ctf_integer(pid_t, tid, current->pid)
1271                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
1272         )
1273 )
1274
1275 LTTNG_TRACEPOINT_EVENT_CLASS(block_unplug,
1276
1277 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
1278         TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),
1279
1280         TP_ARGS(q, depth, explicit),
1281 #else
1282         TP_PROTO(struct request_queue *q),
1283
1284         TP_ARGS(q),
1285 #endif
1286
1287         TP_FIELDS(
1288 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
1289                 ctf_integer(int, nr_rq, depth)
1290 #else
1291                 ctf_integer(int, nr_rq, q->rq.count[READ] + q->rq.count[WRITE])
1292 #endif
1293                 ctf_integer(pid_t, tid, current->pid)
1294                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
1295         )
1296 )
1297
1298 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
1299 /**
1300  * block_unplug_timer - timed release of operations requests in queue to device driver
1301  * @q: request queue to unplug
1302  *
1303  * Unplug the request queue @q because a timer expired and allow block
1304  * operation requests to be sent to the device driver.
1305  */
1306 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_unplug, block_unplug_timer,
1307
1308         TP_PROTO(struct request_queue *q),
1309
1310         TP_ARGS(q)
1311 )
1312 #endif
1313
1314 /**
1315  * block_unplug - release of operations requests in request queue
1316  * @q: request queue to unplug
1317  * @depth: number of requests just added to the queue
1318  * @explicit: whether this was an explicit unplug, or one from schedule()
1319  *
1320  * Unplug request queue @q because device driver is scheduled to work
1321  * on elements in the request queue.
1322  */
1323 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
1324 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_unplug, block_unplug,
1325 #else
1326 LTTNG_TRACEPOINT_EVENT_INSTANCE(block_unplug, block_unplug_io,
1327 #endif
1328
1329 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
1330         TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),
1331
1332         TP_ARGS(q, depth, explicit)
1333 #else
1334         TP_PROTO(struct request_queue *q),
1335
1336         TP_ARGS(q)
1337 #endif
1338 )
1339
1340 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
1341 /**
1342  * block_split - split a single bio struct into two bio structs
1343  * @bio: block operation being split
1344  * @new_sector: The starting sector for the new bio
1345  *
1346  * The bio request @bio needs to be split into two bio requests.  The newly
1347  * created @bio request starts at @new_sector. This split may be required due to
1348  * hardware limitations such as operation crossing device boundaries in a RAID
1349  * system.
1350  */
1351 LTTNG_TRACEPOINT_EVENT(block_split,
1352
1353         TP_PROTO(struct bio *bio, unsigned int new_sector),
1354
1355         TP_ARGS(bio, new_sector),
1356
1357         TP_FIELDS(
1358                 ctf_integer(dev_t, dev, bio_dev(bio))
1359                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
1360                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1361                         lttng_bio_op(bio), lttng_bio_rw(bio),
1362                         bio->bi_iter.bi_size)
1363                 ctf_integer(sector_t, new_sector, new_sector)
1364                 ctf_integer(pid_t, tid, current->pid)
1365                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
1366         )
1367 )
1368
1369 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
1370 /**
1371  * block_split - split a single bio struct into two bio structs
1372  * @q: queue containing the bio
1373  * @bio: block operation being split
1374  * @new_sector: The starting sector for the new bio
1375  *
1376  * The bio request @bio in request queue @q needs to be split into two
1377  * bio requests. The newly created @bio request starts at
1378  * @new_sector. This split may be required due to hardware limitation
1379  * such as operation crossing device boundaries in a RAID system.
1380  */
1381 LTTNG_TRACEPOINT_EVENT(block_split,
1382
1383         TP_PROTO(struct request_queue *q, struct bio *bio,
1384                  unsigned int new_sector),
1385
1386         TP_ARGS(q, bio, new_sector),
1387
1388         TP_FIELDS(
1389                 ctf_integer(dev_t, dev, bio_dev(bio))
1390                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
1391                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1392                         lttng_bio_op(bio), lttng_bio_rw(bio),
1393                         bio->bi_iter.bi_size)
1394                 ctf_integer(sector_t, new_sector, new_sector)
1395                 ctf_integer(pid_t, tid, current->pid)
1396                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
1397         )
1398 )
1399 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
1400 LTTNG_TRACEPOINT_EVENT(block_split,
1401
1402         TP_PROTO(struct request_queue *q, struct bio *bio,
1403                  unsigned int new_sector),
1404
1405         TP_ARGS(q, bio, new_sector),
1406
1407         TP_FIELDS(
1408                 ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
1409                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
1410                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1411                         lttng_bio_op(bio), lttng_bio_rw(bio),
1412                         bio->bi_iter.bi_size)
1413                 ctf_integer(sector_t, new_sector, new_sector)
1414                 ctf_integer(pid_t, tid, current->pid)
1415                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
1416         )
1417 )
1418 #else
1419 LTTNG_TRACEPOINT_EVENT(block_split,
1420
1421         TP_PROTO(struct request_queue *q, struct bio *bio,
1422                  unsigned int new_sector),
1423
1424         TP_ARGS(q, bio, new_sector),
1425
1426         TP_FIELDS(
1427                 ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
1428                 ctf_integer(sector_t, sector, bio->bi_sector)
1429                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1430                         lttng_bio_op(bio), lttng_bio_rw(bio), bio->bi_size)
1431                 ctf_integer(sector_t, new_sector, new_sector)
1432                 ctf_integer(pid_t, tid, current->pid)
1433                 ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
1434         )
1435 )
1436 #endif
1437
1438 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
1439 /**
1440  * block_bio_remap - map request for a logical device to the raw device
1441  * @bio: revised operation
1442  * @dev: original device for the operation
1443  * @from: original sector for the operation
1444  *
1445  * An operation for a logical device has been mapped to the
1446  * raw block device.
1447  */
1448 LTTNG_TRACEPOINT_EVENT(block_bio_remap,
1449
1450         TP_PROTO(struct bio *bio, dev_t dev, sector_t from),
1451
1452         TP_ARGS(bio, dev, from),
1453
1454         TP_FIELDS(
1455                 ctf_integer(dev_t, dev, bio_dev(bio))
1456                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
1457                 ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
1458                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1459                         lttng_bio_op(bio), lttng_bio_rw(bio),
1460                         bio->bi_iter.bi_size)
1461                 ctf_integer(dev_t, old_dev, dev)
1462                 ctf_integer(sector_t, old_sector, from)
1463         )
1464 )
1465 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
1466 /**
1467  * block_bio_remap - map request for a logical device to the raw device
1468  * @q: queue holding the operation
1469  * @bio: revised operation
1470  * @dev: device for the operation
1471  * @from: original sector for the operation
1472  *
1473  * An operation for a logical device has been mapped to the
1474  * raw block device.
1475  */
1476 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
1477 LTTNG_TRACEPOINT_EVENT(block_bio_remap,
1478 #else
1479 LTTNG_TRACEPOINT_EVENT(block_remap,
1480 #endif
1481
1482         TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
1483                  sector_t from),
1484
1485         TP_ARGS(q, bio, dev, from),
1486
1487         TP_FIELDS(
1488                 ctf_integer(dev_t, dev, bio_dev(bio))
1489                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
1490                 ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
1491                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1492                         lttng_bio_op(bio), lttng_bio_rw(bio),
1493                         bio->bi_iter.bi_size)
1494                 ctf_integer(dev_t, old_dev, dev)
1495                 ctf_integer(sector_t, old_sector, from)
1496         )
1497 )
1498 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
1499 LTTNG_TRACEPOINT_EVENT(block_bio_remap,
1500
1501         TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
1502                  sector_t from),
1503
1504         TP_ARGS(q, bio, dev, from),
1505
1506         TP_FIELDS(
1507                 ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
1508                 ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
1509                 ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
1510                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1511                         lttng_bio_op(bio), lttng_bio_rw(bio),
1512                         bio->bi_iter.bi_size)
1513                 ctf_integer(dev_t, old_dev, dev)
1514                 ctf_integer(sector_t, old_sector, from)
1515         )
1516 )
1517 #else
1518 LTTNG_TRACEPOINT_EVENT(block_bio_remap,
1519
1520         TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
1521                  sector_t from),
1522
1523         TP_ARGS(q, bio, dev, from),
1524
1525         TP_FIELDS(
1526                 ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
1527                 ctf_integer(sector_t, sector, bio->bi_sector)
1528                 ctf_integer(unsigned int, nr_sector, bio->bi_size >> 9)
1529                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1530                         lttng_bio_op(bio), lttng_bio_rw(bio), bio->bi_size)
1531                 ctf_integer(dev_t, old_dev, dev)
1532                 ctf_integer(sector_t, old_sector, from)
1533         )
1534 )
1535 #endif
1536
1537 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
1538 /**
1539  * block_rq_remap - map request for a block operation request
1540  * @rq: block IO operation request
1541  * @dev: device for the operation
1542  * @from: original sector for the operation
1543  *
1544  * The block operation request @rq in @q has been remapped.  The block
1545  * operation request @rq holds the current information and @from hold
1546  * the original sector.
1547  */
1548 LTTNG_TRACEPOINT_EVENT(block_rq_remap,
1549
1550         TP_PROTO(struct request *rq, dev_t dev, sector_t from),
1551
1552         TP_ARGS(rq, dev, from),
1553
1554         TP_FIELDS(
1555                 ctf_integer(dev_t, dev, disk_devt(rq->rq_disk))
1556                 ctf_integer(sector_t, sector, blk_rq_pos(rq))
1557                 ctf_integer(unsigned int, nr_sector, blk_rq_sectors(rq))
1558                 ctf_integer(dev_t, old_dev, dev)
1559                 ctf_integer(sector_t, old_sector, from)
1560                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1561                         lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq))
1562         )
1563 )
1564 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32))
1565 /**
1566  * block_rq_remap - map request for a block operation request
1567  * @q: queue holding the operation
1568  * @rq: block IO operation request
1569  * @dev: device for the operation
1570  * @from: original sector for the operation
1571  *
1572  * The block operation request @rq in @q has been remapped.  The block
1573  * operation request @rq holds the current information and @from hold
1574  * the original sector.
1575  */
1576 LTTNG_TRACEPOINT_EVENT(block_rq_remap,
1577
1578         TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev,
1579                  sector_t from),
1580
1581         TP_ARGS(q, rq, dev, from),
1582
1583         TP_FIELDS(
1584                 ctf_integer(dev_t, dev, disk_devt(rq->rq_disk))
1585                 ctf_integer(sector_t, sector, blk_rq_pos(rq))
1586                 ctf_integer(unsigned int, nr_sector, blk_rq_sectors(rq))
1587                 ctf_integer(dev_t, old_dev, dev)
1588                 ctf_integer(sector_t, old_sector, from)
1589                 blk_rwbs_ctf_integer(unsigned int, rwbs,
1590                         lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq))
1591         )
1592 )
1593 #endif
1594
1595 #undef __print_rwbs_flags
1596 #undef blk_fill_rwbs
1597
1598 #endif /* LTTNG_TRACE_BLOCK_H */
1599
1600 /* This part must be outside protection */
1601 #include <probes/define_trace.h>