projects / lttng-modules.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
fix: block: don't call blk_status_to_errno in blk_update_request (v5.16)
[lttng-modules.git] / include / instrumentation / events / block.h
diff --git a/include/instrumentation/events/block.h b/include/instrumentation/events/block.h
index d0d69672d29632b5cca9e66860eb85e2b03fa156..6782c36f8d2925619426dbe3d6048b39aa5ad8ad 100644 (file)
--- a/include/instrumentation/events/block.h
+++ b/include/instrumentation/events/block.h
@@ -9,11 +9,11 @@
 #include <linux/blktrace_api.h>
 #include <linux/blkdev.h>
 #include <linux/trace_seq.h>
-#include <linux/version.h>
+#include <lttng/kernel-version.h>
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0))
 #include <scsi/scsi_request.h>
-#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */
+#endif /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0)) */
 
 #ifndef _TRACE_BLOCK_DEF_
 #define _TRACE_BLOCK_DEF_
@@ -34,6 +34,7 @@ enum {
 
 #endif /* _TRACE_BLOCK_DEF_ */
 
+#ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
 LTTNG_TRACEPOINT_ENUM(block_rq_type,
        TP_ENUM_VALUES(
                ctf_enum_value("RWBS_FLAG_WRITE", RWBS_FLAG_WRITE)
@@ -49,8 +50,9 @@ LTTNG_TRACEPOINT_ENUM(block_rq_type,
                ctf_enum_value("RWBS_FLAG_PREFLUSH", RWBS_FLAG_PREFLUSH)
        )
 )
+#endif /* CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM */
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0) || \
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,8,0) || \
        LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
        LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
        LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
@@ -64,6 +66,7 @@ LTTNG_TRACEPOINT_ENUM(block_rq_type,
 #define lttng_bio_op(bio)      bio_op(bio)
 #define lttng_bio_rw(bio)      ((bio)->bi_opf)
 
+#ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
 #define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes)                              \
                ctf_enum(block_rq_type, type, rwbs,                                           \
                        (((op) == REQ_OP_WRITE || (op) == REQ_OP_WRITE_SAME) ? RWBS_FLAG_WRITE : \
@@ -77,14 +80,30 @@ LTTNG_TRACEPOINT_ENUM(block_rq_type,
                        | ((rw) & REQ_META ? RWBS_FLAG_META : 0)              \
                        | ((rw) & REQ_PREFLUSH ? RWBS_FLAG_PREFLUSH : 0)      \
                        | ((rw) & REQ_FUA ? RWBS_FLAG_FUA : 0))
+#else
+#define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes)                              \
+               ctf_integer(type, rwbs,                                       \
+                       (((op) == REQ_OP_WRITE || (op) == REQ_OP_WRITE_SAME) ? RWBS_FLAG_WRITE : \
+                       ( (op) == REQ_OP_DISCARD ? RWBS_FLAG_DISCARD :        \
+                       ( (op) == REQ_OP_SECURE_ERASE ? (RWBS_FLAG_DISCARD | RWBS_FLAG_SECURE) : \
+                       ( (op) == REQ_OP_FLUSH ? RWBS_FLAG_FLUSH :            \
+                       ( (op) == REQ_OP_READ ? RWBS_FLAG_READ :              \
+                       ( 0 ))))))                                            \
+                       | ((rw) & REQ_RAHEAD ? RWBS_FLAG_RAHEAD : 0)          \
+                       | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0)              \
+                       | ((rw) & REQ_META ? RWBS_FLAG_META : 0)              \
+                       | ((rw) & REQ_PREFLUSH ? RWBS_FLAG_PREFLUSH : 0)      \
+                       | ((rw) & REQ_FUA ? RWBS_FLAG_FUA : 0))
+#endif /* CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM */
 
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,1,0))
 
 #define lttng_req_op(rq)
 #define lttng_req_rw(rq)       ((rq)->cmd_flags)
 #define lttng_bio_op(bio)
 #define lttng_bio_rw(bio)      ((bio)->bi_rw)
 
