[PATCH 0/3] Add virtio_balloon operation tracepoints

[PATCH 0/3] Add virtio_balloon operation tracepoints

[liuqiangneo]

From: Qiang Liu <liuqiang@kylinos.cn>

When a guest does not react to balloon size requests as expected, or balloon
operations stall, guest-side balloon activity cannot be observed. Existing
feedback ("Out of puff" log and host memory stats) cannot be correlated with
specific requests or host latency.

This series adds tracepoints under "virtio_balloon":

1/3: config_change / inflate / deflate: log target size, applied pages and
final size to see partial balloon adjustments.
2/3: host_ack: measure tell_host() waiting latency with vq and PFN info to
distinguish host/guest latency.
3/3: free_page_hint / migrate: track host hint commands/outstanding blocks,
and balloon page migration including balloon_lock -EAGAIN aborts.

Tracepoints are inactive by default and add no production overhead.
Test by enabling events in tracefs, triggering balloon resize, compaction
or live migration, then reading trace_pipe. Verified on QEMU/KVM.

Checkpatch --strict reports harmless alignment warnings inside TRACE_EVENT,
consistent with other trace event headers.

Qiang Liu (3):
  virtio_balloon: add tracepoints for inflate and deflate operations
  virtio_balloon: add tracepoint for host ack latency
  virtio_balloon: add tracepoints for free page hinting and migration

 MAINTAINERS                           |   1 +
 drivers/virtio/virtio_balloon.c       |  43 ++++++-
 include/trace/events/virtio_balloon.h | 157 ++++++++++++++++++++++++++
 3 files changed, 198 insertions(+), 3 deletions(-)
 create mode 100644 include/trace/events/virtio_balloon.h

-- 
2.43.0

[PATCH 1/3] virtio_balloon: add tracepoints for inflate and deflate operations

[liuqiangneo]

From: Qiang Liu <liuqiang@kylinos.cn>

When the guest responds unexpectedly to balloon resize requests,
the actual applied delta cannot be observed from the guest side.

Add a "virtio_balloon" trace system with three tracepoints:
config_change (target / resulting size / delta), and
inflate and deflate (requested / applied page units / resulting size).

Signed-off-by: Qiang Liu <liuqiang@kylinos.cn>
---
 MAINTAINERS                           |  1 +
 drivers/virtio/virtio_balloon.c       | 13 ++++
 include/trace/events/virtio_balloon.h | 87 +++++++++++++++++++++++++++
 3 files changed, 101 insertions(+)
 create mode 100644 include/trace/events/virtio_balloon.h

diff --git a/MAINTAINERS b/MAINTAINERS
index e4ca41cdd872..0ef6f34471de 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -29590,6 +29590,7 @@ M:	David Hildenbrand <david@kernel.org>
 L:	virtualization@lists.linux.dev
 S:	Maintained
 F:	drivers/virtio/virtio_balloon.c
+F:	include/trace/events/virtio_balloon.h
 F:	include/uapi/linux/virtio_balloon.h
 
 VIRTIO BLOCK AND SCSI DRIVERS
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index ab3e3d887e00..2d0b16383661 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -19,6 +19,8 @@
 #include <linux/wait.h>
 #include <linux/mm.h>
 #include <linux/page_reporting.h>
+#define CREATE_TRACE_POINTS
+#include <trace/events/virtio_balloon.h>
 
 /*
  * Balloon device works in 4K page units.  So each page is pointed to by
@@ -285,6 +287,8 @@ static unsigned int fill_balloon(struct virtio_balloon *vb, size_t num)
 	/* Did we get any? */
 	if (vb->num_pfns != 0)
 		tell_host(vb, vb->inflate_vq);
+
+	trace_virtio_balloon_inflate(num, num_allocated_pages, vb->num_pages);
 	mutex_unlock(&vb->balloon_lock);
 
 	return num_allocated_pages;
@@ -333,6 +337,8 @@ static unsigned int leak_balloon(struct virtio_balloon *vb, size_t num)
 	if (vb->num_pfns != 0)
 		tell_host(vb, vb->deflate_vq);
 	release_pages_balloon(vb, &pages);
+
+	trace_virtio_balloon_deflate(num, num_freed_pages, vb->num_pages);
 	mutex_unlock(&vb->balloon_lock);
 	return num_freed_pages;
 }
