diff -Nru lttng-modules-2.12.2/debian/changelog lttng-modules-2.12.2/debian/changelog --- lttng-modules-2.12.2/debian/changelog 2020-11-26 11:07:33.000000000 +0000 +++ lttng-modules-2.12.2/debian/changelog 2021-03-08 10:14:01.000000000 +0000 @@ -1,3 +1,10 @@ +lttng-modules (2.12.2-1ubuntu3) hirsute; urgency=medium + + * Linux 5.11 support (LP: #1918109): + - debian/patches/0010-linux-5.11-support.patch + + -- Andrea Righi Mon, 08 Mar 2021 10:14:01 +0000 + lttng-modules (2.12.2-1ubuntu2) hirsute; urgency=medium * Import upstream/stable-2.12 fixes for Linux 5.9 && 5.10: diff -Nru lttng-modules-2.12.2/debian/patches/0010-linux-5.11-support.patch lttng-modules-2.12.2/debian/patches/0010-linux-5.11-support.patch --- lttng-modules-2.12.2/debian/patches/0010-linux-5.11-support.patch 1970-01-01 00:00:00.000000000 +0000 +++ lttng-modules-2.12.2/debian/patches/0010-linux-5.11-support.patch 2021-03-08 10:14:01.000000000 +0000 @@ -0,0 +1,956 @@ +Subject: properly support linux 5.11 + +Origin: upstream, https://github.com/lttng/lttng-modules.git +Bug-Ubuntu: https://bugs.launchpad.net/bugs/1918109 + +--- + +Index: lttng-modules-2.12.2/instrumentation/events/lttng-module/block.h +=================================================================== +--- lttng-modules-2.12.2.orig/instrumentation/events/lttng-module/block.h ++++ lttng-modules-2.12.2/instrumentation/events/lttng-module/block.h +@@ -266,6 +266,31 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq + ) + #endif + ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) ++/** ++ * block_rq_requeue - place block IO request back on a queue ++ * @rq: block IO operation request ++ * ++ * The block operation request @rq is being placed back into queue ++ * @q. For some reason the request was not completed and needs to be ++ * put back in the queue. ++ */ ++LTTNG_TRACEPOINT_EVENT(block_rq_requeue, ++ ++ TP_PROTO(struct request *rq), ++ ++ TP_ARGS(rq), ++ ++ TP_FIELDS( ++ ctf_integer(dev_t, dev, ++ rq->rq_disk ? disk_devt(rq->rq_disk) : 0) ++ ctf_integer(sector_t, sector, blk_rq_trace_sector(rq)) ++ ctf_integer(unsigned int, nr_sector, blk_rq_trace_nr_sectors(rq)) ++ blk_rwbs_ctf_integer(unsigned int, rwbs, ++ lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq)) ++ ) ++) ++#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0)) + /** + * block_rq_requeue - place block IO request back on a queue + * @q: queue holding operation +@@ -275,7 +300,6 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq + * @q. For some reason the request was not completed and needs to be + * put back in the queue. + */ +-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0)) + LTTNG_TRACEPOINT_EVENT(block_rq_requeue, + + TP_PROTO(struct request_queue *q, struct request *rq), +@@ -434,7 +458,26 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq + + #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0)) */ + +-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0)) ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) ++LTTNG_TRACEPOINT_EVENT_CLASS(block_rq, ++ ++ TP_PROTO(struct request *rq), ++ ++ TP_ARGS(rq), ++ ++ TP_FIELDS( ++ ctf_integer(dev_t, dev, ++ rq->rq_disk ? disk_devt(rq->rq_disk) : 0) ++ ctf_integer(sector_t, sector, blk_rq_trace_sector(rq)) ++ ctf_integer(unsigned int, nr_sector, blk_rq_trace_nr_sectors(rq)) ++ ctf_integer(unsigned int, bytes, blk_rq_bytes(rq)) ++ ctf_integer(pid_t, tid, current->pid) ++ blk_rwbs_ctf_integer(unsigned int, rwbs, ++ lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq)) ++ ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) ++ ) ++) ++#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0)) + LTTNG_TRACEPOINT_EVENT_CLASS(block_rq, + + TP_PROTO(struct request_queue *q, struct request *rq), +@@ -550,6 +593,23 @@ LTTNG_TRACEPOINT_EVENT_CLASS_CODE(block_ + ) + #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */ + ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) ++/** ++ * block_rq_insert - insert block operation request into queue ++ * @rq: block IO operation request ++ * ++ * Called immediately before block operation request @rq is inserted ++ * into queue @q. The fields in the operation request @rq struct can ++ * be examined to determine which device and sectors the pending ++ * operation would access. ++ */ ++LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_insert, ++ ++ TP_PROTO(struct request *rq), ++ ++ TP_ARGS(rq) ++) ++#else + /** + * block_rq_insert - insert block operation request into queue + * @q: target queue +@@ -566,7 +626,23 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq + + TP_ARGS(q, rq) + ) ++#endif ++ ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) ++/** ++ * block_rq_issue - issue pending block IO request operation to device driver ++ * @rq: block IO operation operation request ++ * ++ * Called when block operation request @rq from queue @q is sent to a ++ * device driver for processing. ++ */ ++LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_issue, ++ ++ TP_PROTO(struct request *rq), + ++ TP_ARGS(rq) ++) ++#else + /** + * block_rq_issue - issue pending block IO request operation to device driver + * @q: queue holding operation +@@ -581,48 +657,38 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq + + TP_ARGS(q, rq) + ) ++#endif + ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) + /** +- * block_bio_bounce - used bounce buffer when processing block operation +- * @q: queue holding the block operation +- * @bio: block operation ++ * block_rq_merge - merge request with another one in the elevator ++ * @rq: block IO operation operation request + * +- * A bounce buffer was used to handle the block operation @bio in @q. +- * This occurs when hardware limitations prevent a direct transfer of +- * data between the @bio data memory area and the IO device. Use of a +- * bounce buffer requires extra copying of data and decreases +- * performance. ++ * Called when block operation request @rq from queue @q is merged to another ++ * request queued in the elevator. + */ +-LTTNG_TRACEPOINT_EVENT(block_bio_bounce, +- +- TP_PROTO(struct request_queue *q, struct bio *bio), ++LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_merge, + +- TP_ARGS(q, bio), ++ TP_PROTO(struct request *rq), + +- TP_FIELDS( +-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0)) +- ctf_integer(dev_t, dev, bio_dev(bio)) +-#else +- ctf_integer(dev_t, dev, bio->bi_bdev ? bio->bi_bdev->bd_dev : 0) +-#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(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(pid_t, tid, current->pid) +- ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) +- ) ++ TP_ARGS(rq) + ) ++#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(5,9,0)) ++/** ++ * block_rq_merge - merge request with another one in the elevator ++ * @q: queue holding operation ++ * @rq: block IO operation operation request ++ * ++ * Called when block operation request @rq from queue @q is merged to another ++ * request queued in the elevator. ++ */ ++LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_merge, + ++ TP_PROTO(struct request_queue *q, struct request *rq), ++ ++ TP_ARGS(q, rq) ++) ++#endif + + #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,8,0)) + /** +@@ -729,7 +795,25 @@ LTTNG_TRACEPOINT_EVENT(block_bio_complet + ) + #endif + +-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)) ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) ++LTTNG_TRACEPOINT_EVENT_CLASS(block_bio, ++ ++ TP_PROTO(struct bio *bio), ++ ++ TP_ARGS(bio), ++ ++ 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(pid_t, tid, current->pid) ++ ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) ++ ) ++) ++#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0)) + LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge, + + TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), +@@ -737,31 +821,184 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_m + TP_ARGS(q, rq, bio), + + 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(pid_t, tid, current->pid) ++ ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) ++ ) ++) ++#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) ++LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge, ++ ++ TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), ++ ++ TP_ARGS(q, rq, bio), ++ ++ 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(pid_t, tid, current->pid) ++ ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) ++ ) ++) ++#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)) ++LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge, ++ ++ TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), ++ ++ TP_ARGS(q, rq, bio), ++ ++ 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(pid_t, tid, current->pid) + ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) + ) + ) ++#endif ++ + ++ ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) ++/** ++ * block_bio_bounce - used bounce buffer when processing block operation ++ * @bio: block operation ++ * ++ * A bounce buffer was used to handle the block operation @bio in @q. ++ * This occurs when hardware limitations prevent a direct transfer of ++ * data between the @bio data memory area and the IO device. Use of a ++ * bounce buffer requires extra copying of data and decreases ++ * performance. ++ */ ++LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_bounce, ++ ++ TP_PROTO(struct bio *bio), ++ ++ TP_ARGS(bio) ++) ++#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0)) ++/** ++ * block_bio_bounce - used bounce buffer when processing block operation ++ * @q: queue holding the block operation ++ * @bio: block operation ++ * ++ * A bounce buffer was used to handle the block operation @bio in @q. ++ * This occurs when hardware limitations prevent a direct transfer of ++ * data between the @bio data memory area and the IO device. Use of a ++ * bounce buffer requires extra copying of data and decreases ++ * performance. ++ */ ++LTTNG_TRACEPOINT_EVENT(block_bio_bounce, ++ ++ TP_PROTO(struct request_queue *q, struct bio *bio), ++ ++ TP_ARGS(q, bio), ++ ++ 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(pid_t, tid, current->pid) ++ ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) ++ ) ++) ++#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) ++LTTNG_TRACEPOINT_EVENT(block_bio_bounce, ++ ++ TP_PROTO(struct request_queue *q, struct bio *bio), ++ ++ TP_ARGS(q, bio), ++ ++ TP_FIELDS( ++ ctf_integer(dev_t, dev, bio->bi_bdev ? bio->bi_bdev->bd_dev : 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) ++ ctf_integer(pid_t, tid, current->pid) ++ ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) ++ ) ++) ++#else ++LTTNG_TRACEPOINT_EVENT(block_bio_bounce, ++ ++ TP_PROTO(struct request_queue *q, struct bio *bio), ++ ++ TP_ARGS(q, bio), ++ ++ TP_FIELDS( ++ ctf_integer(dev_t, dev, bio->bi_bdev ? bio->bi_bdev->bd_dev : 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) ++ ctf_integer(pid_t, tid, current->pid) ++ ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) ++ ) ++) ++#endif ++ ++ ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) ++/** ++ * block_bio_backmerge - merging block operation to the end of an existing operation ++ * @bio: new block operation to merge ++ * ++ * Merging block request @bio to the end of an existing block request. ++ */ ++LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_backmerge, ++ ++ TP_PROTO(struct bio *bio), ++ ++ TP_ARGS(bio) ++) ++ ++/** ++ * block_bio_frontmerge - merging block operation to the beginning of an existing operation ++ * @bio: new block operation to merge ++ * ++ * Merging block IO operation @bio to the beginning of an existing block request. ++ */ ++LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_frontmerge, ++ ++ TP_PROTO(struct bio *bio), ++ ++ TP_ARGS(bio) ++) ++ ++/** ++ * block_bio_queue - putting new block IO operation in queue ++ * @bio: new block operation ++ * ++ * About to place the block IO operation @bio into queue @q. ++ */ ++LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_queue, ++ ++ TP_PROTO(struct bio *bio), ++ ++ TP_ARGS(bio) ++) ++#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)) + /** + * block_bio_backmerge - merging block operation to the end of an existing operation + * @q: queue holding operation ++ * @rq: request bio is being merged into + * @bio: new block operation to merge + * + * Merging block request @bio to the end of an existing block request +@@ -777,6 +1014,7 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bi + /** + * block_bio_frontmerge - merging block operation to the beginning of an existing operation + * @q: queue holding operation ++ * @rq: request bio is being merged into + * @bio: new block operation to merge + * + * Merging block IO operation @bio to the beginning of an existing block +@@ -887,6 +1125,20 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bi + ) + #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)) */ + ++#if (LINUX_VERSION_CODE >= 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) ++ * ++ * A request struct has been allocated to handle the block IO operation @bio. ++ */ ++LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_getrq, ++ ++ TP_PROTO(struct bio *bio), ++ ++ TP_ARGS(bio) ++) ++#else + LTTNG_TRACEPOINT_EVENT_CLASS(block_get_rq, + + TP_PROTO(struct request_queue *q, struct bio *bio, int rw), +@@ -954,6 +1206,7 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_ge + + TP_ARGS(q, bio, rw) + ) ++#endif + + /** + * block_plug - keep operations requests in request queue +@@ -1004,6 +1257,36 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(block_un + TP_ARGS(q, depth, explicit) + ) + ++#if (LINUX_VERSION_CODE >= 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 (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0)) + /** + * block_split - split a single bio struct into two bio structs + * @q: queue containing the bio +@@ -1023,27 +1306,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 (LINUX_VERSION_CODE >= 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 (LINUX_VERSION_CODE >= 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 (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0)) + /** + * block_bio_remap - map request for a logical device to the raw device + * @q: queue holding the operation +@@ -1062,28 +1401,83 @@ 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 (LINUX_VERSION_CODE >= 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)) ++/** ++ * block_rq_remap - map request for a block operation request ++ * @rq: block IO operation request ++ * @dev: device for the operation ++ * @from: original sector for the operation ++ * ++ * The block operation request @rq in @q has been remapped. The block ++ * operation request @rq holds the current information and @from hold ++ * the original sector. ++ */ ++LTTNG_TRACEPOINT_EVENT(block_rq_remap, ++ ++ TP_PROTO(struct request *rq, dev_t dev, sector_t from), ++ ++ TP_ARGS(rq, dev, from), ++ ++ TP_FIELDS( ++ ctf_integer(dev_t, dev, disk_devt(rq->rq_disk)) ++ ctf_integer(sector_t, sector, blk_rq_pos(rq)) ++ ctf_integer(unsigned int, nr_sector, blk_rq_sectors(rq)) ++ ctf_integer(dev_t, old_dev, dev) ++ ctf_integer(sector_t, old_sector, from) ++ blk_rwbs_ctf_integer(unsigned int, rwbs, ++ lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq)) ++ ) ++) ++#else + /** + * block_rq_remap - map request for a block operation request + * @q: queue holding the operation +@@ -1112,6 +1506,7 @@ LTTNG_TRACEPOINT_EVENT(block_rq_remap, + lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq)) + ) + ) ++#endif + + #undef __print_rwbs_flags + #undef blk_fill_rwbs +Index: lttng-modules-2.12.2/instrumentation/events/lttng-module/writeback.h +=================================================================== +--- lttng-modules-2.12.2.orig/instrumentation/events/lttng-module/writeback.h ++++ lttng-modules-2.12.2/instrumentation/events/lttng-module/writeback.h +@@ -46,7 +46,8 @@ static inline struct backing_dev_info *l + + #endif + +-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) ++#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) + #define show_inode_state(state) \ + __print_flags(state, "|", \ + {I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \ +@@ -61,7 +62,7 @@ static inline struct backing_dev_info *l + {I_DIRTY_TIME_EXPIRED, "I_DIRTY_TIME_EXPIRED"}, \ + {I_REFERENCED, "I_REFERENCED"} \ + ) +-#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */ ++#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) */ + #define show_inode_state(state) \ + __print_flags(state, "|", \ + {I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \ +@@ -74,7 +75,7 @@ static inline struct backing_dev_info *l + {I_SYNC, "I_SYNC"}, \ + {I_REFERENCED, "I_REFERENCED"} \ + ) +-#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */ ++#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) */ + + #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) + +Index: lttng-modules-2.12.2/lttng-statedump-impl.c +=================================================================== +--- lttng-modules-2.12.2.orig/lttng-statedump-impl.c ++++ lttng-modules-2.12.2/lttng-statedump-impl.c +@@ -188,6 +188,61 @@ enum lttng_process_status { + LTTNG_DEAD = 7, + }; + ++ ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) ++ ++#define LTTNG_PART_STRUCT_TYPE struct block_device ++ ++static ++int lttng_get_part_name(struct gendisk *disk, struct block_device *part, char *name_buf) ++{ ++ const char *p; ++ ++ p = bdevname(part, name_buf); ++ if (!p) ++ return -ENOSYS; ++ ++ return 0; ++} ++ ++static ++dev_t lttng_get_part_devt(struct block_device *part) ++{ ++ return part->bd_dev; ++} ++ ++#else ++ ++#define LTTNG_PART_STRUCT_TYPE struct hd_struct ++ ++static ++int lttng_get_part_name(struct gendisk *disk, struct hd_struct *part, char *name_buf) ++{ ++ const char *p; ++ struct block_device bdev; ++ ++ /* ++ * Create a partial 'struct blockdevice' to use ++ * 'bdevname()' which is a simple wrapper over ++ * 'disk_name()' but has the honor to be EXPORT_SYMBOL. ++ */ ++ bdev.bd_disk = disk; ++ bdev.bd_part = part; ++ ++ p = bdevname(&bdev, name_buf); ++ if (!p) ++ return -ENOSYS; ++ ++ return 0; ++} ++ ++static ++dev_t lttng_get_part_devt(struct hd_struct *part) ++{ ++ return part_devt(part); ++} ++#endif ++ + static + int lttng_enumerate_block_devices(struct lttng_session *session) + { +@@ -207,7 +262,7 @@ int lttng_enumerate_block_devices(struct + while ((dev = class_dev_iter_next(&iter))) { + struct disk_part_iter piter; + struct gendisk *disk = dev_to_disk(dev); +- struct hd_struct *part; ++ LTTNG_PART_STRUCT_TYPE *part; + + /* + * Don't show empty devices or things that have been +@@ -219,26 +274,15 @@ int lttng_enumerate_block_devices(struct + + disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0); + while ((part = disk_part_iter_next(&piter))) { +- struct block_device bdev; + char name_buf[BDEVNAME_SIZE]; +- const char *p; +- +- /* +- * Create a partial 'struct blockdevice' to use +- * 'bdevname()' which is a simple wrapper over +- * 'disk_name()' but has the honor to be EXPORT_SYMBOL. +- */ +- bdev.bd_disk = disk; +- bdev.bd_part = part; + +- p = bdevname(&bdev, name_buf); +- if (!p) { ++ if (lttng_get_part_name(disk, part, name_buf) == -ENOSYS) { + disk_part_iter_exit(&piter); + class_dev_iter_exit(&iter); + return -ENOSYS; + } + trace_lttng_statedump_block_device(session, +- part_devt(part), name_buf); ++ lttng_get_part_devt(part), name_buf); + } + disk_part_iter_exit(&piter); + } +Index: lttng-modules-2.12.2/probes/lttng-kretprobes.c +=================================================================== +--- lttng-modules-2.12.2.orig/probes/lttng-kretprobes.c ++++ lttng-modules-2.12.2/probes/lttng-kretprobes.c +@@ -8,7 +8,7 @@ + */ + + #include +-#include ++#include + #include + #include + #include +@@ -36,7 +36,7 @@ int _lttng_kretprobes_handler(struct kre + enum lttng_kretprobe_type type) + { + struct lttng_krp *lttng_krp = +- container_of(krpi->rp, struct lttng_krp, krp); ++ container_of(lttng_get_kretprobe(krpi), struct lttng_krp, krp); + struct lttng_event *event = + lttng_krp->event[type]; + struct lttng_probe_ctx lttng_probe_ctx = { +@@ -58,7 +58,7 @@ int _lttng_kretprobes_handler(struct kre + if (unlikely(!LTTNG_READ_ONCE(event->enabled))) + return 0; + +- payload.ip = (unsigned long) krpi->rp->kp.addr; ++ payload.ip = (unsigned long) lttng_get_kretprobe(krpi)->kp.addr; + payload.parent_ip = (unsigned long) krpi->ret_addr; + + lib_ring_buffer_ctx_init(&ctx, chan->chan, <tng_probe_ctx, sizeof(payload), +Index: lttng-modules-2.12.2/probes/lttng-uprobes.c +=================================================================== +--- lttng-modules-2.12.2.orig/probes/lttng-uprobes.c ++++ lttng-modules-2.12.2/probes/lttng-uprobes.c +@@ -9,7 +9,7 @@ + * + */ + +-#include ++#include + #include + #include + #include +@@ -126,7 +126,7 @@ static struct inode *get_inode_from_fd(i + * Returns the file backing the given fd. Needs to be done inside an RCU + * critical section. + */ +- file = fcheck(fd); ++ file = lttng_lookup_fd_rcu(fd); + if (file == NULL) { + printk(KERN_WARNING "Cannot access file backing the fd(%d)\n", fd); + inode = NULL; +Index: lttng-modules-2.12.2/wrapper/fdtable.h +=================================================================== +--- lttng-modules-2.12.2.orig/wrapper/fdtable.h ++++ lttng-modules-2.12.2/wrapper/fdtable.h +@@ -11,6 +11,20 @@ + #include + #include + ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) ++static inline ++struct file *lttng_lookup_fd_rcu(unsigned int fd) ++{ ++ return lookup_fd_rcu(fd); ++} ++#else ++static inline ++struct file *lttng_lookup_fd_rcu(unsigned int fd) ++{ ++ return fcheck(fd); ++} ++#endif ++ + #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)) + + int lttng_iterate_fd(struct files_struct *files, +Index: lttng-modules-2.12.2/wrapper/irqdesc.c +=================================================================== +--- lttng-modules-2.12.2.orig/wrapper/irqdesc.c ++++ lttng-modules-2.12.2/wrapper/irqdesc.c +@@ -4,7 +4,7 @@ + * + * wrapper around irq_to_desc. Using KALLSYMS to get its address when + * available, else we need to have a kernel that exports this function to GPL +- * modules. This export was added to the 3.4 kernels. ++ * modules. This export was added to the 3.4 kernels and removed in 5.11. + * + * Copyright (C) 2011-2012 Mathieu Desnoyers + */ +@@ -12,8 +12,9 @@ + #include + #include + +-#if (defined(CONFIG_KALLSYMS) \ +- && (LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0))) ++#if (defined(CONFIG_KALLSYMS) && \ ++ ((LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) || \ ++ (LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0)))) + + #include + #include +Index: lttng-modules-2.12.2/wrapper/kprobes.h +=================================================================== +--- /dev/null ++++ lttng-modules-2.12.2/wrapper/kprobes.h +@@ -0,0 +1,32 @@ ++/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) ++ * ++ * src/wrapper/kprobes.h ++ * ++ * Copyright (C) 2021 Michael Jeanson ++ */ ++ ++#ifndef _LTTNG_WRAPPER_KPROBES_H ++#define _LTTNG_WRAPPER_KPROBES_H ++ ++#include ++#include ++ ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0)) ++ ++static inline ++struct kretprobe *lttng_get_kretprobe(struct kretprobe_instance *ri) ++{ ++ return get_kretprobe(ri); ++} ++ ++#else /* LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0) */ ++ ++static inline ++struct kretprobe *lttng_get_kretprobe(struct kretprobe_instance *ri) ++{ ++ return ri->rp; ++} ++ ++#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0) */ ++ ++#endif /* _LTTNG_WRAPPER_KPROBES_H */ diff -Nru lttng-modules-2.12.2/debian/patches/series lttng-modules-2.12.2/debian/patches/series --- lttng-modules-2.12.2/debian/patches/series 2020-11-26 11:07:33.000000000 +0000 +++ lttng-modules-2.12.2/debian/patches/series 2021-03-08 10:14:01.000000000 +0000 @@ -6,3 +6,4 @@ 0004-fix-objtool-Rename-frame.h-objtool.h-v5.10.patch 0005-fix-tracepoint-Optimize-using-static_call-v5.10.patch 0006-fix-statedump-undefined-symbols-caused-by-incorrect-.patch +0010-linux-5.11-support.patch