+#ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
 #define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes)                              \
                ctf_enum(block_rq_type, type, rwbs, ((rw) & WRITE ? RWBS_FLAG_WRITE : \
                        ( (rw) & REQ_DISCARD ? RWBS_FLAG_DISCARD :            \
@@ -96,6 +115,19 @@ LTTNG_TRACEPOINT_ENUM(block_rq_type,
                        | ((rw) & REQ_SECURE ? RWBS_FLAG_SECURE : 0)          \
                        | ((rw) & REQ_FLUSH ? RWBS_FLAG_FLUSH : 0)            \
                        | ((rw) & REQ_FUA ? RWBS_FLAG_FUA : 0))
+#else
+#define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes)                              \
+               ctf_integer(type, rwbs, ((rw) & WRITE ? RWBS_FLAG_WRITE :     \
+                       ( (rw) & REQ_DISCARD ? RWBS_FLAG_DISCARD :            \
+                       ( (bytes) ? RWBS_FLAG_READ :                          \
+                       ( 0 ))))                                              \
+                       | ((rw) & REQ_RAHEAD ? RWBS_FLAG_RAHEAD : 0)          \
+                       | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0)              \
+                       | ((rw) & REQ_META ? RWBS_FLAG_META : 0)              \
+                       | ((rw) & REQ_SECURE ? RWBS_FLAG_SECURE : 0)          \
+                       | ((rw) & REQ_FLUSH ? RWBS_FLAG_FLUSH : 0)            \
+                       | ((rw) & REQ_FUA ? RWBS_FLAG_FUA : 0))
+#endif /* CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM */
 
 #else
 
@@ -104,6 +136,7 @@ LTTNG_TRACEPOINT_ENUM(block_rq_type,
 #define lttng_bio_op(bio)
 #define lttng_bio_rw(bio)      ((bio)->bi_rw)
 
+#ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
 #define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes)                              \
                ctf_enum(block_rq_type, type, rwbs, ((rw) & WRITE ? RWBS_FLAG_WRITE :     \
                        ( (rw) & REQ_DISCARD ? RWBS_FLAG_DISCARD :            \
@@ -113,10 +146,21 @@ LTTNG_TRACEPOINT_ENUM(block_rq_type,
                        | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0)              \
                        | ((rw) & REQ_META ? RWBS_FLAG_META : 0)              \
                        | ((rw) & REQ_SECURE ? RWBS_FLAG_SECURE : 0))
+#else
+#define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes)                              \
+               ctf_integer(type, rwbs, ((rw) & WRITE ? RWBS_FLAG_WRITE :     \
+                       ( (rw) & REQ_DISCARD ? RWBS_FLAG_DISCARD :            \
+                       ( (bytes) ? RWBS_FLAG_READ :                          \
+                       ( 0 ))))                                              \
+                       | ((rw) & REQ_RAHEAD ? RWBS_FLAG_RAHEAD : 0)          \
+                       | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0)              \
+                       | ((rw) & REQ_META ? RWBS_FLAG_META : 0)              \
+                       | ((rw) & REQ_SECURE ? RWBS_FLAG_SECURE : 0))
+#endif /* CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM */
 
 #endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,9,0))
 LTTNG_TRACEPOINT_EVENT_CLASS(block_buffer,
 
        TP_PROTO(struct buffer_head *bh),
@@ -157,9 +201,9 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_buffer, block_dirty_buffer,
 )
 #endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,12,0))
 /* block_rq_with_error event class removed in kernel 4.12 */
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0))
 LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_rq_with_error,
 
        TP_PROTO(struct request_queue *q, struct request *rq),
@@ -202,7 +246,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_rq_with_error,
 
        TP_code_post()
 )
-#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */
+#else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0)) */
 LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_rq_with_error,
 
        TP_PROTO(struct request_queue *q, struct request *rq),
@@ -245,9 +289,9 @@ LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_rq_with_error,
 
        TP_code_post()
 )