@@ -567,11 +573,18 @@ static void update_balloon_size_func(struct work_struct *work)
 	diff = towards_target(vb);
 
 	if (diff) {
+		unsigned long target = vb->num_pages + diff;
+		unsigned long before = vb->num_pages;
+
 		if (diff > 0)
 			diff -= fill_balloon(vb, diff);
 		else
 			diff += leak_balloon(vb, -diff);
 		update_balloon_size(vb);
+
+		trace_virtio_balloon_config_change(target, vb->num_pages,
+						   (long)vb->num_pages -
+						   (long)before);
 	}
 
 	if (diff)
diff --git a/include/trace/events/virtio_balloon.h b/include/trace/events/virtio_balloon.h
new file mode 100644
index 000000000000..f733fc360d8b
--- /dev/null
+++ b/include/trace/events/virtio_balloon.h
@@ -0,0 +1,87 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM virtio_balloon
+
+#if !defined(_TRACE_VIRTIO_BALLOON_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_VIRTIO_BALLOON_H
+
+#include <linux/tracepoint.h>
+
+/*
+ * All page counts reported by these events are in balloon page units, i.e.
+ * the 4K units the virtio balloon device operates on.  Divide by
+ * VIRTIO_BALLOON_PAGES_PER_PAGE to obtain the number of guest pages.
+ */
+
+TRACE_EVENT(virtio_balloon_config_change,
+
+	TP_PROTO(unsigned long target, unsigned long num_pages, long delta),
+
+	TP_ARGS(target, num_pages, delta),
+
+	TP_STRUCT__entry(
+		__field(unsigned long, target)
+		__field(unsigned long, num_pages)
+		__field(long, delta)
+	),
+
+	TP_fast_assign(
+		__entry->target = target;
+		__entry->num_pages = num_pages;
+		__entry->delta = delta;
+	),
+
+	TP_printk("target=%lu num_pages=%lu delta=%ld",
+		  __entry->target, __entry->num_pages, __entry->delta)
+);
+
+TRACE_EVENT(virtio_balloon_inflate,
+
+	TP_PROTO(unsigned long requested, unsigned long inflated,
+		 unsigned long num_pages),
+
+	TP_ARGS(requested, inflated, num_pages),
+
+	TP_STRUCT__entry(
+		__field(unsigned long, requested)
+		__field(unsigned long, inflated)
+		__field(unsigned long, num_pages)
+	),
+
+	TP_fast_assign(
+		__entry->requested = requested;
+		__entry->inflated = inflated;
+		__entry->num_pages = num_pages;
+	),
+
+	TP_printk("requested=%lu inflated=%lu num_pages=%lu",
+		  __entry->requested, __entry->inflated, __entry->num_pages)
+);
+
+TRACE_EVENT(virtio_balloon_deflate,
+
+	TP_PROTO(unsigned long requested, unsigned long deflated,
+		 unsigned long num_pages),
+
+	TP_ARGS(requested, deflated, num_pages),
+
+	TP_STRUCT__entry(
+		__field(unsigned long, requested)
+		__field(unsigned long, deflated)
+		__field(unsigned long, num_pages)
+	),
+
+	TP_fast_assign(
+		__entry->requested = requested;
+		__entry->deflated = deflated;
+		__entry->num_pages = num_pages;
+	),
+
+	TP_printk("requested=%lu deflated=%lu num_pages=%lu",
+		  __entry->requested, __entry->deflated, __entry->num_pages)
+);
+
+#endif /* _TRACE_VIRTIO_BALLOON_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
-- 
2.43.0


No virus found
		Checked by Hillstone Network AntiVirus

Re: [PATCH 1/3] virtio_balloon: add tracepoints for inflate and deflate operations

[sashiko-bot]

> From: Qiang Liu <liuqiang@kylinos.cn>
> 
> When the guest responds unexpectedly to balloon resize requests,
> the actual applied delta cannot be observed from the guest side.
> 
> Add a "virtio_balloon" trace system with three tracepoints:
> config_change (target / resulting size / delta), and
> inflate and deflate (requested / applied page units / resulting size).
> 
> Signed-off-by: Qiang Liu <liuqiang@kylinos.cn>

Sashiko has reviewed this patch and found no issues.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261030025834.19160-1-liuqiangneo@163.com?part=1

[PATCH 2/3] virtio_balloon: add tracepoint for host ack latency

[liuqiangneo]

From: Qiang Liu <liuqiang@kylinos.cn>

Balloon inflate/deflate block in tell_host() for host buffer consumption.
Host-side stalls are easily mistaken for guest allocation issues.

Add virtio_balloon_host_ack to record tell_host() wait time,
virtqueue and PFN count, to split balloon latency between guest and host.

Signed-off-by: Qiang Liu <liuqiang@kylinos.cn>
---
 drivers/virtio/virtio_balloon.c       | 19 +++++++++++++++++--
 include/trace/events/virtio_balloon.h | 22 ++++++++++++++++++++++
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index 2d0b16383661..c4fdc6815b41 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -19,6 +19,7 @@
 #include <linux/wait.h>
 #include <linux/mm.h>
 #include <linux/page_reporting.h>
+#include <linux/ktime.h>
 #define CREATE_TRACE_POINTS
 #include <trace/events/virtio_balloon.h>
 
@@ -197,8 +198,22 @@ static void tell_host(struct virtio_balloon *vb, struct virtqueue *vq)
 		return;
 	virtqueue_kick(vq);
 
-	/* When host has read buffer, this completes via balloon_ack */
-	wait_event(vb->acked, virtqueue_get_buf(vq, &len));
+	/*
+	 * When host has read buffer, this completes via balloon_ack.
+	 *
+	 * The latency is only measured when the tracepoint is enabled, so a
+	 * disabled tracepoint adds no clock reads on this (hot) path.
+	 */
+	if (trace_virtio_balloon_host_ack_enabled()) {
+		ktime_t start = ktime_get();
+
+		wait_event(vb->acked, virtqueue_get_buf(vq, &len));
+		trace_virtio_balloon_host_ack(vb->num_pfns,
+					      vq->name,
+					      ktime_to_ns(ktime_sub(ktime_get(), start)));
+	} else {
+		wait_event(vb->acked, virtqueue_get_buf(vq, &len));
+	}
 }
 
 static int virtballoon_free_page_report(struct page_reporting_dev_info *pr_dev_info,
diff --git a/include/trace/events/virtio_balloon.h b/include/trace/events/virtio_balloon.h
index f733fc360d8b..559deb997e88 100644
--- a/include/trace/events/virtio_balloon.h
+++ b/include/trace/events/virtio_balloon.h
@@ -81,6 +81,28 @@ TRACE_EVENT(virtio_balloon_deflate,
 		  __entry->requested, __entry->deflated, __entry->num_pages)
 );
 
+TRACE_EVENT(virtio_balloon_host_ack,
+
+	TP_PROTO(unsigned int num_pfns, const char *vq_name, s64 latency_ns),
+
+	TP_ARGS(num_pfns, vq_name, latency_ns),
+
+	TP_STRUCT__entry(
+		__field(unsigned int, num_pfns)
+		__string(vq_name, vq_name)
+		__field(s64, latency_ns)
+	),
+
+	TP_fast_assign(
+		__entry->num_pfns = num_pfns;
+		__assign_str(vq_name);
+		__entry->latency_ns = latency_ns;
+	),
+
+	TP_printk("vq=%s num_pfns=%u latency=%lldns",
+		  __get_str(vq_name), __entry->num_pfns, __entry->latency_ns)
+);
+
 #endif /* _TRACE_VIRTIO_BALLOON_H */
 
 /* This part must be outside protection */
-- 
2.43.0


No virus found
		Checked by Hillstone Network AntiVirus

Re: [PATCH 2/3] virtio_balloon: add tracepoint for host ack latency

[sashiko-bot]

> From: Qiang Liu <liuqiang@kylinos.cn>
> 
> Balloon inflate/deflate block in tell_host() for host buffer consumption.
> Host-side stalls are easily mistaken for guest allocation issues.
> 
> Add virtio_balloon_host_ack to record tell_host() wait time,
> virtqueue and PFN count, to split balloon latency between guest and host.
> 
> Signed-off-by: Qiang Liu <liuqiang@kylinos.cn>

Sashiko has reviewed this patch and found no issues.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261030025834.19160-1-liuqiangneo@163.com?part=2