-#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */
+#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0)) */
 
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(4,12,0))
+#if (LTTNG_LINUX_VERSION_CODE < LTTNG_KERNEL_VERSION(4,12,0))
 /**
  * block_rq_abort - abort block operation request
  * @q: queue containing the block operation request
@@ -266,7 +310,7 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq_with_error, block_rq_abort,
 )
 #endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
 /**
  * block_rq_requeue - place block IO request back on a queue
  * @rq: block IO operation request
@@ -290,7 +334,7 @@ LTTNG_TRACEPOINT_EVENT(block_rq_requeue,
                        lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq))
        )
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,12,0))
 /**
  * block_rq_requeue - place block IO request back on a queue
  * @q: queue holding operation
@@ -336,7 +380,24 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq_with_error, block_rq_requeue,
  * do for the request. If @rq->bio is non-NULL then there is
  * additional work required to complete the request.
  */
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,16,0))
+LTTNG_TRACEPOINT_EVENT(block_rq_complete,
+
+       TP_PROTO(struct request *rq, blk_status_t error, unsigned int nr_bytes),
+
+       TP_ARGS(rq, error, nr_bytes),
+
+       TP_FIELDS(
+               ctf_integer(dev_t, dev,
+                       rq->rq_disk ? disk_devt(rq->rq_disk) : 0)
+               ctf_integer(sector_t, sector, blk_rq_pos(rq))
+               ctf_integer(unsigned int, nr_sector, nr_bytes >> 9)
+               ctf_integer(int, error, blk_status_to_errno(error))
+               blk_rwbs_ctf_integer(unsigned int, rwbs,
+                       lttng_req_op(rq), lttng_req_rw(rq), nr_bytes)
+       )
+)
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,12,0))
 LTTNG_TRACEPOINT_EVENT(block_rq_complete,
 
        TP_PROTO(struct request *rq, int error, unsigned int nr_bytes),
@@ -353,7 +414,7 @@ LTTNG_TRACEPOINT_EVENT(block_rq_complete,
                        lttng_req_op(rq), lttng_req_rw(rq), nr_bytes)
        )
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0))
 LTTNG_TRACEPOINT_EVENT_CODE(block_rq_complete,
 
        TP_PROTO(struct request_queue *q, struct request *rq,
@@ -391,7 +452,7 @@ LTTNG_TRACEPOINT_EVENT_CODE(block_rq_complete,
 
        TP_code_post()
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,5)    \
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,5)        \
        || LTTNG_KERNEL_RANGE(3,12,21, 3,13,0)          \
        || LTTNG_KERNEL_RANGE(3,10,41, 3,11,0)          \
        || LTTNG_KERNEL_RANGE(3,4,91, 3,5,0)            \
@@ -436,7 +497,7 @@ LTTNG_TRACEPOINT_EVENT_CODE(block_rq_complete,
        TP_code_post()
 )
 
-#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0)) */
+#else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,15,0)) */
 
 /**
  * block_rq_complete - block IO operation completed by device driver
@@ -456,9 +517,9 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq_with_error, block_rq_complete,
        TP_ARGS(q, rq)
 )
 
-#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0)) */
+#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,15,0)) */
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
 LTTNG_TRACEPOINT_EVENT_CLASS(block_rq,
 
        TP_PROTO(struct request *rq),
@@ -477,7 +538,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_rq,
                ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
        )
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,12,0))
 LTTNG_TRACEPOINT_EVENT_CLASS(block_rq,
 
        TP_PROTO(struct request_queue *q, struct request *rq),
@@ -496,7 +557,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_rq,
                ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
        )
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0))
 LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_rq,
 
        TP_PROTO(struct request_queue *q, struct request *rq),
@@ -544,7 +605,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_rq,
 
        TP_code_post()
 )
-#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */
+#else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0)) */
 LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_rq,
 
        TP_PROTO(struct request_queue *q, struct request *rq),
@@ -591,9 +652,9 @@ LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_rq,
 
        TP_code_post()
 )