[PATCH 3/3] virtio_balloon: add tracepoints for free page hinting and migration

[liuqiangneo]

From: Qiang Liu <liuqiang@kylinos.cn>

Free page hint requests cannot be traced, and migration only
provides summary stats. Lock contention causing migration abort
cannot be distinguished, making these two flows hard to debug.

Add tracepoints to record host hint commands, leftover hint blocks
and balloon_lock -EAGAIN migration failures.

Signed-off-by: Qiang Liu <liuqiang@kylinos.cn>
---
 drivers/virtio/virtio_balloon.c       | 11 +++++-
 include/trace/events/virtio_balloon.h | 48 +++++++++++++++++++++++++++
 2 files changed, 58 insertions(+), 1 deletion(-)

diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index c4fdc6815b41..faf78c639f3c 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -803,6 +803,7 @@ static void virtio_balloon_report_free_page(struct virtio_balloon *vb)
 {
 	int err;
 	struct device *dev = &vb->vdev->dev;
+	unsigned int cmd_id = virtio_balloon_cmd_id_received(vb);
 
 	/* Start by sending the received cmd id to host with an outbuf. */
 	err = send_cmd_id_start(vb);
@@ -817,6 +818,9 @@ static void virtio_balloon_report_free_page(struct virtio_balloon *vb)
 	err = send_cmd_id_stop(vb);
 	if (unlikely(err))
 		dev_err(dev, "Failed to send a stop id, err = %d\n", err);
+
+	trace_virtio_balloon_free_page_hint(cmd_id,
+					    READ_ONCE(vb->num_free_page_blocks));
 }
 
 static void report_free_page_func(struct work_struct *work)
@@ -869,8 +873,11 @@ static int virtballoon_migratepage(struct balloon_dev_info *vb_dev_info,
 	 * recursion in the case it ends up triggering memory compaction
 	 * while it is attempting to inflate the ballon.
 	 */
-	if (!mutex_trylock(&vb->balloon_lock))
+	if (!mutex_trylock(&vb->balloon_lock)) {
+		trace_virtio_balloon_migrate(page_to_pfn(page),
+					     page_to_pfn(newpage), -EAGAIN);
 		return -EAGAIN;
+	}
 
 	/* balloon's page migration 1st step  -- inflate "newpage" */
 	vb->num_pfns = VIRTIO_BALLOON_PAGES_PER_PAGE;
@@ -883,6 +890,8 @@ static int virtballoon_migratepage(struct balloon_dev_info *vb_dev_info,
 	tell_host(vb, vb->deflate_vq);
 
 	mutex_unlock(&vb->balloon_lock);
+
+	trace_virtio_balloon_migrate(page_to_pfn(page), page_to_pfn(newpage), 0);
 	return 0;
 }
 #endif /* CONFIG_BALLOON_MIGRATION */
diff --git a/include/trace/events/virtio_balloon.h b/include/trace/events/virtio_balloon.h
index 559deb997e88..c29f833fa188 100644
--- a/include/trace/events/virtio_balloon.h
+++ b/include/trace/events/virtio_balloon.h
@@ -103,6 +103,54 @@ TRACE_EVENT(virtio_balloon_host_ack,
 		  __get_str(vq_name), __entry->num_pfns, __entry->latency_ns)
 );
 
+TRACE_EVENT(virtio_balloon_free_page_hint,
+
+	/*
+	 * outstanding_blocks is the number of hint blocks still owned by the
+	 * balloon (handed to the host but not yet reclaimed via a DONE/STOP
+	 * command) at the end of the reporting round.  A high value means the
+	 * host did not fully drain the round.
+	 */
+	TP_PROTO(u32 cmd_id, unsigned long outstanding_blocks),
+
+	TP_ARGS(cmd_id, outstanding_blocks),
+
+	TP_STRUCT__entry(
+		__field(u32, cmd_id)
+		__field(unsigned long, outstanding_blocks)
+	),
+
+	TP_fast_assign(
+		__entry->cmd_id = cmd_id;
+		__entry->outstanding_blocks = outstanding_blocks;
+	),
+
+	TP_printk("cmd_id=%u outstanding_blocks=%lu",
+		  __entry->cmd_id, __entry->outstanding_blocks)
+);
+
+TRACE_EVENT(virtio_balloon_migrate,
+
+	TP_PROTO(unsigned long old_pfn, unsigned long new_pfn, long ret),
+
+	TP_ARGS(old_pfn, new_pfn, ret),
+
+	TP_STRUCT__entry(
+		__field(unsigned long, old_pfn)
+		__field(unsigned long, new_pfn)
+		__field(long, ret)
+	),
+
+	TP_fast_assign(
+		__entry->old_pfn = old_pfn;
+		__entry->new_pfn = new_pfn;
+		__entry->ret = ret;
+	),
+
+	TP_printk("old_pfn=0x%lx new_pfn=0x%lx ret=%ld",
+		  __entry->old_pfn, __entry->new_pfn, __entry->ret)
+);
+
 #endif /* _TRACE_VIRTIO_BALLOON_H */
 
 /* This part must be outside protection */