-#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */
+#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0)) */
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
 /**
  * block_rq_insert - insert block operation request into queue
  * @rq: block IO operation request
@@ -628,7 +689,7 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_insert,
 )
 #endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
 /**
  * block_rq_issue - issue pending block IO request operation to device driver
  * @rq: block IO operation operation request
@@ -659,7 +720,7 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_issue,
 )
 #endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
 /**
  * block_rq_merge - merge request with another one in the elevator
  * @rq: block IO operation operation request
@@ -673,7 +734,7 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_merge,
 
        TP_ARGS(rq)
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(5,9,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,9,0))
 /**
  * block_rq_merge - merge request with another one in the elevator
  * @q: queue holding operation
@@ -690,7 +751,9 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_merge,
 )
 #endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,8,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,8,0) || \
+       LTTNG_RHEL_KERNEL_RANGE(4,18,0,305,0,0, 4,19,0,0,0,0))
+
 /**
  * block_bio_complete - completed all work on the block operation
  * @q: queue holding the block operation
@@ -716,7 +779,7 @@ LTTNG_TRACEPOINT_EVENT(block_bio_complete,
                        bio->bi_iter.bi_size)
        )
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,14,0))
 /**
  * block_bio_complete - completed all work on the block operation
  * @q: queue holding the block operation
@@ -742,7 +805,7 @@ LTTNG_TRACEPOINT_EVENT(block_bio_complete,
                        bio->bi_iter.bi_size)
        )
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0))
 /**
  * block_bio_complete - completed all work on the block operation
  * @q: queue holding the block operation
@@ -795,7 +858,7 @@ LTTNG_TRACEPOINT_EVENT(block_bio_complete,
 )
 #endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
 LTTNG_TRACEPOINT_EVENT_CLASS(block_bio,
 
        TP_PROTO(struct bio *bio),
@@ -813,7 +876,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_bio,
                ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
        )
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,14,0))
 LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge,
 
        TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
@@ -831,7 +894,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge,
                ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
        )
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0))
 LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge,
 
        TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
@@ -849,7 +912,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge,
                ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
        )
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,9,0))
 LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge,
 
        TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
@@ -870,7 +933,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge,
 
 
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
 /**
  * block_bio_bounce - used bounce buffer when processing block operation
  * @bio: block operation
@@ -887,7 +950,7 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_bounce,
 
        TP_ARGS(bio)
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,14,0))
 /**
  * block_bio_bounce - used bounce buffer when processing block operation
  * @q: queue holding the block operation
@@ -916,7 +979,7 @@ LTTNG_TRACEPOINT_EVENT(block_bio_bounce,
                ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
        )
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0))
 LTTNG_TRACEPOINT_EVENT(block_bio_bounce,
 
        TP_PROTO(struct request_queue *q, struct bio *bio),
@@ -955,7 +1018,7 @@ LTTNG_TRACEPOINT_EVENT(block_bio_bounce,
 #endif
 
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
 /**
  * block_bio_backmerge - merging block operation to the end of an existing operation
  * @bio: new block operation to merge
@@ -994,7 +1057,7 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_queue,
 
        TP_ARGS(bio)
 )
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,9,0))
 /**
  * block_bio_backmerge - merging block operation to the end of an existing operation
  * @q: queue holding operation
@@ -1041,28 +1104,28 @@ LTTNG_TRACEPOINT_EVENT(block_bio_queue,
        TP_ARGS(q, bio),
 
        TP_FIELDS(
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,14,0))
                ctf_integer(dev_t, dev, bio_dev(bio))
 #else
                ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
 #endif
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0))
                ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
                ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
                blk_rwbs_ctf_integer(unsigned int, rwbs,
                        lttng_bio_op(bio), lttng_bio_rw(bio),
                        bio->bi_iter.bi_size)
-#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) */
+#else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0)) */
                ctf_integer(sector_t, sector, bio->bi_sector)
                ctf_integer(unsigned int, nr_sector, bio->bi_size >> 9)
                blk_rwbs_ctf_integer(unsigned int, rwbs,
                        lttng_bio_op(bio), lttng_bio_rw(bio), bio->bi_size)
-#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) */
+#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0)) */
                ctf_integer(pid_t, tid, current->pid)
                ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
        )
 )
-#else /* if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)) */
+#else /* if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,9,0)) */
 LTTNG_TRACEPOINT_EVENT_CLASS(block_bio,
 
        TP_PROTO(struct request_queue *q, struct bio *bio),
@@ -1123,9 +1186,9 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_queue,
 
        TP_ARGS(q, bio)
 )
-#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)) */
+#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,9,0)) */
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
 /**
  * block_getrq - get a free request entry in queue for block IO operations
  * @bio: pending block IO operation (can be %NULL)
@@ -1146,12 +1209,12 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_get_rq,
        TP_ARGS(q, bio, rw),
 
        TP_FIELDS(
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,14,0))
                ctf_integer(dev_t, dev, bio ? bio_dev(bio) : 0)
 #else
                ctf_integer(dev_t, dev, bio ? bio->bi_bdev->bd_dev : 0)
 #endif
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0))
                ctf_integer(sector_t, sector, bio ? bio->bi_iter.bi_sector : 0)
                ctf_integer(unsigned int, nr_sector,
                        bio ? bio_sectors(bio) : 0)
@@ -1159,7 +1222,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_get_rq,
                        bio ? lttng_bio_op(bio) : 0,
                        bio ? lttng_bio_rw(bio) : 0,
                        bio ? bio->bi_iter.bi_size : 0)
-#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) */
+#else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0)) */
                ctf_integer(sector_t, sector, bio ? bio->bi_sector : 0)
                ctf_integer(unsigned int, nr_sector,
                        bio ? bio->bi_size >> 9 : 0)
@@ -1167,7 +1230,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_get_rq,
                        bio ? lttng_bio_op(bio) : 0,
                        bio ? lttng_bio_rw(bio) : 0,
                        bio ? bio->bi_size : 0)
-#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) */
+#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0)) */
                ctf_integer(pid_t, tid, current->pid)
                ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
         )
@@ -1257,6 +1320,36 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_unplug, block_unplug,
        TP_ARGS(q, depth, explicit)
 )
 
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
+/**
+ * block_split - split a single bio struct into two bio structs
+ * @bio: block operation being split
+ * @new_sector: The starting sector for the new bio
+ *
+ * The bio request @bio needs to be split into two bio requests.  The newly
+ * created @bio request starts at @new_sector. This split may be required due to
+ * hardware limitations such as operation crossing device boundaries in a RAID
+ * system.
+ */
+LTTNG_TRACEPOINT_EVENT(block_split,
+
+       TP_PROTO(struct bio *bio, unsigned int new_sector),
+
+       TP_ARGS(bio, new_sector),
+
+       TP_FIELDS(
+               ctf_integer(dev_t, dev, bio_dev(bio))
+               ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
+               blk_rwbs_ctf_integer(unsigned int, rwbs,
+                       lttng_bio_op(bio), lttng_bio_rw(bio),
+                       bio->bi_iter.bi_size)
+               ctf_integer(sector_t, new_sector, new_sector)
+               ctf_integer(pid_t, tid, current->pid)
+               ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
+       )
+)
+
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,14,0))
 /**
  * block_split - split a single bio struct into two bio structs
  * @q: queue containing the bio
@@ -1276,27 +1369,83 @@ LTTNG_TRACEPOINT_EVENT(block_split,
        TP_ARGS(q, bio, new_sector),
 
        TP_FIELDS(
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
                ctf_integer(dev_t, dev, bio_dev(bio))
-#else
+               ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
+               blk_rwbs_ctf_integer(unsigned int, rwbs,
+                       lttng_bio_op(bio), lttng_bio_rw(bio),
+                       bio->bi_iter.bi_size)
+               ctf_integer(sector_t, new_sector, new_sector)
+               ctf_integer(pid_t, tid, current->pid)
+               ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
+       )
+)
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0))
+LTTNG_TRACEPOINT_EVENT(block_split,
+
+       TP_PROTO(struct request_queue *q, struct bio *bio,
+                unsigned int new_sector),
+
+       TP_ARGS(q, bio, new_sector),
+
+       TP_FIELDS(
                ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
-#endif
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
                ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
                blk_rwbs_ctf_integer(unsigned int, rwbs,
                        lttng_bio_op(bio), lttng_bio_rw(bio),
                        bio->bi_iter.bi_size)
-#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) */
+               ctf_integer(sector_t, new_sector, new_sector)
+               ctf_integer(pid_t, tid, current->pid)
+               ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
+       )
+)
+#else
+LTTNG_TRACEPOINT_EVENT(block_split,
+
+       TP_PROTO(struct request_queue *q, struct bio *bio,
+                unsigned int new_sector),
+
+       TP_ARGS(q, bio, new_sector),
+
+       TP_FIELDS(
+               ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
                ctf_integer(sector_t, sector, bio->bi_sector)
                blk_rwbs_ctf_integer(unsigned int, rwbs,
                        lttng_bio_op(bio), lttng_bio_rw(bio), bio->bi_size)
-#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) */
                ctf_integer(sector_t, new_sector, new_sector)
                ctf_integer(pid_t, tid, current->pid)
                ctf_array_text(char, comm, current->comm, TASK_COMM_LEN)
        )
 )