-- 
2.43.0


No virus found
		Checked by Hillstone Network AntiVirus

Re: [PATCH 3/3] virtio_balloon: add tracepoints for free page hinting and migration

[sashiko-bot]

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] virtio_balloon: inaccurate hint tracepoint in virtio_balloon_report_free_page()
- [Low] virtio_balloon: unguarded virtio_balloon_migrate tracepoint definition
--

commit 366e84eaf1398af638dddd244580ba2505eef10a
Author: Qiang Liu <liuqiang@kylinos.cn>

virtio_balloon: add tracepoints for free page hinting and migration

This commit adds trace_virtio_balloon_free_page_hint and
trace_virtio_balloon_migrate tracepoints to record free page hinting rounds
and balloon page migration attempts.

> diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
> index c4fdc6815b41b..faf78c639f3c1 100644
> --- a/drivers/virtio/virtio_balloon.c
> +++ b/drivers/virtio/virtio_balloon.c
> @@ -803,6 +803,7 @@ static void virtio_balloon_report_free_page(struct virtio_balloon *vb)
>  {
>  	int err;
>  	struct device *dev = &vb->vdev->dev;
> +	unsigned int cmd_id = virtio_balloon_cmd_id_received(vb);
>  
>  	/* Start by sending the received cmd id to host with an outbuf. */
>  	err = send_cmd_id_start(vb);
> @@ -817,6 +818,9 @@ static void virtio_balloon_report_free_page(struct virtio_balloon *vb)
>  	err = send_cmd_id_stop(vb);
>  	if (unlikely(err))
>  		dev_err(dev, "Failed to send a stop id, err = %d\n", err);
> +
> +	trace_virtio_balloon_free_page_hint(cmd_id,
> +					    READ_ONCE(vb->num_free_page_blocks));
>  }

[Severity: Medium]
Can reading cmd_id via a separate virtio_balloon_cmd_id_received(vb) call
before send_cmd_id_start(vb) record a different command ID than the one
actually used for the round, and does vb->num_free_page_blocks match the
documented semantics of outstanding_blocks?

First, virtio_balloon_cmd_id_received(vb) tests and clears
VIRTIO_BALLOON_CONFIG_READ_CMD_ID before reading config space:

drivers/virtio/virtio_balloon.c:send_cmd_id_start() {
	...
	vb->cmd_id_active = cpu_to_virtio32(vb->vdev,
					virtio_balloon_cmd_id_received(vb));
	...
}

If a config interrupt arrives between the virtio_balloon_cmd_id_received(vb)
call in virtio_balloon_report_free_page() and the second call inside
send_cmd_id_start(vb), cmd_id in the tracepoint will not match the
vb->cmd_id_active sent to the host.

Second, the comment in include/trace/events/virtio_balloon.h for
virtio_balloon_free_page_hint states that outstanding_blocks is the number
of hint blocks handed to the host but not yet reclaimed via a DONE/STOP
command at the end of the reporting round, and that a high value means the
host did not fully drain the round.

However, in report_free_page_func() -> virtio_balloon_report_free_page():