+#endif
 
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
+/**
+ * block_bio_remap - map request for a logical device to the raw device
+ * @bio: revised operation
+ * @dev: original device for the operation
+ * @from: original sector for the operation
+ *
+ * An operation for a logical device has been mapped to the
+ * raw block device.
+ */
+LTTNG_TRACEPOINT_EVENT(block_bio_remap,
+
+       TP_PROTO(struct bio *bio, dev_t dev, sector_t from),
+
+       TP_ARGS(bio, dev, from),
+
+       TP_FIELDS(
+               ctf_integer(dev_t, dev, bio_dev(bio))
+               ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
+               ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
+               blk_rwbs_ctf_integer(unsigned int, rwbs,
+                       lttng_bio_op(bio), lttng_bio_rw(bio),
+                       bio->bi_iter.bi_size)
+               ctf_integer(dev_t, old_dev, dev)
+               ctf_integer(sector_t, old_sector, from)
+       )
+)
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,14,0))
 /**
  * block_bio_remap - map request for a logical device to the raw device
  * @q: queue holding the operation
@@ -1315,29 +1464,56 @@ LTTNG_TRACEPOINT_EVENT(block_bio_remap,
        TP_ARGS(q, bio, dev, from),
 
        TP_FIELDS(
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
                ctf_integer(dev_t, dev, bio_dev(bio))
-#else
+               ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
+               ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
+               blk_rwbs_ctf_integer(unsigned int, rwbs,
+                       lttng_bio_op(bio), lttng_bio_rw(bio),
+                       bio->bi_iter.bi_size)
+               ctf_integer(dev_t, old_dev, dev)
+               ctf_integer(sector_t, old_sector, from)
+       )
+)
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0))
+LTTNG_TRACEPOINT_EVENT(block_bio_remap,
+
+       TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
+                sector_t from),
+
+       TP_ARGS(q, bio, dev, from),
+
+       TP_FIELDS(
                ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
-#endif
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
                ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
                ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
                blk_rwbs_ctf_integer(unsigned int, rwbs,
                        lttng_bio_op(bio), lttng_bio_rw(bio),
                        bio->bi_iter.bi_size)
-#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) */
+               ctf_integer(dev_t, old_dev, dev)
+               ctf_integer(sector_t, old_sector, from)
+       )
+)
+#else
+LTTNG_TRACEPOINT_EVENT(block_bio_remap,
+
+       TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
+                sector_t from),
+
+       TP_ARGS(q, bio, dev, from),
+
+       TP_FIELDS(
+               ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
                ctf_integer(sector_t, sector, bio->bi_sector)
                ctf_integer(unsigned int, nr_sector, bio->bi_size >> 9)
                blk_rwbs_ctf_integer(unsigned int, rwbs,
                        lttng_bio_op(bio), lttng_bio_rw(bio), bio->bi_size)
-#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) */
                ctf_integer(dev_t, old_dev, dev)
                ctf_integer(sector_t, old_sector, from)
        )
 )
+#endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
 /**
  * block_rq_remap - map request for a block operation request
  * @rq: block IO operation request
LTTng 2.0/0.x modules
This page took 0.0342 seconds and 4 git commands to generate.