drivers/virtio/virtio_balloon.c:report_free_page_func() {
	cmd_id_received = virtio_balloon_cmd_id_received(vb);
	if (cmd_id_received == VIRTIO_BALLOON_CMD_ID_DONE) {
		/* Pass ULONG_MAX to give back all the free pages */
		return_free_pages_to_mm(vb, ULONG_MAX);
	} else if (cmd_id_received != VIRTIO_BALLOON_CMD_ID_STOP &&
		   cmd_id_received !=
		   virtio32_to_cpu(vb->vdev, vb->cmd_id_active)) {
		virtio_balloon_report_free_page(vb);
	}
}

While send_free_pages() and send_cmd_id_stop() detach used buffers from
free_page_vq via virtqueue_get_buf(), the allocated pages remain on
vb->free_page_list and counted in vb->num_free_page_blocks until the host
later sends VIRTIO_BALLOON_CMD_ID_DONE and triggers a subsequent
report_free_page_func() run calling return_free_pages_to_mm(). Receiving
VIRTIO_BALLOON_CMD_ID_STOP also does not reclaim blocks from
vb->free_page_list.

As a result, at the end of virtio_balloon_report_free_page(), isn't
vb->num_free_page_blocks simply the total number of blocks accumulated on
vb->free_page_list so far, rather than blocks the host failed to drain from
the virtqueue?

>  
>  static void report_free_page_func(struct work_struct *work)
> @@ -869,8 +873,11 @@ static int virtballoon_migratepage(struct balloon_dev_info *vb_dev_info,
>  	 * recursion in the case it ends up triggering memory compaction
>  	 * while it is attempting to inflate the ballon.
>  	 */
> -	if (!mutex_trylock(&vb->balloon_lock))
> +	if (!mutex_trylock(&vb->balloon_lock)) {
> +		trace_virtio_balloon_migrate(page_to_pfn(page),
> +					     page_to_pfn(newpage), -EAGAIN);
>  		return -EAGAIN;
> +	}
>  
>  	/* balloon's page migration 1st step  -- inflate "newpage" */
>  	vb->num_pfns = VIRTIO_BALLOON_PAGES_PER_PAGE;
> @@ -883,6 +890,8 @@ static int virtballoon_migratepage(struct balloon_dev_info *vb_dev_info,
>  	tell_host(vb, vb->deflate_vq);
>  
>  	mutex_unlock(&vb->balloon_lock);
> +
> +	trace_virtio_balloon_migrate(page_to_pfn(page), page_to_pfn(newpage), 0);
>  	return 0;
>  }
>  #endif /* CONFIG_BALLOON_MIGRATION */
> diff --git a/include/trace/events/virtio_balloon.h b/include/trace/events/virtio_balloon.h
> index 559deb997e885..c29f833fa1889 100644
> --- a/include/trace/events/virtio_balloon.h
> +++ b/include/trace/events/virtio_balloon.h

[ ... ]

> +TRACE_EVENT(virtio_balloon_migrate,
> +
> +	TP_PROTO(unsigned long old_pfn, unsigned long new_pfn, long ret),
> +
> +	TP_ARGS(old_pfn, new_pfn, ret),
> +
> +	TP_STRUCT__entry(
> +		__field(unsigned long, old_pfn)
> +		__field(unsigned long, new_pfn)
> +		__field(long, ret)
> +	),
> +
> +	TP_fast_assign(
> +		__entry->old_pfn = old_pfn;
> +		__entry->new_pfn = new_pfn;
> +		__entry->ret = ret;
> +	),
> +
> +	TP_printk("old_pfn=0x%lx new_pfn=0x%lx ret=%ld",
> +		  __entry->old_pfn, __entry->new_pfn, __entry->ret)
> +);

[Severity: Low]
Should TRACE_EVENT(virtio_balloon_migrate, ...) in
include/trace/events/virtio_balloon.h be guarded by #ifdef
CONFIG_BALLOON_MIGRATION?

In drivers/virtio/virtio_balloon.c, virtballoon_migratepage() and both call
sites of trace_virtio_balloon_migrate() are compiled only when
CONFIG_BALLOON_MIGRATION is enabled. When building with
CONFIG_VIRTIO_BALLOON enabled and CONFIG_BALLOON_MIGRATION disabled, the
tracepoint has no callers, which triggers an unused tracepoint build warning
when CONFIG_WARN_ON_UNUSED_TRACEPOINTS is enabled and emits unreachable
trace event definitions into the image.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261030025834.19160-1-liuqiangneo@163.com?part=3