* Re: [PATCH] blk-mq: use NOIO context to prevent deadlock during debugfs creation
From: Ming Lei @ 2026-02-13 4:43 UTC (permalink / raw)
To: Yu Kuai
Cc: Jens Axboe, nilay, hch, Steven Rostedt, Masami Hiramatsu,
Mathieu Desnoyers, Yi Zhang, Shinichiro Kawasaki, Keith Busch,
Sagi Grimberg, linux-block, linux-nvme, linux-trace-kernel,
linux-kernel
In-Reply-To: <20260212080135.1673063-1-yukuai@fnnas.com>
On Thu, Feb 12, 2026 at 04:01:35PM +0800, Yu Kuai wrote:
> Creating debugfs entries can trigger fs reclaim, which can enter back
> into the block layer request_queue. This can cause deadlock if the
> queue is frozen.
>
> Previously, a WARN_ON_ONCE check was used in debugfs_create_files()
> to detect this condition, but it was racy since the queue can be frozen
> from another context at any time.
debugfs lock doesn't depend on queue freeze, so the implied deadlock isn't
obvious.
Can you explain a bit why freeze from another context may cause dead lock?
Thanks,
Ming
^ permalink raw reply
* Re: [PATCH] blk-mq: use NOIO context to prevent deadlock during debugfs creation
From: Yu Kuai @ 2026-02-13 4:08 UTC (permalink / raw)
To: Nilay Shroff, Jens Axboe, ming.lei, hch, Steven Rostedt,
Masami Hiramatsu
Cc: Mathieu Desnoyers, Yi Zhang, Shinichiro Kawasaki, Keith Busch,
Sagi Grimberg, linux-block, linux-nvme, linux-trace-kernel,
linux-kernel, yukuai
In-Reply-To: <88a12e1c-05b6-44de-806e-06a8e2ff7c0a@linux.ibm.com>
Hi
在 2026/2/12 16:46, Nilay Shroff 写道:
>
> On 2/12/26 1:31 PM, Yu Kuai wrote:
>> Creating debugfs entries can trigger fs reclaim, which can enter back
>> into the block layer request_queue. This can cause deadlock if the
>> queue is frozen.
>>
>> Previously, a WARN_ON_ONCE check was used in debugfs_create_files()
>> to detect this condition, but it was racy since the queue can be frozen
>> from another context at any time.
>>
>> Introduce blk_debugfs_mutex_lock()/blk_debugfs_mutex_unlock() helpers
>> that combine the debugfs_mutex with memalloc_noio_save()/restore() to
>> prevent fs reclaim from triggering block I/O. Replace all raw
>> debugfs_mutex lock/unlock pairs with these helpers.
> It looks like there are still a few places where ->debugfs_mutex is
> taken but the code paths do not enter fs-reclaim. For those cases,
> it may not be necessary to wrap the critical section in a NOIO context.
I agree it's not necessary, however I also feel it doesn't matter.
>
> Perhaps it would make sense to provide two separate helper APIs: one
> that acquires ->debugfs_mutex and also saves/restores the NOIO context
> (using memalloc_noio_save()/restore()), and another that simply acquires
> and releases ->debugfs_mutex without entering NOIO. Callers could then
> choose the appropriate helper depending on whether the code path may
> trigger fs-reclaim.
I don't have preference here, I can do this in the next version.
>
> For reference,
> blk_mq_freeze_queue()/blk_mq_unfreeze_queue() vs
> blk_mq_freeze_queue_nomemsave()/blk_mq_unfreeze_queue_nomemrestore()
>
> Thanks,
> --Nilay
--
Thansk,
Kuai
^ permalink raw reply
* Re: [PATCH] function_graph: restore direct mode when callbacks drop to one
From: Steven Rostedt @ 2026-02-13 3:47 UTC (permalink / raw)
To: hu.shengming
Cc: mhiramat, mark.rutland, mathieu.desnoyers, linux-kernel,
linux-trace-kernel, zhang.run, yang.tao172, yang.yang29
In-Reply-To: <202602131034245558BcmEI95X7Sr39QGM8YLl@zte.com.cn>
On Fri, 13 Feb 2026 10:34:24 +0800 (CST)
<hu.shengming@zte.com.cn> wrote:
> From: Shengming Hu <hu.shengming@zte.com.cn>
>
> When registering a second fgraph callback, direct path is disabled
> and array loop is used instead.
> When ftrace_graph_active falls back to one, we try to re-enable direct
> mode via ftrace_graph_enable_direct(true, ...).
> But ftrace_graph_enable_direct() incorrectly disables the static key
> rather than enabling it.
> This leaves fgraph_do_direct permanently off after first multi-callback
> transition, so direct fast mode is never restored.
Good catch!
>
> Fixes: cc60ee813b503 ("function_graph: Use static_call and branch to optimize entry function")
> Signed-off-by: Shengming Hu <hu.shengming@zte.com.cn>
> ---
> kernel/trace/fgraph.c | 2 +-
> 1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/kernel/trace/fgraph.c b/kernel/trace/fgraph.c
> index cc48d16be43e..4df766c690f9 100644
> --- a/kernel/trace/fgraph.c
> +++ b/kernel/trace/fgraph.c
> @@ -1303,7 +1303,7 @@ static void ftrace_graph_enable_direct(bool enable_branch, struct fgraph_ops *go
> static_call_update(fgraph_func, func);
> static_call_update(fgraph_retfunc, retfunc);
> if (enable_branch)
> - static_branch_disable(&fgraph_do_direct);
> + static_branch_enable(&fgraph_do_direct);
> }
Your email client killed your patch. it has huge white-space damage.
But because it's such a trivial change, I'll fix it up for you. But
next time please make sure your email client doesn't corrupt your
patches.
Thanks,
-- Steve
>
> static void ftrace_graph_disable_direct(bool disable_branch)
> --
> 2.25.1
^ permalink raw reply
* [PATCH] function_graph: restore direct mode when callbacks drop to one
From: hu.shengming @ 2026-02-13 2:34 UTC (permalink / raw)
To: rostedt, mhiramat
Cc: mark.rutland, mathieu.desnoyers, linux-kernel, linux-trace-kernel,
zhang.run, yang.tao172, yang.yang29
From: Shengming Hu <hu.shengming@zte.com.cn>
When registering a second fgraph callback, direct path is disabled
and array loop is used instead.
When ftrace_graph_active falls back to one, we try to re-enable direct
mode via ftrace_graph_enable_direct(true, ...).
But ftrace_graph_enable_direct() incorrectly disables the static key
rather than enabling it.
This leaves fgraph_do_direct permanently off after first multi-callback
transition, so direct fast mode is never restored.
Fixes: cc60ee813b503 ("function_graph: Use static_call and branch to optimize entry function")
Signed-off-by: Shengming Hu <hu.shengming@zte.com.cn>
---
kernel/trace/fgraph.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/kernel/trace/fgraph.c b/kernel/trace/fgraph.c
index cc48d16be43e..4df766c690f9 100644
--- a/kernel/trace/fgraph.c
+++ b/kernel/trace/fgraph.c
@@ -1303,7 +1303,7 @@ static void ftrace_graph_enable_direct(bool enable_branch, struct fgraph_ops *go
static_call_update(fgraph_func, func);
static_call_update(fgraph_retfunc, retfunc);
if (enable_branch)
- static_branch_disable(&fgraph_do_direct);
+ static_branch_enable(&fgraph_do_direct);
}
static void ftrace_graph_disable_direct(bool disable_branch)
--
2.25.1
^ permalink raw reply related
* Re: [PATCH] objpool: fix minimum alignment of 'struct objpool_slot'
From: wuqiang.matt @ 2026-02-13 2:15 UTC (permalink / raw)
To: Arnd Bergmann, Masami Hiramatsu
Cc: Arnd Bergmann, Yury Norov, linux-kernel, linux-trace-kernel
In-Reply-To: <20260210103530.3028454-1-arnd@kernel.org>
On 2026/2/10 18:35, Arnd Bergmann wrote:
> From: Arnd Bergmann <arnd@arndb.de>
>
> Members of objpool_slot get passed into try_cmpxchg_release(),
> which does not work on most architectures unless they are
> naturally aligned. Marking the structure as packed makes it
> only byte-aligned, as shown by this (normally disabled) warning:
>
> include/linux/objpool.h:156:56: warning: taking address of packed member of 'struct objpool_slot' may result in an unaligned pointer value [-Waddress-of-packed-member]
> 156 | if (try_cmpxchg_release(&slot->head, &head, head + 1))
> | ~^~~~~~~~~~~~
>
> As the struct members are all tightly packed on all architectures,
> Just remove the '__packed annotation to give it the required
> alignment of the native word size.
>
> Signed-off-by: Arnd Bergmann <arnd@arndb.de>
> ---
> include/linux/objpool.h | 2 +-
> 1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/include/linux/objpool.h b/include/linux/objpool.h
> index b713a1fe7521..f678b35b20b1 100644
> --- a/include/linux/objpool.h
> +++ b/include/linux/objpool.h
> @@ -56,7 +56,7 @@ struct objpool_slot {
> uint32_t last;
> uint32_t mask;
> void *entries[];
> -} __packed;
> +};
>
> struct objpool_head;
>
Reviewed-by: wuqiang.matt <wuqiang.matt@bytedance.com>
Regards,
Matt Wu
^ permalink raw reply
* Re: [PATCH V4] blktrace: log dropped REQ_OP_ZONE_XXX events ver1
From: Damien Le Moal @ 2026-02-12 23:37 UTC (permalink / raw)
To: Chaitanya Kulkarni, axboe
Cc: rostedt, mhiramat, linux-block, linux-trace-kernel
In-Reply-To: <20260211204752.23061-1-kch@nvidia.com>
On 2/12/26 05:47, Chaitanya Kulkarni wrote:
> Add informational messages during blktrace setup when version 1 tools
> are used on kernels with CONFIG_BLK_DEV_ZONED enabled. This alerts users
> that REQ_OP_ZONE_* events will be dropped and suggests upgrading to
> blktrace tools version 2 or later.
>
> The warning is printed once during trace setup to inform users about
> the limitation without spamming the logs during tracing operations.
> Version 2 blktrace tools properly handle zone management operations
> (zone reset, zone open, zone close, zone finish, zone append) that
> were added for zoned block devices.
>
> * With old blktrace tool and this patch :-
>
> blktests (master) # ./check blktrace/
> blktrace/001 (blktrace zone management command tracing) [passed]
> runtime 3.706s ... 3.735s
> blktrace/002 (blktrace ftrace corruption with sysfs trace) [passed]
> runtime 0.479s ... 0.456s
> blktests (master) # dmesg -c
> [ 9455.610899] null_blk: disk nullb0 created
> [ 9455.610916] null_blk: module loaded
> [ 9455.634103] run blktests blktrace/001 at 2026-02-02 15:02:23
> [ 9455.651710] null_blk: nullb1: using native zone append
> [ 9455.662852] null_blk: disk nullb1 created
> *[ 9455.714998] blktrace: nullb1: blktrace events for zone operations will be dropped*
> *[ 9455.715065] blktrace: use blktrace tools version >= 2 to track zone operations*
> [ 9459.480181] null_blk: disk nullb0 created
> [ 9459.480199] null_blk: module loaded
> [ 9459.514464] run blktests blktrace/002 at 2026-02-02 15:02:27
> [ 9459.541772] null_blk: disk nullb1 created
> blktests (master) #
>
> * With new blktrace tools and this patch :-
>
> blktests (master) # ./check blktrace/
> blktrace/001 (blktrace zone management command tracing) [passed]
> runtime 3.735s ... 3.734s
> blktrace/002 (blktrace ftrace corruption with sysfs trace) [passed]
> runtime 0.456s ... 0.496s
> blktests (master) # dmesg -c
> [ 9490.395572] null_blk: disk nullb0 created
> [ 9490.395591] null_blk: module loaded
> [ 9490.419467] run blktests blktrace/001 at 2026-02-02 15:02:58
> [ 9490.436416] null_blk: nullb1: using native zone append
> [ 9490.447806] null_blk: disk nullb1 created
> [ 9494.262176] null_blk: disk nullb0 created
> [ 9494.262195] null_blk: module loaded
> [ 9494.296653] run blktests blktrace/002 at 2026-02-02 15:03:02
> [ 9494.322261] null_blk: disk nullb1 created
> blktests (master) #
>
> This helps users understand why zone operation traces may be missing
> when using older blktrace tool versions with modern kernels that
> support REQ_OP_ZONE_XXX in blktrace.
>
> Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
> Signed-off-by: Chaitanya Kulkarni <kch@nvidia.com>
> ---
>
> V3->V4:-
>
> Replace REQ_OP_ZONE_XXX with "zone operations". (Damien, Jens)
>
> ---
> kernel/trace/blktrace.c | 6 ++++++
> 1 file changed, 6 insertions(+)
>
> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> index d031c8d80be4..04b41c698127 100644
> --- a/kernel/trace/blktrace.c
> +++ b/kernel/trace/blktrace.c
> @@ -741,6 +741,12 @@ static void blk_trace_setup_finalize(struct request_queue *q,
> * to underscores for this to work as expected
> */
> strreplace(buts->name, '/', '_');
> + if (version == 1 && IS_ENABLED(CONFIG_BLK_DEV_ZONED)) {
> + pr_info("%s: blktrace events for zone operations will be dropped\n",
> + name);
> + pr_info("use blktrace tools version >= 2 to track zone operations\n");
Since this message is split, please keep the same format for the second line. I.e.:
pr_info("%s: use blktrace tools version >= 2 to track zone operations\n",
name);
That will avoid incomprehensible interleaved output of if multiple traces are
started together.
> +
> + }
>
> bt->version = version;
> bt->act_mask = buts->act_mask;
--
Damien Le Moal
Western Digital Research
^ permalink raw reply
* [PATCH 11/11] media: hantro: Add fdinfo callback
From: Detlev Casanova @ 2026-02-12 16:23 UTC (permalink / raw)
To: linux-kernel
Cc: Nicolas Dufresne, Benjamin Gaignard, Philipp Zabel,
Mauro Carvalho Chehab, Heiko Stuebner, Daniel Almeida,
Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers, Hans Verkuil,
Laurent Pinchart, Ricardo Ribalda, Yunke Cao, Detlev Casanova,
Sakari Ailus, Pavan Bobba, James Cowgill, Ma Ke, Jacopo Mondi,
Daniel Scally, linux-media, linux-rockchip, linux-arm-kernel,
linux-trace-kernel, kernel
In-Reply-To: <20260212162328.192217-1-detlev.casanova@collabora.com>
The fdinfo shows the number of buffers in each queue and the total amount
of video buffer memory.
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
drivers/media/platform/verisilicon/hantro.h | 1 +
drivers/media/platform/verisilicon/hantro_drv.c | 15 +++++++++++++++
drivers/media/platform/verisilicon/hantro_v4l2.c | 10 +++++++++-
3 files changed, 25 insertions(+), 1 deletion(-)
diff --git a/drivers/media/platform/verisilicon/hantro.h b/drivers/media/platform/verisilicon/hantro.h
index d5cddc783688..9e9fc0658586 100644
--- a/drivers/media/platform/verisilicon/hantro.h
+++ b/drivers/media/platform/verisilicon/hantro.h
@@ -268,6 +268,7 @@ struct hantro_ctx {
const struct hantro_codec_ops *codec_ops;
struct hantro_postproc_ctx postproc;
bool need_postproc;
+ u64 stats_buf_memory;
/* Specific for particular codec modes. */
union {
diff --git a/drivers/media/platform/verisilicon/hantro_drv.c b/drivers/media/platform/verisilicon/hantro_drv.c
index 8dd26ca32459..86d316a8a3e8 100644
--- a/drivers/media/platform/verisilicon/hantro_drv.c
+++ b/drivers/media/platform/verisilicon/hantro_drv.c
@@ -17,6 +17,7 @@
#include <linux/platform_device.h>
#include <linux/pm.h>
#include <linux/pm_runtime.h>
+#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/videodev2.h>
#include <linux/workqueue.h>
@@ -711,6 +712,19 @@ static int hantro_release(struct file *filp)
return 0;
}
+static void hantro_show_fdinfo(struct seq_file *m, struct file *filp)
+{
+ struct hantro_ctx *ctx =
+ container_of(filp->private_data, struct hantro_ctx, fh);
+
+ struct vb2_queue *src_q = v4l2_m2m_get_src_vq(ctx->fh.m2m_ctx);
+ struct vb2_queue *dst_q = v4l2_m2m_get_dst_vq(ctx->fh.m2m_ctx);
+
+ seq_printf(m, "src-queued-count: %04u\n", src_q->queued_count);
+ seq_printf(m, "dst-queued-count: %04u\n", dst_q->queued_count);
+ seq_printf(m, "buf-size: %llu\n", ctx->stats_buf_memory);
+}
+
static const struct v4l2_file_operations hantro_fops = {
.owner = THIS_MODULE,
.open = hantro_open,
@@ -718,6 +732,7 @@ static const struct v4l2_file_operations hantro_fops = {
.poll = v4l2_m2m_fop_poll,
.unlocked_ioctl = video_ioctl2,
.mmap = v4l2_m2m_fop_mmap,
+ .show_fdinfo = hantro_show_fdinfo,
};
static const struct of_device_id of_hantro_match[] = {
diff --git a/drivers/media/platform/verisilicon/hantro_v4l2.c b/drivers/media/platform/verisilicon/hantro_v4l2.c
index fcf3bd9bcda2..6d129613ea3d 100644
--- a/drivers/media/platform/verisilicon/hantro_v4l2.c
+++ b/drivers/media/platform/verisilicon/hantro_v4l2.c
@@ -820,18 +820,26 @@ hantro_queue_setup(struct vb2_queue *vq, unsigned int *num_buffers,
return -EINVAL;
}
+ ctx->stats_buf_memory = 0;
+
if (*num_planes) {
if (*num_planes != pixfmt->num_planes)
return -EINVAL;
- for (i = 0; i < pixfmt->num_planes; ++i)
+ for (i = 0; i < pixfmt->num_planes; ++i) {
if (sizes[i] < pixfmt->plane_fmt[i].sizeimage)
return -EINVAL;
+ ctx->stats_buf_memory += pixfmt->plane_fmt[i].sizeimage;
+ }
+
+ ctx->stats_buf_memory *= *num_buffers;
+
return 0;
}
*num_planes = pixfmt->num_planes;
for (i = 0; i < pixfmt->num_planes; ++i)
sizes[i] = pixfmt->plane_fmt[i].sizeimage;
+
return 0;
}
--
2.53.0
^ permalink raw reply related
* [PATCH 10/11] media: v4l2: Add callback for show_fdinfo
From: Detlev Casanova @ 2026-02-12 16:23 UTC (permalink / raw)
To: linux-kernel
Cc: Nicolas Dufresne, Benjamin Gaignard, Philipp Zabel,
Mauro Carvalho Chehab, Heiko Stuebner, Daniel Almeida,
Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers, Hans Verkuil,
Laurent Pinchart, Ricardo Ribalda, Yunke Cao, Detlev Casanova,
Sakari Ailus, Pavan Bobba, James Cowgill, Ma Ke, Jacopo Mondi,
Daniel Scally, linux-media, linux-rockchip, linux-arm-kernel,
linux-trace-kernel, kernel
In-Reply-To: <20260212162328.192217-1-detlev.casanova@collabora.com>
Allow v4l2 drivers to add information in the fdinfo file matching the
opened /dev/videoX file.
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
drivers/media/v4l2-core/v4l2-dev.c | 10 ++++++++++
include/media/v4l2-dev.h | 1 +
2 files changed, 11 insertions(+)
diff --git a/drivers/media/v4l2-core/v4l2-dev.c b/drivers/media/v4l2-core/v4l2-dev.c
index 10a126e50c1c..29c04f5f4c59 100644
--- a/drivers/media/v4l2-core/v4l2-dev.c
+++ b/drivers/media/v4l2-core/v4l2-dev.c
@@ -481,6 +481,15 @@ static int v4l2_release(struct inode *inode, struct file *filp)
return ret;
}
+/* Override for the show_fdinfo function */
+static void v4l2_show_fdinfo(struct seq_file *m, struct file *filp)
+{
+ struct video_device *vdev = video_devdata(filp);
+
+ if (vdev->fops->show_fdinfo)
+ vdev->fops->show_fdinfo(m, filp);
+}
+
static const struct file_operations v4l2_fops = {
.owner = THIS_MODULE,
.read = v4l2_read,
@@ -494,6 +503,7 @@ static const struct file_operations v4l2_fops = {
#endif
.release = v4l2_release,
.poll = v4l2_poll,
+ .show_fdinfo = v4l2_show_fdinfo,
};
/**
diff --git a/include/media/v4l2-dev.h b/include/media/v4l2-dev.h
index 2e0f6d2e6a78..1635ab186f21 100644
--- a/include/media/v4l2-dev.h
+++ b/include/media/v4l2-dev.h
@@ -212,6 +212,7 @@ struct v4l2_file_operations {
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open) (struct file *);
int (*release) (struct file *);
+ void (*show_fdinfo)(struct seq_file *, struct file *);
};
/*
--
2.53.0
^ permalink raw reply related
* [PATCH 09/11] media: hantro: Add v4l2_hw run/done traces
From: Detlev Casanova @ 2026-02-12 16:23 UTC (permalink / raw)
To: linux-kernel
Cc: Nicolas Dufresne, Benjamin Gaignard, Philipp Zabel,
Mauro Carvalho Chehab, Heiko Stuebner, Daniel Almeida,
Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers, Hans Verkuil,
Laurent Pinchart, Ricardo Ribalda, Yunke Cao, Detlev Casanova,
Sakari Ailus, Pavan Bobba, James Cowgill, Ma Ke, Jacopo Mondi,
Daniel Scally, linux-media, linux-rockchip, linux-arm-kernel,
linux-trace-kernel, kernel
In-Reply-To: <20260212162328.192217-1-detlev.casanova@collabora.com>
Add the trace calls as well as retrieving the number of clock cycles for
the rockchip_vpu core.
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
drivers/media/platform/verisilicon/hantro.h | 1 +
drivers/media/platform/verisilicon/hantro_drv.c | 10 ++++++++++
.../media/platform/verisilicon/rockchip_vpu981_regs.h | 1 +
drivers/media/platform/verisilicon/rockchip_vpu_hw.c | 4 ++++
4 files changed, 16 insertions(+)
diff --git a/drivers/media/platform/verisilicon/hantro.h b/drivers/media/platform/verisilicon/hantro.h
index 0353de154a1e..d5cddc783688 100644
--- a/drivers/media/platform/verisilicon/hantro.h
+++ b/drivers/media/platform/verisilicon/hantro.h
@@ -253,6 +253,7 @@ struct hantro_ctx {
u32 sequence_cap;
u32 sequence_out;
+ u32 hw_cycles;
const struct hantro_fmt *vpu_src_fmt;
struct v4l2_pix_format_mplane src_fmt;
diff --git a/drivers/media/platform/verisilicon/hantro_drv.c b/drivers/media/platform/verisilicon/hantro_drv.c
index 94f58f4e4a4e..8dd26ca32459 100644
--- a/drivers/media/platform/verisilicon/hantro_drv.c
+++ b/drivers/media/platform/verisilicon/hantro_drv.c
@@ -25,6 +25,8 @@
#include <media/videobuf2-core.h>
#include <media/videobuf2-vmalloc.h>
+#include <trace/events/v4l2.h>
+
#include "hantro_v4l2.h"
#include "hantro.h"
#include "hantro_hw.h"
@@ -103,6 +105,9 @@ void hantro_irq_done(struct hantro_dev *vpu,
struct hantro_ctx *ctx =
v4l2_m2m_get_curr_priv(vpu->m2m_dev);
+ if (ctx)
+ trace_v4l2_hw_done(ctx->fh.tgid, ctx->fh.fd, ctx->hw_cycles);
+
/*
* If cancel_delayed_work returns false
* the timeout expired. The watchdog is running,
@@ -125,6 +130,9 @@ void hantro_watchdog(struct work_struct *work)
ctx = v4l2_m2m_get_curr_priv(vpu->m2m_dev);
if (ctx) {
vpu_err("frame processing timed out!\n");
+
+ trace_v4l2_hw_done(ctx->fh.tgid, ctx->fh.fd, ctx->hw_cycles);
+
if (ctx->codec_ops->reset)
ctx->codec_ops->reset(ctx);
hantro_job_finish(vpu, ctx, VB2_BUF_STATE_ERROR);
@@ -189,6 +197,8 @@ static void device_run(void *priv)
if (ctx->codec_ops->run(ctx))
goto err_cancel_job;
+ trace_v4l2_hw_run(ctx->fh.tgid, ctx->fh.fd);
+
return;
err_cancel_job:
diff --git a/drivers/media/platform/verisilicon/rockchip_vpu981_regs.h b/drivers/media/platform/verisilicon/rockchip_vpu981_regs.h
index e4008da64f19..96b85470208b 100644
--- a/drivers/media/platform/verisilicon/rockchip_vpu981_regs.h
+++ b/drivers/media/platform/verisilicon/rockchip_vpu981_regs.h
@@ -451,6 +451,7 @@
#define av1_pp0_dup_ver AV1_DEC_REG(394, 16, 0xff)
#define av1_pp0_dup_hor AV1_DEC_REG(394, 24, 0xff)
+#define AV1_CYCLE_COUNT (AV1_SWREG(63))
#define AV1_TILE_OUT_LU (AV1_SWREG(65))
#define AV1_REFERENCE_Y(i) (AV1_SWREG(67) + ((i) * 0x8))
#define AV1_SEGMENTATION (AV1_SWREG(81))
diff --git a/drivers/media/platform/verisilicon/rockchip_vpu_hw.c b/drivers/media/platform/verisilicon/rockchip_vpu_hw.c
index 02673be9878e..f959151b6645 100644
--- a/drivers/media/platform/verisilicon/rockchip_vpu_hw.c
+++ b/drivers/media/platform/verisilicon/rockchip_vpu_hw.c
@@ -424,6 +424,8 @@ static irqreturn_t rk3588_vpu981_irq(int irq, void *dev_id)
{
struct hantro_dev *vpu = dev_id;
enum vb2_buffer_state state;
+ struct hantro_ctx *ctx =
+ v4l2_m2m_get_curr_priv(vpu->m2m_dev);
u32 status;
status = vdpu_read(vpu, AV1_REG_INTERRUPT);
@@ -433,6 +435,8 @@ static irqreturn_t rk3588_vpu981_irq(int irq, void *dev_id)
vdpu_write(vpu, 0, AV1_REG_INTERRUPT);
vdpu_write(vpu, AV1_REG_CONFIG_DEC_CLK_GATE_E, AV1_REG_CONFIG);
+ ctx->hw_cycles = vdpu_read(vpu, AV1_CYCLE_COUNT);
+
hantro_irq_done(vpu, state);
return IRQ_HANDLED;
--
2.53.0
^ permalink raw reply related
* [PATCH 08/11] media: Add HW run/done trace events
From: Detlev Casanova @ 2026-02-12 16:23 UTC (permalink / raw)
To: linux-kernel
Cc: Nicolas Dufresne, Benjamin Gaignard, Philipp Zabel,
Mauro Carvalho Chehab, Heiko Stuebner, Daniel Almeida,
Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers, Hans Verkuil,
Laurent Pinchart, Ricardo Ribalda, Yunke Cao, Detlev Casanova,
Sakari Ailus, Pavan Bobba, James Cowgill, Ma Ke, Jacopo Mondi,
Daniel Scally, linux-media, linux-rockchip, linux-arm-kernel,
linux-trace-kernel, kernel
In-Reply-To: <20260212162328.192217-1-detlev.casanova@collabora.com>
The events can be fired by drivers when the hardware is run and when it
is done.
That can be used by userspace tracers to see HW performance and usage.
The hw_done event allows setting the number of clock cycles the HW needed
to do the work, to help tools evaluate performances.
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
drivers/media/v4l2-core/v4l2-trace.c | 3 +++
include/trace/events/v4l2.h | 30 ++++++++++++++++++++++++++++
2 files changed, 33 insertions(+)
diff --git a/drivers/media/v4l2-core/v4l2-trace.c b/drivers/media/v4l2-core/v4l2-trace.c
index 9ce54c1968ef..2fbc05dde346 100644
--- a/drivers/media/v4l2-core/v4l2-trace.c
+++ b/drivers/media/v4l2-core/v4l2-trace.c
@@ -12,6 +12,9 @@ EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_buf_queue);
EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_dqbuf);
EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_qbuf);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_hw_run);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_hw_done);
+
/* Export AV1 controls */
EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_av1_sequence);
EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_av1_frame);
diff --git a/include/trace/events/v4l2.h b/include/trace/events/v4l2.h
index bec310eaedc7..4a9dcdbea22b 100644
--- a/include/trace/events/v4l2.h
+++ b/include/trace/events/v4l2.h
@@ -290,6 +290,36 @@ DEFINE_EVENT(v4l2_stream_class, v4l2_streamoff,
TP_ARGS(tgid, fd)
);
+DEFINE_EVENT(v4l2_stream_class, v4l2_hw_run,
+ TP_PROTO(u32 tgid, u32 fd),
+ TP_ARGS(tgid, fd)
+);
+
+DECLARE_EVENT_CLASS(v4l2_hw_done_class,
+ TP_PROTO(u32 tgid, u32 fd, u32 hw_cycles),
+ TP_ARGS(tgid, fd, hw_cycles),
+
+ TP_STRUCT__entry(
+ __field(u32, tgid)
+ __field(u32, fd)
+ __field(u32, hw_cycles)
+ ),
+
+ TP_fast_assign(
+ __entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->hw_cycles = hw_cycles;
+ ),
+
+ TP_printk("tgid = %u, fd = %u, hw_cycles = %u",
+ __entry->tgid, __entry->fd, __entry->hw_cycles)
+);
+
+DEFINE_EVENT(v4l2_hw_done_class, v4l2_hw_done,
+ TP_PROTO(u32 tgid, u32 fd, u32 hw_cycles),
+ TP_ARGS(tgid, fd, hw_cycles)
+);
+
#endif /* if !defined(_TRACE_V4L2_H) || defined(TRACE_HEADER_MULTI_READ) */
/* This part must be outside protection */
--
2.53.0
^ permalink raw reply related
* [PATCH 07/11] media: Add stream on/off traces and run them in the ioctl
From: Detlev Casanova @ 2026-02-12 16:23 UTC (permalink / raw)
To: linux-kernel
Cc: Nicolas Dufresne, Benjamin Gaignard, Philipp Zabel,
Mauro Carvalho Chehab, Heiko Stuebner, Daniel Almeida,
Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers, Hans Verkuil,
Laurent Pinchart, Ricardo Ribalda, Yunke Cao, Detlev Casanova,
Sakari Ailus, Pavan Bobba, James Cowgill, Ma Ke, Jacopo Mondi,
Daniel Scally, linux-media, linux-rockchip, linux-arm-kernel,
linux-trace-kernel, kernel
In-Reply-To: <20260212162328.192217-1-detlev.casanova@collabora.com>
This will automatically add stream on/off tracing for all v4l2 drivers.
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
drivers/media/v4l2-core/v4l2-ioctl.c | 20 ++++++++++++++++++--
include/trace/events/v4l2.h | 28 ++++++++++++++++++++++++++++
2 files changed, 46 insertions(+), 2 deletions(-)
diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
index a3b6df0571d6..fd5193fc722e 100644
--- a/drivers/media/v4l2-core/v4l2-ioctl.c
+++ b/drivers/media/v4l2-core/v4l2-ioctl.c
@@ -1963,13 +1963,29 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
static int v4l_streamon(const struct v4l2_ioctl_ops *ops, struct file *file,
void *arg)
{
- return ops->vidioc_streamon(file, NULL, *(unsigned int *)arg);
+ struct v4l2_fh *fh = file_to_v4l2_fh(file);
+ int err;
+
+ err = ops->vidioc_streamon(file, NULL, *(unsigned int *)arg);
+
+ if (!err)
+ trace_v4l2_streamon(fh->tgid, fh->fd);
+
+ return err;
}
static int v4l_streamoff(const struct v4l2_ioctl_ops *ops, struct file *file,
void *arg)
{
- return ops->vidioc_streamoff(file, NULL, *(unsigned int *)arg);
+ struct v4l2_fh *fh = file_to_v4l2_fh(file);
+ int err;
+
+ err = ops->vidioc_streamoff(file, NULL, *(unsigned int *)arg);
+
+ if (!err)
+ trace_v4l2_streamoff(fh->tgid, fh->fd);
+
+ return err;
}
static int v4l_g_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
diff --git a/include/trace/events/v4l2.h b/include/trace/events/v4l2.h
index 248bc09bfc99..bec310eaedc7 100644
--- a/include/trace/events/v4l2.h
+++ b/include/trace/events/v4l2.h
@@ -262,6 +262,34 @@ DEFINE_EVENT(vb2_v4l2_event_class, vb2_v4l2_qbuf,
TP_ARGS(q, vb)
);
+DECLARE_EVENT_CLASS(v4l2_stream_class,
+ TP_PROTO(u32 tgid, u32 fd),
+ TP_ARGS(tgid, fd),
+
+ TP_STRUCT__entry(
+ __field(u32, tgid)
+ __field(u32, fd)
+ ),
+
+ TP_fast_assign(
+ __entry->tgid = tgid;
+ __entry->fd = fd;
+ ),
+
+ TP_printk("tgid = %u, fd = %u",
+ __entry->tgid, __entry->fd)
+);
+
+DEFINE_EVENT(v4l2_stream_class, v4l2_streamon,
+ TP_PROTO(u32 tgid, u32 fd),
+ TP_ARGS(tgid, fd)
+);
+
+DEFINE_EVENT(v4l2_stream_class, v4l2_streamoff,
+ TP_PROTO(u32 tgid, u32 fd),
+ TP_ARGS(tgid, fd)
+);
+
#endif /* if !defined(_TRACE_V4L2_H) || defined(TRACE_HEADER_MULTI_READ) */
/* This part must be outside protection */
--
2.53.0
^ permalink raw reply related
* [PATCH 06/11] media: Trace the stateless controls when set in v4l2-ctrls-core.c
From: Detlev Casanova @ 2026-02-12 16:23 UTC (permalink / raw)
To: linux-kernel
Cc: Nicolas Dufresne, Benjamin Gaignard, Philipp Zabel,
Mauro Carvalho Chehab, Heiko Stuebner, Daniel Almeida,
Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers, Hans Verkuil,
Laurent Pinchart, Ricardo Ribalda, Yunke Cao, Detlev Casanova,
Sakari Ailus, Pavan Bobba, James Cowgill, Ma Ke, Jacopo Mondi,
Daniel Scally, linux-media, linux-rockchip, linux-arm-kernel,
linux-trace-kernel, kernel
In-Reply-To: <20260212162328.192217-1-detlev.casanova@collabora.com>
Also remove the trace from visl as the generic v4l2-requests traces can
now be used instead.
It allows all stateless drivers to inherit traceability, with just a small
overhead when disabled in userspace.
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
drivers/media/test-drivers/visl/visl-dec.c | 74 -------------
drivers/media/v4l2-core/v4l2-ctrls-api.c | 10 ++
drivers/media/v4l2-core/v4l2-ctrls-core.c | 114 +++++++++++++++++++++
include/media/v4l2-ctrls.h | 15 +++
4 files changed, 139 insertions(+), 74 deletions(-)
diff --git a/drivers/media/test-drivers/visl/visl-dec.c b/drivers/media/test-drivers/visl/visl-dec.c
index fc216da17048..9517830fb3e8 100644
--- a/drivers/media/test-drivers/visl/visl-dec.c
+++ b/drivers/media/test-drivers/visl/visl-dec.c
@@ -12,7 +12,6 @@
#include <linux/workqueue.h>
#include <media/v4l2-mem2mem.h>
#include <media/tpg/v4l2-tpg.h>
-#include <trace/events/v4l2_requests.h>
#define LAST_BUF_IDX (V4L2_AV1_REF_LAST_FRAME - V4L2_AV1_REF_LAST_FRAME)
#define LAST2_BUF_IDX (V4L2_AV1_REF_LAST2_FRAME - V4L2_AV1_REF_LAST_FRAME)
@@ -486,78 +485,6 @@ static void visl_tpg_fill(struct visl_ctx *ctx, struct visl_run *run)
}
}
-static void visl_trace_ctrls(struct visl_ctx *ctx, struct visl_run *run)
-{
- int i;
- struct v4l2_fh *fh = &ctx->fh;
-
- switch (ctx->current_codec) {
- default:
- case VISL_CODEC_NONE:
- break;
- case VISL_CODEC_FWHT:
- trace_v4l2_ctrl_fwht_params(fh->tgid, fh->fd, run->fwht.params);
- break;
- case VISL_CODEC_MPEG2:
- trace_v4l2_ctrl_mpeg2_sequence(fh->tgid, fh->fd, run->mpeg2.seq);
- trace_v4l2_ctrl_mpeg2_picture(fh->tgid, fh->fd, run->mpeg2.pic);
- trace_v4l2_ctrl_mpeg2_quantisation(fh->tgid, fh->fd, run->mpeg2.quant);
- break;
- case VISL_CODEC_VP8:
- trace_v4l2_ctrl_vp8_frame(fh->tgid, fh->fd, run->vp8.frame);
- trace_v4l2_ctrl_vp8_entropy(fh->tgid, fh->fd, run->vp8.frame);
- break;
- case VISL_CODEC_VP9:
- trace_v4l2_ctrl_vp9_frame(fh->tgid, fh->fd, run->vp9.frame);
- trace_v4l2_ctrl_vp9_compressed_hdr(fh->tgid, fh->fd, run->vp9.probs);
- trace_v4l2_ctrl_vp9_compressed_coeff(fh->tgid, fh->fd, run->vp9.probs);
- trace_v4l2_vp9_mv_probs(fh->tgid, fh->fd, &run->vp9.probs->mv);
- break;
- case VISL_CODEC_H264:
- trace_v4l2_ctrl_h264_sps(fh->tgid, fh->fd, run->h264.sps);
- trace_v4l2_ctrl_h264_pps(fh->tgid, fh->fd, run->h264.pps);
- trace_v4l2_ctrl_h264_scaling_matrix(fh->tgid, fh->fd, run->h264.sm);
- trace_v4l2_ctrl_h264_slice_params(fh->tgid, fh->fd, run->h264.spram);
-
- for (i = 0; i < ARRAY_SIZE(run->h264.spram->ref_pic_list0); i++)
- trace_v4l2_h264_ref_pic_list0(fh->tgid, fh->fd,
- &run->h264.spram->ref_pic_list0[i], i);
- for (i = 0; i < ARRAY_SIZE(run->h264.spram->ref_pic_list0); i++)
- trace_v4l2_h264_ref_pic_list1(fh->tgid, fh->fd,
- &run->h264.spram->ref_pic_list1[i], i);
-
- trace_v4l2_ctrl_h264_decode_params(fh->tgid, fh->fd, run->h264.dpram);
-
- for (i = 0; i < ARRAY_SIZE(run->h264.dpram->dpb); i++)
- trace_v4l2_h264_dpb_entry(fh->tgid, fh->fd, &run->h264.dpram->dpb[i], i);
-
- trace_v4l2_ctrl_h264_pred_weights(fh->tgid, fh->fd, run->h264.pwht);
- break;
- case VISL_CODEC_HEVC:
- trace_v4l2_ctrl_hevc_sps(fh->tgid, fh->fd, run->hevc.sps);
- trace_v4l2_ctrl_hevc_pps(fh->tgid, fh->fd, run->hevc.pps);
- trace_v4l2_ctrl_hevc_slice_params(fh->tgid, fh->fd, run->hevc.spram);
- trace_v4l2_ctrl_hevc_scaling_matrix(fh->tgid, fh->fd, run->hevc.sm);
- trace_v4l2_ctrl_hevc_decode_params(fh->tgid, fh->fd, run->hevc.dpram);
-
- for (i = 0; i < ARRAY_SIZE(run->hevc.dpram->dpb); i++)
- trace_v4l2_hevc_dpb_entry(fh->tgid, fh->fd, &run->hevc.dpram->dpb[i]);
-
-
- trace_v4l2_hevc_pred_weight_table(fh->tgid, fh->fd,
- &run->hevc.spram->pred_weight_table);
- trace_v4l2_ctrl_hevc_ext_sps_lt_rps(fh->tgid, fh->fd, run->hevc.rps_lt);
- trace_v4l2_ctrl_hevc_ext_sps_st_rps(fh->tgid, fh->fd, run->hevc.rps_st);
- break;
- case VISL_CODEC_AV1:
- trace_v4l2_ctrl_av1_sequence(fh->tgid, fh->fd, run->av1.seq);
- trace_v4l2_ctrl_av1_frame(fh->tgid, fh->fd, run->av1.frame);
- trace_v4l2_ctrl_av1_film_grain(fh->tgid, fh->fd, run->av1.grain);
- trace_v4l2_ctrl_av1_tile_group_entry(fh->tgid, fh->fd, run->av1.tge);
- break;
- }
-}
-
void visl_device_run(void *priv)
{
struct visl_ctx *ctx = priv;
@@ -634,7 +561,6 @@ void visl_device_run(void *priv)
run.dst->sequence, run.dst->vb2_buf.timestamp);
visl_tpg_fill(ctx, &run);
- visl_trace_ctrls(ctx, &run);
if (bitstream_trace_frame_start > -1 &&
run.dst->sequence >= bitstream_trace_frame_start &&
diff --git a/drivers/media/v4l2-core/v4l2-ctrls-api.c b/drivers/media/v4l2-core/v4l2-ctrls-api.c
index 0078a04c5445..8a814eec7a30 100644
--- a/drivers/media/v4l2-core/v4l2-ctrls-api.c
+++ b/drivers/media/v4l2-core/v4l2-ctrls-api.c
@@ -524,6 +524,12 @@ int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct video_device *vdev,
}
EXPORT_SYMBOL(v4l2_g_ext_ctrls);
+static void trace_ext_ctrl(struct v4l2_fh *fh, const struct v4l2_ctrl *ctrl)
+{
+ if (ctrl->type_ops->trace)
+ ctrl->type_ops->trace(fh, ctrl, ctrl->p_cur);
+}
+
/* Validate a new control */
static int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
{
@@ -713,6 +719,10 @@ int try_set_ext_ctrls_common(struct v4l2_fh *fh,
idx = helpers[idx].next;
} while (!ret && idx);
}
+
+ if (set)
+ trace_ext_ctrl(fh, master);
+
v4l2_ctrl_unlock(master);
}
diff --git a/drivers/media/v4l2-core/v4l2-ctrls-core.c b/drivers/media/v4l2-core/v4l2-ctrls-core.c
index 79a157975f70..6165e36d8879 100644
--- a/drivers/media/v4l2-core/v4l2-ctrls-core.c
+++ b/drivers/media/v4l2-core/v4l2-ctrls-core.c
@@ -10,8 +10,11 @@
#include <linux/slab.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-event.h>
+#include <media/v4l2-fh.h>
#include <media/v4l2-fwnode.h>
+#include <trace/events/v4l2_requests.h>
+
#include "v4l2-ctrls-priv.h"
static const union v4l2_ctrl_ptr ptr_null;
@@ -1462,12 +1465,123 @@ int v4l2_ctrl_type_op_validate(const struct v4l2_ctrl *ctrl,
}
EXPORT_SYMBOL(v4l2_ctrl_type_op_validate);
+void v4l2_ctrl_type_op_trace(const struct v4l2_fh *fh,
+ const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr ptr)
+{
+ int i = 0;
+
+ switch ((u32)ctrl->type) {
+ case V4L2_CTRL_TYPE_FWHT_PARAMS:
+ trace_v4l2_ctrl_fwht_params(fh->tgid, fh->fd, ptr.p_fwht_params);
+ break;
+ case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
+ trace_v4l2_ctrl_mpeg2_sequence(fh->tgid, fh->fd, ptr.p_mpeg2_sequence);
+ break;
+ case V4L2_CTRL_TYPE_MPEG2_PICTURE:
+ trace_v4l2_ctrl_mpeg2_picture(fh->tgid, fh->fd, ptr.p_mpeg2_picture);
+ break;
+ case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
+ trace_v4l2_ctrl_mpeg2_quantisation(fh->tgid, fh->fd, ptr.p_mpeg2_quantisation);
+ break;
+ case V4L2_CTRL_TYPE_VP8_FRAME:
+ trace_v4l2_ctrl_vp8_frame(fh->tgid, fh->fd, ptr.p_vp8_frame);
+ trace_v4l2_ctrl_vp8_entropy(fh->tgid, fh->fd, ptr.p_vp8_frame);
+ break;
+ case V4L2_CTRL_TYPE_VP9_FRAME:
+ trace_v4l2_ctrl_vp9_frame(fh->tgid, fh->fd, ptr.p_vp9_frame);
+ break;
+ case V4L2_CTRL_TYPE_VP9_COMPRESSED_HDR:
+ trace_v4l2_ctrl_vp9_compressed_hdr(fh->tgid, fh->fd,
+ ptr.p_vp9_compressed_hdr_probs);
+ trace_v4l2_ctrl_vp9_compressed_coeff(fh->tgid, fh->fd,
+ ptr.p_vp9_compressed_hdr_probs);
+ trace_v4l2_vp9_mv_probs(fh->tgid, fh->fd, &ptr.p_vp9_compressed_hdr_probs->mv);
+ break;
+ case V4L2_CTRL_TYPE_H264_SPS:
+ trace_v4l2_ctrl_h264_sps(fh->tgid, fh->fd, ptr.p_h264_sps);
+ break;
+ case V4L2_CTRL_TYPE_H264_PPS:
+ trace_v4l2_ctrl_h264_pps(fh->tgid, fh->fd, ptr.p_h264_pps);
+ break;
+ case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
+ trace_v4l2_ctrl_h264_scaling_matrix(fh->tgid, fh->fd, ptr.p_h264_scaling_matrix);
+ break;
+ case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
+ {
+ struct v4l2_ctrl_h264_slice_params *sp = ptr.p_h264_slice_params;
+
+ trace_v4l2_ctrl_h264_slice_params(fh->tgid, fh->fd, sp);
+
+ for (i = 0; i < ARRAY_SIZE(sp->ref_pic_list0); i++)
+ trace_v4l2_h264_ref_pic_list0(fh->tgid, fh->fd, &sp->ref_pic_list0[i], i);
+ for (i = 0; i < ARRAY_SIZE(sp->ref_pic_list1); i++)
+ trace_v4l2_h264_ref_pic_list1(fh->tgid, fh->fd, &sp->ref_pic_list1[i], i);
+
+ break;
+ }
+ case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
+ {
+ struct v4l2_ctrl_h264_decode_params *dp = ptr.p_h264_decode_params;
+
+ trace_v4l2_ctrl_h264_decode_params(fh->tgid, fh->fd, dp);
+
+ for (i = 0; i < ARRAY_SIZE(dp->dpb); i++)
+ trace_v4l2_h264_dpb_entry(fh->tgid, fh->fd, &dp->dpb[i], i);
+
+ break;
+ }
+ case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
+ trace_v4l2_ctrl_h264_pred_weights(fh->tgid, fh->fd, ptr.p_h264_pred_weights);
+ break;
+ case V4L2_CTRL_TYPE_HEVC_SPS:
+ trace_v4l2_ctrl_hevc_sps(fh->tgid, fh->fd, ptr.p_hevc_sps);
+ break;
+ case V4L2_CTRL_TYPE_HEVC_PPS:
+ trace_v4l2_ctrl_hevc_pps(fh->tgid, fh->fd, ptr.p_hevc_pps);
+ break;
+ case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
+ trace_v4l2_ctrl_hevc_slice_params(fh->tgid, fh->fd, ptr.p_hevc_slice_params);
+ trace_v4l2_hevc_pred_weight_table(fh->tgid, fh->fd,
+ &ptr.p_hevc_slice_params->pred_weight_table);
+ break;
+ case V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX:
+ trace_v4l2_ctrl_hevc_scaling_matrix(fh->tgid, fh->fd, ptr.p_hevc_scaling_matrix);
+ break;
+ case V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS:
+ {
+ struct v4l2_ctrl_hevc_decode_params *dp = ptr.p_hevc_decode_params;
+
+ trace_v4l2_ctrl_hevc_decode_params(fh->tgid, fh->fd, dp);
+
+ for (i = 0; i < ARRAY_SIZE(dp->dpb); i++)
+ trace_v4l2_hevc_dpb_entry(fh->tgid, fh->fd, &dp->dpb[i]);
+
+ break;
+ }
+ case V4L2_CTRL_TYPE_AV1_SEQUENCE:
+ trace_v4l2_ctrl_av1_sequence(fh->tgid, fh->fd, ptr.p_av1_sequence);
+ break;
+ case V4L2_CTRL_TYPE_AV1_FRAME:
+ trace_v4l2_ctrl_av1_frame(fh->tgid, fh->fd, ptr.p_av1_frame);
+ break;
+ case V4L2_CTRL_TYPE_AV1_FILM_GRAIN:
+ trace_v4l2_ctrl_av1_film_grain(fh->tgid, fh->fd, ptr.p_av1_film_grain);
+ break;
+ case V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY:
+ trace_v4l2_ctrl_av1_tile_group_entry(fh->tgid, fh->fd, ptr.p_av1_tile_group_entry);
+ break;
+ }
+
+}
+EXPORT_SYMBOL(v4l2_ctrl_type_op_trace);
+
static const struct v4l2_ctrl_type_ops std_type_ops = {
.equal = v4l2_ctrl_type_op_equal,
.init = v4l2_ctrl_type_op_init,
.minimum = v4l2_ctrl_type_op_minimum,
.maximum = v4l2_ctrl_type_op_maximum,
.log = v4l2_ctrl_type_op_log,
+ .trace = v4l2_ctrl_type_op_trace,
.validate = v4l2_ctrl_type_op_validate,
};
diff --git a/include/media/v4l2-ctrls.h b/include/media/v4l2-ctrls.h
index a2b4c96a9a6f..57c4bb999b7b 100644
--- a/include/media/v4l2-ctrls.h
+++ b/include/media/v4l2-ctrls.h
@@ -140,6 +140,7 @@ struct v4l2_ctrl_ops {
* @minimum: set the value to the minimum value of the control.
* @maximum: set the value to the maximum value of the control.
* @log: log the value.
+ * @trace: trace the value of the control with Ftrace.
* @validate: validate the value for ctrl->new_elems array elements.
* Return 0 on success and a negative value otherwise.
*/
@@ -153,6 +154,8 @@ struct v4l2_ctrl_type_ops {
void (*maximum)(const struct v4l2_ctrl *ctrl, u32 idx,
union v4l2_ctrl_ptr ptr);
void (*log)(const struct v4l2_ctrl *ctrl);
+ void (*trace)(const struct v4l2_fh *fh,
+ const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr ptr);
int (*validate)(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr ptr);
};
@@ -1627,6 +1630,18 @@ void v4l2_ctrl_type_op_init(const struct v4l2_ctrl *ctrl, u32 from_idx,
*/
void v4l2_ctrl_type_op_log(const struct v4l2_ctrl *ctrl);
+/**
+ * v4l2_ctrl_type_op_trace - Default v4l2_ctrl_type_ops trace callback.
+ *
+ * @fh: The v4l2_fh of the current context.
+ * @ctrl: The v4l2_ctrl pointer.
+ * @ptr: The v4l2 control value.
+ *
+ * Return: void
+ */
+void v4l2_ctrl_type_op_trace(const struct v4l2_fh *fh,
+ const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr ptr);
+
/**
* v4l2_ctrl_type_op_validate - Default v4l2_ctrl_type_ops validate callback.
*
--
2.53.0
^ permalink raw reply related
* [PATCH 05/11] media: Add missing types to v4l2_ctrl_ptr
From: Detlev Casanova @ 2026-02-12 16:23 UTC (permalink / raw)
To: linux-kernel
Cc: Nicolas Dufresne, Benjamin Gaignard, Philipp Zabel,
Mauro Carvalho Chehab, Heiko Stuebner, Daniel Almeida,
Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers, Hans Verkuil,
Laurent Pinchart, Ricardo Ribalda, Yunke Cao, Detlev Casanova,
Sakari Ailus, Pavan Bobba, James Cowgill, Ma Ke, Jacopo Mondi,
Daniel Scally, linux-media, linux-rockchip, linux-arm-kernel,
linux-trace-kernel, kernel
In-Reply-To: <20260212162328.192217-1-detlev.casanova@collabora.com>
The v4l2_ctrl_ptr union contains pointers for all control types, but
v4l2_ctrl_hevc_decode_params and v4l2_ctrl_hevc_scaling_matrix are missing.
Add them.
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
include/media/v4l2-ctrls.h | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/include/media/v4l2-ctrls.h b/include/media/v4l2-ctrls.h
index 327976b14d50..a2b4c96a9a6f 100644
--- a/include/media/v4l2-ctrls.h
+++ b/include/media/v4l2-ctrls.h
@@ -49,6 +49,8 @@ struct video_device;
* @p_hevc_sps: Pointer to an HEVC sequence parameter set structure.
* @p_hevc_pps: Pointer to an HEVC picture parameter set structure.
* @p_hevc_slice_params: Pointer to an HEVC slice parameters structure.
+ * @p_hevc_decode_params: Pointer to an HEVC decode parameters structure.
+ * @p_hevc_scaling_matrix Pointer to an HEVC scaling matrix structure.
* @p_hdr10_cll: Pointer to an HDR10 Content Light Level structure.
* @p_hdr10_mastering: Pointer to an HDR10 Mastering Display structure.
* @p_area: Pointer to an area.
@@ -81,6 +83,8 @@ union v4l2_ctrl_ptr {
struct v4l2_ctrl_hevc_sps *p_hevc_sps;
struct v4l2_ctrl_hevc_pps *p_hevc_pps;
struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params;
+ struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params;
+ struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix;
struct v4l2_ctrl_vp9_compressed_hdr *p_vp9_compressed_hdr_probs;
struct v4l2_ctrl_vp9_frame *p_vp9_frame;
struct v4l2_ctrl_hdr10_cll_info *p_hdr10_cll;
--
2.53.0
^ permalink raw reply related
* [PATCH 04/11] media: Add tgid and fd to the v4l2-requests trace fields
From: Detlev Casanova @ 2026-02-12 16:23 UTC (permalink / raw)
To: linux-kernel
Cc: Nicolas Dufresne, Benjamin Gaignard, Philipp Zabel,
Mauro Carvalho Chehab, Heiko Stuebner, Daniel Almeida,
Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers, Hans Verkuil,
Laurent Pinchart, Ricardo Ribalda, Yunke Cao, Detlev Casanova,
Sakari Ailus, Pavan Bobba, James Cowgill, Ma Ke, Jacopo Mondi,
Daniel Scally, linux-media, linux-rockchip, linux-arm-kernel,
linux-trace-kernel, kernel
In-Reply-To: <20260212162328.192217-1-detlev.casanova@collabora.com>
With these fields, userspace can better track which trace event matches
with a given stream.
Even though the trace shows the PID (based on current->tgid), trace
functions could be called from other contexts, therefore showing the wrong
PID, or none at all.
These will ensure that the trace event can be matched with the PID/FD that
opened and configured the video device file.
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
drivers/media/test-drivers/visl/visl-dec.c | 68 +--
include/trace/events/v4l2_requests.h | 622 +++++++++++++--------
2 files changed, 439 insertions(+), 251 deletions(-)
diff --git a/drivers/media/test-drivers/visl/visl-dec.c b/drivers/media/test-drivers/visl/visl-dec.c
index d49208e83726..fc216da17048 100644
--- a/drivers/media/test-drivers/visl/visl-dec.c
+++ b/drivers/media/test-drivers/visl/visl-dec.c
@@ -489,67 +489,71 @@ static void visl_tpg_fill(struct visl_ctx *ctx, struct visl_run *run)
static void visl_trace_ctrls(struct visl_ctx *ctx, struct visl_run *run)
{
int i;
+ struct v4l2_fh *fh = &ctx->fh;
switch (ctx->current_codec) {
default:
case VISL_CODEC_NONE:
break;
case VISL_CODEC_FWHT:
- trace_v4l2_ctrl_fwht_params(run->fwht.params);
+ trace_v4l2_ctrl_fwht_params(fh->tgid, fh->fd, run->fwht.params);
break;
case VISL_CODEC_MPEG2:
- trace_v4l2_ctrl_mpeg2_sequence(run->mpeg2.seq);
- trace_v4l2_ctrl_mpeg2_picture(run->mpeg2.pic);
- trace_v4l2_ctrl_mpeg2_quantisation(run->mpeg2.quant);
+ trace_v4l2_ctrl_mpeg2_sequence(fh->tgid, fh->fd, run->mpeg2.seq);
+ trace_v4l2_ctrl_mpeg2_picture(fh->tgid, fh->fd, run->mpeg2.pic);
+ trace_v4l2_ctrl_mpeg2_quantisation(fh->tgid, fh->fd, run->mpeg2.quant);
break;
case VISL_CODEC_VP8:
- trace_v4l2_ctrl_vp8_frame(run->vp8.frame);
- trace_v4l2_ctrl_vp8_entropy(run->vp8.frame);
+ trace_v4l2_ctrl_vp8_frame(fh->tgid, fh->fd, run->vp8.frame);
+ trace_v4l2_ctrl_vp8_entropy(fh->tgid, fh->fd, run->vp8.frame);
break;
case VISL_CODEC_VP9:
- trace_v4l2_ctrl_vp9_frame(run->vp9.frame);
- trace_v4l2_ctrl_vp9_compressed_hdr(run->vp9.probs);
- trace_v4l2_ctrl_vp9_compressed_coeff(run->vp9.probs);
- trace_v4l2_vp9_mv_probs(&run->vp9.probs->mv);
+ trace_v4l2_ctrl_vp9_frame(fh->tgid, fh->fd, run->vp9.frame);
+ trace_v4l2_ctrl_vp9_compressed_hdr(fh->tgid, fh->fd, run->vp9.probs);
+ trace_v4l2_ctrl_vp9_compressed_coeff(fh->tgid, fh->fd, run->vp9.probs);
+ trace_v4l2_vp9_mv_probs(fh->tgid, fh->fd, &run->vp9.probs->mv);
break;
case VISL_CODEC_H264:
- trace_v4l2_ctrl_h264_sps(run->h264.sps);
- trace_v4l2_ctrl_h264_pps(run->h264.pps);
- trace_v4l2_ctrl_h264_scaling_matrix(run->h264.sm);
- trace_v4l2_ctrl_h264_slice_params(run->h264.spram);
+ trace_v4l2_ctrl_h264_sps(fh->tgid, fh->fd, run->h264.sps);
+ trace_v4l2_ctrl_h264_pps(fh->tgid, fh->fd, run->h264.pps);
+ trace_v4l2_ctrl_h264_scaling_matrix(fh->tgid, fh->fd, run->h264.sm);
+ trace_v4l2_ctrl_h264_slice_params(fh->tgid, fh->fd, run->h264.spram);
for (i = 0; i < ARRAY_SIZE(run->h264.spram->ref_pic_list0); i++)
- trace_v4l2_h264_ref_pic_list0(&run->h264.spram->ref_pic_list0[i], i);
+ trace_v4l2_h264_ref_pic_list0(fh->tgid, fh->fd,
+ &run->h264.spram->ref_pic_list0[i], i);
for (i = 0; i < ARRAY_SIZE(run->h264.spram->ref_pic_list0); i++)
- trace_v4l2_h264_ref_pic_list1(&run->h264.spram->ref_pic_list1[i], i);
+ trace_v4l2_h264_ref_pic_list1(fh->tgid, fh->fd,
+ &run->h264.spram->ref_pic_list1[i], i);
- trace_v4l2_ctrl_h264_decode_params(run->h264.dpram);
+ trace_v4l2_ctrl_h264_decode_params(fh->tgid, fh->fd, run->h264.dpram);
for (i = 0; i < ARRAY_SIZE(run->h264.dpram->dpb); i++)
- trace_v4l2_h264_dpb_entry(&run->h264.dpram->dpb[i], i);
+ trace_v4l2_h264_dpb_entry(fh->tgid, fh->fd, &run->h264.dpram->dpb[i], i);
- trace_v4l2_ctrl_h264_pred_weights(run->h264.pwht);
+ trace_v4l2_ctrl_h264_pred_weights(fh->tgid, fh->fd, run->h264.pwht);
break;
case VISL_CODEC_HEVC:
- trace_v4l2_ctrl_hevc_sps(run->hevc.sps);
- trace_v4l2_ctrl_hevc_pps(run->hevc.pps);
- trace_v4l2_ctrl_hevc_slice_params(run->hevc.spram);
- trace_v4l2_ctrl_hevc_scaling_matrix(run->hevc.sm);
- trace_v4l2_ctrl_hevc_decode_params(run->hevc.dpram);
+ trace_v4l2_ctrl_hevc_sps(fh->tgid, fh->fd, run->hevc.sps);
+ trace_v4l2_ctrl_hevc_pps(fh->tgid, fh->fd, run->hevc.pps);
+ trace_v4l2_ctrl_hevc_slice_params(fh->tgid, fh->fd, run->hevc.spram);
+ trace_v4l2_ctrl_hevc_scaling_matrix(fh->tgid, fh->fd, run->hevc.sm);
+ trace_v4l2_ctrl_hevc_decode_params(fh->tgid, fh->fd, run->hevc.dpram);
for (i = 0; i < ARRAY_SIZE(run->hevc.dpram->dpb); i++)
- trace_v4l2_hevc_dpb_entry(&run->hevc.dpram->dpb[i]);
+ trace_v4l2_hevc_dpb_entry(fh->tgid, fh->fd, &run->hevc.dpram->dpb[i]);
- trace_v4l2_hevc_pred_weight_table(&run->hevc.spram->pred_weight_table);
- trace_v4l2_ctrl_hevc_ext_sps_lt_rps(run->hevc.rps_lt);
- trace_v4l2_ctrl_hevc_ext_sps_st_rps(run->hevc.rps_st);
+ trace_v4l2_hevc_pred_weight_table(fh->tgid, fh->fd,
+ &run->hevc.spram->pred_weight_table);
+ trace_v4l2_ctrl_hevc_ext_sps_lt_rps(fh->tgid, fh->fd, run->hevc.rps_lt);
+ trace_v4l2_ctrl_hevc_ext_sps_st_rps(fh->tgid, fh->fd, run->hevc.rps_st);
break;
case VISL_CODEC_AV1:
- trace_v4l2_ctrl_av1_sequence(run->av1.seq);
- trace_v4l2_ctrl_av1_frame(run->av1.frame);
- trace_v4l2_ctrl_av1_film_grain(run->av1.grain);
- trace_v4l2_ctrl_av1_tile_group_entry(run->av1.tge);
+ trace_v4l2_ctrl_av1_sequence(fh->tgid, fh->fd, run->av1.seq);
+ trace_v4l2_ctrl_av1_frame(fh->tgid, fh->fd, run->av1.frame);
+ trace_v4l2_ctrl_av1_film_grain(fh->tgid, fh->fd, run->av1.grain);
+ trace_v4l2_ctrl_av1_tile_group_entry(fh->tgid, fh->fd, run->av1.tge);
break;
}
}
diff --git a/include/trace/events/v4l2_requests.h b/include/trace/events/v4l2_requests.h
index 34f4a74df5ea..ab6718f40e28 100644
--- a/include/trace/events/v4l2_requests.h
+++ b/include/trace/events/v4l2_requests.h
@@ -10,12 +10,18 @@
/* AV1 controls */
DECLARE_EVENT_CLASS(v4l2_ctrl_av1_seq_tmpl,
- TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_sequence, s)),
- TP_fast_assign(__entry->s = *s;),
- TP_printk("flags = %s, seq_profile = %u, order_hint_bits = %u, bit_depth = %u, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_sequence *s),
+ TP_ARGS(tgid, fd, s),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_av1_sequence, s)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->s = *s;),
+ TP_printk("tgid = %u, fd = %u, "
+ "flags = %s, seq_profile = %u, order_hint_bits = %u, bit_depth = %u, "
"max_frame_width_minus_1 = %u, max_frame_height_minus_1 = %u",
+ __entry->tgid, __entry->fd,
__print_flags(__entry->s.flags, "|",
{V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE, "STILL_PICTURE"},
{V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK, "USE_128X128_SUPERBLOCK"},
@@ -46,11 +52,17 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_seq_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_av1_tge_tmpl,
- TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
- TP_ARGS(t),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_tile_group_entry, t)),
- TP_fast_assign(__entry->t = *t;),
- TP_printk("tile_offset = %u, tile_size = %u, tile_row = %u, tile_col = %u",
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_tile_group_entry *t),
+ TP_ARGS(tgid, fd, t),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_av1_tile_group_entry, t)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->t = *t;),
+ TP_printk("tgid = %u, fd = %u, "
+ "tile_offset = %u, tile_size = %u, tile_row = %u, tile_col = %u",
+ __entry->tgid, __entry->fd,
__entry->t.tile_offset,
__entry->t.tile_size,
__entry->t.tile_row,
@@ -59,11 +71,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_tge_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
- TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
- TP_ARGS(f),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_frame, f)),
- TP_fast_assign(__entry->f = *f;),
- TP_printk("tile_info.flags = %s, tile_info.context_update_tile_id = %u, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_frame *f),
+ TP_ARGS(tgid, fd, f),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_av1_frame, f)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->f = *f;),
+ TP_printk("tgid = %u, fd = %u, "
+ "tile_info.flags = %s, tile_info.context_update_tile_id = %u, "
"tile_info.tile_cols = %u, tile_info.tile_rows = %u, "
"tile_info.mi_col_starts = %s, tile_info.mi_row_starts = %s, "
"tile_info.width_in_sbs_minus_1 = %s, tile_info.height_in_sbs_minus_1 = %s, "
@@ -87,6 +104,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
"render_width_minus_1 = %u, render_height_minus_1 = %u, current_frame_id = %u, "
"buffer_removal_time = %s, order_hints = %s, reference_frame_ts = %s, "
"ref_frame_idx = %s, refresh_frame_flags = %u",
+ __entry->tgid, __entry->fd,
__print_flags(__entry->f.tile_info.flags, "|",
{V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING, "UNIFORM_TILE_SPACING"}),
__entry->f.tile_info.context_update_tile_id,
@@ -222,11 +240,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
- TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
- TP_ARGS(f),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_film_grain, f)),
- TP_fast_assign(__entry->f = *f;),
- TP_printk("flags = %s, cr_mult = %u, grain_seed = %u, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_film_grain *f),
+ TP_ARGS(tgid, fd, f),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_av1_film_grain, f)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->f = *f;),
+ TP_printk("tgid = %u, fd = %u, "
+ "flags = %s, cr_mult = %u, grain_seed = %u, "
"film_grain_params_ref_idx = %u, num_y_points = %u, point_y_value = %s, "
"point_y_scaling = %s, num_cb_points = %u, point_cb_value = %s, "
"point_cb_scaling = %s, num_cr_points = %u, point_cr_value = %s, "
@@ -235,6 +258,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
"ar_coeffs_cr_plus_128 = %s, ar_coeff_shift_minus_6 = %u, "
"grain_scale_shift = %u, cb_mult = %u, cb_luma_mult = %u, cr_luma_mult = %u, "
"cb_offset = %u, cr_offset = %u",
+ __entry->tgid, __entry->fd,
__print_flags(__entry->f.flags, "|",
{V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN, "APPLY_GRAIN"},
{V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN, "UPDATE_GRAIN"},
@@ -287,31 +311,32 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
)
DEFINE_EVENT(v4l2_ctrl_av1_seq_tmpl, v4l2_ctrl_av1_sequence,
- TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
- TP_ARGS(s)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_sequence *s),
+ TP_ARGS(tgid, fd, s)
);
DEFINE_EVENT(v4l2_ctrl_av1_frame_tmpl, v4l2_ctrl_av1_frame,
- TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
- TP_ARGS(f)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_frame *f),
+ TP_ARGS(tgid, fd, f)
);
DEFINE_EVENT(v4l2_ctrl_av1_tge_tmpl, v4l2_ctrl_av1_tile_group_entry,
- TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
- TP_ARGS(t)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_tile_group_entry *t),
+ TP_ARGS(tgid, fd, t)
);
DEFINE_EVENT(v4l2_ctrl_av1_film_grain_tmpl, v4l2_ctrl_av1_film_grain,
- TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
- TP_ARGS(f)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_film_grain *f),
+ TP_ARGS(tgid, fd, f)
);
/* FWHT controls */
DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
- TP_PROTO(const struct v4l2_ctrl_fwht_params *p),
- TP_ARGS(p),
- TP_STRUCT__entry(
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_fwht_params *p),
+ TP_ARGS(tgid, fd, p),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
__field(u64, backward_ref_ts)
__field(u32, version)
__field(u32, width)
@@ -322,7 +347,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
__field(u32, ycbcr_enc)
__field(u32, quantization)
),
- TP_fast_assign(
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
__entry->backward_ref_ts = p->backward_ref_ts;
__entry->version = p->version;
__entry->width = p->width;
@@ -333,7 +359,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
__entry->ycbcr_enc = p->ycbcr_enc;
__entry->quantization = p->quantization;
),
- TP_printk("backward_ref_ts = %llu, "
+ TP_printk("tgid = %u, fd = %u, "
+ "backward_ref_ts = %llu, "
"version = %u, "
"width = %u, "
"height = %u, "
@@ -342,6 +369,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
"xfer_func = %u, "
"ycbcr_enc = %u, "
"quantization = %u",
+ __entry->tgid, __entry->fd,
__entry->backward_ref_ts, __entry->version, __entry->width, __entry->height,
__print_flags(__entry->flags, "|",
{V4L2_FWHT_FL_IS_INTERLACED, "IS_INTERLACED"},
@@ -361,18 +389,23 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
);
DEFINE_EVENT(v4l2_ctrl_fwht_params_tmpl, v4l2_ctrl_fwht_params,
- TP_PROTO(const struct v4l2_ctrl_fwht_params *p),
- TP_ARGS(p)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_fwht_params *p),
+ TP_ARGS(tgid, fd, p)
);
/* H264 controls */
DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
- TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_sps, s)),
- TP_fast_assign(__entry->s = *s),
- TP_printk("profile_idc = %u, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_sps *s),
+ TP_ARGS(tgid, fd, s),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_h264_sps, s)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->s = *s),
+ TP_printk("tgid = %u, fd = %u, "
+ "profile_idc = %u, "
"constraint_set_flags = %s, "
"level_idc = %u, "
"seq_parameter_set_id = %u, "
@@ -390,6 +423,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
"pic_width_in_mbs_minus1 = %u, "
"pic_height_in_map_units_minus1 = %u, "
"flags = %s",
+ __entry->tgid, __entry->fd,
__entry->s.profile_idc,
__print_flags(__entry->s.constraint_set_flags, "|",
{V4L2_H264_SPS_CONSTRAINT_SET0_FLAG, "CONSTRAINT_SET0_FLAG"},
@@ -427,11 +461,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
- TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
- TP_ARGS(p),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pps, p)),
- TP_fast_assign(__entry->p = *p),
- TP_printk("pic_parameter_set_id = %u, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_pps *p),
+ TP_ARGS(tgid, fd, p),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_h264_pps, p)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->p = *p),
+ TP_printk("tgid = %u, fd = %u, "
+ "pic_parameter_set_id = %u, "
"seq_parameter_set_id = %u, "
"num_slice_groups_minus1 = %u, "
"num_ref_idx_l0_default_active_minus1 = %u, "
@@ -442,6 +481,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
"chroma_qp_index_offset = %d, "
"second_chroma_qp_index_offset = %d, "
"flags = %s",
+ __entry->tgid, __entry->fd,
__entry->p.pic_parameter_set_id,
__entry->p.seq_parameter_set_id,
__entry->p.num_slice_groups_minus1,
@@ -465,11 +505,17 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_h264_scaling_matrix_tmpl,
- TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_scaling_matrix, s)),
- TP_fast_assign(__entry->s = *s),
- TP_printk("scaling_list_4x4 = {%s}, scaling_list_8x8 = {%s}",
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_scaling_matrix *s),
+ TP_ARGS(tgid, fd, s),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_h264_scaling_matrix, s)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->s = *s),
+ TP_printk("tgid = %u, fd = %u, "
+ "scaling_list_4x4 = {%s}, scaling_list_8x8 = {%s}",
+ __entry->tgid, __entry->fd,
__print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
__entry->s.scaling_list_4x4,
sizeof(__entry->s.scaling_list_4x4),
@@ -482,11 +528,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_scaling_matrix_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
- TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
- TP_ARGS(p),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pred_weights, p)),
- TP_fast_assign(__entry->p = *p),
- TP_printk("luma_log2_weight_denom = %u, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_pred_weights *p),
+ TP_ARGS(tgid, fd, p),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_h264_pred_weights, p)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->p = *p),
+ TP_printk("tgid = %u, fd = %u, "
+ "luma_log2_weight_denom = %u, "
"chroma_log2_weight_denom = %u, "
"weight_factor[0].luma_weight = %s, "
"weight_factor[0].luma_offset = %s, "
@@ -496,6 +547,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
"weight_factor[1].luma_offset = %s, "
"weight_factor[1].chroma_weight = {%s}, "
"weight_factor[1].chroma_offset = {%s}",
+ __entry->tgid, __entry->fd,
__entry->p.luma_log2_weight_denom,
__entry->p.chroma_log2_weight_denom,
__print_array(__entry->p.weight_factors[0].luma_weight,
@@ -530,11 +582,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
- TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_slice_params, s)),
- TP_fast_assign(__entry->s = *s),
- TP_printk("header_bit_size = %u, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_slice_params *s),
+ TP_ARGS(tgid, fd, s),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_h264_slice_params, s)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->s = *s),
+ TP_printk("tgid = %u, fd = %u, "
+ "header_bit_size = %u, "
"first_mb_in_slice = %u, "
"slice_type = %s, "
"colour_plane_id = %u, "
@@ -548,6 +605,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
"num_ref_idx_l0_active_minus1 = %u, "
"num_ref_idx_l1_active_minus1 = %u, "
"flags = %s",
+ __entry->tgid, __entry->fd,
__entry->s.header_bit_size,
__entry->s.first_mb_in_slice,
__print_symbolic(__entry->s.slice_type,
@@ -573,12 +631,18 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_h264_reference_tmpl,
- TP_PROTO(const struct v4l2_h264_reference *r, int i),
- TP_ARGS(r, i),
- TP_STRUCT__entry(__field_struct(struct v4l2_h264_reference, r)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_h264_reference *r, int i),
+ TP_ARGS(tgid, fd, r, i),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_h264_reference, r)
__field(int, i)),
- TP_fast_assign(__entry->r = *r; __entry->i = i;),
- TP_printk("[%d]: fields = %s, index = %u",
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->r = *r; __entry->i = i;),
+ TP_printk("tgid = %u, fd = %u, "
+ "[%d]: fields = %s, index = %u",
+ __entry->tgid, __entry->fd,
__entry->i,
__print_flags(__entry->r.fields, "|",
{V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
@@ -589,11 +653,16 @@ DECLARE_EVENT_CLASS(v4l2_h264_reference_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
- TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
- TP_ARGS(d),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_decode_params, d)),
- TP_fast_assign(__entry->d = *d),
- TP_printk("nal_ref_idc = %u, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_decode_params *d),
+ TP_ARGS(tgid, fd, d),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_h264_decode_params, d)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->d = *d),
+ TP_printk("tgid = %u, fd = %u, "
+ "nal_ref_idc = %u, "
"frame_num = %u, "
"top_field_order_cnt = %d, "
"bottom_field_order_cnt = %d, "
@@ -606,6 +675,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
"pic_order_cnt_bit_size = %u, "
"slice_group_change_cycle = %u, "
"flags = %s",
+ __entry->tgid, __entry->fd,
__entry->d.nal_ref_idc,
__entry->d.frame_num,
__entry->d.top_field_order_cnt,
@@ -628,13 +698,19 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
- TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
- TP_ARGS(e, i),
- TP_STRUCT__entry(__field_struct(struct v4l2_h264_dpb_entry, e)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_h264_dpb_entry *e, int i),
+ TP_ARGS(tgid, fd, e, i),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_h264_dpb_entry, e)
__field(int, i)),
- TP_fast_assign(__entry->e = *e; __entry->i = i;),
- TP_printk("[%d]: reference_ts = %llu, pic_num = %u, frame_num = %u, fields = %s "
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->e = *e; __entry->i = i;),
+ TP_printk("tgid = %u, fd = %u, "
+ "[%d]: reference_ts = %llu, pic_num = %u, frame_num = %u, fields = %s, "
"top_field_order_cnt = %d, bottom_field_order_cnt = %d, flags = %s",
+ __entry->tgid, __entry->fd,
__entry->i,
__entry->e.reference_ts,
__entry->e.pic_num,
@@ -654,58 +730,63 @@ DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
);
DEFINE_EVENT(v4l2_ctrl_h264_sps_tmpl, v4l2_ctrl_h264_sps,
- TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
- TP_ARGS(s)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_sps *s),
+ TP_ARGS(tgid, fd, s)
);
DEFINE_EVENT(v4l2_ctrl_h264_pps_tmpl, v4l2_ctrl_h264_pps,
- TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
- TP_ARGS(p)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_pps *p),
+ TP_ARGS(tgid, fd, p)
);
DEFINE_EVENT(v4l2_ctrl_h264_scaling_matrix_tmpl, v4l2_ctrl_h264_scaling_matrix,
- TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
- TP_ARGS(s)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_scaling_matrix *s),
+ TP_ARGS(tgid, fd, s)
);
DEFINE_EVENT(v4l2_ctrl_h264_pred_weights_tmpl, v4l2_ctrl_h264_pred_weights,
- TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
- TP_ARGS(p)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_pred_weights *p),
+ TP_ARGS(tgid, fd, p)
);
DEFINE_EVENT(v4l2_ctrl_h264_slice_params_tmpl, v4l2_ctrl_h264_slice_params,
- TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
- TP_ARGS(s)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_slice_params *s),
+ TP_ARGS(tgid, fd, s)
);
DEFINE_EVENT(v4l2_h264_reference_tmpl, v4l2_h264_ref_pic_list0,
- TP_PROTO(const struct v4l2_h264_reference *r, int i),
- TP_ARGS(r, i)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_h264_reference *r, int i),
+ TP_ARGS(tgid, fd, r, i)
);
DEFINE_EVENT(v4l2_h264_reference_tmpl, v4l2_h264_ref_pic_list1,
- TP_PROTO(const struct v4l2_h264_reference *r, int i),
- TP_ARGS(r, i)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_h264_reference *r, int i),
+ TP_ARGS(tgid, fd, r, i)
);
DEFINE_EVENT(v4l2_ctrl_h264_decode_params_tmpl, v4l2_ctrl_h264_decode_params,
- TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
- TP_ARGS(d)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_decode_params *d),
+ TP_ARGS(tgid, fd, d)
);
DEFINE_EVENT(v4l2_h264_dpb_entry_tmpl, v4l2_h264_dpb_entry,
- TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
- TP_ARGS(e, i)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_h264_dpb_entry *e, int i),
+ TP_ARGS(tgid, fd, e, i)
);
/* HEVC controls */
DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_sps, s)),
- TP_fast_assign(__entry->s = *s),
- TP_printk("video_parameter_set_id = %u, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_sps *s),
+ TP_ARGS(tgid, fd, s),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_hevc_sps, s)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->s = *s),
+ TP_printk("tgid = %u, fd = %u, "
+ "video_parameter_set_id = %u, "
"seq_parameter_set_id = %u, "
"pic_width_in_luma_samples = %u, "
"pic_height_in_luma_samples = %u, "
@@ -730,6 +811,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
"chroma_format_idc = %u, "
"sps_max_sub_layers_minus1 = %u, "
"flags = %s",
+ __entry->tgid, __entry->fd,
__entry->s.video_parameter_set_id,
__entry->s.seq_parameter_set_id,
__entry->s.pic_width_in_luma_samples,
@@ -770,11 +852,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
- TP_ARGS(p),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_pps, p)),
- TP_fast_assign(__entry->p = *p),
- TP_printk("pic_parameter_set_id = %u, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_pps *p),
+ TP_ARGS(tgid, fd, p),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_hevc_pps, p)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->p = *p),
+ TP_printk("tgid = %u, fd = %u, "
+ "pic_parameter_set_id = %u, "
"num_extra_slice_header_bits = %u, "
"num_ref_idx_l0_default_active_minus1 = %u, "
"num_ref_idx_l1_default_active_minus1 = %u, "
@@ -790,6 +877,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
"pps_tc_offset_div2 = %d, "
"log2_parallel_merge_level_minus2 = %u, "
"flags = %s",
+ __entry->tgid, __entry->fd,
__entry->p.pic_parameter_set_id,
__entry->p.num_extra_slice_header_bits,
__entry->p.num_ref_idx_l0_default_active_minus1,
@@ -837,11 +925,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_slice_params, s)),
- TP_fast_assign(__entry->s = *s),
- TP_printk("bit_size = %u, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_slice_params *s),
+ TP_ARGS(tgid, fd, s),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_hevc_slice_params, s)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->s = *s),
+ TP_printk("tgid = %u, fd = %u, "
+ "bit_size = %u, "
"data_byte_offset = %u, "
"num_entry_point_offsets = %u, "
"nal_unit_type = %u, "
@@ -868,6 +961,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
"short_term_ref_pic_set_size = %u, "
"long_term_ref_pic_set_size = %u, "
"flags = %s",
+ __entry->tgid, __entry->fd,
__entry->s.bit_size,
__entry->s.data_byte_offset,
__entry->s.num_entry_point_offsets,
@@ -914,11 +1008,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
- TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
- TP_ARGS(p),
- TP_STRUCT__entry(__field_struct(struct v4l2_hevc_pred_weight_table, p)),
- TP_fast_assign(__entry->p = *p),
- TP_printk("delta_luma_weight_l0 = %s, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_hevc_pred_weight_table *p),
+ TP_ARGS(tgid, fd, p),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_hevc_pred_weight_table, p)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->p = *p),
+ TP_printk("tgid = %u, fd = %u, "
+ "delta_luma_weight_l0 = %s, "
"luma_offset_l0 = %s, "
"delta_chroma_weight_l0 = {%s}, "
"chroma_offset_l0 = {%s}, "
@@ -928,6 +1027,7 @@ DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
"chroma_offset_l1 = {%s}, "
"luma_log2_weight_denom = %d, "
"delta_chroma_log2_weight_denom = %d",
+ __entry->tgid, __entry->fd,
__print_array(__entry->p.delta_luma_weight_l0,
ARRAY_SIZE(__entry->p.delta_luma_weight_l0),
sizeof(__entry->p.delta_luma_weight_l0[0])),
@@ -962,16 +1062,22 @@ DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
))
DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_scaling_matrix_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_scaling_matrix, s)),
- TP_fast_assign(__entry->s = *s),
- TP_printk("scaling_list_4x4 = {%s}, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_scaling_matrix *s),
+ TP_ARGS(tgid, fd, s),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_hevc_scaling_matrix, s)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->s = *s),
+ TP_printk("tgid = %u, fd = %u, "
+ "scaling_list_4x4 = {%s}, "
"scaling_list_8x8 = {%s}, "
"scaling_list_16x16 = {%s}, "
"scaling_list_32x32 = {%s}, "
"scaling_list_dc_coef_16x16 = %s, "
"scaling_list_dc_coef_32x32 = %s",
+ __entry->tgid, __entry->fd,
__print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
__entry->s.scaling_list_4x4,
sizeof(__entry->s.scaling_list_4x4),
@@ -997,11 +1103,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_scaling_matrix_tmpl,
))
DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
- TP_ARGS(d),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_decode_params, d)),
- TP_fast_assign(__entry->d = *d),
- TP_printk("pic_order_cnt_val = %d, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_decode_params *d),
+ TP_ARGS(tgid, fd, d),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_hevc_decode_params, d)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->d = *d),
+ TP_printk("tgid = %u, fd = %u, "
+ "pic_order_cnt_val = %d, "
"short_term_ref_pic_set_size = %u, "
"long_term_ref_pic_set_size = %u, "
"num_active_dpb_entries = %u, "
@@ -1012,6 +1123,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
"poc_st_curr_after = %s, "
"poc_lt_curr = %s, "
"flags = %s",
+ __entry->tgid, __entry->fd,
__entry->d.pic_order_cnt_val,
__entry->d.short_term_ref_pic_set_size,
__entry->d.long_term_ref_pic_set_size,
@@ -1036,12 +1148,18 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
- TP_ARGS(lt),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_lt_rps, lt)),
- TP_fast_assign(__entry->lt = *lt),
- TP_printk("flags = %s, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
+ TP_ARGS(tgid, fd, lt),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_hevc_ext_sps_lt_rps, lt)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->lt = *lt),
+ TP_printk("tgid = %u, fd = %u, "
+ "flags = %s, "
"lt_ref_pic_poc_lsb_sps = %x",
+ __entry->tgid, __entry->fd,
__print_flags(__entry->lt.flags, "|",
{V4L2_HEVC_EXT_SPS_LT_RPS_FLAG_USED_LT, "USED_LT"}
),
@@ -1050,11 +1168,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
- TP_ARGS(st),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_st_rps, st)),
- TP_fast_assign(__entry->st = *st),
- TP_printk("flags = %s, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
+ TP_ARGS(tgid, fd, st),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_hevc_ext_sps_st_rps, st)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->st = *st),
+ TP_printk("tgid = %u, fd = %u, "
+ "flags = %s, "
"delta_idx_minus1 = %u, "
"delta_rps_sign = %u, "
"abs_delta_rps_minus1 = %u, "
@@ -1064,6 +1187,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
"use_delta_flag = %08x, "
"delta_poc_s0_minus1 = %s, "
"delta_poc_s1_minus1 = %s",
+ __entry->tgid, __entry->fd,
__print_flags(__entry->st.flags, "|",
{V4L2_HEVC_EXT_SPS_ST_RPS_FLAG_INTER_REF_PIC_SET_PRED, "INTER_REF_PIC_SET_PRED"}
),
@@ -1084,14 +1208,20 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_hevc_dpb_entry_tmpl,
- TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
- TP_ARGS(e),
- TP_STRUCT__entry(__field_struct(struct v4l2_hevc_dpb_entry, e)),
- TP_fast_assign(__entry->e = *e),
- TP_printk("timestamp = %llu, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_hevc_dpb_entry *e),
+ TP_ARGS(tgid, fd, e),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_hevc_dpb_entry, e)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->e = *e),
+ TP_printk("tgid = %u, fd = %u, "
+ "timestamp = %llu, "
"flags = %s, "
"field_pic = %u, "
"pic_order_cnt_val = %d",
+ __entry->tgid, __entry->fd,
__entry->e.timestamp,
__print_flags(__entry->e.flags, "|",
{V4L2_HEVC_DPB_ENTRY_LONG_TERM_REFERENCE, "LONG_TERM_REFERENCE"}
@@ -1101,59 +1231,65 @@ DECLARE_EVENT_CLASS(v4l2_hevc_dpb_entry_tmpl,
))
DEFINE_EVENT(v4l2_ctrl_hevc_sps_tmpl, v4l2_ctrl_hevc_sps,
- TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
- TP_ARGS(s)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_sps *s),
+ TP_ARGS(tgid, fd, s)
);
DEFINE_EVENT(v4l2_ctrl_hevc_pps_tmpl, v4l2_ctrl_hevc_pps,
- TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
- TP_ARGS(p)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_pps *p),
+ TP_ARGS(tgid, fd, p)
);
DEFINE_EVENT(v4l2_ctrl_hevc_slice_params_tmpl, v4l2_ctrl_hevc_slice_params,
- TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
- TP_ARGS(s)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_slice_params *s),
+ TP_ARGS(tgid, fd, s)
);
DEFINE_EVENT(v4l2_hevc_pred_weight_table_tmpl, v4l2_hevc_pred_weight_table,
- TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
- TP_ARGS(p)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_hevc_pred_weight_table *p),
+ TP_ARGS(tgid, fd, p)
);
DEFINE_EVENT(v4l2_ctrl_hevc_scaling_matrix_tmpl, v4l2_ctrl_hevc_scaling_matrix,
- TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
- TP_ARGS(s)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_scaling_matrix *s),
+ TP_ARGS(tgid, fd, s)
);
DEFINE_EVENT(v4l2_ctrl_hevc_decode_params_tmpl, v4l2_ctrl_hevc_decode_params,
- TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
- TP_ARGS(d)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_decode_params *d),
+ TP_ARGS(tgid, fd, d)
);
DEFINE_EVENT(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl, v4l2_ctrl_hevc_ext_sps_lt_rps,
- TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
- TP_ARGS(lt)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
+ TP_ARGS(tgid, fd, lt)
);
DEFINE_EVENT(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl, v4l2_ctrl_hevc_ext_sps_st_rps,
- TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
- TP_ARGS(st)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
+ TP_ARGS(tgid, fd, st)
);
DEFINE_EVENT(v4l2_hevc_dpb_entry_tmpl, v4l2_hevc_dpb_entry,
- TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
- TP_ARGS(e)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_hevc_dpb_entry *e),
+ TP_ARGS(tgid, fd, e)
);
/* MPEG2 controls */
DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_seq_tmpl,
- TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_sequence, s)),
- TP_fast_assign(__entry->s = *s;),
- TP_printk("horizontal_size = %u, vertical_size = %u, vbv_buffer_size = %u, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_mpeg2_sequence *s),
+ TP_ARGS(tgid, fd, s),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_mpeg2_sequence, s)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->s = *s;),
+ TP_printk("tgid = %u, fd = %u, "
+ "horizontal_size = %u, vertical_size = %u, vbv_buffer_size = %u, "
"profile_and_level_indication = %u, chroma_format = %u, flags = %s",
+ __entry->tgid, __entry->fd,
__entry->s.horizontal_size,
__entry->s.vertical_size,
__entry->s.vbv_buffer_size,
@@ -1165,12 +1301,18 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_seq_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_pic_tmpl,
- TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
- TP_ARGS(p),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_picture, p)),
- TP_fast_assign(__entry->p = *p;),
- TP_printk("backward_ref_ts = %llu, forward_ref_ts = %llu, flags = %s, f_code = {%s}, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_mpeg2_picture *p),
+ TP_ARGS(tgid, fd, p),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_mpeg2_picture, p)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->p = *p;),
+ TP_printk("tgid = %u, fd = %u, "
+ "backward_ref_ts = %llu, forward_ref_ts = %llu, flags = %s, f_code = {%s}, "
"picture_coding_type = %u, picture_structure = %u, intra_dc_precision = %u",
+ __entry->tgid, __entry->fd,
__entry->p.backward_ref_ts,
__entry->p.forward_ref_ts,
__print_flags(__entry->p.flags, "|",
@@ -1193,12 +1335,18 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_pic_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_quant_tmpl,
- TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
- TP_ARGS(q),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_quantisation, q)),
- TP_fast_assign(__entry->q = *q;),
- TP_printk("intra_quantiser_matrix = %s, non_intra_quantiser_matrix = %s, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_mpeg2_quantisation *q),
+ TP_ARGS(tgid, fd, q),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_mpeg2_quantisation, q)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->q = *q;),
+ TP_printk("tgid = %u, fd = %u, "
+ "intra_quantiser_matrix = %s, non_intra_quantiser_matrix = %s, "
"chroma_intra_quantiser_matrix = %s, chroma_non_intra_quantiser_matrix = %s",
+ __entry->tgid, __entry->fd,
__print_array(__entry->q.intra_quantiser_matrix,
ARRAY_SIZE(__entry->q.intra_quantiser_matrix),
sizeof(__entry->q.intra_quantiser_matrix[0])),
@@ -1215,31 +1363,37 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_quant_tmpl,
)
DEFINE_EVENT(v4l2_ctrl_mpeg2_seq_tmpl, v4l2_ctrl_mpeg2_sequence,
- TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
- TP_ARGS(s)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_mpeg2_sequence *s),
+ TP_ARGS(tgid, fd, s)
);
DEFINE_EVENT(v4l2_ctrl_mpeg2_pic_tmpl, v4l2_ctrl_mpeg2_picture,
- TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
- TP_ARGS(p)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_mpeg2_picture *p),
+ TP_ARGS(tgid, fd, p)
);
DEFINE_EVENT(v4l2_ctrl_mpeg2_quant_tmpl, v4l2_ctrl_mpeg2_quantisation,
- TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
- TP_ARGS(q)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_mpeg2_quantisation *q),
+ TP_ARGS(tgid, fd, q)
);
/* VP8 controls */
DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_entropy_tmpl,
- TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
- TP_ARGS(f),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
- TP_fast_assign(__entry->f = *f;),
- TP_printk("entropy.coeff_probs = {%s}, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp8_frame *f),
+ TP_ARGS(tgid, fd, f),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_vp8_frame, f)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->f = *f;),
+ TP_printk("tgid = %u, fd = %u, "
+ "entropy.coeff_probs = {%s}, "
"entropy.y_mode_probs = %s, "
"entropy.uv_mode_probs = %s, "
"entropy.mv_probs = {%s}",
+ __entry->tgid, __entry->fd,
__print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
__entry->f.entropy.coeff_probs,
sizeof(__entry->f.entropy.coeff_probs),
@@ -1258,11 +1412,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_entropy_tmpl,
)
DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
- TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
- TP_ARGS(f),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
- TP_fast_assign(__entry->f = *f;),
- TP_printk("segment.quant_update = %s, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp8_frame *f),
+ TP_ARGS(tgid, fd, f),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_vp8_frame, f)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->f = *f;),
+ TP_printk("tgid = %u, fd = %u, "
+ "segment.quant_update = %s, "
"segment.lf_update = %s, "
"segment.segment_probs = %s, "
"segment.flags = %s, "
@@ -1297,6 +1456,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
"golden_frame_ts = %llu, "
"alt_frame_ts = %llu, "
"flags = %s",
+ __entry->tgid, __entry->fd,
__print_array(__entry->f.segment.quant_update,
ARRAY_SIZE(__entry->f.segment.quant_update),
sizeof(__entry->f.segment.quant_update[0])),
@@ -1361,23 +1521,28 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
);
DEFINE_EVENT(v4l2_ctrl_vp8_frame_tmpl, v4l2_ctrl_vp8_frame,
- TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
- TP_ARGS(f)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp8_frame *f),
+ TP_ARGS(tgid, fd, f)
);
DEFINE_EVENT(v4l2_ctrl_vp8_entropy_tmpl, v4l2_ctrl_vp8_entropy,
- TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
- TP_ARGS(f)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp8_frame *f),
+ TP_ARGS(tgid, fd, f)
);
/* VP9 controls */
DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
- TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
- TP_ARGS(f),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_frame, f)),
- TP_fast_assign(__entry->f = *f;),
- TP_printk("lf.ref_deltas = %s, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp9_frame *f),
+ TP_ARGS(tgid, fd, f),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_vp9_frame, f)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->f = *f;),
+ TP_printk("tgid = %u, fd = %u, "
+ "lf.ref_deltas = %s, "
"lf.mode_deltas = %s, "
"lf.level = %u, "
"lf.sharpness = %u, "
@@ -1410,6 +1575,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
"tile_cols_log2 = %u, "
"tile_rows_log_2 = %u, "
"reference_mode = %s",
+ __entry->tgid, __entry->fd,
__print_array(__entry->f.lf.ref_deltas,
ARRAY_SIZE(__entry->f.lf.ref_deltas),
sizeof(__entry->f.lf.ref_deltas[0])),
@@ -1490,11 +1656,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
- TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
- TP_ARGS(h),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
- TP_fast_assign(__entry->h = *h;),
- TP_printk("tx_mode = %s, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp9_compressed_hdr *h),
+ TP_ARGS(tgid, fd, h),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->h = *h;),
+ TP_printk("tgid = %u, fd = %u, "
+ "tx_mode = %s, "
"tx8 = {%s}, "
"tx16 = {%s}, "
"tx32 = {%s}, "
@@ -1508,6 +1679,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
"y_mode = {%s}, "
"uv_mode = {%s}, "
"partition = {%s}",
+ __entry->tgid, __entry->fd,
__print_symbolic(__entry->h.tx_mode,
{V4L2_VP9_TX_MODE_ONLY_4X4, "TX_MODE_ONLY_4X4"},
{V4L2_VP9_TX_MODE_ALLOW_8X8, "TX_MODE_ALLOW_8X8"},
@@ -1566,11 +1738,17 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_coef_tmpl,
- TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
- TP_ARGS(h),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
- TP_fast_assign(__entry->h = *h;),
- TP_printk("coef = {%s}",
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp9_compressed_hdr *h),
+ TP_ARGS(tgid, fd, h),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->h = *h;),
+ TP_printk("tgid = %u, fd = %u, "
+ "coef = {%s}",
+ __entry->tgid, __entry->fd,
__print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
__entry->h.coef,
sizeof(__entry->h.coef),
@@ -1579,11 +1757,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_coef_tmpl,
);
DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
- TP_PROTO(const struct v4l2_vp9_mv_probs *p),
- TP_ARGS(p),
- TP_STRUCT__entry(__field_struct(struct v4l2_vp9_mv_probs, p)),
- TP_fast_assign(__entry->p = *p;),
- TP_printk("joint = %s, "
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_vp9_mv_probs *p),
+ TP_ARGS(tgid, fd, p),
+ TP_STRUCT__entry(__field(u32, tgid)
+ __field(u32, fd)
+ __field_struct(struct v4l2_vp9_mv_probs, p)),
+ TP_fast_assign(__entry->tgid = tgid;
+ __entry->fd = fd;
+ __entry->p = *p;),
+ TP_printk("tgid = %u, fd = %u, "
+ "joint = %s, "
"sign = %s, "
"classes = {%s}, "
"class0_bit = %s, "
@@ -1592,6 +1775,7 @@ DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
"fr = {%s}, "
"class0_hp = %s, "
"hp = %s",
+ __entry->tgid, __entry->fd,
__print_array(__entry->p.joint,
ARRAY_SIZE(__entry->p.joint),
sizeof(__entry->p.joint[0])),
@@ -1627,24 +1811,24 @@ DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
);
DEFINE_EVENT(v4l2_ctrl_vp9_frame_tmpl, v4l2_ctrl_vp9_frame,
- TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
- TP_ARGS(f)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp9_frame *f),
+ TP_ARGS(tgid, fd, f)
);
DEFINE_EVENT(v4l2_ctrl_vp9_compressed_hdr_tmpl, v4l2_ctrl_vp9_compressed_hdr,
- TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
- TP_ARGS(h)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp9_compressed_hdr *h),
+ TP_ARGS(tgid, fd, h)
);
DEFINE_EVENT(v4l2_ctrl_vp9_compressed_coef_tmpl, v4l2_ctrl_vp9_compressed_coeff,
- TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
- TP_ARGS(h)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp9_compressed_hdr *h),
+ TP_ARGS(tgid, fd, h)
);
DEFINE_EVENT(v4l2_vp9_mv_probs_tmpl, v4l2_vp9_mv_probs,
- TP_PROTO(const struct v4l2_vp9_mv_probs *p),
- TP_ARGS(p)
+ TP_PROTO(u32 tgid, u32 fd, const struct v4l2_vp9_mv_probs *p),
+ TP_ARGS(tgid, fd, p)
);
#endif /* if !defined(_TRACE_V4L2_REQUESTS_H_) || defined(TRACE_HEADER_MULTI_READ) */
--
2.53.0
^ permalink raw reply related
* [PATCH 03/11] media: Add tgid and fd fields in v4l2_fh struct
From: Detlev Casanova @ 2026-02-12 16:23 UTC (permalink / raw)
To: linux-kernel
Cc: Nicolas Dufresne, Benjamin Gaignard, Philipp Zabel,
Mauro Carvalho Chehab, Heiko Stuebner, Daniel Almeida,
Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers, Hans Verkuil,
Laurent Pinchart, Ricardo Ribalda, Yunke Cao, Detlev Casanova,
Sakari Ailus, Pavan Bobba, James Cowgill, Ma Ke, Jacopo Mondi,
Daniel Scally, linux-media, linux-rockchip, linux-arm-kernel,
linux-trace-kernel, kernel
In-Reply-To: <20260212162328.192217-1-detlev.casanova@collabora.com>
These fields will be used in traces to help userspace tracing tools
identify streams.
The tgid field will keep the PID of the process that opened the video
file.
That is needed because trace calls can happen in IRQs, for which there is
no current PID.
The fd field helps identify the context in case the same process opens the
video device multiple times.
Note that the fd field is set in the __video_do_ioctl() function.
That is because the file descriptor has not been allocated yet when
v4l2_open() is called.
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
drivers/media/v4l2-core/v4l2-fh.c | 1 +
drivers/media/v4l2-core/v4l2-ioctl.c | 17 +++++++++++++++++
include/media/v4l2-fh.h | 4 ++++
3 files changed, 22 insertions(+)
diff --git a/drivers/media/v4l2-core/v4l2-fh.c b/drivers/media/v4l2-core/v4l2-fh.c
index df3ba9d4674b..86e8223b46cb 100644
--- a/drivers/media/v4l2-core/v4l2-fh.c
+++ b/drivers/media/v4l2-core/v4l2-fh.c
@@ -37,6 +37,7 @@ void v4l2_fh_init(struct v4l2_fh *fh, struct video_device *vdev)
INIT_LIST_HEAD(&fh->available);
INIT_LIST_HEAD(&fh->subscribed);
fh->sequence = -1;
+ fh->tgid = current->tgid;
mutex_init(&fh->subscribe_lock);
}
EXPORT_SYMBOL_GPL(v4l2_fh_init);
diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
index 37d33d4a363d..a3b6df0571d6 100644
--- a/drivers/media/v4l2-core/v4l2-ioctl.c
+++ b/drivers/media/v4l2-core/v4l2-ioctl.c
@@ -9,6 +9,7 @@
*/
#include <linux/compat.h>
+#include <linux/fdtable.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/slab.h>
@@ -3061,6 +3062,16 @@ void v4l_printk_ioctl(const char *prefix, unsigned int cmd)
}
EXPORT_SYMBOL(v4l_printk_ioctl);
+static int _file_iterate(const void *priv, struct file *filp, unsigned int fd)
+{
+ const struct file *fh_filp = priv;
+
+ if (fh_filp == filp)
+ return fd;
+
+ return 0;
+}
+
static long __video_do_ioctl(struct file *file,
unsigned int cmd, void *arg)
{
@@ -3081,6 +3092,12 @@ static long __video_do_ioctl(struct file *file,
return ret;
}
+ if (unlikely(!vfh->fd)) {
+ vfh->fd = iterate_fd(current->files, 0, _file_iterate, file);
+ if (!vfh->fd)
+ vfh->fd = -1;
+ }
+
/*
* We need to serialize streamon/off with queueing new requests.
* These ioctls may trigger the cancellation of a streaming
diff --git a/include/media/v4l2-fh.h b/include/media/v4l2-fh.h
index aad4b3689d7e..4ef4e58ab8d1 100644
--- a/include/media/v4l2-fh.h
+++ b/include/media/v4l2-fh.h
@@ -28,6 +28,8 @@ struct v4l2_ctrl_handler;
* @vdev: pointer to &struct video_device
* @ctrl_handler: pointer to &struct v4l2_ctrl_handler
* @prio: priority of the file handler, as defined by &enum v4l2_priority
+ * @tgid: process id that initialized the v4l2_fh
+ * @fd: file descriptor associated to this v4l2_fh for the process id in tgid
*
* @wait: event' s wait queue
* @subscribe_lock: serialise changes to the subscribed list; guarantee that
@@ -44,6 +46,8 @@ struct v4l2_fh {
struct video_device *vdev;
struct v4l2_ctrl_handler *ctrl_handler;
enum v4l2_priority prio;
+ uint32_t tgid;
+ int fd;
/* Events */
wait_queue_head_t wait;
--
2.53.0
^ permalink raw reply related
* [PATCH 02/11] media: Reformat v4l2-requests trace event printk
From: Detlev Casanova @ 2026-02-12 16:23 UTC (permalink / raw)
To: linux-kernel
Cc: Nicolas Dufresne, Benjamin Gaignard, Philipp Zabel,
Mauro Carvalho Chehab, Heiko Stuebner, Daniel Almeida,
Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers, Hans Verkuil,
Laurent Pinchart, Ricardo Ribalda, Yunke Cao, Detlev Casanova,
Sakari Ailus, Pavan Bobba, James Cowgill, Ma Ke, Jacopo Mondi,
Daniel Scally, linux-media, linux-rockchip, linux-arm-kernel,
linux-trace-kernel, kernel
In-Reply-To: <20260212162328.192217-1-detlev.casanova@collabora.com>
When printing the v4l2-request traces the format was not stable.
Sometimes using a ':' separator, sometimes with an extra space and using
new lines.
Reformat the printk calls to match the format used in v4l2.h so that
parsers can use the same format for all events.
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
include/trace/events/v4l2_requests.h | 649 ++++++++++++++-------------
1 file changed, 328 insertions(+), 321 deletions(-)
diff --git a/include/trace/events/v4l2_requests.h b/include/trace/events/v4l2_requests.h
index 1e137d39d5fe..34f4a74df5ea 100644
--- a/include/trace/events/v4l2_requests.h
+++ b/include/trace/events/v4l2_requests.h
@@ -14,8 +14,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_seq_tmpl,
TP_ARGS(s),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_sequence, s)),
TP_fast_assign(__entry->s = *s;),
- TP_printk("\nflags %s\nseq_profile: %u\norder_hint_bits: %u\nbit_depth: %u\n"
- "max_frame_width_minus_1: %u\nmax_frame_height_minus_1: %u\n",
+ TP_printk("flags = %s, seq_profile = %u, order_hint_bits = %u, bit_depth = %u, "
+ "max_frame_width_minus_1 = %u, max_frame_height_minus_1 = %u",
__print_flags(__entry->s.flags, "|",
{V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE, "STILL_PICTURE"},
{V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK, "USE_128X128_SUPERBLOCK"},
@@ -50,7 +50,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_tge_tmpl,
TP_ARGS(t),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_tile_group_entry, t)),
TP_fast_assign(__entry->t = *t;),
- TP_printk("\ntile_offset: %u\n tile_size: %u\n tile_row: %u\ntile_col: %u\n",
+ TP_printk("tile_offset = %u, tile_size = %u, tile_row = %u, tile_col = %u",
__entry->t.tile_offset,
__entry->t.tile_size,
__entry->t.tile_row,
@@ -63,30 +63,30 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
TP_ARGS(f),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_frame, f)),
TP_fast_assign(__entry->f = *f;),
- TP_printk("\ntile_info.flags: %s\ntile_info.context_update_tile_id: %u\n"
- "tile_info.tile_cols: %u\ntile_info.tile_rows: %u\n"
- "tile_info.mi_col_starts: %s\ntile_info.mi_row_starts: %s\n"
- "tile_info.width_in_sbs_minus_1: %s\ntile_info.height_in_sbs_minus_1: %s\n"
- "tile_info.tile_size_bytes: %u\nquantization.flags: %s\n"
- "quantization.base_q_idx: %u\nquantization.delta_q_y_dc: %d\n"
- "quantization.delta_q_u_dc: %d\nquantization.delta_q_u_ac: %d\n"
- "quantization.delta_q_v_dc: %d\nquantization.delta_q_v_ac: %d\n"
- "quantization.qm_y: %u\nquantization.qm_u: %u\nquantization.qm_v: %u\n"
- "quantization.delta_q_res: %u\nsuperres_denom: %u\nsegmentation.flags: %s\n"
- "segmentation.last_active_seg_id: %u\nsegmentation.feature_enabled:%s\n"
- "loop_filter.flags: %s\nloop_filter.level: %s\nloop_filter.sharpness: %u\n"
- "loop_filter.ref_deltas: %s\nloop_filter.mode_deltas: %s\n"
- "loop_filter.delta_lf_res: %u\ncdef.damping_minus_3: %u\ncdef.bits: %u\n"
- "cdef.y_pri_strength: %s\ncdef.y_sec_strength: %s\n"
- "cdef.uv_pri_strength: %s\ncdef.uv_sec_strength:%s\nskip_mode_frame: %s\n"
- "primary_ref_frame: %u\nloop_restoration.flags: %s\n"
- "loop_restoration.lr_unit_shift: %u\nloop_restoration.lr_uv_shift: %u\n"
- "loop_restoration.frame_restoration_type: %s\n"
- "loop_restoration.loop_restoration_size: %s\nflags: %s\norder_hint: %u\n"
- "upscaled_width: %u\nframe_width_minus_1: %u\nframe_height_minus_1: %u\n"
- "render_width_minus_1: %u\nrender_height_minus_1: %u\ncurrent_frame_id: %u\n"
- "buffer_removal_time: %s\norder_hints: %s\nreference_frame_ts: %s\n"
- "ref_frame_idx: %s\nrefresh_frame_flags: %u\n",
+ TP_printk("tile_info.flags = %s, tile_info.context_update_tile_id = %u, "
+ "tile_info.tile_cols = %u, tile_info.tile_rows = %u, "
+ "tile_info.mi_col_starts = %s, tile_info.mi_row_starts = %s, "
+ "tile_info.width_in_sbs_minus_1 = %s, tile_info.height_in_sbs_minus_1 = %s, "
+ "tile_info.tile_size_bytes = %u, quantization.flags = %s, "
+ "quantization.base_q_idx = %u, quantization.delta_q_y_dc = %d, "
+ "quantization.delta_q_u_dc = %d, quantization.delta_q_u_ac = %d, "
+ "quantization.delta_q_v_dc = %d, quantization.delta_q_v_ac = %d, "
+ "quantization.qm_y = %u, quantization.qm_u = %u, quantization.qm_v = %u, "
+ "quantization.delta_q_res = %u, superres_denom = %u, segmentation.flags = %s, "
+ "segmentation.last_active_seg_id = %u, segmentation.feature_enabled = %s, "
+ "loop_filter.flags = %s, loop_filter.level = %s, loop_filter.sharpness = %u, "
+ "loop_filter.ref_deltas = %s, loop_filter.mode_deltas = %s, "
+ "loop_filter.delta_lf_res = %u, cdef.damping_minus_3 = %u, cdef.bits = %u, "
+ "cdef.y_pri_strength = %s, cdef.y_sec_strength = %s, "
+ "cdef.uv_pri_strength = %s, cdef.uv_sec_strength = %s, skip_mode_frame = %s, "
+ "primary_ref_frame = %u, loop_restoration.flags = %s, "
+ "loop_restoration.lr_unit_shift = %u, loop_restoration.lr_uv_shift = %u, "
+ "loop_restoration.frame_restoration_type = %s, "
+ "loop_restoration.loop_restoration_size = %s, flags = %s, order_hint = %u, "
+ "upscaled_width = %u, frame_width_minus_1 = %u, frame_height_minus_1 = %u, "
+ "render_width_minus_1 = %u, render_height_minus_1 = %u, current_frame_id = %u, "
+ "buffer_removal_time = %s, order_hints = %s, reference_frame_ts = %s, "
+ "ref_frame_idx = %s, refresh_frame_flags = %u",
__print_flags(__entry->f.tile_info.flags, "|",
{V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING, "UNIFORM_TILE_SPACING"}),
__entry->f.tile_info.context_update_tile_id,
@@ -226,15 +226,15 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
TP_ARGS(f),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_film_grain, f)),
TP_fast_assign(__entry->f = *f;),
- TP_printk("\nflags %s\ncr_mult: %u\ngrain_seed: %u\n"
- "film_grain_params_ref_idx: %u\nnum_y_points: %u\npoint_y_value: %s\n"
- "point_y_scaling: %s\nnum_cb_points: %u\npoint_cb_value: %s\n"
- "point_cb_scaling: %s\nnum_cr_points: %u\npoint_cr_value: %s\n"
- "point_cr_scaling: %s\ngrain_scaling_minus_8: %u\nar_coeff_lag: %u\n"
- "ar_coeffs_y_plus_128: %s\nar_coeffs_cb_plus_128: %s\n"
- "ar_coeffs_cr_plus_128: %s\nar_coeff_shift_minus_6: %u\n"
- "grain_scale_shift: %u\ncb_mult: %u\ncb_luma_mult: %u\ncr_luma_mult: %u\n"
- "cb_offset: %u\ncr_offset: %u\n",
+ TP_printk("flags = %s, cr_mult = %u, grain_seed = %u, "
+ "film_grain_params_ref_idx = %u, num_y_points = %u, point_y_value = %s, "
+ "point_y_scaling = %s, num_cb_points = %u, point_cb_value = %s, "
+ "point_cb_scaling = %s, num_cr_points = %u, point_cr_value = %s, "
+ "point_cr_scaling = %s, grain_scaling_minus_8 = %u, ar_coeff_lag = %u, "
+ "ar_coeffs_y_plus_128 = %s, ar_coeffs_cb_plus_128 = %s, "
+ "ar_coeffs_cr_plus_128 = %s, ar_coeff_shift_minus_6 = %u, "
+ "grain_scale_shift = %u, cb_mult = %u, cb_luma_mult = %u, cr_luma_mult = %u, "
+ "cb_offset = %u, cr_offset = %u",
__print_flags(__entry->f.flags, "|",
{V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN, "APPLY_GRAIN"},
{V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN, "UPDATE_GRAIN"},
@@ -333,7 +333,15 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
__entry->ycbcr_enc = p->ycbcr_enc;
__entry->quantization = p->quantization;
),
- TP_printk("backward_ref_ts %llu version %u width %u height %u flags %s colorspace %u xfer_func %u ycbcr_enc %u quantization %u",
+ TP_printk("backward_ref_ts = %llu, "
+ "version = %u, "
+ "width = %u, "
+ "height = %u, "
+ "flags = %s, "
+ "colorspace = %u, "
+ "xfer_func = %u, "
+ "ycbcr_enc = %u, "
+ "quantization = %u",
__entry->backward_ref_ts, __entry->version, __entry->width, __entry->height,
__print_flags(__entry->flags, "|",
{V4L2_FWHT_FL_IS_INTERLACED, "IS_INTERLACED"},
@@ -364,24 +372,24 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
TP_ARGS(s),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_sps, s)),
TP_fast_assign(__entry->s = *s),
- TP_printk("\nprofile_idc %u\n"
- "constraint_set_flags %s\n"
- "level_idc %u\n"
- "seq_parameter_set_id %u\n"
- "chroma_format_idc %u\n"
- "bit_depth_luma_minus8 %u\n"
- "bit_depth_chroma_minus8 %u\n"
- "log2_max_frame_num_minus4 %u\n"
- "pic_order_cnt_type %u\n"
- "log2_max_pic_order_cnt_lsb_minus4 %u\n"
- "max_num_ref_frames %u\n"
- "num_ref_frames_in_pic_order_cnt_cycle %u\n"
- "offset_for_ref_frame %s\n"
- "offset_for_non_ref_pic %d\n"
- "offset_for_top_to_bottom_field %d\n"
- "pic_width_in_mbs_minus1 %u\n"
- "pic_height_in_map_units_minus1 %u\n"
- "flags %s",
+ TP_printk("profile_idc = %u, "
+ "constraint_set_flags = %s, "
+ "level_idc = %u, "
+ "seq_parameter_set_id = %u, "
+ "chroma_format_idc = %u, "
+ "bit_depth_luma_minus8 = %u, "
+ "bit_depth_chroma_minus8 = %u, "
+ "log2_max_frame_num_minus4 = %u, "
+ "pic_order_cnt_type = %u, "
+ "log2_max_pic_order_cnt_lsb_minus4 = %u, "
+ "max_num_ref_frames = %u, "
+ "num_ref_frames_in_pic_order_cnt_cycle = %u, "
+ "offset_for_ref_frame = %s, "
+ "offset_for_non_ref_pic = %d, "
+ "offset_for_top_to_bottom_field = %d, "
+ "pic_width_in_mbs_minus1 = %u, "
+ "pic_height_in_map_units_minus1 = %u, "
+ "flags = %s",
__entry->s.profile_idc,
__print_flags(__entry->s.constraint_set_flags, "|",
{V4L2_H264_SPS_CONSTRAINT_SET0_FLAG, "CONSTRAINT_SET0_FLAG"},
@@ -423,17 +431,17 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
TP_ARGS(p),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pps, p)),
TP_fast_assign(__entry->p = *p),
- TP_printk("\npic_parameter_set_id %u\n"
- "seq_parameter_set_id %u\n"
- "num_slice_groups_minus1 %u\n"
- "num_ref_idx_l0_default_active_minus1 %u\n"
- "num_ref_idx_l1_default_active_minus1 %u\n"
- "weighted_bipred_idc %u\n"
- "pic_init_qp_minus26 %d\n"
- "pic_init_qs_minus26 %d\n"
- "chroma_qp_index_offset %d\n"
- "second_chroma_qp_index_offset %d\n"
- "flags %s",
+ TP_printk("pic_parameter_set_id = %u, "
+ "seq_parameter_set_id = %u, "
+ "num_slice_groups_minus1 = %u, "
+ "num_ref_idx_l0_default_active_minus1 = %u, "
+ "num_ref_idx_l1_default_active_minus1 = %u, "
+ "weighted_bipred_idc = %u, "
+ "pic_init_qp_minus26 = %d, "
+ "pic_init_qs_minus26 = %d, "
+ "chroma_qp_index_offset = %d, "
+ "second_chroma_qp_index_offset = %d, "
+ "flags = %s",
__entry->p.pic_parameter_set_id,
__entry->p.seq_parameter_set_id,
__entry->p.num_slice_groups_minus1,
@@ -461,7 +469,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_scaling_matrix_tmpl,
TP_ARGS(s),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_scaling_matrix, s)),
TP_fast_assign(__entry->s = *s),
- TP_printk("\nscaling_list_4x4 {%s}\nscaling_list_8x8 {%s}",
+ TP_printk("scaling_list_4x4 = {%s}, scaling_list_8x8 = {%s}",
__print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
__entry->s.scaling_list_4x4,
sizeof(__entry->s.scaling_list_4x4),
@@ -478,16 +486,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
TP_ARGS(p),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pred_weights, p)),
TP_fast_assign(__entry->p = *p),
- TP_printk("\nluma_log2_weight_denom %u\n"
- "chroma_log2_weight_denom %u\n"
- "weight_factor[0].luma_weight %s\n"
- "weight_factor[0].luma_offset %s\n"
- "weight_factor[0].chroma_weight {%s}\n"
- "weight_factor[0].chroma_offset {%s}\n"
- "weight_factor[1].luma_weight %s\n"
- "weight_factor[1].luma_offset %s\n"
- "weight_factor[1].chroma_weight {%s}\n"
- "weight_factor[1].chroma_offset {%s}\n",
+ TP_printk("luma_log2_weight_denom = %u, "
+ "chroma_log2_weight_denom = %u, "
+ "weight_factor[0].luma_weight = %s, "
+ "weight_factor[0].luma_offset = %s, "
+ "weight_factor[0].chroma_weight = {%s}, "
+ "weight_factor[0].chroma_offset = {%s}, "
+ "weight_factor[1].luma_weight = %s, "
+ "weight_factor[1].luma_offset = %s, "
+ "weight_factor[1].chroma_weight = {%s}, "
+ "weight_factor[1].chroma_offset = {%s}",
__entry->p.luma_log2_weight_denom,
__entry->p.chroma_log2_weight_denom,
__print_array(__entry->p.weight_factors[0].luma_weight,
@@ -526,20 +534,20 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
TP_ARGS(s),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_slice_params, s)),
TP_fast_assign(__entry->s = *s),
- TP_printk("\nheader_bit_size %u\n"
- "first_mb_in_slice %u\n"
- "slice_type %s\n"
- "colour_plane_id %u\n"
- "redundant_pic_cnt %u\n"
- "cabac_init_idc %u\n"
- "slice_qp_delta %d\n"
- "slice_qs_delta %d\n"
- "disable_deblocking_filter_idc %u\n"
- "slice_alpha_c0_offset_div2 %u\n"
- "slice_beta_offset_div2 %u\n"
- "num_ref_idx_l0_active_minus1 %u\n"
- "num_ref_idx_l1_active_minus1 %u\n"
- "flags %s",
+ TP_printk("header_bit_size = %u, "
+ "first_mb_in_slice = %u, "
+ "slice_type = %s, "
+ "colour_plane_id = %u, "
+ "redundant_pic_cnt = %u, "
+ "cabac_init_idc = %u, "
+ "slice_qp_delta = %d, "
+ "slice_qs_delta = %d, "
+ "disable_deblocking_filter_idc = %u, "
+ "slice_alpha_c0_offset_div2 = %u, "
+ "slice_beta_offset_div2 = %u, "
+ "num_ref_idx_l0_active_minus1 = %u, "
+ "num_ref_idx_l1_active_minus1 = %u, "
+ "flags = %s",
__entry->s.header_bit_size,
__entry->s.first_mb_in_slice,
__print_symbolic(__entry->s.slice_type,
@@ -570,7 +578,7 @@ DECLARE_EVENT_CLASS(v4l2_h264_reference_tmpl,
TP_STRUCT__entry(__field_struct(struct v4l2_h264_reference, r)
__field(int, i)),
TP_fast_assign(__entry->r = *r; __entry->i = i;),
- TP_printk("[%d]: fields %s index %u",
+ TP_printk("[%d]: fields = %s, index = %u",
__entry->i,
__print_flags(__entry->r.fields, "|",
{V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
@@ -585,19 +593,19 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
TP_ARGS(d),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_decode_params, d)),
TP_fast_assign(__entry->d = *d),
- TP_printk("\nnal_ref_idc %u\n"
- "frame_num %u\n"
- "top_field_order_cnt %d\n"
- "bottom_field_order_cnt %d\n"
- "idr_pic_id %u\n"
- "pic_order_cnt_lsb %u\n"
- "delta_pic_order_cnt_bottom %d\n"
- "delta_pic_order_cnt0 %d\n"
- "delta_pic_order_cnt1 %d\n"
- "dec_ref_pic_marking_bit_size %u\n"
- "pic_order_cnt_bit_size %u\n"
- "slice_group_change_cycle %u\n"
- "flags %s\n",
+ TP_printk("nal_ref_idc = %u, "
+ "frame_num = %u, "
+ "top_field_order_cnt = %d, "
+ "bottom_field_order_cnt = %d, "
+ "idr_pic_id = %u, "
+ "pic_order_cnt_lsb = %u, "
+ "delta_pic_order_cnt_bottom = %d, "
+ "delta_pic_order_cnt0 = %d, "
+ "delta_pic_order_cnt1 = %d, "
+ "dec_ref_pic_marking_bit_size = %u, "
+ "pic_order_cnt_bit_size = %u, "
+ "slice_group_change_cycle = %u, "
+ "flags = %s",
__entry->d.nal_ref_idc,
__entry->d.frame_num,
__entry->d.top_field_order_cnt,
@@ -625,8 +633,8 @@ DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
TP_STRUCT__entry(__field_struct(struct v4l2_h264_dpb_entry, e)
__field(int, i)),
TP_fast_assign(__entry->e = *e; __entry->i = i;),
- TP_printk("[%d]: reference_ts %llu, pic_num %u frame_num %u fields %s "
- "top_field_order_cnt %d bottom_field_order_cnt %d flags %s",
+ TP_printk("[%d]: reference_ts = %llu, pic_num = %u, frame_num = %u, fields = %s "
+ "top_field_order_cnt = %d, bottom_field_order_cnt = %d, flags = %s",
__entry->i,
__entry->e.reference_ts,
__entry->e.pic_num,
@@ -642,7 +650,6 @@ DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
{V4L2_H264_DPB_ENTRY_FLAG_ACTIVE, "ACTIVE"},
{V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM, "LONG_TERM"},
{V4L2_H264_DPB_ENTRY_FLAG_FIELD, "FIELD"})
-
)
);
@@ -698,31 +705,31 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
TP_ARGS(s),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_sps, s)),
TP_fast_assign(__entry->s = *s),
- TP_printk("\nvideo_parameter_set_id %u\n"
- "seq_parameter_set_id %u\n"
- "pic_width_in_luma_samples %u\n"
- "pic_height_in_luma_samples %u\n"
- "bit_depth_luma_minus8 %u\n"
- "bit_depth_chroma_minus8 %u\n"
- "log2_max_pic_order_cnt_lsb_minus4 %u\n"
- "sps_max_dec_pic_buffering_minus1 %u\n"
- "sps_max_num_reorder_pics %u\n"
- "sps_max_latency_increase_plus1 %u\n"
- "log2_min_luma_coding_block_size_minus3 %u\n"
- "log2_diff_max_min_luma_coding_block_size %u\n"
- "log2_min_luma_transform_block_size_minus2 %u\n"
- "log2_diff_max_min_luma_transform_block_size %u\n"
- "max_transform_hierarchy_depth_inter %u\n"
- "max_transform_hierarchy_depth_intra %u\n"
- "pcm_sample_bit_depth_luma_minus1 %u\n"
- "pcm_sample_bit_depth_chroma_minus1 %u\n"
- "log2_min_pcm_luma_coding_block_size_minus3 %u\n"
- "log2_diff_max_min_pcm_luma_coding_block_size %u\n"
- "num_short_term_ref_pic_sets %u\n"
- "num_long_term_ref_pics_sps %u\n"
- "chroma_format_idc %u\n"
- "sps_max_sub_layers_minus1 %u\n"
- "flags %s",
+ TP_printk("video_parameter_set_id = %u, "
+ "seq_parameter_set_id = %u, "
+ "pic_width_in_luma_samples = %u, "
+ "pic_height_in_luma_samples = %u, "
+ "bit_depth_luma_minus8 = %u, "
+ "bit_depth_chroma_minus8 = %u, "
+ "log2_max_pic_order_cnt_lsb_minus4 = %u, "
+ "sps_max_dec_pic_buffering_minus1 = %u, "
+ "sps_max_num_reorder_pics = %u, "
+ "sps_max_latency_increase_plus1 = %u, "
+ "log2_min_luma_coding_block_size_minus3 = %u, "
+ "log2_diff_max_min_luma_coding_block_size = %u, "
+ "log2_min_luma_transform_block_size_minus2 = %u, "
+ "log2_diff_max_min_luma_transform_block_size = %u, "
+ "max_transform_hierarchy_depth_inter = %u, "
+ "max_transform_hierarchy_depth_intra = %u, "
+ "pcm_sample_bit_depth_luma_minus1 = %u, "
+ "pcm_sample_bit_depth_chroma_minus1 = %u, "
+ "log2_min_pcm_luma_coding_block_size_minus3 = %u, "
+ "log2_diff_max_min_pcm_luma_coding_block_size = %u, "
+ "num_short_term_ref_pic_sets = %u, "
+ "num_long_term_ref_pics_sps = %u, "
+ "chroma_format_idc = %u, "
+ "sps_max_sub_layers_minus1 = %u, "
+ "flags = %s",
__entry->s.video_parameter_set_id,
__entry->s.seq_parameter_set_id,
__entry->s.pic_width_in_luma_samples,
@@ -767,22 +774,22 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
TP_ARGS(p),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_pps, p)),
TP_fast_assign(__entry->p = *p),
- TP_printk("\npic_parameter_set_id %u\n"
- "num_extra_slice_header_bits %u\n"
- "num_ref_idx_l0_default_active_minus1 %u\n"
- "num_ref_idx_l1_default_active_minus1 %u\n"
- "init_qp_minus26 %d\n"
- "diff_cu_qp_delta_depth %u\n"
- "pps_cb_qp_offset %d\n"
- "pps_cr_qp_offset %d\n"
- "num_tile_columns_minus1 %d\n"
- "num_tile_rows_minus1 %d\n"
- "column_width_minus1 %s\n"
- "row_height_minus1 %s\n"
- "pps_beta_offset_div2 %d\n"
- "pps_tc_offset_div2 %d\n"
- "log2_parallel_merge_level_minus2 %u\n"
- "flags %s",
+ TP_printk("pic_parameter_set_id = %u, "
+ "num_extra_slice_header_bits = %u, "
+ "num_ref_idx_l0_default_active_minus1 = %u, "
+ "num_ref_idx_l1_default_active_minus1 = %u, "
+ "init_qp_minus26 = %d, "
+ "diff_cu_qp_delta_depth = %u, "
+ "pps_cb_qp_offset = %d, "
+ "pps_cr_qp_offset = %d, "
+ "num_tile_columns_minus1 = %d, "
+ "num_tile_rows_minus1 = %d, "
+ "column_width_minus1 = %s, "
+ "row_height_minus1 = %s, "
+ "pps_beta_offset_div2 = %d, "
+ "pps_tc_offset_div2 = %d, "
+ "log2_parallel_merge_level_minus2 = %u, "
+ "flags = %s",
__entry->p.pic_parameter_set_id,
__entry->p.num_extra_slice_header_bits,
__entry->p.num_ref_idx_l0_default_active_minus1,
@@ -834,33 +841,33 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
TP_ARGS(s),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_slice_params, s)),
TP_fast_assign(__entry->s = *s),
- TP_printk("\nbit_size %u\n"
- "data_byte_offset %u\n"
- "num_entry_point_offsets %u\n"
- "nal_unit_type %u\n"
- "nuh_temporal_id_plus1 %u\n"
- "slice_type %u\n"
- "colour_plane_id %u\n"
- "slice_pic_order_cnt %d\n"
- "num_ref_idx_l0_active_minus1 %u\n"
- "num_ref_idx_l1_active_minus1 %u\n"
- "collocated_ref_idx %u\n"
- "five_minus_max_num_merge_cand %u\n"
- "slice_qp_delta %d\n"
- "slice_cb_qp_offset %d\n"
- "slice_cr_qp_offset %d\n"
- "slice_act_y_qp_offset %d\n"
- "slice_act_cb_qp_offset %d\n"
- "slice_act_cr_qp_offset %d\n"
- "slice_beta_offset_div2 %d\n"
- "slice_tc_offset_div2 %d\n"
- "pic_struct %u\n"
- "slice_segment_addr %u\n"
- "ref_idx_l0 %s\n"
- "ref_idx_l1 %s\n"
- "short_term_ref_pic_set_size %u\n"
- "long_term_ref_pic_set_size %u\n"
- "flags %s",
+ TP_printk("bit_size = %u, "
+ "data_byte_offset = %u, "
+ "num_entry_point_offsets = %u, "
+ "nal_unit_type = %u, "
+ "nuh_temporal_id_plus1 = %u, "
+ "slice_type = %u, "
+ "colour_plane_id = %u, "
+ "slice_pic_order_cnt = %d, "
+ "num_ref_idx_l0_active_minus1 = %u, "
+ "num_ref_idx_l1_active_minus1 = %u, "
+ "collocated_ref_idx = %u, "
+ "five_minus_max_num_merge_cand = %u, "
+ "slice_qp_delta = %d, "
+ "slice_cb_qp_offset = %d, "
+ "slice_cr_qp_offset = %d, "
+ "slice_act_y_qp_offset = %d, "
+ "slice_act_cb_qp_offset = %d, "
+ "slice_act_cr_qp_offset = %d, "
+ "slice_beta_offset_div2 = %d, "
+ "slice_tc_offset_div2 = %d, "
+ "pic_struct = %u, "
+ "slice_segment_addr = %u, "
+ "ref_idx_l0 = %s, "
+ "ref_idx_l1 = %s, "
+ "short_term_ref_pic_set_size = %u, "
+ "long_term_ref_pic_set_size = %u, "
+ "flags = %s",
__entry->s.bit_size,
__entry->s.data_byte_offset,
__entry->s.num_entry_point_offsets,
@@ -911,16 +918,16 @@ DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
TP_ARGS(p),
TP_STRUCT__entry(__field_struct(struct v4l2_hevc_pred_weight_table, p)),
TP_fast_assign(__entry->p = *p),
- TP_printk("\ndelta_luma_weight_l0 %s\n"
- "luma_offset_l0 %s\n"
- "delta_chroma_weight_l0 {%s}\n"
- "chroma_offset_l0 {%s}\n"
- "delta_luma_weight_l1 %s\n"
- "luma_offset_l1 %s\n"
- "delta_chroma_weight_l1 {%s}\n"
- "chroma_offset_l1 {%s}\n"
- "luma_log2_weight_denom %d\n"
- "delta_chroma_log2_weight_denom %d\n",
+ TP_printk("delta_luma_weight_l0 = %s, "
+ "luma_offset_l0 = %s, "
+ "delta_chroma_weight_l0 = {%s}, "
+ "chroma_offset_l0 = {%s}, "
+ "delta_luma_weight_l1 = %s, "
+ "luma_offset_l1 = %s, "
+ "delta_chroma_weight_l1 = {%s}, "
+ "chroma_offset_l1 = {%s}, "
+ "luma_log2_weight_denom = %d, "
+ "delta_chroma_log2_weight_denom = %d",
__print_array(__entry->p.delta_luma_weight_l0,
ARRAY_SIZE(__entry->p.delta_luma_weight_l0),
sizeof(__entry->p.delta_luma_weight_l0[0])),
@@ -959,12 +966,12 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_scaling_matrix_tmpl,
TP_ARGS(s),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_scaling_matrix, s)),
TP_fast_assign(__entry->s = *s),
- TP_printk("\nscaling_list_4x4 {%s}\n"
- "scaling_list_8x8 {%s}\n"
- "scaling_list_16x16 {%s}\n"
- "scaling_list_32x32 {%s}\n"
- "scaling_list_dc_coef_16x16 %s\n"
- "scaling_list_dc_coef_32x32 %s\n",
+ TP_printk("scaling_list_4x4 = {%s}, "
+ "scaling_list_8x8 = {%s}, "
+ "scaling_list_16x16 = {%s}, "
+ "scaling_list_32x32 = {%s}, "
+ "scaling_list_dc_coef_16x16 = %s, "
+ "scaling_list_dc_coef_32x32 = %s",
__print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
__entry->s.scaling_list_4x4,
sizeof(__entry->s.scaling_list_4x4),
@@ -994,17 +1001,17 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
TP_ARGS(d),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_decode_params, d)),
TP_fast_assign(__entry->d = *d),
- TP_printk("\npic_order_cnt_val %d\n"
- "short_term_ref_pic_set_size %u\n"
- "long_term_ref_pic_set_size %u\n"
- "num_active_dpb_entries %u\n"
- "num_poc_st_curr_before %u\n"
- "num_poc_st_curr_after %u\n"
- "num_poc_lt_curr %u\n"
- "poc_st_curr_before %s\n"
- "poc_st_curr_after %s\n"
- "poc_lt_curr %s\n"
- "flags %s",
+ TP_printk("pic_order_cnt_val = %d, "
+ "short_term_ref_pic_set_size = %u, "
+ "long_term_ref_pic_set_size = %u, "
+ "num_active_dpb_entries = %u, "
+ "num_poc_st_curr_before = %u, "
+ "num_poc_st_curr_after = %u, "
+ "num_poc_lt_curr = %u, "
+ "poc_st_curr_before = %s, "
+ "poc_st_curr_after = %s, "
+ "poc_lt_curr = %s, "
+ "flags = %s",
__entry->d.pic_order_cnt_val,
__entry->d.short_term_ref_pic_set_size,
__entry->d.long_term_ref_pic_set_size,
@@ -1033,8 +1040,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl,
TP_ARGS(lt),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_lt_rps, lt)),
TP_fast_assign(__entry->lt = *lt),
- TP_printk("\nflags %s\n"
- "lt_ref_pic_poc_lsb_sps %x\n",
+ TP_printk("flags = %s, "
+ "lt_ref_pic_poc_lsb_sps = %x",
__print_flags(__entry->lt.flags, "|",
{V4L2_HEVC_EXT_SPS_LT_RPS_FLAG_USED_LT, "USED_LT"}
),
@@ -1047,16 +1054,16 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
TP_ARGS(st),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_st_rps, st)),
TP_fast_assign(__entry->st = *st),
- TP_printk("\nflags %s\n"
- "delta_idx_minus1: %u\n"
- "delta_rps_sign: %u\n"
- "abs_delta_rps_minus1: %u\n"
- "num_negative_pics: %u\n"
- "num_positive_pics: %u\n"
- "used_by_curr_pic: %08x\n"
- "use_delta_flag: %08x\n"
- "delta_poc_s0_minus1: %s\n"
- "delta_poc_s1_minus1: %s\n",
+ TP_printk("flags = %s, "
+ "delta_idx_minus1 = %u, "
+ "delta_rps_sign = %u, "
+ "abs_delta_rps_minus1 = %u, "
+ "num_negative_pics = %u, "
+ "num_positive_pics = %u, "
+ "used_by_curr_pic = %08x, "
+ "use_delta_flag = %08x, "
+ "delta_poc_s0_minus1 = %s, "
+ "delta_poc_s1_minus1 = %s",
__print_flags(__entry->st.flags, "|",
{V4L2_HEVC_EXT_SPS_ST_RPS_FLAG_INTER_REF_PIC_SET_PRED, "INTER_REF_PIC_SET_PRED"}
),
@@ -1081,10 +1088,10 @@ DECLARE_EVENT_CLASS(v4l2_hevc_dpb_entry_tmpl,
TP_ARGS(e),
TP_STRUCT__entry(__field_struct(struct v4l2_hevc_dpb_entry, e)),
TP_fast_assign(__entry->e = *e),
- TP_printk("\ntimestamp %llu\n"
- "flags %s\n"
- "field_pic %u\n"
- "pic_order_cnt_val %d\n",
+ TP_printk("timestamp = %llu, "
+ "flags = %s, "
+ "field_pic = %u, "
+ "pic_order_cnt_val = %d",
__entry->e.timestamp,
__print_flags(__entry->e.flags, "|",
{V4L2_HEVC_DPB_ENTRY_LONG_TERM_REFERENCE, "LONG_TERM_REFERENCE"}
@@ -1145,8 +1152,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_seq_tmpl,
TP_ARGS(s),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_sequence, s)),
TP_fast_assign(__entry->s = *s;),
- TP_printk("\nhorizontal_size %u\nvertical_size %u\nvbv_buffer_size %u\n"
- "profile_and_level_indication %u\nchroma_format %u\nflags %s\n",
+ TP_printk("horizontal_size = %u, vertical_size = %u, vbv_buffer_size = %u, "
+ "profile_and_level_indication = %u, chroma_format = %u, flags = %s",
__entry->s.horizontal_size,
__entry->s.vertical_size,
__entry->s.vbv_buffer_size,
@@ -1162,8 +1169,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_pic_tmpl,
TP_ARGS(p),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_picture, p)),
TP_fast_assign(__entry->p = *p;),
- TP_printk("\nbackward_ref_ts %llu\nforward_ref_ts %llu\nflags %s\nf_code {%s}\n"
- "picture_coding_type: %u\npicture_structure %u\nintra_dc_precision %u\n",
+ TP_printk("backward_ref_ts = %llu, forward_ref_ts = %llu, flags = %s, f_code = {%s}, "
+ "picture_coding_type = %u, picture_structure = %u, intra_dc_precision = %u",
__entry->p.backward_ref_ts,
__entry->p.forward_ref_ts,
__print_flags(__entry->p.flags, "|",
@@ -1190,8 +1197,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_quant_tmpl,
TP_ARGS(q),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_quantisation, q)),
TP_fast_assign(__entry->q = *q;),
- TP_printk("\nintra_quantiser_matrix %s\nnon_intra_quantiser_matrix %s\n"
- "chroma_intra_quantiser_matrix %s\nchroma_non_intra_quantiser_matrix %s\n",
+ TP_printk("intra_quantiser_matrix = %s, non_intra_quantiser_matrix = %s, "
+ "chroma_intra_quantiser_matrix = %s, chroma_non_intra_quantiser_matrix = %s",
__print_array(__entry->q.intra_quantiser_matrix,
ARRAY_SIZE(__entry->q.intra_quantiser_matrix),
sizeof(__entry->q.intra_quantiser_matrix[0])),
@@ -1229,10 +1236,10 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_entropy_tmpl,
TP_ARGS(f),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
TP_fast_assign(__entry->f = *f;),
- TP_printk("\nentropy.coeff_probs {%s}\n"
- "entropy.y_mode_probs %s\n"
- "entropy.uv_mode_probs %s\n"
- "entropy.mv_probs {%s}",
+ TP_printk("entropy.coeff_probs = {%s}, "
+ "entropy.y_mode_probs = %s, "
+ "entropy.uv_mode_probs = %s, "
+ "entropy.mv_probs = {%s}",
__print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
__entry->f.entropy.coeff_probs,
sizeof(__entry->f.entropy.coeff_probs),
@@ -1255,41 +1262,41 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
TP_ARGS(f),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
TP_fast_assign(__entry->f = *f;),
- TP_printk("\nsegment.quant_update %s\n"
- "segment.lf_update %s\n"
- "segment.segment_probs %s\n"
- "segment.flags %s\n"
- "lf.ref_frm_delta %s\n"
- "lf.mb_mode_delta %s\n"
- "lf.sharpness_level %u\n"
- "lf.level %u\n"
- "lf.flags %s\n"
- "quant.y_ac_qi %u\n"
- "quant.y_dc_delta %d\n"
- "quant.y2_dc_delta %d\n"
- "quant.y2_ac_delta %d\n"
- "quant.uv_dc_delta %d\n"
- "quant.uv_ac_delta %d\n"
- "coder_state.range %u\n"
- "coder_state.value %u\n"
- "coder_state.bit_count %u\n"
- "width %u\n"
- "height %u\n"
- "horizontal_scale %u\n"
- "vertical_scale %u\n"
- "version %u\n"
- "prob_skip_false %u\n"
- "prob_intra %u\n"
- "prob_last %u\n"
- "prob_gf %u\n"
- "num_dct_parts %u\n"
- "first_part_size %u\n"
- "first_part_header_bits %u\n"
- "dct_part_sizes %s\n"
- "last_frame_ts %llu\n"
- "golden_frame_ts %llu\n"
- "alt_frame_ts %llu\n"
- "flags %s",
+ TP_printk("segment.quant_update = %s, "
+ "segment.lf_update = %s, "
+ "segment.segment_probs = %s, "
+ "segment.flags = %s, "
+ "lf.ref_frm_delta = %s, "
+ "lf.mb_mode_delta = %s, "
+ "lf.sharpness_level = %u, "
+ "lf.level = %u, "
+ "lf.flags = %s, "
+ "quant.y_ac_qi = %u, "
+ "quant.y_dc_delta = %d, "
+ "quant.y2_dc_delta = %d, "
+ "quant.y2_ac_delta = %d, "
+ "quant.uv_dc_delta = %d, "
+ "quant.uv_ac_delta = %d, "
+ "coder_state.range = %u, "
+ "coder_state.value = %u, "
+ "coder_state.bit_count = %u, "
+ "width = %u, "
+ "height = %u, "
+ "horizontal_scale = %u, "
+ "vertical_scale = %u, "
+ "version = %u, "
+ "prob_skip_false = %u, "
+ "prob_intra = %u, "
+ "prob_last = %u, "
+ "prob_gf = %u, "
+ "num_dct_parts = %u, "
+ "first_part_size = %u, "
+ "first_part_header_bits = %u, "
+ "dct_part_sizes = %s, "
+ "last_frame_ts = %llu, "
+ "golden_frame_ts = %llu, "
+ "alt_frame_ts = %llu, "
+ "flags = %s",
__print_array(__entry->f.segment.quant_update,
ARRAY_SIZE(__entry->f.segment.quant_update),
sizeof(__entry->f.segment.quant_update[0])),
@@ -1370,39 +1377,39 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
TP_ARGS(f),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_frame, f)),
TP_fast_assign(__entry->f = *f;),
- TP_printk("\nlf.ref_deltas %s\n"
- "lf.mode_deltas %s\n"
- "lf.level %u\n"
- "lf.sharpness %u\n"
- "lf.flags %s\n"
- "quant.base_q_idx %u\n"
- "quant.delta_q_y_dc %d\n"
- "quant.delta_q_uv_dc %d\n"
- "quant.delta_q_uv_ac %d\n"
- "seg.feature_data {%s}\n"
- "seg.feature_enabled %s\n"
- "seg.tree_probs %s\n"
- "seg.pred_probs %s\n"
- "seg.flags %s\n"
- "flags %s\n"
- "compressed_header_size %u\n"
- "uncompressed_header_size %u\n"
- "frame_width_minus_1 %u\n"
- "frame_height_minus_1 %u\n"
- "render_width_minus_1 %u\n"
- "render_height_minus_1 %u\n"
- "last_frame_ts %llu\n"
- "golden_frame_ts %llu\n"
- "alt_frame_ts %llu\n"
- "ref_frame_sign_bias %s\n"
- "reset_frame_context %s\n"
- "frame_context_idx %u\n"
- "profile %u\n"
- "bit_depth %u\n"
- "interpolation_filter %s\n"
- "tile_cols_log2 %u\n"
- "tile_rows_log_2 %u\n"
- "reference_mode %s\n",
+ TP_printk("lf.ref_deltas = %s, "
+ "lf.mode_deltas = %s, "
+ "lf.level = %u, "
+ "lf.sharpness = %u, "
+ "lf.flags = %s, "
+ "quant.base_q_idx = %u, "
+ "quant.delta_q_y_dc = %d, "
+ "quant.delta_q_uv_dc = %d, "
+ "quant.delta_q_uv_ac = %d, "
+ "seg.feature_data = {%s}, "
+ "seg.feature_enabled = %s, "
+ "seg.tree_probs = %s, "
+ "seg.pred_probs = %s, "
+ "seg.flags = %s, "
+ "flags = %s, "
+ "compressed_header_size = %u, "
+ "uncompressed_header_size = %u, "
+ "frame_width_minus_1 = %u, "
+ "frame_height_minus_1 = %u, "
+ "render_width_minus_1 = %u, "
+ "render_height_minus_1 = %u, "
+ "last_frame_ts = %llu, "
+ "golden_frame_ts = %llu, "
+ "alt_frame_ts = %llu, "
+ "ref_frame_sign_bias = %s, "
+ "reset_frame_context = %s, "
+ "frame_context_idx = %u, "
+ "profile = %u, "
+ "bit_depth = %u, "
+ "interpolation_filter = %s, "
+ "tile_cols_log2 = %u, "
+ "tile_rows_log_2 = %u, "
+ "reference_mode = %s",
__print_array(__entry->f.lf.ref_deltas,
ARRAY_SIZE(__entry->f.lf.ref_deltas),
sizeof(__entry->f.lf.ref_deltas[0])),
@@ -1487,20 +1494,20 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
TP_ARGS(h),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
TP_fast_assign(__entry->h = *h;),
- TP_printk("\ntx_mode %s\n"
- "tx8 {%s}\n"
- "tx16 {%s}\n"
- "tx32 {%s}\n"
- "skip %s\n"
- "inter_mode {%s}\n"
- "interp_filter {%s}\n"
- "is_inter %s\n"
- "comp_mode %s\n"
- "single_ref {%s}\n"
- "comp_ref %s\n"
- "y_mode {%s}\n"
- "uv_mode {%s}\n"
- "partition {%s}\n",
+ TP_printk("tx_mode = %s, "
+ "tx8 = {%s}, "
+ "tx16 = {%s}, "
+ "tx32 = {%s}, "
+ "skip = %s, "
+ "inter_mode = {%s}, "
+ "interp_filter = {%s}, "
+ "is_inter = %s, "
+ "comp_mode = %s, "
+ "single_ref = {%s}, "
+ "comp_ref = %s, "
+ "y_mode = {%s}, "
+ "uv_mode = {%s}, "
+ "partition = {%s}",
__print_symbolic(__entry->h.tx_mode,
{V4L2_VP9_TX_MODE_ONLY_4X4, "TX_MODE_ONLY_4X4"},
{V4L2_VP9_TX_MODE_ALLOW_8X8, "TX_MODE_ALLOW_8X8"},
@@ -1563,7 +1570,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_coef_tmpl,
TP_ARGS(h),
TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
TP_fast_assign(__entry->h = *h;),
- TP_printk("\n coef {%s}",
+ TP_printk("coef = {%s}",
__print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
__entry->h.coef,
sizeof(__entry->h.coef),
@@ -1576,15 +1583,15 @@ DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
TP_ARGS(p),
TP_STRUCT__entry(__field_struct(struct v4l2_vp9_mv_probs, p)),
TP_fast_assign(__entry->p = *p;),
- TP_printk("\n joint %s\n"
- "sign %s\n"
- "classes {%s}\n"
- "class0_bit %s\n"
- "bits {%s}\n"
- "class0_fr {%s}\n"
- "fr {%s}\n"
- "class0_hp %s\n"
- "hp %s\n",
+ TP_printk("joint = %s, "
+ "sign = %s, "
+ "classes = {%s}, "
+ "class0_bit = %s, "
+ "bits = {%s}, "
+ "class0_fr = {%s}, "
+ "fr = {%s}, "
+ "class0_hp = %s, "
+ "hp = %s",
__print_array(__entry->p.joint,
ARRAY_SIZE(__entry->p.joint),
sizeof(__entry->p.joint[0])),
--
2.53.0
^ permalink raw reply related
* [PATCH 01/11] media: Move visl traces to v4l2-core
From: Detlev Casanova @ 2026-02-12 16:23 UTC (permalink / raw)
To: linux-kernel
Cc: Nicolas Dufresne, Benjamin Gaignard, Philipp Zabel,
Mauro Carvalho Chehab, Heiko Stuebner, Daniel Almeida,
Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers, Hans Verkuil,
Laurent Pinchart, Ricardo Ribalda, Yunke Cao, Detlev Casanova,
Sakari Ailus, Pavan Bobba, James Cowgill, Ma Ke, Jacopo Mondi,
Daniel Scally, linux-media, linux-rockchip, linux-arm-kernel,
linux-trace-kernel, kernel
In-Reply-To: <20260212162328.192217-1-detlev.casanova@collabora.com>
The visl driver defines traces for all stateless controls.
Move those definition to a new v4l2_requests.h file and expose them for
all drivers to use.
As each event can be enabled individually in userspace, group them all in
the same v4l2_requests event folder.
Later, it can also be used by v4l2-core to trace controls as they are
being set.
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
drivers/media/test-drivers/visl/Makefile | 2 +-
drivers/media/test-drivers/visl/visl-dec.c | 8 +-
.../media/test-drivers/visl/visl-trace-av1.h | 314 ----
.../media/test-drivers/visl/visl-trace-fwht.h | 66 -
.../media/test-drivers/visl/visl-trace-h264.h | 349 ----
.../media/test-drivers/visl/visl-trace-hevc.h | 464 -----
.../test-drivers/visl/visl-trace-mpeg2.h | 99 -
.../test-drivers/visl/visl-trace-points.c | 11 -
.../media/test-drivers/visl/visl-trace-vp8.h | 156 --
.../media/test-drivers/visl/visl-trace-vp9.h | 292 ---
drivers/media/v4l2-core/v4l2-trace.c | 45 +
include/trace/events/v4l2_requests.h | 1645 +++++++++++++++++
12 files changed, 1692 insertions(+), 1759 deletions(-)
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-av1.h
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-fwht.h
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-h264.h
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-hevc.h
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-mpeg2.h
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-points.c
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-vp8.h
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-vp9.h
create mode 100644 include/trace/events/v4l2_requests.h
diff --git a/drivers/media/test-drivers/visl/Makefile b/drivers/media/test-drivers/visl/Makefile
index fb4d5ae1b17f..a5049e2af844 100644
--- a/drivers/media/test-drivers/visl/Makefile
+++ b/drivers/media/test-drivers/visl/Makefile
@@ -1,5 +1,5 @@
# SPDX-License-Identifier: GPL-2.0+
-visl-y := visl-core.o visl-video.o visl-dec.o visl-trace-points.o
+visl-y := visl-core.o visl-video.o visl-dec.o
ifeq ($(CONFIG_VISL_DEBUGFS),y)
visl-y += visl-debugfs.o
diff --git a/drivers/media/test-drivers/visl/visl-dec.c b/drivers/media/test-drivers/visl/visl-dec.c
index 6bbf93757047..d49208e83726 100644
--- a/drivers/media/test-drivers/visl/visl-dec.c
+++ b/drivers/media/test-drivers/visl/visl-dec.c
@@ -7,18 +7,12 @@
#include "visl.h"
#include "visl-debugfs.h"
#include "visl-dec.h"
-#include "visl-trace-fwht.h"
-#include "visl-trace-mpeg2.h"
-#include "visl-trace-vp8.h"
-#include "visl-trace-vp9.h"
-#include "visl-trace-h264.h"
-#include "visl-trace-hevc.h"
-#include "visl-trace-av1.h"
#include <linux/delay.h>
#include <linux/workqueue.h>
#include <media/v4l2-mem2mem.h>
#include <media/tpg/v4l2-tpg.h>
+#include <trace/events/v4l2_requests.h>
#define LAST_BUF_IDX (V4L2_AV1_REF_LAST_FRAME - V4L2_AV1_REF_LAST_FRAME)
#define LAST2_BUF_IDX (V4L2_AV1_REF_LAST2_FRAME - V4L2_AV1_REF_LAST_FRAME)
diff --git a/drivers/media/test-drivers/visl/visl-trace-av1.h b/drivers/media/test-drivers/visl/visl-trace-av1.h
deleted file mode 100644
index 09f205de53df..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-av1.h
+++ /dev/null
@@ -1,314 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#if !defined(_VISL_TRACE_AV1_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_AV1_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_av1_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_av1_seq_tmpl,
- TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_sequence, s)),
- TP_fast_assign(__entry->s = *s;),
- TP_printk("\nflags %s\nseq_profile: %u\norder_hint_bits: %u\nbit_depth: %u\n"
- "max_frame_width_minus_1: %u\nmax_frame_height_minus_1: %u\n",
- __print_flags(__entry->s.flags, "|",
- {V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE, "STILL_PICTURE"},
- {V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK, "USE_128X128_SUPERBLOCK"},
- {V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA, "ENABLE_FILTER_INTRA"},
- {V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER, "ENABLE_INTRA_EDGE_FILTER"},
- {V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND, "ENABLE_INTERINTRA_COMPOUND"},
- {V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND, "ENABLE_MASKED_COMPOUND"},
- {V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION, "ENABLE_WARPED_MOTION"},
- {V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER, "ENABLE_DUAL_FILTER"},
- {V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT, "ENABLE_ORDER_HINT"},
- {V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP, "ENABLE_JNT_COMP"},
- {V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS, "ENABLE_REF_FRAME_MVS"},
- {V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES, "ENABLE_SUPERRES"},
- {V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF, "ENABLE_CDEF"},
- {V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION, "ENABLE_RESTORATION"},
- {V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME, "MONO_CHROME"},
- {V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE, "COLOR_RANGE"},
- {V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X, "SUBSAMPLING_X"},
- {V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y, "SUBSAMPLING_Y"},
- {V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT, "FILM_GRAIN_PARAMS_PRESENT"},
- {V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q, "SEPARATE_UV_DELTA_Q"}),
- __entry->s.seq_profile,
- __entry->s.order_hint_bits,
- __entry->s.bit_depth,
- __entry->s.max_frame_width_minus_1,
- __entry->s.max_frame_height_minus_1
- )
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_av1_tge_tmpl,
- TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
- TP_ARGS(t),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_tile_group_entry, t)),
- TP_fast_assign(__entry->t = *t;),
- TP_printk("\ntile_offset: %u\n tile_size: %u\n tile_row: %u\ntile_col: %u\n",
- __entry->t.tile_offset,
- __entry->t.tile_size,
- __entry->t.tile_row,
- __entry->t.tile_col
- )
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
- TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
- TP_ARGS(f),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_frame, f)),
- TP_fast_assign(__entry->f = *f;),
- TP_printk("\ntile_info.flags: %s\ntile_info.context_update_tile_id: %u\n"
- "tile_info.tile_cols: %u\ntile_info.tile_rows: %u\n"
- "tile_info.mi_col_starts: %s\ntile_info.mi_row_starts: %s\n"
- "tile_info.width_in_sbs_minus_1: %s\ntile_info.height_in_sbs_minus_1: %s\n"
- "tile_info.tile_size_bytes: %u\nquantization.flags: %s\n"
- "quantization.base_q_idx: %u\nquantization.delta_q_y_dc: %d\n"
- "quantization.delta_q_u_dc: %d\nquantization.delta_q_u_ac: %d\n"
- "quantization.delta_q_v_dc: %d\nquantization.delta_q_v_ac: %d\n"
- "quantization.qm_y: %u\nquantization.qm_u: %u\nquantization.qm_v: %u\n"
- "quantization.delta_q_res: %u\nsuperres_denom: %u\nsegmentation.flags: %s\n"
- "segmentation.last_active_seg_id: %u\nsegmentation.feature_enabled:%s\n"
- "loop_filter.flags: %s\nloop_filter.level: %s\nloop_filter.sharpness: %u\n"
- "loop_filter.ref_deltas: %s\nloop_filter.mode_deltas: %s\n"
- "loop_filter.delta_lf_res: %u\ncdef.damping_minus_3: %u\ncdef.bits: %u\n"
- "cdef.y_pri_strength: %s\ncdef.y_sec_strength: %s\n"
- "cdef.uv_pri_strength: %s\ncdef.uv_sec_strength:%s\nskip_mode_frame: %s\n"
- "primary_ref_frame: %u\nloop_restoration.flags: %s\n"
- "loop_restoration.lr_unit_shift: %u\nloop_restoration.lr_uv_shift: %u\n"
- "loop_restoration.frame_restoration_type: %s\n"
- "loop_restoration.loop_restoration_size: %s\nflags: %s\norder_hint: %u\n"
- "upscaled_width: %u\nframe_width_minus_1: %u\nframe_height_minus_1: %u\n"
- "render_width_minus_1: %u\nrender_height_minus_1: %u\ncurrent_frame_id: %u\n"
- "buffer_removal_time: %s\norder_hints: %s\nreference_frame_ts: %s\n"
- "ref_frame_idx: %s\nrefresh_frame_flags: %u\n",
- __print_flags(__entry->f.tile_info.flags, "|",
- {V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING, "UNIFORM_TILE_SPACING"}),
- __entry->f.tile_info.context_update_tile_id,
- __entry->f.tile_info.tile_cols,
- __entry->f.tile_info.tile_rows,
- __print_array(__entry->f.tile_info.mi_col_starts,
- ARRAY_SIZE(__entry->f.tile_info.mi_col_starts),
- sizeof(__entry->f.tile_info.mi_col_starts[0])),
- __print_array(__entry->f.tile_info.mi_row_starts,
- ARRAY_SIZE(__entry->f.tile_info.mi_row_starts),
- sizeof(__entry->f.tile_info.mi_row_starts[0])),
- __print_array(__entry->f.tile_info.width_in_sbs_minus_1,
- ARRAY_SIZE(__entry->f.tile_info.width_in_sbs_minus_1),
- sizeof(__entry->f.tile_info.width_in_sbs_minus_1[0])),
- __print_array(__entry->f.tile_info.height_in_sbs_minus_1,
- ARRAY_SIZE(__entry->f.tile_info.height_in_sbs_minus_1),
- sizeof(__entry->f.tile_info.height_in_sbs_minus_1[0])),
- __entry->f.tile_info.tile_size_bytes,
- __print_flags(__entry->f.quantization.flags, "|",
- {V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA, "DIFF_UV_DELTA"},
- {V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX, "USING_QMATRIX"},
- {V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT, "DELTA_Q_PRESENT"}),
- __entry->f.quantization.base_q_idx,
- __entry->f.quantization.delta_q_y_dc,
- __entry->f.quantization.delta_q_u_dc,
- __entry->f.quantization.delta_q_u_ac,
- __entry->f.quantization.delta_q_v_dc,
- __entry->f.quantization.delta_q_v_ac,
- __entry->f.quantization.qm_y,
- __entry->f.quantization.qm_u,
- __entry->f.quantization.qm_v,
- __entry->f.quantization.delta_q_res,
- __entry->f.superres_denom,
- __print_flags(__entry->f.segmentation.flags, "|",
- {V4L2_AV1_SEGMENTATION_FLAG_ENABLED, "ENABLED"},
- {V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP, "UPDATE_MAP"},
- {V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE, "TEMPORAL_UPDATE"},
- {V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA, "UPDATE_DATA"},
- {V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP, "SEG_ID_PRE_SKIP"}),
- __entry->f.segmentation.last_active_seg_id,
- __print_array(__entry->f.segmentation.feature_enabled,
- ARRAY_SIZE(__entry->f.segmentation.feature_enabled),
- sizeof(__entry->f.segmentation.feature_enabled[0])),
- __print_flags(__entry->f.loop_filter.flags, "|",
- {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED, "DELTA_ENABLED"},
- {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE, "DELTA_UPDATE"},
- {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT, "DELTA_LF_PRESENT"},
- {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI, "DELTA_LF_MULTI"}),
- __print_array(__entry->f.loop_filter.level,
- ARRAY_SIZE(__entry->f.loop_filter.level),
- sizeof(__entry->f.loop_filter.level[0])),
- __entry->f.loop_filter.sharpness,
- __print_array(__entry->f.loop_filter.ref_deltas,
- ARRAY_SIZE(__entry->f.loop_filter.ref_deltas),
- sizeof(__entry->f.loop_filter.ref_deltas[0])),
- __print_array(__entry->f.loop_filter.mode_deltas,
- ARRAY_SIZE(__entry->f.loop_filter.mode_deltas),
- sizeof(__entry->f.loop_filter.mode_deltas[0])),
- __entry->f.loop_filter.delta_lf_res,
- __entry->f.cdef.damping_minus_3,
- __entry->f.cdef.bits,
- __print_array(__entry->f.cdef.y_pri_strength,
- ARRAY_SIZE(__entry->f.cdef.y_pri_strength),
- sizeof(__entry->f.cdef.y_pri_strength[0])),
- __print_array(__entry->f.cdef.y_sec_strength,
- ARRAY_SIZE(__entry->f.cdef.y_sec_strength),
- sizeof(__entry->f.cdef.y_sec_strength[0])),
- __print_array(__entry->f.cdef.uv_pri_strength,
- ARRAY_SIZE(__entry->f.cdef.uv_pri_strength),
- sizeof(__entry->f.cdef.uv_pri_strength[0])),
- __print_array(__entry->f.cdef.uv_sec_strength,
- ARRAY_SIZE(__entry->f.cdef.uv_sec_strength),
- sizeof(__entry->f.cdef.uv_sec_strength[0])),
- __print_array(__entry->f.skip_mode_frame,
- ARRAY_SIZE(__entry->f.skip_mode_frame),
- sizeof(__entry->f.skip_mode_frame[0])),
- __entry->f.primary_ref_frame,
- __print_flags(__entry->f.loop_restoration.flags, "|",
- {V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR, "USES_LR"},
- {V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR, "USES_CHROMA_LR"}),
- __entry->f.loop_restoration.lr_unit_shift,
- __entry->f.loop_restoration.lr_uv_shift,
- __print_array(__entry->f.loop_restoration.frame_restoration_type,
- ARRAY_SIZE(__entry->f.loop_restoration.frame_restoration_type),
- sizeof(__entry->f.loop_restoration.frame_restoration_type[0])),
- __print_array(__entry->f.loop_restoration.loop_restoration_size,
- ARRAY_SIZE(__entry->f.loop_restoration.loop_restoration_size),
- sizeof(__entry->f.loop_restoration.loop_restoration_size[0])),
- __print_flags(__entry->f.flags, "|",
- {V4L2_AV1_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
- {V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME, "SHOWABLE_FRAME"},
- {V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE, "ERROR_RESILIENT_MODE"},
- {V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE, "DISABLE_CDF_UPDATE"},
- {V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS, "ALLOW_SCREEN_CONTENT_TOOLS"},
- {V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV, "FORCE_INTEGER_MV"},
- {V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC, "ALLOW_INTRABC"},
- {V4L2_AV1_FRAME_FLAG_USE_SUPERRES, "USE_SUPERRES"},
- {V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV, "ALLOW_HIGH_PRECISION_MV"},
- {V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE, "IS_MOTION_MODE_SWITCHABLE"},
- {V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS, "USE_REF_FRAME_MVS"},
- {V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF,
- "DISABLE_FRAME_END_UPDATE_CDF"},
- {V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION, "ALLOW_WARPED_MOTION"},
- {V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT, "REFERENCE_SELECT"},
- {V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET, "REDUCED_TX_SET"},
- {V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED, "SKIP_MODE_ALLOWED"},
- {V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT, "SKIP_MODE_PRESENT"},
- {V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE, "FRAME_SIZE_OVERRIDE"},
- {V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT, "BUFFER_REMOVAL_TIME_PRESENT"},
- {V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING, "FRAME_REFS_SHORT_SIGNALING"}),
- __entry->f.order_hint,
- __entry->f.upscaled_width,
- __entry->f.frame_width_minus_1,
- __entry->f.frame_height_minus_1,
- __entry->f.render_width_minus_1,
- __entry->f.render_height_minus_1,
- __entry->f.current_frame_id,
- __print_array(__entry->f.buffer_removal_time,
- ARRAY_SIZE(__entry->f.buffer_removal_time),
- sizeof(__entry->f.buffer_removal_time[0])),
- __print_array(__entry->f.order_hints,
- ARRAY_SIZE(__entry->f.order_hints),
- sizeof(__entry->f.order_hints[0])),
- __print_array(__entry->f.reference_frame_ts,
- ARRAY_SIZE(__entry->f.reference_frame_ts),
- sizeof(__entry->f.reference_frame_ts[0])),
- __print_array(__entry->f.ref_frame_idx,
- ARRAY_SIZE(__entry->f.ref_frame_idx),
- sizeof(__entry->f.ref_frame_idx[0])),
- __entry->f.refresh_frame_flags
- )
-);
-
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
- TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
- TP_ARGS(f),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_film_grain, f)),
- TP_fast_assign(__entry->f = *f;),
- TP_printk("\nflags %s\ncr_mult: %u\ngrain_seed: %u\n"
- "film_grain_params_ref_idx: %u\nnum_y_points: %u\npoint_y_value: %s\n"
- "point_y_scaling: %s\nnum_cb_points: %u\npoint_cb_value: %s\n"
- "point_cb_scaling: %s\nnum_cr_points: %u\npoint_cr_value: %s\n"
- "point_cr_scaling: %s\ngrain_scaling_minus_8: %u\nar_coeff_lag: %u\n"
- "ar_coeffs_y_plus_128: %s\nar_coeffs_cb_plus_128: %s\n"
- "ar_coeffs_cr_plus_128: %s\nar_coeff_shift_minus_6: %u\n"
- "grain_scale_shift: %u\ncb_mult: %u\ncb_luma_mult: %u\ncr_luma_mult: %u\n"
- "cb_offset: %u\ncr_offset: %u\n",
- __print_flags(__entry->f.flags, "|",
- {V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN, "APPLY_GRAIN"},
- {V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN, "UPDATE_GRAIN"},
- {V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA, "CHROMA_SCALING_FROM_LUMA"},
- {V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP, "OVERLAP"},
- {V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE, "CLIP_TO_RESTRICTED_RANGE"}),
- __entry->f.cr_mult,
- __entry->f.grain_seed,
- __entry->f.film_grain_params_ref_idx,
- __entry->f.num_y_points,
- __print_array(__entry->f.point_y_value,
- ARRAY_SIZE(__entry->f.point_y_value),
- sizeof(__entry->f.point_y_value[0])),
- __print_array(__entry->f.point_y_scaling,
- ARRAY_SIZE(__entry->f.point_y_scaling),
- sizeof(__entry->f.point_y_scaling[0])),
- __entry->f.num_cb_points,
- __print_array(__entry->f.point_cb_value,
- ARRAY_SIZE(__entry->f.point_cb_value),
- sizeof(__entry->f.point_cb_value[0])),
- __print_array(__entry->f.point_cb_scaling,
- ARRAY_SIZE(__entry->f.point_cb_scaling),
- sizeof(__entry->f.point_cb_scaling[0])),
- __entry->f.num_cr_points,
- __print_array(__entry->f.point_cr_value,
- ARRAY_SIZE(__entry->f.point_cr_value),
- sizeof(__entry->f.point_cr_value[0])),
- __print_array(__entry->f.point_cr_scaling,
- ARRAY_SIZE(__entry->f.point_cr_scaling),
- sizeof(__entry->f.point_cr_scaling[0])),
- __entry->f.grain_scaling_minus_8,
- __entry->f.ar_coeff_lag,
- __print_array(__entry->f.ar_coeffs_y_plus_128,
- ARRAY_SIZE(__entry->f.ar_coeffs_y_plus_128),
- sizeof(__entry->f.ar_coeffs_y_plus_128[0])),
- __print_array(__entry->f.ar_coeffs_cb_plus_128,
- ARRAY_SIZE(__entry->f.ar_coeffs_cb_plus_128),
- sizeof(__entry->f.ar_coeffs_cb_plus_128[0])),
- __print_array(__entry->f.ar_coeffs_cr_plus_128,
- ARRAY_SIZE(__entry->f.ar_coeffs_cr_plus_128),
- sizeof(__entry->f.ar_coeffs_cr_plus_128[0])),
- __entry->f.ar_coeff_shift_minus_6,
- __entry->f.grain_scale_shift,
- __entry->f.cb_mult,
- __entry->f.cb_luma_mult,
- __entry->f.cr_luma_mult,
- __entry->f.cb_offset,
- __entry->f.cr_offset
- )
-)
-
-DEFINE_EVENT(v4l2_ctrl_av1_seq_tmpl, v4l2_ctrl_av1_sequence,
- TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
- TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_ctrl_av1_frame_tmpl, v4l2_ctrl_av1_frame,
- TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
- TP_ARGS(f)
-);
-
-DEFINE_EVENT(v4l2_ctrl_av1_tge_tmpl, v4l2_ctrl_av1_tile_group_entry,
- TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
- TP_ARGS(t)
-);
-
-DEFINE_EVENT(v4l2_ctrl_av1_film_grain_tmpl, v4l2_ctrl_av1_film_grain,
- TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
- TP_ARGS(f)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-av1
-#include <trace/define_trace.h>
diff --git a/drivers/media/test-drivers/visl/visl-trace-fwht.h b/drivers/media/test-drivers/visl/visl-trace-fwht.h
deleted file mode 100644
index 54b119359ff5..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-fwht.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#if !defined(_VISL_TRACE_FWHT_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_FWHT_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_fwht_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
- TP_PROTO(const struct v4l2_ctrl_fwht_params *p),
- TP_ARGS(p),
- TP_STRUCT__entry(
- __field(u64, backward_ref_ts)
- __field(u32, version)
- __field(u32, width)
- __field(u32, height)
- __field(u32, flags)
- __field(u32, colorspace)
- __field(u32, xfer_func)
- __field(u32, ycbcr_enc)
- __field(u32, quantization)
- ),
- TP_fast_assign(
- __entry->backward_ref_ts = p->backward_ref_ts;
- __entry->version = p->version;
- __entry->width = p->width;
- __entry->height = p->height;
- __entry->flags = p->flags;
- __entry->colorspace = p->colorspace;
- __entry->xfer_func = p->xfer_func;
- __entry->ycbcr_enc = p->ycbcr_enc;
- __entry->quantization = p->quantization;
- ),
- TP_printk("backward_ref_ts %llu version %u width %u height %u flags %s colorspace %u xfer_func %u ycbcr_enc %u quantization %u",
- __entry->backward_ref_ts, __entry->version, __entry->width, __entry->height,
- __print_flags(__entry->flags, "|",
- {V4L2_FWHT_FL_IS_INTERLACED, "IS_INTERLACED"},
- {V4L2_FWHT_FL_IS_BOTTOM_FIRST, "IS_BOTTOM_FIRST"},
- {V4L2_FWHT_FL_IS_ALTERNATE, "IS_ALTERNATE"},
- {V4L2_FWHT_FL_IS_BOTTOM_FIELD, "IS_BOTTOM_FIELD"},
- {V4L2_FWHT_FL_LUMA_IS_UNCOMPRESSED, "LUMA_IS_UNCOMPRESSED"},
- {V4L2_FWHT_FL_CB_IS_UNCOMPRESSED, "CB_IS_UNCOMPRESSED"},
- {V4L2_FWHT_FL_CR_IS_UNCOMPRESSED, "CR_IS_UNCOMPRESSED"},
- {V4L2_FWHT_FL_ALPHA_IS_UNCOMPRESSED, "ALPHA_IS_UNCOMPRESSED"},
- {V4L2_FWHT_FL_I_FRAME, "I_FRAME"},
- {V4L2_FWHT_FL_PIXENC_HSV, "PIXENC_HSV"},
- {V4L2_FWHT_FL_PIXENC_RGB, "PIXENC_RGB"},
- {V4L2_FWHT_FL_PIXENC_YUV, "PIXENC_YUV"}),
- __entry->colorspace, __entry->xfer_func, __entry->ycbcr_enc,
- __entry->quantization)
-);
-
-DEFINE_EVENT(v4l2_ctrl_fwht_params_tmpl, v4l2_ctrl_fwht_params,
- TP_PROTO(const struct v4l2_ctrl_fwht_params *p),
- TP_ARGS(p)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-fwht
-#include <trace/define_trace.h>
diff --git a/drivers/media/test-drivers/visl/visl-trace-h264.h b/drivers/media/test-drivers/visl/visl-trace-h264.h
deleted file mode 100644
index d84296a01deb..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-h264.h
+++ /dev/null
@@ -1,349 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#if !defined(_VISL_TRACE_H264_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_H264_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_h264_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
- TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_sps, s)),
- TP_fast_assign(__entry->s = *s),
- TP_printk("\nprofile_idc %u\n"
- "constraint_set_flags %s\n"
- "level_idc %u\n"
- "seq_parameter_set_id %u\n"
- "chroma_format_idc %u\n"
- "bit_depth_luma_minus8 %u\n"
- "bit_depth_chroma_minus8 %u\n"
- "log2_max_frame_num_minus4 %u\n"
- "pic_order_cnt_type %u\n"
- "log2_max_pic_order_cnt_lsb_minus4 %u\n"
- "max_num_ref_frames %u\n"
- "num_ref_frames_in_pic_order_cnt_cycle %u\n"
- "offset_for_ref_frame %s\n"
- "offset_for_non_ref_pic %d\n"
- "offset_for_top_to_bottom_field %d\n"
- "pic_width_in_mbs_minus1 %u\n"
- "pic_height_in_map_units_minus1 %u\n"
- "flags %s",
- __entry->s.profile_idc,
- __print_flags(__entry->s.constraint_set_flags, "|",
- {V4L2_H264_SPS_CONSTRAINT_SET0_FLAG, "CONSTRAINT_SET0_FLAG"},
- {V4L2_H264_SPS_CONSTRAINT_SET1_FLAG, "CONSTRAINT_SET1_FLAG"},
- {V4L2_H264_SPS_CONSTRAINT_SET2_FLAG, "CONSTRAINT_SET2_FLAG"},
- {V4L2_H264_SPS_CONSTRAINT_SET3_FLAG, "CONSTRAINT_SET3_FLAG"},
- {V4L2_H264_SPS_CONSTRAINT_SET4_FLAG, "CONSTRAINT_SET4_FLAG"},
- {V4L2_H264_SPS_CONSTRAINT_SET5_FLAG, "CONSTRAINT_SET5_FLAG"}),
- __entry->s.level_idc,
- __entry->s.seq_parameter_set_id,
- __entry->s.chroma_format_idc,
- __entry->s.bit_depth_luma_minus8,
- __entry->s.bit_depth_chroma_minus8,
- __entry->s.log2_max_frame_num_minus4,
- __entry->s.pic_order_cnt_type,
- __entry->s.log2_max_pic_order_cnt_lsb_minus4,
- __entry->s.max_num_ref_frames,
- __entry->s.num_ref_frames_in_pic_order_cnt_cycle,
- __print_array(__entry->s.offset_for_ref_frame,
- ARRAY_SIZE(__entry->s.offset_for_ref_frame),
- sizeof(__entry->s.offset_for_ref_frame[0])),
- __entry->s.offset_for_non_ref_pic,
- __entry->s.offset_for_top_to_bottom_field,
- __entry->s.pic_width_in_mbs_minus1,
- __entry->s.pic_height_in_map_units_minus1,
- __print_flags(__entry->s.flags, "|",
- {V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE, "SEPARATE_COLOUR_PLANE"},
- {V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS, "QPPRIME_Y_ZERO_TRANSFORM_BYPASS"},
- {V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO, "DELTA_PIC_ORDER_ALWAYS_ZERO"},
- {V4L2_H264_SPS_FLAG_GAPS_IN_FRAME_NUM_VALUE_ALLOWED, "GAPS_IN_FRAME_NUM_VALUE_ALLOWED"},
- {V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY, "FRAME_MBS_ONLY"},
- {V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD, "MB_ADAPTIVE_FRAME_FIELD"},
- {V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE, "DIRECT_8X8_INFERENCE"}
- ))
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
- TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
- TP_ARGS(p),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pps, p)),
- TP_fast_assign(__entry->p = *p),
- TP_printk("\npic_parameter_set_id %u\n"
- "seq_parameter_set_id %u\n"
- "num_slice_groups_minus1 %u\n"
- "num_ref_idx_l0_default_active_minus1 %u\n"
- "num_ref_idx_l1_default_active_minus1 %u\n"
- "weighted_bipred_idc %u\n"
- "pic_init_qp_minus26 %d\n"
- "pic_init_qs_minus26 %d\n"
- "chroma_qp_index_offset %d\n"
- "second_chroma_qp_index_offset %d\n"
- "flags %s",
- __entry->p.pic_parameter_set_id,
- __entry->p.seq_parameter_set_id,
- __entry->p.num_slice_groups_minus1,
- __entry->p.num_ref_idx_l0_default_active_minus1,
- __entry->p.num_ref_idx_l1_default_active_minus1,
- __entry->p.weighted_bipred_idc,
- __entry->p.pic_init_qp_minus26,
- __entry->p.pic_init_qs_minus26,
- __entry->p.chroma_qp_index_offset,
- __entry->p.second_chroma_qp_index_offset,
- __print_flags(__entry->p.flags, "|",
- {V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE, "ENTROPY_CODING_MODE"},
- {V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT, "BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT"},
- {V4L2_H264_PPS_FLAG_WEIGHTED_PRED, "WEIGHTED_PRED"},
- {V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT, "DEBLOCKING_FILTER_CONTROL_PRESENT"},
- {V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED, "CONSTRAINED_INTRA_PRED"},
- {V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT, "REDUNDANT_PIC_CNT_PRESENT"},
- {V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE, "TRANSFORM_8X8_MODE"},
- {V4L2_H264_PPS_FLAG_SCALING_MATRIX_PRESENT, "SCALING_MATRIX_PRESENT"}
- ))
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_h264_scaling_matrix_tmpl,
- TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_scaling_matrix, s)),
- TP_fast_assign(__entry->s = *s),
- TP_printk("\nscaling_list_4x4 {%s}\nscaling_list_8x8 {%s}",
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->s.scaling_list_4x4,
- sizeof(__entry->s.scaling_list_4x4),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->s.scaling_list_8x8,
- sizeof(__entry->s.scaling_list_8x8),
- false)
- )
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
- TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
- TP_ARGS(p),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pred_weights, p)),
- TP_fast_assign(__entry->p = *p),
- TP_printk("\nluma_log2_weight_denom %u\n"
- "chroma_log2_weight_denom %u\n"
- "weight_factor[0].luma_weight %s\n"
- "weight_factor[0].luma_offset %s\n"
- "weight_factor[0].chroma_weight {%s}\n"
- "weight_factor[0].chroma_offset {%s}\n"
- "weight_factor[1].luma_weight %s\n"
- "weight_factor[1].luma_offset %s\n"
- "weight_factor[1].chroma_weight {%s}\n"
- "weight_factor[1].chroma_offset {%s}\n",
- __entry->p.luma_log2_weight_denom,
- __entry->p.chroma_log2_weight_denom,
- __print_array(__entry->p.weight_factors[0].luma_weight,
- ARRAY_SIZE(__entry->p.weight_factors[0].luma_weight),
- sizeof(__entry->p.weight_factors[0].luma_weight[0])),
- __print_array(__entry->p.weight_factors[0].luma_offset,
- ARRAY_SIZE(__entry->p.weight_factors[0].luma_offset),
- sizeof(__entry->p.weight_factors[0].luma_offset[0])),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.weight_factors[0].chroma_weight,
- sizeof(__entry->p.weight_factors[0].chroma_weight),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.weight_factors[0].chroma_offset,
- sizeof(__entry->p.weight_factors[0].chroma_offset),
- false),
- __print_array(__entry->p.weight_factors[1].luma_weight,
- ARRAY_SIZE(__entry->p.weight_factors[1].luma_weight),
- sizeof(__entry->p.weight_factors[1].luma_weight[0])),
- __print_array(__entry->p.weight_factors[1].luma_offset,
- ARRAY_SIZE(__entry->p.weight_factors[1].luma_offset),
- sizeof(__entry->p.weight_factors[1].luma_offset[0])),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.weight_factors[1].chroma_weight,
- sizeof(__entry->p.weight_factors[1].chroma_weight),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.weight_factors[1].chroma_offset,
- sizeof(__entry->p.weight_factors[1].chroma_offset),
- false)
- )
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
- TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_slice_params, s)),
- TP_fast_assign(__entry->s = *s),
- TP_printk("\nheader_bit_size %u\n"
- "first_mb_in_slice %u\n"
- "slice_type %s\n"
- "colour_plane_id %u\n"
- "redundant_pic_cnt %u\n"
- "cabac_init_idc %u\n"
- "slice_qp_delta %d\n"
- "slice_qs_delta %d\n"
- "disable_deblocking_filter_idc %u\n"
- "slice_alpha_c0_offset_div2 %u\n"
- "slice_beta_offset_div2 %u\n"
- "num_ref_idx_l0_active_minus1 %u\n"
- "num_ref_idx_l1_active_minus1 %u\n"
- "flags %s",
- __entry->s.header_bit_size,
- __entry->s.first_mb_in_slice,
- __print_symbolic(__entry->s.slice_type,
- {V4L2_H264_SLICE_TYPE_P, "P"},
- {V4L2_H264_SLICE_TYPE_B, "B"},
- {V4L2_H264_SLICE_TYPE_I, "I"},
- {V4L2_H264_SLICE_TYPE_SP, "SP"},
- {V4L2_H264_SLICE_TYPE_SI, "SI"}),
- __entry->s.colour_plane_id,
- __entry->s.redundant_pic_cnt,
- __entry->s.cabac_init_idc,
- __entry->s.slice_qp_delta,
- __entry->s.slice_qs_delta,
- __entry->s.disable_deblocking_filter_idc,
- __entry->s.slice_alpha_c0_offset_div2,
- __entry->s.slice_beta_offset_div2,
- __entry->s.num_ref_idx_l0_active_minus1,
- __entry->s.num_ref_idx_l1_active_minus1,
- __print_flags(__entry->s.flags, "|",
- {V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED, "DIRECT_SPATIAL_MV_PRED"},
- {V4L2_H264_SLICE_FLAG_SP_FOR_SWITCH, "SP_FOR_SWITCH"})
- )
-);
-
-DECLARE_EVENT_CLASS(v4l2_h264_reference_tmpl,
- TP_PROTO(const struct v4l2_h264_reference *r, int i),
- TP_ARGS(r, i),
- TP_STRUCT__entry(__field_struct(struct v4l2_h264_reference, r)
- __field(int, i)),
- TP_fast_assign(__entry->r = *r; __entry->i = i;),
- TP_printk("[%d]: fields %s index %u",
- __entry->i,
- __print_flags(__entry->r.fields, "|",
- {V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
- {V4L2_H264_BOTTOM_FIELD_REF, "BOTTOM_FIELD_REF"},
- {V4L2_H264_FRAME_REF, "FRAME_REF"}),
- __entry->r.index
- )
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
- TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
- TP_ARGS(d),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_decode_params, d)),
- TP_fast_assign(__entry->d = *d),
- TP_printk("\nnal_ref_idc %u\n"
- "frame_num %u\n"
- "top_field_order_cnt %d\n"
- "bottom_field_order_cnt %d\n"
- "idr_pic_id %u\n"
- "pic_order_cnt_lsb %u\n"
- "delta_pic_order_cnt_bottom %d\n"
- "delta_pic_order_cnt0 %d\n"
- "delta_pic_order_cnt1 %d\n"
- "dec_ref_pic_marking_bit_size %u\n"
- "pic_order_cnt_bit_size %u\n"
- "slice_group_change_cycle %u\n"
- "flags %s\n",
- __entry->d.nal_ref_idc,
- __entry->d.frame_num,
- __entry->d.top_field_order_cnt,
- __entry->d.bottom_field_order_cnt,
- __entry->d.idr_pic_id,
- __entry->d.pic_order_cnt_lsb,
- __entry->d.delta_pic_order_cnt_bottom,
- __entry->d.delta_pic_order_cnt0,
- __entry->d.delta_pic_order_cnt1,
- __entry->d.dec_ref_pic_marking_bit_size,
- __entry->d.pic_order_cnt_bit_size,
- __entry->d.slice_group_change_cycle,
- __print_flags(__entry->d.flags, "|",
- {V4L2_H264_DECODE_PARAM_FLAG_IDR_PIC, "IDR_PIC"},
- {V4L2_H264_DECODE_PARAM_FLAG_FIELD_PIC, "FIELD_PIC"},
- {V4L2_H264_DECODE_PARAM_FLAG_BOTTOM_FIELD, "BOTTOM_FIELD"},
- {V4L2_H264_DECODE_PARAM_FLAG_PFRAME, "PFRAME"},
- {V4L2_H264_DECODE_PARAM_FLAG_BFRAME, "BFRAME"})
- )
-);
-
-DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
- TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
- TP_ARGS(e, i),
- TP_STRUCT__entry(__field_struct(struct v4l2_h264_dpb_entry, e)
- __field(int, i)),
- TP_fast_assign(__entry->e = *e; __entry->i = i;),
- TP_printk("[%d]: reference_ts %llu, pic_num %u frame_num %u fields %s "
- "top_field_order_cnt %d bottom_field_order_cnt %d flags %s",
- __entry->i,
- __entry->e.reference_ts,
- __entry->e.pic_num,
- __entry->e.frame_num,
- __print_flags(__entry->e.fields, "|",
- {V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
- {V4L2_H264_BOTTOM_FIELD_REF, "BOTTOM_FIELD_REF"},
- {V4L2_H264_FRAME_REF, "FRAME_REF"}),
- __entry->e.top_field_order_cnt,
- __entry->e.bottom_field_order_cnt,
- __print_flags(__entry->e.flags, "|",
- {V4L2_H264_DPB_ENTRY_FLAG_VALID, "VALID"},
- {V4L2_H264_DPB_ENTRY_FLAG_ACTIVE, "ACTIVE"},
- {V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM, "LONG_TERM"},
- {V4L2_H264_DPB_ENTRY_FLAG_FIELD, "FIELD"})
-
- )
-);
-
-DEFINE_EVENT(v4l2_ctrl_h264_sps_tmpl, v4l2_ctrl_h264_sps,
- TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
- TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_ctrl_h264_pps_tmpl, v4l2_ctrl_h264_pps,
- TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
- TP_ARGS(p)
-);
-
-DEFINE_EVENT(v4l2_ctrl_h264_scaling_matrix_tmpl, v4l2_ctrl_h264_scaling_matrix,
- TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
- TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_ctrl_h264_pred_weights_tmpl, v4l2_ctrl_h264_pred_weights,
- TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
- TP_ARGS(p)
-);
-
-DEFINE_EVENT(v4l2_ctrl_h264_slice_params_tmpl, v4l2_ctrl_h264_slice_params,
- TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
- TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_h264_reference_tmpl, v4l2_h264_ref_pic_list0,
- TP_PROTO(const struct v4l2_h264_reference *r, int i),
- TP_ARGS(r, i)
-);
-
-DEFINE_EVENT(v4l2_h264_reference_tmpl, v4l2_h264_ref_pic_list1,
- TP_PROTO(const struct v4l2_h264_reference *r, int i),
- TP_ARGS(r, i)
-);
-
-DEFINE_EVENT(v4l2_ctrl_h264_decode_params_tmpl, v4l2_ctrl_h264_decode_params,
- TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
- TP_ARGS(d)
-);
-
-DEFINE_EVENT(v4l2_h264_dpb_entry_tmpl, v4l2_h264_dpb_entry,
- TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
- TP_ARGS(e, i)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-h264
-#include <trace/define_trace.h>
diff --git a/drivers/media/test-drivers/visl/visl-trace-hevc.h b/drivers/media/test-drivers/visl/visl-trace-hevc.h
deleted file mode 100644
index 963914c463db..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-hevc.h
+++ /dev/null
@@ -1,464 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0+ */
-#include "linux/v4l2-controls.h"
-#if !defined(_VISL_TRACE_HEVC_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_HEVC_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_hevc_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_sps, s)),
- TP_fast_assign(__entry->s = *s),
- TP_printk("\nvideo_parameter_set_id %u\n"
- "seq_parameter_set_id %u\n"
- "pic_width_in_luma_samples %u\n"
- "pic_height_in_luma_samples %u\n"
- "bit_depth_luma_minus8 %u\n"
- "bit_depth_chroma_minus8 %u\n"
- "log2_max_pic_order_cnt_lsb_minus4 %u\n"
- "sps_max_dec_pic_buffering_minus1 %u\n"
- "sps_max_num_reorder_pics %u\n"
- "sps_max_latency_increase_plus1 %u\n"
- "log2_min_luma_coding_block_size_minus3 %u\n"
- "log2_diff_max_min_luma_coding_block_size %u\n"
- "log2_min_luma_transform_block_size_minus2 %u\n"
- "log2_diff_max_min_luma_transform_block_size %u\n"
- "max_transform_hierarchy_depth_inter %u\n"
- "max_transform_hierarchy_depth_intra %u\n"
- "pcm_sample_bit_depth_luma_minus1 %u\n"
- "pcm_sample_bit_depth_chroma_minus1 %u\n"
- "log2_min_pcm_luma_coding_block_size_minus3 %u\n"
- "log2_diff_max_min_pcm_luma_coding_block_size %u\n"
- "num_short_term_ref_pic_sets %u\n"
- "num_long_term_ref_pics_sps %u\n"
- "chroma_format_idc %u\n"
- "sps_max_sub_layers_minus1 %u\n"
- "flags %s",
- __entry->s.video_parameter_set_id,
- __entry->s.seq_parameter_set_id,
- __entry->s.pic_width_in_luma_samples,
- __entry->s.pic_height_in_luma_samples,
- __entry->s.bit_depth_luma_minus8,
- __entry->s.bit_depth_chroma_minus8,
- __entry->s.log2_max_pic_order_cnt_lsb_minus4,
- __entry->s.sps_max_dec_pic_buffering_minus1,
- __entry->s.sps_max_num_reorder_pics,
- __entry->s.sps_max_latency_increase_plus1,
- __entry->s.log2_min_luma_coding_block_size_minus3,
- __entry->s.log2_diff_max_min_luma_coding_block_size,
- __entry->s.log2_min_luma_transform_block_size_minus2,
- __entry->s.log2_diff_max_min_luma_transform_block_size,
- __entry->s.max_transform_hierarchy_depth_inter,
- __entry->s.max_transform_hierarchy_depth_intra,
- __entry->s.pcm_sample_bit_depth_luma_minus1,
- __entry->s.pcm_sample_bit_depth_chroma_minus1,
- __entry->s.log2_min_pcm_luma_coding_block_size_minus3,
- __entry->s.log2_diff_max_min_pcm_luma_coding_block_size,
- __entry->s.num_short_term_ref_pic_sets,
- __entry->s.num_long_term_ref_pics_sps,
- __entry->s.chroma_format_idc,
- __entry->s.sps_max_sub_layers_minus1,
- __print_flags(__entry->s.flags, "|",
- {V4L2_HEVC_SPS_FLAG_SEPARATE_COLOUR_PLANE, "SEPARATE_COLOUR_PLANE"},
- {V4L2_HEVC_SPS_FLAG_SCALING_LIST_ENABLED, "SCALING_LIST_ENABLED"},
- {V4L2_HEVC_SPS_FLAG_AMP_ENABLED, "AMP_ENABLED"},
- {V4L2_HEVC_SPS_FLAG_SAMPLE_ADAPTIVE_OFFSET, "SAMPLE_ADAPTIVE_OFFSET"},
- {V4L2_HEVC_SPS_FLAG_PCM_ENABLED, "PCM_ENABLED"},
- {V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED, "V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED"},
- {V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT, "LONG_TERM_REF_PICS_PRESENT"},
- {V4L2_HEVC_SPS_FLAG_SPS_TEMPORAL_MVP_ENABLED, "TEMPORAL_MVP_ENABLED"},
- {V4L2_HEVC_SPS_FLAG_STRONG_INTRA_SMOOTHING_ENABLED, "STRONG_INTRA_SMOOTHING_ENABLED"}
- ))
-
-);
-
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
- TP_ARGS(p),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_pps, p)),
- TP_fast_assign(__entry->p = *p),
- TP_printk("\npic_parameter_set_id %u\n"
- "num_extra_slice_header_bits %u\n"
- "num_ref_idx_l0_default_active_minus1 %u\n"
- "num_ref_idx_l1_default_active_minus1 %u\n"
- "init_qp_minus26 %d\n"
- "diff_cu_qp_delta_depth %u\n"
- "pps_cb_qp_offset %d\n"
- "pps_cr_qp_offset %d\n"
- "num_tile_columns_minus1 %d\n"
- "num_tile_rows_minus1 %d\n"
- "column_width_minus1 %s\n"
- "row_height_minus1 %s\n"
- "pps_beta_offset_div2 %d\n"
- "pps_tc_offset_div2 %d\n"
- "log2_parallel_merge_level_minus2 %u\n"
- "flags %s",
- __entry->p.pic_parameter_set_id,
- __entry->p.num_extra_slice_header_bits,
- __entry->p.num_ref_idx_l0_default_active_minus1,
- __entry->p.num_ref_idx_l1_default_active_minus1,
- __entry->p.init_qp_minus26,
- __entry->p.diff_cu_qp_delta_depth,
- __entry->p.pps_cb_qp_offset,
- __entry->p.pps_cr_qp_offset,
- __entry->p.num_tile_columns_minus1,
- __entry->p.num_tile_rows_minus1,
- __print_array(__entry->p.column_width_minus1,
- ARRAY_SIZE(__entry->p.column_width_minus1),
- sizeof(__entry->p.column_width_minus1[0])),
- __print_array(__entry->p.row_height_minus1,
- ARRAY_SIZE(__entry->p.row_height_minus1),
- sizeof(__entry->p.row_height_minus1[0])),
- __entry->p.pps_beta_offset_div2,
- __entry->p.pps_tc_offset_div2,
- __entry->p.log2_parallel_merge_level_minus2,
- __print_flags(__entry->p.flags, "|",
- {V4L2_HEVC_PPS_FLAG_DEPENDENT_SLICE_SEGMENT_ENABLED, "DEPENDENT_SLICE_SEGMENT_ENABLED"},
- {V4L2_HEVC_PPS_FLAG_OUTPUT_FLAG_PRESENT, "OUTPUT_FLAG_PRESENT"},
- {V4L2_HEVC_PPS_FLAG_SIGN_DATA_HIDING_ENABLED, "SIGN_DATA_HIDING_ENABLED"},
- {V4L2_HEVC_PPS_FLAG_CABAC_INIT_PRESENT, "CABAC_INIT_PRESENT"},
- {V4L2_HEVC_PPS_FLAG_CONSTRAINED_INTRA_PRED, "CONSTRAINED_INTRA_PRED"},
- {V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED, "CU_QP_DELTA_ENABLED"},
- {V4L2_HEVC_PPS_FLAG_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT, "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT"},
- {V4L2_HEVC_PPS_FLAG_WEIGHTED_PRED, "WEIGHTED_PRED"},
- {V4L2_HEVC_PPS_FLAG_WEIGHTED_BIPRED, "WEIGHTED_BIPRED"},
- {V4L2_HEVC_PPS_FLAG_TRANSQUANT_BYPASS_ENABLED, "TRANSQUANT_BYPASS_ENABLED"},
- {V4L2_HEVC_PPS_FLAG_TILES_ENABLED, "TILES_ENABLED"},
- {V4L2_HEVC_PPS_FLAG_ENTROPY_CODING_SYNC_ENABLED, "ENTROPY_CODING_SYNC_ENABLED"},
- {V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED, "LOOP_FILTER_ACROSS_TILES_ENABLED"},
- {V4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED, "PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED"},
- {V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_OVERRIDE_ENABLED, "DEBLOCKING_FILTER_OVERRIDE_ENABLED"},
- {V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER, "DISABLE_DEBLOCKING_FILTER"},
- {V4L2_HEVC_PPS_FLAG_LISTS_MODIFICATION_PRESENT, "LISTS_MODIFICATION_PRESENT"},
- {V4L2_HEVC_PPS_FLAG_SLICE_SEGMENT_HEADER_EXTENSION_PRESENT, "SLICE_SEGMENT_HEADER_EXTENSION_PRESENT"},
- {V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT, "DEBLOCKING_FILTER_CONTROL_PRESENT"},
- {V4L2_HEVC_PPS_FLAG_UNIFORM_SPACING, "UNIFORM_SPACING"}
- ))
-
-);
-
-
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_slice_params, s)),
- TP_fast_assign(__entry->s = *s),
- TP_printk("\nbit_size %u\n"
- "data_byte_offset %u\n"
- "num_entry_point_offsets %u\n"
- "nal_unit_type %u\n"
- "nuh_temporal_id_plus1 %u\n"
- "slice_type %u\n"
- "colour_plane_id %u\n"
- "slice_pic_order_cnt %d\n"
- "num_ref_idx_l0_active_minus1 %u\n"
- "num_ref_idx_l1_active_minus1 %u\n"
- "collocated_ref_idx %u\n"
- "five_minus_max_num_merge_cand %u\n"
- "slice_qp_delta %d\n"
- "slice_cb_qp_offset %d\n"
- "slice_cr_qp_offset %d\n"
- "slice_act_y_qp_offset %d\n"
- "slice_act_cb_qp_offset %d\n"
- "slice_act_cr_qp_offset %d\n"
- "slice_beta_offset_div2 %d\n"
- "slice_tc_offset_div2 %d\n"
- "pic_struct %u\n"
- "slice_segment_addr %u\n"
- "ref_idx_l0 %s\n"
- "ref_idx_l1 %s\n"
- "short_term_ref_pic_set_size %u\n"
- "long_term_ref_pic_set_size %u\n"
- "flags %s",
- __entry->s.bit_size,
- __entry->s.data_byte_offset,
- __entry->s.num_entry_point_offsets,
- __entry->s.nal_unit_type,
- __entry->s.nuh_temporal_id_plus1,
- __entry->s.slice_type,
- __entry->s.colour_plane_id,
- __entry->s.slice_pic_order_cnt,
- __entry->s.num_ref_idx_l0_active_minus1,
- __entry->s.num_ref_idx_l1_active_minus1,
- __entry->s.collocated_ref_idx,
- __entry->s.five_minus_max_num_merge_cand,
- __entry->s.slice_qp_delta,
- __entry->s.slice_cb_qp_offset,
- __entry->s.slice_cr_qp_offset,
- __entry->s.slice_act_y_qp_offset,
- __entry->s.slice_act_cb_qp_offset,
- __entry->s.slice_act_cr_qp_offset,
- __entry->s.slice_beta_offset_div2,
- __entry->s.slice_tc_offset_div2,
- __entry->s.pic_struct,
- __entry->s.slice_segment_addr,
- __print_array(__entry->s.ref_idx_l0,
- ARRAY_SIZE(__entry->s.ref_idx_l0),
- sizeof(__entry->s.ref_idx_l0[0])),
- __print_array(__entry->s.ref_idx_l1,
- ARRAY_SIZE(__entry->s.ref_idx_l1),
- sizeof(__entry->s.ref_idx_l1[0])),
- __entry->s.short_term_ref_pic_set_size,
- __entry->s.long_term_ref_pic_set_size,
- __print_flags(__entry->s.flags, "|",
- {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_LUMA, "SLICE_SAO_LUMA"},
- {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_CHROMA, "SLICE_SAO_CHROMA"},
- {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_TEMPORAL_MVP_ENABLED, "SLICE_TEMPORAL_MVP_ENABLED"},
- {V4L2_HEVC_SLICE_PARAMS_FLAG_MVD_L1_ZERO, "MVD_L1_ZERO"},
- {V4L2_HEVC_SLICE_PARAMS_FLAG_CABAC_INIT, "CABAC_INIT"},
- {V4L2_HEVC_SLICE_PARAMS_FLAG_COLLOCATED_FROM_L0, "COLLOCATED_FROM_L0"},
- {V4L2_HEVC_SLICE_PARAMS_FLAG_USE_INTEGER_MV, "USE_INTEGER_MV"},
- {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_DEBLOCKING_FILTER_DISABLED, "SLICE_DEBLOCKING_FILTER_DISABLED"},
- {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED, "SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED"},
- {V4L2_HEVC_SLICE_PARAMS_FLAG_DEPENDENT_SLICE_SEGMENT, "DEPENDENT_SLICE_SEGMENT"}
-
- ))
-);
-
-DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
- TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
- TP_ARGS(p),
- TP_STRUCT__entry(__field_struct(struct v4l2_hevc_pred_weight_table, p)),
- TP_fast_assign(__entry->p = *p),
- TP_printk("\ndelta_luma_weight_l0 %s\n"
- "luma_offset_l0 %s\n"
- "delta_chroma_weight_l0 {%s}\n"
- "chroma_offset_l0 {%s}\n"
- "delta_luma_weight_l1 %s\n"
- "luma_offset_l1 %s\n"
- "delta_chroma_weight_l1 {%s}\n"
- "chroma_offset_l1 {%s}\n"
- "luma_log2_weight_denom %d\n"
- "delta_chroma_log2_weight_denom %d\n",
- __print_array(__entry->p.delta_luma_weight_l0,
- ARRAY_SIZE(__entry->p.delta_luma_weight_l0),
- sizeof(__entry->p.delta_luma_weight_l0[0])),
- __print_array(__entry->p.luma_offset_l0,
- ARRAY_SIZE(__entry->p.luma_offset_l0),
- sizeof(__entry->p.luma_offset_l0[0])),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.delta_chroma_weight_l0,
- sizeof(__entry->p.delta_chroma_weight_l0),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.chroma_offset_l0,
- sizeof(__entry->p.chroma_offset_l0),
- false),
- __print_array(__entry->p.delta_luma_weight_l1,
- ARRAY_SIZE(__entry->p.delta_luma_weight_l1),
- sizeof(__entry->p.delta_luma_weight_l1[0])),
- __print_array(__entry->p.luma_offset_l1,
- ARRAY_SIZE(__entry->p.luma_offset_l1),
- sizeof(__entry->p.luma_offset_l1[0])),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.delta_chroma_weight_l1,
- sizeof(__entry->p.delta_chroma_weight_l1),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.chroma_offset_l1,
- sizeof(__entry->p.chroma_offset_l1),
- false),
- __entry->p.luma_log2_weight_denom,
- __entry->p.delta_chroma_log2_weight_denom
-
- ))
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_scaling_matrix_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_scaling_matrix, s)),
- TP_fast_assign(__entry->s = *s),
- TP_printk("\nscaling_list_4x4 {%s}\n"
- "scaling_list_8x8 {%s}\n"
- "scaling_list_16x16 {%s}\n"
- "scaling_list_32x32 {%s}\n"
- "scaling_list_dc_coef_16x16 %s\n"
- "scaling_list_dc_coef_32x32 %s\n",
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->s.scaling_list_4x4,
- sizeof(__entry->s.scaling_list_4x4),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->s.scaling_list_8x8,
- sizeof(__entry->s.scaling_list_8x8),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->s.scaling_list_16x16,
- sizeof(__entry->s.scaling_list_16x16),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->s.scaling_list_32x32,
- sizeof(__entry->s.scaling_list_32x32),
- false),
- __print_array(__entry->s.scaling_list_dc_coef_16x16,
- ARRAY_SIZE(__entry->s.scaling_list_dc_coef_16x16),
- sizeof(__entry->s.scaling_list_dc_coef_16x16[0])),
- __print_array(__entry->s.scaling_list_dc_coef_32x32,
- ARRAY_SIZE(__entry->s.scaling_list_dc_coef_32x32),
- sizeof(__entry->s.scaling_list_dc_coef_32x32[0]))
- ))
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
- TP_ARGS(d),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_decode_params, d)),
- TP_fast_assign(__entry->d = *d),
- TP_printk("\npic_order_cnt_val %d\n"
- "short_term_ref_pic_set_size %u\n"
- "long_term_ref_pic_set_size %u\n"
- "num_active_dpb_entries %u\n"
- "num_poc_st_curr_before %u\n"
- "num_poc_st_curr_after %u\n"
- "num_poc_lt_curr %u\n"
- "poc_st_curr_before %s\n"
- "poc_st_curr_after %s\n"
- "poc_lt_curr %s\n"
- "flags %s",
- __entry->d.pic_order_cnt_val,
- __entry->d.short_term_ref_pic_set_size,
- __entry->d.long_term_ref_pic_set_size,
- __entry->d.num_active_dpb_entries,
- __entry->d.num_poc_st_curr_before,
- __entry->d.num_poc_st_curr_after,
- __entry->d.num_poc_lt_curr,
- __print_array(__entry->d.poc_st_curr_before,
- ARRAY_SIZE(__entry->d.poc_st_curr_before),
- sizeof(__entry->d.poc_st_curr_before[0])),
- __print_array(__entry->d.poc_st_curr_after,
- ARRAY_SIZE(__entry->d.poc_st_curr_after),
- sizeof(__entry->d.poc_st_curr_after[0])),
- __print_array(__entry->d.poc_lt_curr,
- ARRAY_SIZE(__entry->d.poc_lt_curr),
- sizeof(__entry->d.poc_lt_curr[0])),
- __print_flags(__entry->d.flags, "|",
- {V4L2_HEVC_DECODE_PARAM_FLAG_IRAP_PIC, "IRAP_PIC"},
- {V4L2_HEVC_DECODE_PARAM_FLAG_IDR_PIC, "IDR_PIC"},
- {V4L2_HEVC_DECODE_PARAM_FLAG_NO_OUTPUT_OF_PRIOR, "NO_OUTPUT_OF_PRIOR"}
- ))
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
- TP_ARGS(lt),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_lt_rps, lt)),
- TP_fast_assign(__entry->lt = *lt),
- TP_printk("\nflags %s\n"
- "lt_ref_pic_poc_lsb_sps %x\n",
- __print_flags(__entry->lt.flags, "|",
- {V4L2_HEVC_EXT_SPS_LT_RPS_FLAG_USED_LT, "USED_LT"}
- ),
- __entry->lt.lt_ref_pic_poc_lsb_sps
- )
-)
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
- TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
- TP_ARGS(st),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_st_rps, st)),
- TP_fast_assign(__entry->st = *st),
- TP_printk("\nflags %s\n"
- "delta_idx_minus1: %u\n"
- "delta_rps_sign: %u\n"
- "abs_delta_rps_minus1: %u\n"
- "num_negative_pics: %u\n"
- "num_positive_pics: %u\n"
- "used_by_curr_pic: %08x\n"
- "use_delta_flag: %08x\n"
- "delta_poc_s0_minus1: %s\n"
- "delta_poc_s1_minus1: %s\n",
- __print_flags(__entry->st.flags, "|",
- {V4L2_HEVC_EXT_SPS_ST_RPS_FLAG_INTER_REF_PIC_SET_PRED, "INTER_REF_PIC_SET_PRED"}
- ),
- __entry->st.delta_idx_minus1,
- __entry->st.delta_rps_sign,
- __entry->st.abs_delta_rps_minus1,
- __entry->st.num_negative_pics,
- __entry->st.num_positive_pics,
- __entry->st.used_by_curr_pic,
- __entry->st.use_delta_flag,
- __print_array(__entry->st.delta_poc_s0_minus1,
- ARRAY_SIZE(__entry->st.delta_poc_s0_minus1),
- sizeof(__entry->st.delta_poc_s0_minus1[0])),
- __print_array(__entry->st.delta_poc_s1_minus1,
- ARRAY_SIZE(__entry->st.delta_poc_s1_minus1),
- sizeof(__entry->st.delta_poc_s1_minus1[0]))
- )
-)
-
-
-DECLARE_EVENT_CLASS(v4l2_hevc_dpb_entry_tmpl,
- TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
- TP_ARGS(e),
- TP_STRUCT__entry(__field_struct(struct v4l2_hevc_dpb_entry, e)),
- TP_fast_assign(__entry->e = *e),
- TP_printk("\ntimestamp %llu\n"
- "flags %s\n"
- "field_pic %u\n"
- "pic_order_cnt_val %d\n",
- __entry->e.timestamp,
- __print_flags(__entry->e.flags, "|",
- {V4L2_HEVC_DPB_ENTRY_LONG_TERM_REFERENCE, "LONG_TERM_REFERENCE"}
- ),
- __entry->e.field_pic,
- __entry->e.pic_order_cnt_val
- ))
-
-DEFINE_EVENT(v4l2_ctrl_hevc_sps_tmpl, v4l2_ctrl_hevc_sps,
- TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
- TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_ctrl_hevc_pps_tmpl, v4l2_ctrl_hevc_pps,
- TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
- TP_ARGS(p)
-);
-
-DEFINE_EVENT(v4l2_ctrl_hevc_slice_params_tmpl, v4l2_ctrl_hevc_slice_params,
- TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
- TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_hevc_pred_weight_table_tmpl, v4l2_hevc_pred_weight_table,
- TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
- TP_ARGS(p)
-);
-
-DEFINE_EVENT(v4l2_ctrl_hevc_scaling_matrix_tmpl, v4l2_ctrl_hevc_scaling_matrix,
- TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
- TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_ctrl_hevc_decode_params_tmpl, v4l2_ctrl_hevc_decode_params,
- TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
- TP_ARGS(d)
-);
-
-DEFINE_EVENT(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl, v4l2_ctrl_hevc_ext_sps_lt_rps,
- TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
- TP_ARGS(lt)
-);
-
-DEFINE_EVENT(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl, v4l2_ctrl_hevc_ext_sps_st_rps,
- TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
- TP_ARGS(st)
-);
-
-DEFINE_EVENT(v4l2_hevc_dpb_entry_tmpl, v4l2_hevc_dpb_entry,
- TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
- TP_ARGS(e)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-hevc
-#include <trace/define_trace.h>
diff --git a/drivers/media/test-drivers/visl/visl-trace-mpeg2.h b/drivers/media/test-drivers/visl/visl-trace-mpeg2.h
deleted file mode 100644
index ba6c65481194..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-mpeg2.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#if !defined(_VISL_TRACE_MPEG2_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_MPEG2_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_mpeg2_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_seq_tmpl,
- TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
- TP_ARGS(s),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_sequence, s)),
- TP_fast_assign(__entry->s = *s;),
- TP_printk("\nhorizontal_size %u\nvertical_size %u\nvbv_buffer_size %u\n"
- "profile_and_level_indication %u\nchroma_format %u\nflags %s\n",
- __entry->s.horizontal_size,
- __entry->s.vertical_size,
- __entry->s.vbv_buffer_size,
- __entry->s.profile_and_level_indication,
- __entry->s.chroma_format,
- __print_flags(__entry->s.flags, "|",
- {V4L2_MPEG2_SEQ_FLAG_PROGRESSIVE, "PROGRESSIVE"})
- )
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_pic_tmpl,
- TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
- TP_ARGS(p),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_picture, p)),
- TP_fast_assign(__entry->p = *p;),
- TP_printk("\nbackward_ref_ts %llu\nforward_ref_ts %llu\nflags %s\nf_code {%s}\n"
- "picture_coding_type: %u\npicture_structure %u\nintra_dc_precision %u\n",
- __entry->p.backward_ref_ts,
- __entry->p.forward_ref_ts,
- __print_flags(__entry->p.flags, "|",
- {V4L2_MPEG2_PIC_FLAG_TOP_FIELD_FIRST, "TOP_FIELD_FIRST"},
- {V4L2_MPEG2_PIC_FLAG_FRAME_PRED_DCT, "FRAME_PRED_DCT"},
- {V4L2_MPEG2_PIC_FLAG_CONCEALMENT_MV, "CONCEALMENT_MV"},
- {V4L2_MPEG2_PIC_FLAG_Q_SCALE_TYPE, "Q_SCALE_TYPE"},
- {V4L2_MPEG2_PIC_FLAG_INTRA_VLC, "INTA_VLC"},
- {V4L2_MPEG2_PIC_FLAG_ALT_SCAN, "ALT_SCAN"},
- {V4L2_MPEG2_PIC_FLAG_REPEAT_FIRST, "REPEAT_FIRST"},
- {V4L2_MPEG2_PIC_FLAG_PROGRESSIVE, "PROGRESSIVE"}),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.f_code,
- sizeof(__entry->p.f_code),
- false),
- __entry->p.picture_coding_type,
- __entry->p.picture_structure,
- __entry->p.intra_dc_precision
- )
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_quant_tmpl,
- TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
- TP_ARGS(q),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_quantisation, q)),
- TP_fast_assign(__entry->q = *q;),
- TP_printk("\nintra_quantiser_matrix %s\nnon_intra_quantiser_matrix %s\n"
- "chroma_intra_quantiser_matrix %s\nchroma_non_intra_quantiser_matrix %s\n",
- __print_array(__entry->q.intra_quantiser_matrix,
- ARRAY_SIZE(__entry->q.intra_quantiser_matrix),
- sizeof(__entry->q.intra_quantiser_matrix[0])),
- __print_array(__entry->q.non_intra_quantiser_matrix,
- ARRAY_SIZE(__entry->q.non_intra_quantiser_matrix),
- sizeof(__entry->q.non_intra_quantiser_matrix[0])),
- __print_array(__entry->q.chroma_intra_quantiser_matrix,
- ARRAY_SIZE(__entry->q.chroma_intra_quantiser_matrix),
- sizeof(__entry->q.chroma_intra_quantiser_matrix[0])),
- __print_array(__entry->q.chroma_non_intra_quantiser_matrix,
- ARRAY_SIZE(__entry->q.chroma_non_intra_quantiser_matrix),
- sizeof(__entry->q.chroma_non_intra_quantiser_matrix[0]))
- )
-)
-
-DEFINE_EVENT(v4l2_ctrl_mpeg2_seq_tmpl, v4l2_ctrl_mpeg2_sequence,
- TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
- TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_ctrl_mpeg2_pic_tmpl, v4l2_ctrl_mpeg2_picture,
- TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
- TP_ARGS(p)
-);
-
-DEFINE_EVENT(v4l2_ctrl_mpeg2_quant_tmpl, v4l2_ctrl_mpeg2_quantisation,
- TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
- TP_ARGS(q)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-mpeg2
-#include <trace/define_trace.h>
diff --git a/drivers/media/test-drivers/visl/visl-trace-points.c b/drivers/media/test-drivers/visl/visl-trace-points.c
deleted file mode 100644
index 321ff732c682..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-points.c
+++ /dev/null
@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-#include "visl.h"
-
-#define CREATE_TRACE_POINTS
-#include "visl-trace-fwht.h"
-#include "visl-trace-mpeg2.h"
-#include "visl-trace-vp8.h"
-#include "visl-trace-vp9.h"
-#include "visl-trace-h264.h"
-#include "visl-trace-hevc.h"
-#include "visl-trace-av1.h"
diff --git a/drivers/media/test-drivers/visl/visl-trace-vp8.h b/drivers/media/test-drivers/visl/visl-trace-vp8.h
deleted file mode 100644
index dabe17d69ddc..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-vp8.h
+++ /dev/null
@@ -1,156 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#if !defined(_VISL_TRACE_VP8_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_VP8_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_vp8_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_entropy_tmpl,
- TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
- TP_ARGS(f),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
- TP_fast_assign(__entry->f = *f;),
- TP_printk("\nentropy.coeff_probs {%s}\n"
- "entropy.y_mode_probs %s\n"
- "entropy.uv_mode_probs %s\n"
- "entropy.mv_probs {%s}",
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->f.entropy.coeff_probs,
- sizeof(__entry->f.entropy.coeff_probs),
- false),
- __print_array(__entry->f.entropy.y_mode_probs,
- ARRAY_SIZE(__entry->f.entropy.y_mode_probs),
- sizeof(__entry->f.entropy.y_mode_probs[0])),
- __print_array(__entry->f.entropy.uv_mode_probs,
- ARRAY_SIZE(__entry->f.entropy.uv_mode_probs),
- sizeof(__entry->f.entropy.uv_mode_probs[0])),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->f.entropy.mv_probs,
- sizeof(__entry->f.entropy.mv_probs),
- false)
- )
-)
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
- TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
- TP_ARGS(f),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
- TP_fast_assign(__entry->f = *f;),
- TP_printk("\nsegment.quant_update %s\n"
- "segment.lf_update %s\n"
- "segment.segment_probs %s\n"
- "segment.flags %s\n"
- "lf.ref_frm_delta %s\n"
- "lf.mb_mode_delta %s\n"
- "lf.sharpness_level %u\n"
- "lf.level %u\n"
- "lf.flags %s\n"
- "quant.y_ac_qi %u\n"
- "quant.y_dc_delta %d\n"
- "quant.y2_dc_delta %d\n"
- "quant.y2_ac_delta %d\n"
- "quant.uv_dc_delta %d\n"
- "quant.uv_ac_delta %d\n"
- "coder_state.range %u\n"
- "coder_state.value %u\n"
- "coder_state.bit_count %u\n"
- "width %u\n"
- "height %u\n"
- "horizontal_scale %u\n"
- "vertical_scale %u\n"
- "version %u\n"
- "prob_skip_false %u\n"
- "prob_intra %u\n"
- "prob_last %u\n"
- "prob_gf %u\n"
- "num_dct_parts %u\n"
- "first_part_size %u\n"
- "first_part_header_bits %u\n"
- "dct_part_sizes %s\n"
- "last_frame_ts %llu\n"
- "golden_frame_ts %llu\n"
- "alt_frame_ts %llu\n"
- "flags %s",
- __print_array(__entry->f.segment.quant_update,
- ARRAY_SIZE(__entry->f.segment.quant_update),
- sizeof(__entry->f.segment.quant_update[0])),
- __print_array(__entry->f.segment.lf_update,
- ARRAY_SIZE(__entry->f.segment.lf_update),
- sizeof(__entry->f.segment.lf_update[0])),
- __print_array(__entry->f.segment.segment_probs,
- ARRAY_SIZE(__entry->f.segment.segment_probs),
- sizeof(__entry->f.segment.segment_probs[0])),
- __print_flags(__entry->f.segment.flags, "|",
- {V4L2_VP8_SEGMENT_FLAG_ENABLED, "SEGMENT_ENABLED"},
- {V4L2_VP8_SEGMENT_FLAG_UPDATE_MAP, "SEGMENT_UPDATE_MAP"},
- {V4L2_VP8_SEGMENT_FLAG_UPDATE_FEATURE_DATA, "SEGMENT_UPDATE_FEATURE_DATA"},
- {V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE, "SEGMENT_DELTA_VALUE_MODE"}),
- __print_array(__entry->f.lf.ref_frm_delta,
- ARRAY_SIZE(__entry->f.lf.ref_frm_delta),
- sizeof(__entry->f.lf.ref_frm_delta[0])),
- __print_array(__entry->f.lf.mb_mode_delta,
- ARRAY_SIZE(__entry->f.lf.mb_mode_delta),
- sizeof(__entry->f.lf.mb_mode_delta[0])),
- __entry->f.lf.sharpness_level,
- __entry->f.lf.level,
- __print_flags(__entry->f.lf.flags, "|",
- {V4L2_VP8_LF_ADJ_ENABLE, "LF_ADJ_ENABLED"},
- {V4L2_VP8_LF_DELTA_UPDATE, "LF_DELTA_UPDATE"},
- {V4L2_VP8_LF_FILTER_TYPE_SIMPLE, "LF_FILTER_TYPE_SIMPLE"}),
- __entry->f.quant.y_ac_qi,
- __entry->f.quant.y_dc_delta,
- __entry->f.quant.y2_dc_delta,
- __entry->f.quant.y2_ac_delta,
- __entry->f.quant.uv_dc_delta,
- __entry->f.quant.uv_ac_delta,
- __entry->f.coder_state.range,
- __entry->f.coder_state.value,
- __entry->f.coder_state.bit_count,
- __entry->f.width,
- __entry->f.height,
- __entry->f.horizontal_scale,
- __entry->f.vertical_scale,
- __entry->f.version,
- __entry->f.prob_skip_false,
- __entry->f.prob_intra,
- __entry->f.prob_last,
- __entry->f.prob_gf,
- __entry->f.num_dct_parts,
- __entry->f.first_part_size,
- __entry->f.first_part_header_bits,
- __print_array(__entry->f.dct_part_sizes,
- ARRAY_SIZE(__entry->f.dct_part_sizes),
- sizeof(__entry->f.dct_part_sizes[0])),
- __entry->f.last_frame_ts,
- __entry->f.golden_frame_ts,
- __entry->f.alt_frame_ts,
- __print_flags(__entry->f.flags, "|",
- {V4L2_VP8_FRAME_FLAG_KEY_FRAME, "KEY_FRAME"},
- {V4L2_VP8_FRAME_FLAG_EXPERIMENTAL, "EXPERIMENTAL"},
- {V4L2_VP8_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
- {V4L2_VP8_FRAME_FLAG_MB_NO_SKIP_COEFF, "MB_NO_SKIP_COEFF"},
- {V4L2_VP8_FRAME_FLAG_SIGN_BIAS_GOLDEN, "SIGN_BIAS_GOLDEN"},
- {V4L2_VP8_FRAME_FLAG_SIGN_BIAS_ALT, "SIGN_BIAS_ALT"})
- )
-);
-
-DEFINE_EVENT(v4l2_ctrl_vp8_frame_tmpl, v4l2_ctrl_vp8_frame,
- TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
- TP_ARGS(f)
-);
-
-DEFINE_EVENT(v4l2_ctrl_vp8_entropy_tmpl, v4l2_ctrl_vp8_entropy,
- TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
- TP_ARGS(f)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-vp8
-#include <trace/define_trace.h>
diff --git a/drivers/media/test-drivers/visl/visl-trace-vp9.h b/drivers/media/test-drivers/visl/visl-trace-vp9.h
deleted file mode 100644
index 362b92b07f93..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-vp9.h
+++ /dev/null
@@ -1,292 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#if !defined(_VISL_TRACE_VP9_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_VP9_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_vp9_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
- TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
- TP_ARGS(f),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_frame, f)),
- TP_fast_assign(__entry->f = *f;),
- TP_printk("\nlf.ref_deltas %s\n"
- "lf.mode_deltas %s\n"
- "lf.level %u\n"
- "lf.sharpness %u\n"
- "lf.flags %s\n"
- "quant.base_q_idx %u\n"
- "quant.delta_q_y_dc %d\n"
- "quant.delta_q_uv_dc %d\n"
- "quant.delta_q_uv_ac %d\n"
- "seg.feature_data {%s}\n"
- "seg.feature_enabled %s\n"
- "seg.tree_probs %s\n"
- "seg.pred_probs %s\n"
- "seg.flags %s\n"
- "flags %s\n"
- "compressed_header_size %u\n"
- "uncompressed_header_size %u\n"
- "frame_width_minus_1 %u\n"
- "frame_height_minus_1 %u\n"
- "render_width_minus_1 %u\n"
- "render_height_minus_1 %u\n"
- "last_frame_ts %llu\n"
- "golden_frame_ts %llu\n"
- "alt_frame_ts %llu\n"
- "ref_frame_sign_bias %s\n"
- "reset_frame_context %s\n"
- "frame_context_idx %u\n"
- "profile %u\n"
- "bit_depth %u\n"
- "interpolation_filter %s\n"
- "tile_cols_log2 %u\n"
- "tile_rows_log_2 %u\n"
- "reference_mode %s\n",
- __print_array(__entry->f.lf.ref_deltas,
- ARRAY_SIZE(__entry->f.lf.ref_deltas),
- sizeof(__entry->f.lf.ref_deltas[0])),
- __print_array(__entry->f.lf.mode_deltas,
- ARRAY_SIZE(__entry->f.lf.mode_deltas),
- sizeof(__entry->f.lf.mode_deltas[0])),
- __entry->f.lf.level,
- __entry->f.lf.sharpness,
- __print_flags(__entry->f.lf.flags, "|",
- {V4L2_VP9_LOOP_FILTER_FLAG_DELTA_ENABLED, "DELTA_ENABLED"},
- {V4L2_VP9_LOOP_FILTER_FLAG_DELTA_UPDATE, "DELTA_UPDATE"}),
- __entry->f.quant.base_q_idx,
- __entry->f.quant.delta_q_y_dc,
- __entry->f.quant.delta_q_uv_dc,
- __entry->f.quant.delta_q_uv_ac,
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->f.seg.feature_data,
- sizeof(__entry->f.seg.feature_data),
- false),
- __print_array(__entry->f.seg.feature_enabled,
- ARRAY_SIZE(__entry->f.seg.feature_enabled),
- sizeof(__entry->f.seg.feature_enabled[0])),
- __print_array(__entry->f.seg.tree_probs,
- ARRAY_SIZE(__entry->f.seg.tree_probs),
- sizeof(__entry->f.seg.tree_probs[0])),
- __print_array(__entry->f.seg.pred_probs,
- ARRAY_SIZE(__entry->f.seg.pred_probs),
- sizeof(__entry->f.seg.pred_probs[0])),
- __print_flags(__entry->f.seg.flags, "|",
- {V4L2_VP9_SEGMENTATION_FLAG_ENABLED, "ENABLED"},
- {V4L2_VP9_SEGMENTATION_FLAG_UPDATE_MAP, "UPDATE_MAP"},
- {V4L2_VP9_SEGMENTATION_FLAG_TEMPORAL_UPDATE, "TEMPORAL_UPDATE"},
- {V4L2_VP9_SEGMENTATION_FLAG_UPDATE_DATA, "UPDATE_DATA"},
- {V4L2_VP9_SEGMENTATION_FLAG_ABS_OR_DELTA_UPDATE, "ABS_OR_DELTA_UPDATE"}),
- __print_flags(__entry->f.flags, "|",
- {V4L2_VP9_FRAME_FLAG_KEY_FRAME, "KEY_FRAME"},
- {V4L2_VP9_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
- {V4L2_VP9_FRAME_FLAG_ERROR_RESILIENT, "ERROR_RESILIENT"},
- {V4L2_VP9_FRAME_FLAG_INTRA_ONLY, "INTRA_ONLY"},
- {V4L2_VP9_FRAME_FLAG_ALLOW_HIGH_PREC_MV, "ALLOW_HIGH_PREC_MV"},
- {V4L2_VP9_FRAME_FLAG_REFRESH_FRAME_CTX, "REFRESH_FRAME_CTX"},
- {V4L2_VP9_FRAME_FLAG_PARALLEL_DEC_MODE, "PARALLEL_DEC_MODE"},
- {V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING, "X_SUBSAMPLING"},
- {V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING, "Y_SUBSAMPLING"},
- {V4L2_VP9_FRAME_FLAG_COLOR_RANGE_FULL_SWING, "COLOR_RANGE_FULL_SWING"}),
- __entry->f.compressed_header_size,
- __entry->f.uncompressed_header_size,
- __entry->f.frame_width_minus_1,
- __entry->f.frame_height_minus_1,
- __entry->f.render_width_minus_1,
- __entry->f.render_height_minus_1,
- __entry->f.last_frame_ts,
- __entry->f.golden_frame_ts,
- __entry->f.alt_frame_ts,
- __print_symbolic(__entry->f.ref_frame_sign_bias,
- {V4L2_VP9_SIGN_BIAS_LAST, "SIGN_BIAS_LAST"},
- {V4L2_VP9_SIGN_BIAS_GOLDEN, "SIGN_BIAS_GOLDEN"},
- {V4L2_VP9_SIGN_BIAS_ALT, "SIGN_BIAS_ALT"}),
- __print_symbolic(__entry->f.reset_frame_context,
- {V4L2_VP9_RESET_FRAME_CTX_NONE, "RESET_FRAME_CTX_NONE"},
- {V4L2_VP9_RESET_FRAME_CTX_SPEC, "RESET_FRAME_CTX_SPEC"},
- {V4L2_VP9_RESET_FRAME_CTX_ALL, "RESET_FRAME_CTX_ALL"}),
- __entry->f.frame_context_idx,
- __entry->f.profile,
- __entry->f.bit_depth,
- __print_symbolic(__entry->f.interpolation_filter,
- {V4L2_VP9_INTERP_FILTER_EIGHTTAP, "INTERP_FILTER_EIGHTTAP"},
- {V4L2_VP9_INTERP_FILTER_EIGHTTAP_SMOOTH, "INTERP_FILTER_EIGHTTAP_SMOOTH"},
- {V4L2_VP9_INTERP_FILTER_EIGHTTAP_SHARP, "INTERP_FILTER_EIGHTTAP_SHARP"},
- {V4L2_VP9_INTERP_FILTER_BILINEAR, "INTERP_FILTER_BILINEAR"},
- {V4L2_VP9_INTERP_FILTER_SWITCHABLE, "INTERP_FILTER_SWITCHABLE"}),
- __entry->f.tile_cols_log2,
- __entry->f.tile_rows_log2,
- __print_symbolic(__entry->f.reference_mode,
- {V4L2_VP9_REFERENCE_MODE_SINGLE_REFERENCE, "REFERENCE_MODE_SINGLE_REFERENCE"},
- {V4L2_VP9_REFERENCE_MODE_COMPOUND_REFERENCE, "REFERENCE_MODE_COMPOUND_REFERENCE"},
- {V4L2_VP9_REFERENCE_MODE_SELECT, "REFERENCE_MODE_SELECT"}))
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
- TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
- TP_ARGS(h),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
- TP_fast_assign(__entry->h = *h;),
- TP_printk("\ntx_mode %s\n"
- "tx8 {%s}\n"
- "tx16 {%s}\n"
- "tx32 {%s}\n"
- "skip %s\n"
- "inter_mode {%s}\n"
- "interp_filter {%s}\n"
- "is_inter %s\n"
- "comp_mode %s\n"
- "single_ref {%s}\n"
- "comp_ref %s\n"
- "y_mode {%s}\n"
- "uv_mode {%s}\n"
- "partition {%s}\n",
- __print_symbolic(__entry->h.tx_mode,
- {V4L2_VP9_TX_MODE_ONLY_4X4, "TX_MODE_ONLY_4X4"},
- {V4L2_VP9_TX_MODE_ALLOW_8X8, "TX_MODE_ALLOW_8X8"},
- {V4L2_VP9_TX_MODE_ALLOW_16X16, "TX_MODE_ALLOW_16X16"},
- {V4L2_VP9_TX_MODE_ALLOW_32X32, "TX_MODE_ALLOW_32X32"},
- {V4L2_VP9_TX_MODE_SELECT, "TX_MODE_SELECT"}),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->h.tx8,
- sizeof(__entry->h.tx8),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->h.tx16,
- sizeof(__entry->h.tx16),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->h.tx32,
- sizeof(__entry->h.tx32),
- false),
- __print_array(__entry->h.skip,
- ARRAY_SIZE(__entry->h.skip),
- sizeof(__entry->h.skip[0])),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->h.inter_mode,
- sizeof(__entry->h.inter_mode),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->h.interp_filter,
- sizeof(__entry->h.interp_filter),
- false),
- __print_array(__entry->h.is_inter,
- ARRAY_SIZE(__entry->h.is_inter),
- sizeof(__entry->h.is_inter[0])),
- __print_array(__entry->h.comp_mode,
- ARRAY_SIZE(__entry->h.comp_mode),
- sizeof(__entry->h.comp_mode[0])),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->h.single_ref,
- sizeof(__entry->h.single_ref),
- false),
- __print_array(__entry->h.comp_ref,
- ARRAY_SIZE(__entry->h.comp_ref),
- sizeof(__entry->h.comp_ref[0])),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->h.y_mode,
- sizeof(__entry->h.y_mode),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->h.uv_mode,
- sizeof(__entry->h.uv_mode),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->h.partition,
- sizeof(__entry->h.partition),
- false)
- )
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_coef_tmpl,
- TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
- TP_ARGS(h),
- TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
- TP_fast_assign(__entry->h = *h;),
- TP_printk("\n coef {%s}",
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->h.coef,
- sizeof(__entry->h.coef),
- false)
- )
-);
-
-DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
- TP_PROTO(const struct v4l2_vp9_mv_probs *p),
- TP_ARGS(p),
- TP_STRUCT__entry(__field_struct(struct v4l2_vp9_mv_probs, p)),
- TP_fast_assign(__entry->p = *p;),
- TP_printk("\n joint %s\n"
- "sign %s\n"
- "classes {%s}\n"
- "class0_bit %s\n"
- "bits {%s}\n"
- "class0_fr {%s}\n"
- "fr {%s}\n"
- "class0_hp %s\n"
- "hp %s\n",
- __print_array(__entry->p.joint,
- ARRAY_SIZE(__entry->p.joint),
- sizeof(__entry->p.joint[0])),
- __print_array(__entry->p.sign,
- ARRAY_SIZE(__entry->p.sign),
- sizeof(__entry->p.sign[0])),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.classes,
- sizeof(__entry->p.classes),
- false),
- __print_array(__entry->p.class0_bit,
- ARRAY_SIZE(__entry->p.class0_bit),
- sizeof(__entry->p.class0_bit[0])),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.bits,
- sizeof(__entry->p.bits),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.class0_fr,
- sizeof(__entry->p.class0_fr),
- false),
- __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
- __entry->p.fr,
- sizeof(__entry->p.fr),
- false),
- __print_array(__entry->p.class0_hp,
- ARRAY_SIZE(__entry->p.class0_hp),
- sizeof(__entry->p.class0_hp[0])),
- __print_array(__entry->p.hp,
- ARRAY_SIZE(__entry->p.hp),
- sizeof(__entry->p.hp[0]))
- )
-);
-
-DEFINE_EVENT(v4l2_ctrl_vp9_frame_tmpl, v4l2_ctrl_vp9_frame,
- TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
- TP_ARGS(f)
-);
-
-DEFINE_EVENT(v4l2_ctrl_vp9_compressed_hdr_tmpl, v4l2_ctrl_vp9_compressed_hdr,
- TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
- TP_ARGS(h)
-);
-
-DEFINE_EVENT(v4l2_ctrl_vp9_compressed_coef_tmpl, v4l2_ctrl_vp9_compressed_coeff,
- TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
- TP_ARGS(h)
-);
-
-
-DEFINE_EVENT(v4l2_vp9_mv_probs_tmpl, v4l2_vp9_mv_probs,
- TP_PROTO(const struct v4l2_vp9_mv_probs *p),
- TP_ARGS(p)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-vp9
-#include <trace/define_trace.h>
diff --git a/drivers/media/v4l2-core/v4l2-trace.c b/drivers/media/v4l2-core/v4l2-trace.c
index 95f3b02e1f84..9ce54c1968ef 100644
--- a/drivers/media/v4l2-core/v4l2-trace.c
+++ b/drivers/media/v4l2-core/v4l2-trace.c
@@ -5,8 +5,53 @@
#define CREATE_TRACE_POINTS
#include <trace/events/v4l2.h>
+#include <trace/events/v4l2_requests.h>
EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_buf_done);
EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_buf_queue);
EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_dqbuf);
EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_qbuf);
+
+/* Export AV1 controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_av1_sequence);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_av1_frame);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_av1_tile_group_entry);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_av1_film_grain);
+
+/* Export FWHT controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_fwht_params);
+
+/* Export H264 controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_h264_sps);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_h264_pps);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_h264_scaling_matrix);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_h264_pred_weights);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_h264_slice_params);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_h264_ref_pic_list0);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_h264_ref_pic_list1);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_h264_decode_params);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_h264_dpb_entry);
+
+/* Export HEVC controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_hevc_sps);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_hevc_pps);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_hevc_slice_params);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_hevc_pred_weight_table);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_hevc_scaling_matrix);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_hevc_decode_params);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_hevc_dpb_entry);
+
+/* Export MPEG2 controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_mpeg2_sequence);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_mpeg2_picture);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_mpeg2_quantisation);
+
+/* Export VP8 controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_vp8_frame);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_vp8_entropy);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_vp9_frame);
+
+/* Export VP9 controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_vp9_compressed_hdr);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_vp9_compressed_coeff);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_vp9_mv_probs);
diff --git a/include/trace/events/v4l2_requests.h b/include/trace/events/v4l2_requests.h
new file mode 100644
index 000000000000..1e137d39d5fe
--- /dev/null
+++ b/include/trace/events/v4l2_requests.h
@@ -0,0 +1,1645 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#if !defined(_TRACE_V4L2_REQUESTS_H_) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_V4L2_REQUESTS_H_
+
+#include <linux/tracepoint.h>
+#include <linux/v4l2-controls.h>
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM v4l2_requests
+
+/* AV1 controls */
+DECLARE_EVENT_CLASS(v4l2_ctrl_av1_seq_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
+ TP_ARGS(s),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_sequence, s)),
+ TP_fast_assign(__entry->s = *s;),
+ TP_printk("\nflags %s\nseq_profile: %u\norder_hint_bits: %u\nbit_depth: %u\n"
+ "max_frame_width_minus_1: %u\nmax_frame_height_minus_1: %u\n",
+ __print_flags(__entry->s.flags, "|",
+ {V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE, "STILL_PICTURE"},
+ {V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK, "USE_128X128_SUPERBLOCK"},
+ {V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA, "ENABLE_FILTER_INTRA"},
+ {V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER, "ENABLE_INTRA_EDGE_FILTER"},
+ {V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND, "ENABLE_INTERINTRA_COMPOUND"},
+ {V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND, "ENABLE_MASKED_COMPOUND"},
+ {V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION, "ENABLE_WARPED_MOTION"},
+ {V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER, "ENABLE_DUAL_FILTER"},
+ {V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT, "ENABLE_ORDER_HINT"},
+ {V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP, "ENABLE_JNT_COMP"},
+ {V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS, "ENABLE_REF_FRAME_MVS"},
+ {V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES, "ENABLE_SUPERRES"},
+ {V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF, "ENABLE_CDEF"},
+ {V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION, "ENABLE_RESTORATION"},
+ {V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME, "MONO_CHROME"},
+ {V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE, "COLOR_RANGE"},
+ {V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X, "SUBSAMPLING_X"},
+ {V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y, "SUBSAMPLING_Y"},
+ {V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT, "FILM_GRAIN_PARAMS_PRESENT"},
+ {V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q, "SEPARATE_UV_DELTA_Q"}),
+ __entry->s.seq_profile,
+ __entry->s.order_hint_bits,
+ __entry->s.bit_depth,
+ __entry->s.max_frame_width_minus_1,
+ __entry->s.max_frame_height_minus_1
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_av1_tge_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
+ TP_ARGS(t),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_tile_group_entry, t)),
+ TP_fast_assign(__entry->t = *t;),
+ TP_printk("\ntile_offset: %u\n tile_size: %u\n tile_row: %u\ntile_col: %u\n",
+ __entry->t.tile_offset,
+ __entry->t.tile_size,
+ __entry->t.tile_row,
+ __entry->t.tile_col
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
+ TP_ARGS(f),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_frame, f)),
+ TP_fast_assign(__entry->f = *f;),
+ TP_printk("\ntile_info.flags: %s\ntile_info.context_update_tile_id: %u\n"
+ "tile_info.tile_cols: %u\ntile_info.tile_rows: %u\n"
+ "tile_info.mi_col_starts: %s\ntile_info.mi_row_starts: %s\n"
+ "tile_info.width_in_sbs_minus_1: %s\ntile_info.height_in_sbs_minus_1: %s\n"
+ "tile_info.tile_size_bytes: %u\nquantization.flags: %s\n"
+ "quantization.base_q_idx: %u\nquantization.delta_q_y_dc: %d\n"
+ "quantization.delta_q_u_dc: %d\nquantization.delta_q_u_ac: %d\n"
+ "quantization.delta_q_v_dc: %d\nquantization.delta_q_v_ac: %d\n"
+ "quantization.qm_y: %u\nquantization.qm_u: %u\nquantization.qm_v: %u\n"
+ "quantization.delta_q_res: %u\nsuperres_denom: %u\nsegmentation.flags: %s\n"
+ "segmentation.last_active_seg_id: %u\nsegmentation.feature_enabled:%s\n"
+ "loop_filter.flags: %s\nloop_filter.level: %s\nloop_filter.sharpness: %u\n"
+ "loop_filter.ref_deltas: %s\nloop_filter.mode_deltas: %s\n"
+ "loop_filter.delta_lf_res: %u\ncdef.damping_minus_3: %u\ncdef.bits: %u\n"
+ "cdef.y_pri_strength: %s\ncdef.y_sec_strength: %s\n"
+ "cdef.uv_pri_strength: %s\ncdef.uv_sec_strength:%s\nskip_mode_frame: %s\n"
+ "primary_ref_frame: %u\nloop_restoration.flags: %s\n"
+ "loop_restoration.lr_unit_shift: %u\nloop_restoration.lr_uv_shift: %u\n"
+ "loop_restoration.frame_restoration_type: %s\n"
+ "loop_restoration.loop_restoration_size: %s\nflags: %s\norder_hint: %u\n"
+ "upscaled_width: %u\nframe_width_minus_1: %u\nframe_height_minus_1: %u\n"
+ "render_width_minus_1: %u\nrender_height_minus_1: %u\ncurrent_frame_id: %u\n"
+ "buffer_removal_time: %s\norder_hints: %s\nreference_frame_ts: %s\n"
+ "ref_frame_idx: %s\nrefresh_frame_flags: %u\n",
+ __print_flags(__entry->f.tile_info.flags, "|",
+ {V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING, "UNIFORM_TILE_SPACING"}),
+ __entry->f.tile_info.context_update_tile_id,
+ __entry->f.tile_info.tile_cols,
+ __entry->f.tile_info.tile_rows,
+ __print_array(__entry->f.tile_info.mi_col_starts,
+ ARRAY_SIZE(__entry->f.tile_info.mi_col_starts),
+ sizeof(__entry->f.tile_info.mi_col_starts[0])),
+ __print_array(__entry->f.tile_info.mi_row_starts,
+ ARRAY_SIZE(__entry->f.tile_info.mi_row_starts),
+ sizeof(__entry->f.tile_info.mi_row_starts[0])),
+ __print_array(__entry->f.tile_info.width_in_sbs_minus_1,
+ ARRAY_SIZE(__entry->f.tile_info.width_in_sbs_minus_1),
+ sizeof(__entry->f.tile_info.width_in_sbs_minus_1[0])),
+ __print_array(__entry->f.tile_info.height_in_sbs_minus_1,
+ ARRAY_SIZE(__entry->f.tile_info.height_in_sbs_minus_1),
+ sizeof(__entry->f.tile_info.height_in_sbs_minus_1[0])),
+ __entry->f.tile_info.tile_size_bytes,
+ __print_flags(__entry->f.quantization.flags, "|",
+ {V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA, "DIFF_UV_DELTA"},
+ {V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX, "USING_QMATRIX"},
+ {V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT, "DELTA_Q_PRESENT"}),
+ __entry->f.quantization.base_q_idx,
+ __entry->f.quantization.delta_q_y_dc,
+ __entry->f.quantization.delta_q_u_dc,
+ __entry->f.quantization.delta_q_u_ac,
+ __entry->f.quantization.delta_q_v_dc,
+ __entry->f.quantization.delta_q_v_ac,
+ __entry->f.quantization.qm_y,
+ __entry->f.quantization.qm_u,
+ __entry->f.quantization.qm_v,
+ __entry->f.quantization.delta_q_res,
+ __entry->f.superres_denom,
+ __print_flags(__entry->f.segmentation.flags, "|",
+ {V4L2_AV1_SEGMENTATION_FLAG_ENABLED, "ENABLED"},
+ {V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP, "UPDATE_MAP"},
+ {V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE, "TEMPORAL_UPDATE"},
+ {V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA, "UPDATE_DATA"},
+ {V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP, "SEG_ID_PRE_SKIP"}),
+ __entry->f.segmentation.last_active_seg_id,
+ __print_array(__entry->f.segmentation.feature_enabled,
+ ARRAY_SIZE(__entry->f.segmentation.feature_enabled),
+ sizeof(__entry->f.segmentation.feature_enabled[0])),
+ __print_flags(__entry->f.loop_filter.flags, "|",
+ {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED, "DELTA_ENABLED"},
+ {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE, "DELTA_UPDATE"},
+ {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT, "DELTA_LF_PRESENT"},
+ {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI, "DELTA_LF_MULTI"}),
+ __print_array(__entry->f.loop_filter.level,
+ ARRAY_SIZE(__entry->f.loop_filter.level),
+ sizeof(__entry->f.loop_filter.level[0])),
+ __entry->f.loop_filter.sharpness,
+ __print_array(__entry->f.loop_filter.ref_deltas,
+ ARRAY_SIZE(__entry->f.loop_filter.ref_deltas),
+ sizeof(__entry->f.loop_filter.ref_deltas[0])),
+ __print_array(__entry->f.loop_filter.mode_deltas,
+ ARRAY_SIZE(__entry->f.loop_filter.mode_deltas),
+ sizeof(__entry->f.loop_filter.mode_deltas[0])),
+ __entry->f.loop_filter.delta_lf_res,
+ __entry->f.cdef.damping_minus_3,
+ __entry->f.cdef.bits,
+ __print_array(__entry->f.cdef.y_pri_strength,
+ ARRAY_SIZE(__entry->f.cdef.y_pri_strength),
+ sizeof(__entry->f.cdef.y_pri_strength[0])),
+ __print_array(__entry->f.cdef.y_sec_strength,
+ ARRAY_SIZE(__entry->f.cdef.y_sec_strength),
+ sizeof(__entry->f.cdef.y_sec_strength[0])),
+ __print_array(__entry->f.cdef.uv_pri_strength,
+ ARRAY_SIZE(__entry->f.cdef.uv_pri_strength),
+ sizeof(__entry->f.cdef.uv_pri_strength[0])),
+ __print_array(__entry->f.cdef.uv_sec_strength,
+ ARRAY_SIZE(__entry->f.cdef.uv_sec_strength),
+ sizeof(__entry->f.cdef.uv_sec_strength[0])),
+ __print_array(__entry->f.skip_mode_frame,
+ ARRAY_SIZE(__entry->f.skip_mode_frame),
+ sizeof(__entry->f.skip_mode_frame[0])),
+ __entry->f.primary_ref_frame,
+ __print_flags(__entry->f.loop_restoration.flags, "|",
+ {V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR, "USES_LR"},
+ {V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR, "USES_CHROMA_LR"}),
+ __entry->f.loop_restoration.lr_unit_shift,
+ __entry->f.loop_restoration.lr_uv_shift,
+ __print_array(__entry->f.loop_restoration.frame_restoration_type,
+ ARRAY_SIZE(__entry->f.loop_restoration.frame_restoration_type),
+ sizeof(__entry->f.loop_restoration.frame_restoration_type[0])),
+ __print_array(__entry->f.loop_restoration.loop_restoration_size,
+ ARRAY_SIZE(__entry->f.loop_restoration.loop_restoration_size),
+ sizeof(__entry->f.loop_restoration.loop_restoration_size[0])),
+ __print_flags(__entry->f.flags, "|",
+ {V4L2_AV1_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
+ {V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME, "SHOWABLE_FRAME"},
+ {V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE, "ERROR_RESILIENT_MODE"},
+ {V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE, "DISABLE_CDF_UPDATE"},
+ {V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS, "ALLOW_SCREEN_CONTENT_TOOLS"},
+ {V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV, "FORCE_INTEGER_MV"},
+ {V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC, "ALLOW_INTRABC"},
+ {V4L2_AV1_FRAME_FLAG_USE_SUPERRES, "USE_SUPERRES"},
+ {V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV, "ALLOW_HIGH_PRECISION_MV"},
+ {V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE, "IS_MOTION_MODE_SWITCHABLE"},
+ {V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS, "USE_REF_FRAME_MVS"},
+ {V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF,
+ "DISABLE_FRAME_END_UPDATE_CDF"},
+ {V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION, "ALLOW_WARPED_MOTION"},
+ {V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT, "REFERENCE_SELECT"},
+ {V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET, "REDUCED_TX_SET"},
+ {V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED, "SKIP_MODE_ALLOWED"},
+ {V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT, "SKIP_MODE_PRESENT"},
+ {V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE, "FRAME_SIZE_OVERRIDE"},
+ {V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT, "BUFFER_REMOVAL_TIME_PRESENT"},
+ {V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING, "FRAME_REFS_SHORT_SIGNALING"}),
+ __entry->f.order_hint,
+ __entry->f.upscaled_width,
+ __entry->f.frame_width_minus_1,
+ __entry->f.frame_height_minus_1,
+ __entry->f.render_width_minus_1,
+ __entry->f.render_height_minus_1,
+ __entry->f.current_frame_id,
+ __print_array(__entry->f.buffer_removal_time,
+ ARRAY_SIZE(__entry->f.buffer_removal_time),
+ sizeof(__entry->f.buffer_removal_time[0])),
+ __print_array(__entry->f.order_hints,
+ ARRAY_SIZE(__entry->f.order_hints),
+ sizeof(__entry->f.order_hints[0])),
+ __print_array(__entry->f.reference_frame_ts,
+ ARRAY_SIZE(__entry->f.reference_frame_ts),
+ sizeof(__entry->f.reference_frame_ts[0])),
+ __print_array(__entry->f.ref_frame_idx,
+ ARRAY_SIZE(__entry->f.ref_frame_idx),
+ sizeof(__entry->f.ref_frame_idx[0])),
+ __entry->f.refresh_frame_flags
+ )
+);
+
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
+ TP_ARGS(f),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_film_grain, f)),
+ TP_fast_assign(__entry->f = *f;),
+ TP_printk("\nflags %s\ncr_mult: %u\ngrain_seed: %u\n"
+ "film_grain_params_ref_idx: %u\nnum_y_points: %u\npoint_y_value: %s\n"
+ "point_y_scaling: %s\nnum_cb_points: %u\npoint_cb_value: %s\n"
+ "point_cb_scaling: %s\nnum_cr_points: %u\npoint_cr_value: %s\n"
+ "point_cr_scaling: %s\ngrain_scaling_minus_8: %u\nar_coeff_lag: %u\n"
+ "ar_coeffs_y_plus_128: %s\nar_coeffs_cb_plus_128: %s\n"
+ "ar_coeffs_cr_plus_128: %s\nar_coeff_shift_minus_6: %u\n"
+ "grain_scale_shift: %u\ncb_mult: %u\ncb_luma_mult: %u\ncr_luma_mult: %u\n"
+ "cb_offset: %u\ncr_offset: %u\n",
+ __print_flags(__entry->f.flags, "|",
+ {V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN, "APPLY_GRAIN"},
+ {V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN, "UPDATE_GRAIN"},
+ {V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA, "CHROMA_SCALING_FROM_LUMA"},
+ {V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP, "OVERLAP"},
+ {V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE, "CLIP_TO_RESTRICTED_RANGE"}),
+ __entry->f.cr_mult,
+ __entry->f.grain_seed,
+ __entry->f.film_grain_params_ref_idx,
+ __entry->f.num_y_points,
+ __print_array(__entry->f.point_y_value,
+ ARRAY_SIZE(__entry->f.point_y_value),
+ sizeof(__entry->f.point_y_value[0])),
+ __print_array(__entry->f.point_y_scaling,
+ ARRAY_SIZE(__entry->f.point_y_scaling),
+ sizeof(__entry->f.point_y_scaling[0])),
+ __entry->f.num_cb_points,
+ __print_array(__entry->f.point_cb_value,
+ ARRAY_SIZE(__entry->f.point_cb_value),
+ sizeof(__entry->f.point_cb_value[0])),
+ __print_array(__entry->f.point_cb_scaling,
+ ARRAY_SIZE(__entry->f.point_cb_scaling),
+ sizeof(__entry->f.point_cb_scaling[0])),
+ __entry->f.num_cr_points,
+ __print_array(__entry->f.point_cr_value,
+ ARRAY_SIZE(__entry->f.point_cr_value),
+ sizeof(__entry->f.point_cr_value[0])),
+ __print_array(__entry->f.point_cr_scaling,
+ ARRAY_SIZE(__entry->f.point_cr_scaling),
+ sizeof(__entry->f.point_cr_scaling[0])),
+ __entry->f.grain_scaling_minus_8,
+ __entry->f.ar_coeff_lag,
+ __print_array(__entry->f.ar_coeffs_y_plus_128,
+ ARRAY_SIZE(__entry->f.ar_coeffs_y_plus_128),
+ sizeof(__entry->f.ar_coeffs_y_plus_128[0])),
+ __print_array(__entry->f.ar_coeffs_cb_plus_128,
+ ARRAY_SIZE(__entry->f.ar_coeffs_cb_plus_128),
+ sizeof(__entry->f.ar_coeffs_cb_plus_128[0])),
+ __print_array(__entry->f.ar_coeffs_cr_plus_128,
+ ARRAY_SIZE(__entry->f.ar_coeffs_cr_plus_128),
+ sizeof(__entry->f.ar_coeffs_cr_plus_128[0])),
+ __entry->f.ar_coeff_shift_minus_6,
+ __entry->f.grain_scale_shift,
+ __entry->f.cb_mult,
+ __entry->f.cb_luma_mult,
+ __entry->f.cr_luma_mult,
+ __entry->f.cb_offset,
+ __entry->f.cr_offset
+ )
+)
+
+DEFINE_EVENT(v4l2_ctrl_av1_seq_tmpl, v4l2_ctrl_av1_sequence,
+ TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
+ TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_ctrl_av1_frame_tmpl, v4l2_ctrl_av1_frame,
+ TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
+ TP_ARGS(f)
+);
+
+DEFINE_EVENT(v4l2_ctrl_av1_tge_tmpl, v4l2_ctrl_av1_tile_group_entry,
+ TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
+ TP_ARGS(t)
+);
+
+DEFINE_EVENT(v4l2_ctrl_av1_film_grain_tmpl, v4l2_ctrl_av1_film_grain,
+ TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
+ TP_ARGS(f)
+);
+
+/* FWHT controls */
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_fwht_params *p),
+ TP_ARGS(p),
+ TP_STRUCT__entry(
+ __field(u64, backward_ref_ts)
+ __field(u32, version)
+ __field(u32, width)
+ __field(u32, height)
+ __field(u32, flags)
+ __field(u32, colorspace)
+ __field(u32, xfer_func)
+ __field(u32, ycbcr_enc)
+ __field(u32, quantization)
+ ),
+ TP_fast_assign(
+ __entry->backward_ref_ts = p->backward_ref_ts;
+ __entry->version = p->version;
+ __entry->width = p->width;
+ __entry->height = p->height;
+ __entry->flags = p->flags;
+ __entry->colorspace = p->colorspace;
+ __entry->xfer_func = p->xfer_func;
+ __entry->ycbcr_enc = p->ycbcr_enc;
+ __entry->quantization = p->quantization;
+ ),
+ TP_printk("backward_ref_ts %llu version %u width %u height %u flags %s colorspace %u xfer_func %u ycbcr_enc %u quantization %u",
+ __entry->backward_ref_ts, __entry->version, __entry->width, __entry->height,
+ __print_flags(__entry->flags, "|",
+ {V4L2_FWHT_FL_IS_INTERLACED, "IS_INTERLACED"},
+ {V4L2_FWHT_FL_IS_BOTTOM_FIRST, "IS_BOTTOM_FIRST"},
+ {V4L2_FWHT_FL_IS_ALTERNATE, "IS_ALTERNATE"},
+ {V4L2_FWHT_FL_IS_BOTTOM_FIELD, "IS_BOTTOM_FIELD"},
+ {V4L2_FWHT_FL_LUMA_IS_UNCOMPRESSED, "LUMA_IS_UNCOMPRESSED"},
+ {V4L2_FWHT_FL_CB_IS_UNCOMPRESSED, "CB_IS_UNCOMPRESSED"},
+ {V4L2_FWHT_FL_CR_IS_UNCOMPRESSED, "CR_IS_UNCOMPRESSED"},
+ {V4L2_FWHT_FL_ALPHA_IS_UNCOMPRESSED, "ALPHA_IS_UNCOMPRESSED"},
+ {V4L2_FWHT_FL_I_FRAME, "I_FRAME"},
+ {V4L2_FWHT_FL_PIXENC_HSV, "PIXENC_HSV"},
+ {V4L2_FWHT_FL_PIXENC_RGB, "PIXENC_RGB"},
+ {V4L2_FWHT_FL_PIXENC_YUV, "PIXENC_YUV"}),
+ __entry->colorspace, __entry->xfer_func, __entry->ycbcr_enc,
+ __entry->quantization)
+);
+
+DEFINE_EVENT(v4l2_ctrl_fwht_params_tmpl, v4l2_ctrl_fwht_params,
+ TP_PROTO(const struct v4l2_ctrl_fwht_params *p),
+ TP_ARGS(p)
+);
+
+/* H264 controls */
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
+ TP_ARGS(s),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_sps, s)),
+ TP_fast_assign(__entry->s = *s),
+ TP_printk("\nprofile_idc %u\n"
+ "constraint_set_flags %s\n"
+ "level_idc %u\n"
+ "seq_parameter_set_id %u\n"
+ "chroma_format_idc %u\n"
+ "bit_depth_luma_minus8 %u\n"
+ "bit_depth_chroma_minus8 %u\n"
+ "log2_max_frame_num_minus4 %u\n"
+ "pic_order_cnt_type %u\n"
+ "log2_max_pic_order_cnt_lsb_minus4 %u\n"
+ "max_num_ref_frames %u\n"
+ "num_ref_frames_in_pic_order_cnt_cycle %u\n"
+ "offset_for_ref_frame %s\n"
+ "offset_for_non_ref_pic %d\n"
+ "offset_for_top_to_bottom_field %d\n"
+ "pic_width_in_mbs_minus1 %u\n"
+ "pic_height_in_map_units_minus1 %u\n"
+ "flags %s",
+ __entry->s.profile_idc,
+ __print_flags(__entry->s.constraint_set_flags, "|",
+ {V4L2_H264_SPS_CONSTRAINT_SET0_FLAG, "CONSTRAINT_SET0_FLAG"},
+ {V4L2_H264_SPS_CONSTRAINT_SET1_FLAG, "CONSTRAINT_SET1_FLAG"},
+ {V4L2_H264_SPS_CONSTRAINT_SET2_FLAG, "CONSTRAINT_SET2_FLAG"},
+ {V4L2_H264_SPS_CONSTRAINT_SET3_FLAG, "CONSTRAINT_SET3_FLAG"},
+ {V4L2_H264_SPS_CONSTRAINT_SET4_FLAG, "CONSTRAINT_SET4_FLAG"},
+ {V4L2_H264_SPS_CONSTRAINT_SET5_FLAG, "CONSTRAINT_SET5_FLAG"}),
+ __entry->s.level_idc,
+ __entry->s.seq_parameter_set_id,
+ __entry->s.chroma_format_idc,
+ __entry->s.bit_depth_luma_minus8,
+ __entry->s.bit_depth_chroma_minus8,
+ __entry->s.log2_max_frame_num_minus4,
+ __entry->s.pic_order_cnt_type,
+ __entry->s.log2_max_pic_order_cnt_lsb_minus4,
+ __entry->s.max_num_ref_frames,
+ __entry->s.num_ref_frames_in_pic_order_cnt_cycle,
+ __print_array(__entry->s.offset_for_ref_frame,
+ ARRAY_SIZE(__entry->s.offset_for_ref_frame),
+ sizeof(__entry->s.offset_for_ref_frame[0])),
+ __entry->s.offset_for_non_ref_pic,
+ __entry->s.offset_for_top_to_bottom_field,
+ __entry->s.pic_width_in_mbs_minus1,
+ __entry->s.pic_height_in_map_units_minus1,
+ __print_flags(__entry->s.flags, "|",
+ {V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE, "SEPARATE_COLOUR_PLANE"},
+ {V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS, "QPPRIME_Y_ZERO_TRANSFORM_BYPASS"},
+ {V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO, "DELTA_PIC_ORDER_ALWAYS_ZERO"},
+ {V4L2_H264_SPS_FLAG_GAPS_IN_FRAME_NUM_VALUE_ALLOWED, "GAPS_IN_FRAME_NUM_VALUE_ALLOWED"},
+ {V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY, "FRAME_MBS_ONLY"},
+ {V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD, "MB_ADAPTIVE_FRAME_FIELD"},
+ {V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE, "DIRECT_8X8_INFERENCE"}
+ ))
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
+ TP_ARGS(p),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pps, p)),
+ TP_fast_assign(__entry->p = *p),
+ TP_printk("\npic_parameter_set_id %u\n"
+ "seq_parameter_set_id %u\n"
+ "num_slice_groups_minus1 %u\n"
+ "num_ref_idx_l0_default_active_minus1 %u\n"
+ "num_ref_idx_l1_default_active_minus1 %u\n"
+ "weighted_bipred_idc %u\n"
+ "pic_init_qp_minus26 %d\n"
+ "pic_init_qs_minus26 %d\n"
+ "chroma_qp_index_offset %d\n"
+ "second_chroma_qp_index_offset %d\n"
+ "flags %s",
+ __entry->p.pic_parameter_set_id,
+ __entry->p.seq_parameter_set_id,
+ __entry->p.num_slice_groups_minus1,
+ __entry->p.num_ref_idx_l0_default_active_minus1,
+ __entry->p.num_ref_idx_l1_default_active_minus1,
+ __entry->p.weighted_bipred_idc,
+ __entry->p.pic_init_qp_minus26,
+ __entry->p.pic_init_qs_minus26,
+ __entry->p.chroma_qp_index_offset,
+ __entry->p.second_chroma_qp_index_offset,
+ __print_flags(__entry->p.flags, "|",
+ {V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE, "ENTROPY_CODING_MODE"},
+ {V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT, "BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT"},
+ {V4L2_H264_PPS_FLAG_WEIGHTED_PRED, "WEIGHTED_PRED"},
+ {V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT, "DEBLOCKING_FILTER_CONTROL_PRESENT"},
+ {V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED, "CONSTRAINED_INTRA_PRED"},
+ {V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT, "REDUNDANT_PIC_CNT_PRESENT"},
+ {V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE, "TRANSFORM_8X8_MODE"},
+ {V4L2_H264_PPS_FLAG_SCALING_MATRIX_PRESENT, "SCALING_MATRIX_PRESENT"}
+ ))
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_h264_scaling_matrix_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
+ TP_ARGS(s),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_scaling_matrix, s)),
+ TP_fast_assign(__entry->s = *s),
+ TP_printk("\nscaling_list_4x4 {%s}\nscaling_list_8x8 {%s}",
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->s.scaling_list_4x4,
+ sizeof(__entry->s.scaling_list_4x4),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->s.scaling_list_8x8,
+ sizeof(__entry->s.scaling_list_8x8),
+ false)
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
+ TP_ARGS(p),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pred_weights, p)),
+ TP_fast_assign(__entry->p = *p),
+ TP_printk("\nluma_log2_weight_denom %u\n"
+ "chroma_log2_weight_denom %u\n"
+ "weight_factor[0].luma_weight %s\n"
+ "weight_factor[0].luma_offset %s\n"
+ "weight_factor[0].chroma_weight {%s}\n"
+ "weight_factor[0].chroma_offset {%s}\n"
+ "weight_factor[1].luma_weight %s\n"
+ "weight_factor[1].luma_offset %s\n"
+ "weight_factor[1].chroma_weight {%s}\n"
+ "weight_factor[1].chroma_offset {%s}\n",
+ __entry->p.luma_log2_weight_denom,
+ __entry->p.chroma_log2_weight_denom,
+ __print_array(__entry->p.weight_factors[0].luma_weight,
+ ARRAY_SIZE(__entry->p.weight_factors[0].luma_weight),
+ sizeof(__entry->p.weight_factors[0].luma_weight[0])),
+ __print_array(__entry->p.weight_factors[0].luma_offset,
+ ARRAY_SIZE(__entry->p.weight_factors[0].luma_offset),
+ sizeof(__entry->p.weight_factors[0].luma_offset[0])),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.weight_factors[0].chroma_weight,
+ sizeof(__entry->p.weight_factors[0].chroma_weight),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.weight_factors[0].chroma_offset,
+ sizeof(__entry->p.weight_factors[0].chroma_offset),
+ false),
+ __print_array(__entry->p.weight_factors[1].luma_weight,
+ ARRAY_SIZE(__entry->p.weight_factors[1].luma_weight),
+ sizeof(__entry->p.weight_factors[1].luma_weight[0])),
+ __print_array(__entry->p.weight_factors[1].luma_offset,
+ ARRAY_SIZE(__entry->p.weight_factors[1].luma_offset),
+ sizeof(__entry->p.weight_factors[1].luma_offset[0])),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.weight_factors[1].chroma_weight,
+ sizeof(__entry->p.weight_factors[1].chroma_weight),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.weight_factors[1].chroma_offset,
+ sizeof(__entry->p.weight_factors[1].chroma_offset),
+ false)
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
+ TP_ARGS(s),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_slice_params, s)),
+ TP_fast_assign(__entry->s = *s),
+ TP_printk("\nheader_bit_size %u\n"
+ "first_mb_in_slice %u\n"
+ "slice_type %s\n"
+ "colour_plane_id %u\n"
+ "redundant_pic_cnt %u\n"
+ "cabac_init_idc %u\n"
+ "slice_qp_delta %d\n"
+ "slice_qs_delta %d\n"
+ "disable_deblocking_filter_idc %u\n"
+ "slice_alpha_c0_offset_div2 %u\n"
+ "slice_beta_offset_div2 %u\n"
+ "num_ref_idx_l0_active_minus1 %u\n"
+ "num_ref_idx_l1_active_minus1 %u\n"
+ "flags %s",
+ __entry->s.header_bit_size,
+ __entry->s.first_mb_in_slice,
+ __print_symbolic(__entry->s.slice_type,
+ {V4L2_H264_SLICE_TYPE_P, "P"},
+ {V4L2_H264_SLICE_TYPE_B, "B"},
+ {V4L2_H264_SLICE_TYPE_I, "I"},
+ {V4L2_H264_SLICE_TYPE_SP, "SP"},
+ {V4L2_H264_SLICE_TYPE_SI, "SI"}),
+ __entry->s.colour_plane_id,
+ __entry->s.redundant_pic_cnt,
+ __entry->s.cabac_init_idc,
+ __entry->s.slice_qp_delta,
+ __entry->s.slice_qs_delta,
+ __entry->s.disable_deblocking_filter_idc,
+ __entry->s.slice_alpha_c0_offset_div2,
+ __entry->s.slice_beta_offset_div2,
+ __entry->s.num_ref_idx_l0_active_minus1,
+ __entry->s.num_ref_idx_l1_active_minus1,
+ __print_flags(__entry->s.flags, "|",
+ {V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED, "DIRECT_SPATIAL_MV_PRED"},
+ {V4L2_H264_SLICE_FLAG_SP_FOR_SWITCH, "SP_FOR_SWITCH"})
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_h264_reference_tmpl,
+ TP_PROTO(const struct v4l2_h264_reference *r, int i),
+ TP_ARGS(r, i),
+ TP_STRUCT__entry(__field_struct(struct v4l2_h264_reference, r)
+ __field(int, i)),
+ TP_fast_assign(__entry->r = *r; __entry->i = i;),
+ TP_printk("[%d]: fields %s index %u",
+ __entry->i,
+ __print_flags(__entry->r.fields, "|",
+ {V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
+ {V4L2_H264_BOTTOM_FIELD_REF, "BOTTOM_FIELD_REF"},
+ {V4L2_H264_FRAME_REF, "FRAME_REF"}),
+ __entry->r.index
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
+ TP_ARGS(d),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_decode_params, d)),
+ TP_fast_assign(__entry->d = *d),
+ TP_printk("\nnal_ref_idc %u\n"
+ "frame_num %u\n"
+ "top_field_order_cnt %d\n"
+ "bottom_field_order_cnt %d\n"
+ "idr_pic_id %u\n"
+ "pic_order_cnt_lsb %u\n"
+ "delta_pic_order_cnt_bottom %d\n"
+ "delta_pic_order_cnt0 %d\n"
+ "delta_pic_order_cnt1 %d\n"
+ "dec_ref_pic_marking_bit_size %u\n"
+ "pic_order_cnt_bit_size %u\n"
+ "slice_group_change_cycle %u\n"
+ "flags %s\n",
+ __entry->d.nal_ref_idc,
+ __entry->d.frame_num,
+ __entry->d.top_field_order_cnt,
+ __entry->d.bottom_field_order_cnt,
+ __entry->d.idr_pic_id,
+ __entry->d.pic_order_cnt_lsb,
+ __entry->d.delta_pic_order_cnt_bottom,
+ __entry->d.delta_pic_order_cnt0,
+ __entry->d.delta_pic_order_cnt1,
+ __entry->d.dec_ref_pic_marking_bit_size,
+ __entry->d.pic_order_cnt_bit_size,
+ __entry->d.slice_group_change_cycle,
+ __print_flags(__entry->d.flags, "|",
+ {V4L2_H264_DECODE_PARAM_FLAG_IDR_PIC, "IDR_PIC"},
+ {V4L2_H264_DECODE_PARAM_FLAG_FIELD_PIC, "FIELD_PIC"},
+ {V4L2_H264_DECODE_PARAM_FLAG_BOTTOM_FIELD, "BOTTOM_FIELD"},
+ {V4L2_H264_DECODE_PARAM_FLAG_PFRAME, "PFRAME"},
+ {V4L2_H264_DECODE_PARAM_FLAG_BFRAME, "BFRAME"})
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
+ TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
+ TP_ARGS(e, i),
+ TP_STRUCT__entry(__field_struct(struct v4l2_h264_dpb_entry, e)
+ __field(int, i)),
+ TP_fast_assign(__entry->e = *e; __entry->i = i;),
+ TP_printk("[%d]: reference_ts %llu, pic_num %u frame_num %u fields %s "
+ "top_field_order_cnt %d bottom_field_order_cnt %d flags %s",
+ __entry->i,
+ __entry->e.reference_ts,
+ __entry->e.pic_num,
+ __entry->e.frame_num,
+ __print_flags(__entry->e.fields, "|",
+ {V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
+ {V4L2_H264_BOTTOM_FIELD_REF, "BOTTOM_FIELD_REF"},
+ {V4L2_H264_FRAME_REF, "FRAME_REF"}),
+ __entry->e.top_field_order_cnt,
+ __entry->e.bottom_field_order_cnt,
+ __print_flags(__entry->e.flags, "|",
+ {V4L2_H264_DPB_ENTRY_FLAG_VALID, "VALID"},
+ {V4L2_H264_DPB_ENTRY_FLAG_ACTIVE, "ACTIVE"},
+ {V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM, "LONG_TERM"},
+ {V4L2_H264_DPB_ENTRY_FLAG_FIELD, "FIELD"})
+
+ )
+);
+
+DEFINE_EVENT(v4l2_ctrl_h264_sps_tmpl, v4l2_ctrl_h264_sps,
+ TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
+ TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_ctrl_h264_pps_tmpl, v4l2_ctrl_h264_pps,
+ TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
+ TP_ARGS(p)
+);
+
+DEFINE_EVENT(v4l2_ctrl_h264_scaling_matrix_tmpl, v4l2_ctrl_h264_scaling_matrix,
+ TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
+ TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_ctrl_h264_pred_weights_tmpl, v4l2_ctrl_h264_pred_weights,
+ TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
+ TP_ARGS(p)
+);
+
+DEFINE_EVENT(v4l2_ctrl_h264_slice_params_tmpl, v4l2_ctrl_h264_slice_params,
+ TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
+ TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_h264_reference_tmpl, v4l2_h264_ref_pic_list0,
+ TP_PROTO(const struct v4l2_h264_reference *r, int i),
+ TP_ARGS(r, i)
+);
+
+DEFINE_EVENT(v4l2_h264_reference_tmpl, v4l2_h264_ref_pic_list1,
+ TP_PROTO(const struct v4l2_h264_reference *r, int i),
+ TP_ARGS(r, i)
+);
+
+DEFINE_EVENT(v4l2_ctrl_h264_decode_params_tmpl, v4l2_ctrl_h264_decode_params,
+ TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
+ TP_ARGS(d)
+);
+
+DEFINE_EVENT(v4l2_h264_dpb_entry_tmpl, v4l2_h264_dpb_entry,
+ TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
+ TP_ARGS(e, i)
+);
+
+/* HEVC controls */
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
+ TP_ARGS(s),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_sps, s)),
+ TP_fast_assign(__entry->s = *s),
+ TP_printk("\nvideo_parameter_set_id %u\n"
+ "seq_parameter_set_id %u\n"
+ "pic_width_in_luma_samples %u\n"
+ "pic_height_in_luma_samples %u\n"
+ "bit_depth_luma_minus8 %u\n"
+ "bit_depth_chroma_minus8 %u\n"
+ "log2_max_pic_order_cnt_lsb_minus4 %u\n"
+ "sps_max_dec_pic_buffering_minus1 %u\n"
+ "sps_max_num_reorder_pics %u\n"
+ "sps_max_latency_increase_plus1 %u\n"
+ "log2_min_luma_coding_block_size_minus3 %u\n"
+ "log2_diff_max_min_luma_coding_block_size %u\n"
+ "log2_min_luma_transform_block_size_minus2 %u\n"
+ "log2_diff_max_min_luma_transform_block_size %u\n"
+ "max_transform_hierarchy_depth_inter %u\n"
+ "max_transform_hierarchy_depth_intra %u\n"
+ "pcm_sample_bit_depth_luma_minus1 %u\n"
+ "pcm_sample_bit_depth_chroma_minus1 %u\n"
+ "log2_min_pcm_luma_coding_block_size_minus3 %u\n"
+ "log2_diff_max_min_pcm_luma_coding_block_size %u\n"
+ "num_short_term_ref_pic_sets %u\n"
+ "num_long_term_ref_pics_sps %u\n"
+ "chroma_format_idc %u\n"
+ "sps_max_sub_layers_minus1 %u\n"
+ "flags %s",
+ __entry->s.video_parameter_set_id,
+ __entry->s.seq_parameter_set_id,
+ __entry->s.pic_width_in_luma_samples,
+ __entry->s.pic_height_in_luma_samples,
+ __entry->s.bit_depth_luma_minus8,
+ __entry->s.bit_depth_chroma_minus8,
+ __entry->s.log2_max_pic_order_cnt_lsb_minus4,
+ __entry->s.sps_max_dec_pic_buffering_minus1,
+ __entry->s.sps_max_num_reorder_pics,
+ __entry->s.sps_max_latency_increase_plus1,
+ __entry->s.log2_min_luma_coding_block_size_minus3,
+ __entry->s.log2_diff_max_min_luma_coding_block_size,
+ __entry->s.log2_min_luma_transform_block_size_minus2,
+ __entry->s.log2_diff_max_min_luma_transform_block_size,
+ __entry->s.max_transform_hierarchy_depth_inter,
+ __entry->s.max_transform_hierarchy_depth_intra,
+ __entry->s.pcm_sample_bit_depth_luma_minus1,
+ __entry->s.pcm_sample_bit_depth_chroma_minus1,
+ __entry->s.log2_min_pcm_luma_coding_block_size_minus3,
+ __entry->s.log2_diff_max_min_pcm_luma_coding_block_size,
+ __entry->s.num_short_term_ref_pic_sets,
+ __entry->s.num_long_term_ref_pics_sps,
+ __entry->s.chroma_format_idc,
+ __entry->s.sps_max_sub_layers_minus1,
+ __print_flags(__entry->s.flags, "|",
+ {V4L2_HEVC_SPS_FLAG_SEPARATE_COLOUR_PLANE, "SEPARATE_COLOUR_PLANE"},
+ {V4L2_HEVC_SPS_FLAG_SCALING_LIST_ENABLED, "SCALING_LIST_ENABLED"},
+ {V4L2_HEVC_SPS_FLAG_AMP_ENABLED, "AMP_ENABLED"},
+ {V4L2_HEVC_SPS_FLAG_SAMPLE_ADAPTIVE_OFFSET, "SAMPLE_ADAPTIVE_OFFSET"},
+ {V4L2_HEVC_SPS_FLAG_PCM_ENABLED, "PCM_ENABLED"},
+ {V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED, "V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED"},
+ {V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT, "LONG_TERM_REF_PICS_PRESENT"},
+ {V4L2_HEVC_SPS_FLAG_SPS_TEMPORAL_MVP_ENABLED, "TEMPORAL_MVP_ENABLED"},
+ {V4L2_HEVC_SPS_FLAG_STRONG_INTRA_SMOOTHING_ENABLED, "STRONG_INTRA_SMOOTHING_ENABLED"}
+ ))
+
+);
+
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
+ TP_ARGS(p),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_pps, p)),
+ TP_fast_assign(__entry->p = *p),
+ TP_printk("\npic_parameter_set_id %u\n"
+ "num_extra_slice_header_bits %u\n"
+ "num_ref_idx_l0_default_active_minus1 %u\n"
+ "num_ref_idx_l1_default_active_minus1 %u\n"
+ "init_qp_minus26 %d\n"
+ "diff_cu_qp_delta_depth %u\n"
+ "pps_cb_qp_offset %d\n"
+ "pps_cr_qp_offset %d\n"
+ "num_tile_columns_minus1 %d\n"
+ "num_tile_rows_minus1 %d\n"
+ "column_width_minus1 %s\n"
+ "row_height_minus1 %s\n"
+ "pps_beta_offset_div2 %d\n"
+ "pps_tc_offset_div2 %d\n"
+ "log2_parallel_merge_level_minus2 %u\n"
+ "flags %s",
+ __entry->p.pic_parameter_set_id,
+ __entry->p.num_extra_slice_header_bits,
+ __entry->p.num_ref_idx_l0_default_active_minus1,
+ __entry->p.num_ref_idx_l1_default_active_minus1,
+ __entry->p.init_qp_minus26,
+ __entry->p.diff_cu_qp_delta_depth,
+ __entry->p.pps_cb_qp_offset,
+ __entry->p.pps_cr_qp_offset,
+ __entry->p.num_tile_columns_minus1,
+ __entry->p.num_tile_rows_minus1,
+ __print_array(__entry->p.column_width_minus1,
+ ARRAY_SIZE(__entry->p.column_width_minus1),
+ sizeof(__entry->p.column_width_minus1[0])),
+ __print_array(__entry->p.row_height_minus1,
+ ARRAY_SIZE(__entry->p.row_height_minus1),
+ sizeof(__entry->p.row_height_minus1[0])),
+ __entry->p.pps_beta_offset_div2,
+ __entry->p.pps_tc_offset_div2,
+ __entry->p.log2_parallel_merge_level_minus2,
+ __print_flags(__entry->p.flags, "|",
+ {V4L2_HEVC_PPS_FLAG_DEPENDENT_SLICE_SEGMENT_ENABLED, "DEPENDENT_SLICE_SEGMENT_ENABLED"},
+ {V4L2_HEVC_PPS_FLAG_OUTPUT_FLAG_PRESENT, "OUTPUT_FLAG_PRESENT"},
+ {V4L2_HEVC_PPS_FLAG_SIGN_DATA_HIDING_ENABLED, "SIGN_DATA_HIDING_ENABLED"},
+ {V4L2_HEVC_PPS_FLAG_CABAC_INIT_PRESENT, "CABAC_INIT_PRESENT"},
+ {V4L2_HEVC_PPS_FLAG_CONSTRAINED_INTRA_PRED, "CONSTRAINED_INTRA_PRED"},
+ {V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED, "CU_QP_DELTA_ENABLED"},
+ {V4L2_HEVC_PPS_FLAG_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT, "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT"},
+ {V4L2_HEVC_PPS_FLAG_WEIGHTED_PRED, "WEIGHTED_PRED"},
+ {V4L2_HEVC_PPS_FLAG_WEIGHTED_BIPRED, "WEIGHTED_BIPRED"},
+ {V4L2_HEVC_PPS_FLAG_TRANSQUANT_BYPASS_ENABLED, "TRANSQUANT_BYPASS_ENABLED"},
+ {V4L2_HEVC_PPS_FLAG_TILES_ENABLED, "TILES_ENABLED"},
+ {V4L2_HEVC_PPS_FLAG_ENTROPY_CODING_SYNC_ENABLED, "ENTROPY_CODING_SYNC_ENABLED"},
+ {V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED, "LOOP_FILTER_ACROSS_TILES_ENABLED"},
+ {V4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED, "PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED"},
+ {V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_OVERRIDE_ENABLED, "DEBLOCKING_FILTER_OVERRIDE_ENABLED"},
+ {V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER, "DISABLE_DEBLOCKING_FILTER"},
+ {V4L2_HEVC_PPS_FLAG_LISTS_MODIFICATION_PRESENT, "LISTS_MODIFICATION_PRESENT"},
+ {V4L2_HEVC_PPS_FLAG_SLICE_SEGMENT_HEADER_EXTENSION_PRESENT, "SLICE_SEGMENT_HEADER_EXTENSION_PRESENT"},
+ {V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT, "DEBLOCKING_FILTER_CONTROL_PRESENT"},
+ {V4L2_HEVC_PPS_FLAG_UNIFORM_SPACING, "UNIFORM_SPACING"}
+ ))
+
+);
+
+
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
+ TP_ARGS(s),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_slice_params, s)),
+ TP_fast_assign(__entry->s = *s),
+ TP_printk("\nbit_size %u\n"
+ "data_byte_offset %u\n"
+ "num_entry_point_offsets %u\n"
+ "nal_unit_type %u\n"
+ "nuh_temporal_id_plus1 %u\n"
+ "slice_type %u\n"
+ "colour_plane_id %u\n"
+ "slice_pic_order_cnt %d\n"
+ "num_ref_idx_l0_active_minus1 %u\n"
+ "num_ref_idx_l1_active_minus1 %u\n"
+ "collocated_ref_idx %u\n"
+ "five_minus_max_num_merge_cand %u\n"
+ "slice_qp_delta %d\n"
+ "slice_cb_qp_offset %d\n"
+ "slice_cr_qp_offset %d\n"
+ "slice_act_y_qp_offset %d\n"
+ "slice_act_cb_qp_offset %d\n"
+ "slice_act_cr_qp_offset %d\n"
+ "slice_beta_offset_div2 %d\n"
+ "slice_tc_offset_div2 %d\n"
+ "pic_struct %u\n"
+ "slice_segment_addr %u\n"
+ "ref_idx_l0 %s\n"
+ "ref_idx_l1 %s\n"
+ "short_term_ref_pic_set_size %u\n"
+ "long_term_ref_pic_set_size %u\n"
+ "flags %s",
+ __entry->s.bit_size,
+ __entry->s.data_byte_offset,
+ __entry->s.num_entry_point_offsets,
+ __entry->s.nal_unit_type,
+ __entry->s.nuh_temporal_id_plus1,
+ __entry->s.slice_type,
+ __entry->s.colour_plane_id,
+ __entry->s.slice_pic_order_cnt,
+ __entry->s.num_ref_idx_l0_active_minus1,
+ __entry->s.num_ref_idx_l1_active_minus1,
+ __entry->s.collocated_ref_idx,
+ __entry->s.five_minus_max_num_merge_cand,
+ __entry->s.slice_qp_delta,
+ __entry->s.slice_cb_qp_offset,
+ __entry->s.slice_cr_qp_offset,
+ __entry->s.slice_act_y_qp_offset,
+ __entry->s.slice_act_cb_qp_offset,
+ __entry->s.slice_act_cr_qp_offset,
+ __entry->s.slice_beta_offset_div2,
+ __entry->s.slice_tc_offset_div2,
+ __entry->s.pic_struct,
+ __entry->s.slice_segment_addr,
+ __print_array(__entry->s.ref_idx_l0,
+ ARRAY_SIZE(__entry->s.ref_idx_l0),
+ sizeof(__entry->s.ref_idx_l0[0])),
+ __print_array(__entry->s.ref_idx_l1,
+ ARRAY_SIZE(__entry->s.ref_idx_l1),
+ sizeof(__entry->s.ref_idx_l1[0])),
+ __entry->s.short_term_ref_pic_set_size,
+ __entry->s.long_term_ref_pic_set_size,
+ __print_flags(__entry->s.flags, "|",
+ {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_LUMA, "SLICE_SAO_LUMA"},
+ {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_CHROMA, "SLICE_SAO_CHROMA"},
+ {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_TEMPORAL_MVP_ENABLED, "SLICE_TEMPORAL_MVP_ENABLED"},
+ {V4L2_HEVC_SLICE_PARAMS_FLAG_MVD_L1_ZERO, "MVD_L1_ZERO"},
+ {V4L2_HEVC_SLICE_PARAMS_FLAG_CABAC_INIT, "CABAC_INIT"},
+ {V4L2_HEVC_SLICE_PARAMS_FLAG_COLLOCATED_FROM_L0, "COLLOCATED_FROM_L0"},
+ {V4L2_HEVC_SLICE_PARAMS_FLAG_USE_INTEGER_MV, "USE_INTEGER_MV"},
+ {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_DEBLOCKING_FILTER_DISABLED, "SLICE_DEBLOCKING_FILTER_DISABLED"},
+ {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED, "SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED"},
+ {V4L2_HEVC_SLICE_PARAMS_FLAG_DEPENDENT_SLICE_SEGMENT, "DEPENDENT_SLICE_SEGMENT"}
+
+ ))
+);
+
+DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
+ TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
+ TP_ARGS(p),
+ TP_STRUCT__entry(__field_struct(struct v4l2_hevc_pred_weight_table, p)),
+ TP_fast_assign(__entry->p = *p),
+ TP_printk("\ndelta_luma_weight_l0 %s\n"
+ "luma_offset_l0 %s\n"
+ "delta_chroma_weight_l0 {%s}\n"
+ "chroma_offset_l0 {%s}\n"
+ "delta_luma_weight_l1 %s\n"
+ "luma_offset_l1 %s\n"
+ "delta_chroma_weight_l1 {%s}\n"
+ "chroma_offset_l1 {%s}\n"
+ "luma_log2_weight_denom %d\n"
+ "delta_chroma_log2_weight_denom %d\n",
+ __print_array(__entry->p.delta_luma_weight_l0,
+ ARRAY_SIZE(__entry->p.delta_luma_weight_l0),
+ sizeof(__entry->p.delta_luma_weight_l0[0])),
+ __print_array(__entry->p.luma_offset_l0,
+ ARRAY_SIZE(__entry->p.luma_offset_l0),
+ sizeof(__entry->p.luma_offset_l0[0])),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.delta_chroma_weight_l0,
+ sizeof(__entry->p.delta_chroma_weight_l0),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.chroma_offset_l0,
+ sizeof(__entry->p.chroma_offset_l0),
+ false),
+ __print_array(__entry->p.delta_luma_weight_l1,
+ ARRAY_SIZE(__entry->p.delta_luma_weight_l1),
+ sizeof(__entry->p.delta_luma_weight_l1[0])),
+ __print_array(__entry->p.luma_offset_l1,
+ ARRAY_SIZE(__entry->p.luma_offset_l1),
+ sizeof(__entry->p.luma_offset_l1[0])),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.delta_chroma_weight_l1,
+ sizeof(__entry->p.delta_chroma_weight_l1),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.chroma_offset_l1,
+ sizeof(__entry->p.chroma_offset_l1),
+ false),
+ __entry->p.luma_log2_weight_denom,
+ __entry->p.delta_chroma_log2_weight_denom
+
+ ))
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_scaling_matrix_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
+ TP_ARGS(s),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_scaling_matrix, s)),
+ TP_fast_assign(__entry->s = *s),
+ TP_printk("\nscaling_list_4x4 {%s}\n"
+ "scaling_list_8x8 {%s}\n"
+ "scaling_list_16x16 {%s}\n"
+ "scaling_list_32x32 {%s}\n"
+ "scaling_list_dc_coef_16x16 %s\n"
+ "scaling_list_dc_coef_32x32 %s\n",
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->s.scaling_list_4x4,
+ sizeof(__entry->s.scaling_list_4x4),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->s.scaling_list_8x8,
+ sizeof(__entry->s.scaling_list_8x8),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->s.scaling_list_16x16,
+ sizeof(__entry->s.scaling_list_16x16),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->s.scaling_list_32x32,
+ sizeof(__entry->s.scaling_list_32x32),
+ false),
+ __print_array(__entry->s.scaling_list_dc_coef_16x16,
+ ARRAY_SIZE(__entry->s.scaling_list_dc_coef_16x16),
+ sizeof(__entry->s.scaling_list_dc_coef_16x16[0])),
+ __print_array(__entry->s.scaling_list_dc_coef_32x32,
+ ARRAY_SIZE(__entry->s.scaling_list_dc_coef_32x32),
+ sizeof(__entry->s.scaling_list_dc_coef_32x32[0]))
+ ))
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
+ TP_ARGS(d),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_decode_params, d)),
+ TP_fast_assign(__entry->d = *d),
+ TP_printk("\npic_order_cnt_val %d\n"
+ "short_term_ref_pic_set_size %u\n"
+ "long_term_ref_pic_set_size %u\n"
+ "num_active_dpb_entries %u\n"
+ "num_poc_st_curr_before %u\n"
+ "num_poc_st_curr_after %u\n"
+ "num_poc_lt_curr %u\n"
+ "poc_st_curr_before %s\n"
+ "poc_st_curr_after %s\n"
+ "poc_lt_curr %s\n"
+ "flags %s",
+ __entry->d.pic_order_cnt_val,
+ __entry->d.short_term_ref_pic_set_size,
+ __entry->d.long_term_ref_pic_set_size,
+ __entry->d.num_active_dpb_entries,
+ __entry->d.num_poc_st_curr_before,
+ __entry->d.num_poc_st_curr_after,
+ __entry->d.num_poc_lt_curr,
+ __print_array(__entry->d.poc_st_curr_before,
+ ARRAY_SIZE(__entry->d.poc_st_curr_before),
+ sizeof(__entry->d.poc_st_curr_before[0])),
+ __print_array(__entry->d.poc_st_curr_after,
+ ARRAY_SIZE(__entry->d.poc_st_curr_after),
+ sizeof(__entry->d.poc_st_curr_after[0])),
+ __print_array(__entry->d.poc_lt_curr,
+ ARRAY_SIZE(__entry->d.poc_lt_curr),
+ sizeof(__entry->d.poc_lt_curr[0])),
+ __print_flags(__entry->d.flags, "|",
+ {V4L2_HEVC_DECODE_PARAM_FLAG_IRAP_PIC, "IRAP_PIC"},
+ {V4L2_HEVC_DECODE_PARAM_FLAG_IDR_PIC, "IDR_PIC"},
+ {V4L2_HEVC_DECODE_PARAM_FLAG_NO_OUTPUT_OF_PRIOR, "NO_OUTPUT_OF_PRIOR"}
+ ))
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
+ TP_ARGS(lt),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_lt_rps, lt)),
+ TP_fast_assign(__entry->lt = *lt),
+ TP_printk("\nflags %s\n"
+ "lt_ref_pic_poc_lsb_sps %x\n",
+ __print_flags(__entry->lt.flags, "|",
+ {V4L2_HEVC_EXT_SPS_LT_RPS_FLAG_USED_LT, "USED_LT"}
+ ),
+ __entry->lt.lt_ref_pic_poc_lsb_sps
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
+ TP_ARGS(st),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_st_rps, st)),
+ TP_fast_assign(__entry->st = *st),
+ TP_printk("\nflags %s\n"
+ "delta_idx_minus1: %u\n"
+ "delta_rps_sign: %u\n"
+ "abs_delta_rps_minus1: %u\n"
+ "num_negative_pics: %u\n"
+ "num_positive_pics: %u\n"
+ "used_by_curr_pic: %08x\n"
+ "use_delta_flag: %08x\n"
+ "delta_poc_s0_minus1: %s\n"
+ "delta_poc_s1_minus1: %s\n",
+ __print_flags(__entry->st.flags, "|",
+ {V4L2_HEVC_EXT_SPS_ST_RPS_FLAG_INTER_REF_PIC_SET_PRED, "INTER_REF_PIC_SET_PRED"}
+ ),
+ __entry->st.delta_idx_minus1,
+ __entry->st.delta_rps_sign,
+ __entry->st.abs_delta_rps_minus1,
+ __entry->st.num_negative_pics,
+ __entry->st.num_positive_pics,
+ __entry->st.used_by_curr_pic,
+ __entry->st.use_delta_flag,
+ __print_array(__entry->st.delta_poc_s0_minus1,
+ ARRAY_SIZE(__entry->st.delta_poc_s0_minus1),
+ sizeof(__entry->st.delta_poc_s0_minus1[0])),
+ __print_array(__entry->st.delta_poc_s1_minus1,
+ ARRAY_SIZE(__entry->st.delta_poc_s1_minus1),
+ sizeof(__entry->st.delta_poc_s1_minus1[0]))
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_hevc_dpb_entry_tmpl,
+ TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
+ TP_ARGS(e),
+ TP_STRUCT__entry(__field_struct(struct v4l2_hevc_dpb_entry, e)),
+ TP_fast_assign(__entry->e = *e),
+ TP_printk("\ntimestamp %llu\n"
+ "flags %s\n"
+ "field_pic %u\n"
+ "pic_order_cnt_val %d\n",
+ __entry->e.timestamp,
+ __print_flags(__entry->e.flags, "|",
+ {V4L2_HEVC_DPB_ENTRY_LONG_TERM_REFERENCE, "LONG_TERM_REFERENCE"}
+ ),
+ __entry->e.field_pic,
+ __entry->e.pic_order_cnt_val
+ ))
+
+DEFINE_EVENT(v4l2_ctrl_hevc_sps_tmpl, v4l2_ctrl_hevc_sps,
+ TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
+ TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_ctrl_hevc_pps_tmpl, v4l2_ctrl_hevc_pps,
+ TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
+ TP_ARGS(p)
+);
+
+DEFINE_EVENT(v4l2_ctrl_hevc_slice_params_tmpl, v4l2_ctrl_hevc_slice_params,
+ TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
+ TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_hevc_pred_weight_table_tmpl, v4l2_hevc_pred_weight_table,
+ TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
+ TP_ARGS(p)
+);
+
+DEFINE_EVENT(v4l2_ctrl_hevc_scaling_matrix_tmpl, v4l2_ctrl_hevc_scaling_matrix,
+ TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
+ TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_ctrl_hevc_decode_params_tmpl, v4l2_ctrl_hevc_decode_params,
+ TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
+ TP_ARGS(d)
+);
+
+DEFINE_EVENT(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl, v4l2_ctrl_hevc_ext_sps_lt_rps,
+ TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
+ TP_ARGS(lt)
+);
+
+DEFINE_EVENT(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl, v4l2_ctrl_hevc_ext_sps_st_rps,
+ TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
+ TP_ARGS(st)
+);
+
+DEFINE_EVENT(v4l2_hevc_dpb_entry_tmpl, v4l2_hevc_dpb_entry,
+ TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
+ TP_ARGS(e)
+);
+
+/* MPEG2 controls */
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_seq_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
+ TP_ARGS(s),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_sequence, s)),
+ TP_fast_assign(__entry->s = *s;),
+ TP_printk("\nhorizontal_size %u\nvertical_size %u\nvbv_buffer_size %u\n"
+ "profile_and_level_indication %u\nchroma_format %u\nflags %s\n",
+ __entry->s.horizontal_size,
+ __entry->s.vertical_size,
+ __entry->s.vbv_buffer_size,
+ __entry->s.profile_and_level_indication,
+ __entry->s.chroma_format,
+ __print_flags(__entry->s.flags, "|",
+ {V4L2_MPEG2_SEQ_FLAG_PROGRESSIVE, "PROGRESSIVE"})
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_pic_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
+ TP_ARGS(p),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_picture, p)),
+ TP_fast_assign(__entry->p = *p;),
+ TP_printk("\nbackward_ref_ts %llu\nforward_ref_ts %llu\nflags %s\nf_code {%s}\n"
+ "picture_coding_type: %u\npicture_structure %u\nintra_dc_precision %u\n",
+ __entry->p.backward_ref_ts,
+ __entry->p.forward_ref_ts,
+ __print_flags(__entry->p.flags, "|",
+ {V4L2_MPEG2_PIC_FLAG_TOP_FIELD_FIRST, "TOP_FIELD_FIRST"},
+ {V4L2_MPEG2_PIC_FLAG_FRAME_PRED_DCT, "FRAME_PRED_DCT"},
+ {V4L2_MPEG2_PIC_FLAG_CONCEALMENT_MV, "CONCEALMENT_MV"},
+ {V4L2_MPEG2_PIC_FLAG_Q_SCALE_TYPE, "Q_SCALE_TYPE"},
+ {V4L2_MPEG2_PIC_FLAG_INTRA_VLC, "INTA_VLC"},
+ {V4L2_MPEG2_PIC_FLAG_ALT_SCAN, "ALT_SCAN"},
+ {V4L2_MPEG2_PIC_FLAG_REPEAT_FIRST, "REPEAT_FIRST"},
+ {V4L2_MPEG2_PIC_FLAG_PROGRESSIVE, "PROGRESSIVE"}),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.f_code,
+ sizeof(__entry->p.f_code),
+ false),
+ __entry->p.picture_coding_type,
+ __entry->p.picture_structure,
+ __entry->p.intra_dc_precision
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_quant_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
+ TP_ARGS(q),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_quantisation, q)),
+ TP_fast_assign(__entry->q = *q;),
+ TP_printk("\nintra_quantiser_matrix %s\nnon_intra_quantiser_matrix %s\n"
+ "chroma_intra_quantiser_matrix %s\nchroma_non_intra_quantiser_matrix %s\n",
+ __print_array(__entry->q.intra_quantiser_matrix,
+ ARRAY_SIZE(__entry->q.intra_quantiser_matrix),
+ sizeof(__entry->q.intra_quantiser_matrix[0])),
+ __print_array(__entry->q.non_intra_quantiser_matrix,
+ ARRAY_SIZE(__entry->q.non_intra_quantiser_matrix),
+ sizeof(__entry->q.non_intra_quantiser_matrix[0])),
+ __print_array(__entry->q.chroma_intra_quantiser_matrix,
+ ARRAY_SIZE(__entry->q.chroma_intra_quantiser_matrix),
+ sizeof(__entry->q.chroma_intra_quantiser_matrix[0])),
+ __print_array(__entry->q.chroma_non_intra_quantiser_matrix,
+ ARRAY_SIZE(__entry->q.chroma_non_intra_quantiser_matrix),
+ sizeof(__entry->q.chroma_non_intra_quantiser_matrix[0]))
+ )
+)
+
+DEFINE_EVENT(v4l2_ctrl_mpeg2_seq_tmpl, v4l2_ctrl_mpeg2_sequence,
+ TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
+ TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_ctrl_mpeg2_pic_tmpl, v4l2_ctrl_mpeg2_picture,
+ TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
+ TP_ARGS(p)
+);
+
+DEFINE_EVENT(v4l2_ctrl_mpeg2_quant_tmpl, v4l2_ctrl_mpeg2_quantisation,
+ TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
+ TP_ARGS(q)
+);
+
+/* VP8 controls */
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_entropy_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
+ TP_ARGS(f),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
+ TP_fast_assign(__entry->f = *f;),
+ TP_printk("\nentropy.coeff_probs {%s}\n"
+ "entropy.y_mode_probs %s\n"
+ "entropy.uv_mode_probs %s\n"
+ "entropy.mv_probs {%s}",
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->f.entropy.coeff_probs,
+ sizeof(__entry->f.entropy.coeff_probs),
+ false),
+ __print_array(__entry->f.entropy.y_mode_probs,
+ ARRAY_SIZE(__entry->f.entropy.y_mode_probs),
+ sizeof(__entry->f.entropy.y_mode_probs[0])),
+ __print_array(__entry->f.entropy.uv_mode_probs,
+ ARRAY_SIZE(__entry->f.entropy.uv_mode_probs),
+ sizeof(__entry->f.entropy.uv_mode_probs[0])),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->f.entropy.mv_probs,
+ sizeof(__entry->f.entropy.mv_probs),
+ false)
+ )
+)
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
+ TP_ARGS(f),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
+ TP_fast_assign(__entry->f = *f;),
+ TP_printk("\nsegment.quant_update %s\n"
+ "segment.lf_update %s\n"
+ "segment.segment_probs %s\n"
+ "segment.flags %s\n"
+ "lf.ref_frm_delta %s\n"
+ "lf.mb_mode_delta %s\n"
+ "lf.sharpness_level %u\n"
+ "lf.level %u\n"
+ "lf.flags %s\n"
+ "quant.y_ac_qi %u\n"
+ "quant.y_dc_delta %d\n"
+ "quant.y2_dc_delta %d\n"
+ "quant.y2_ac_delta %d\n"
+ "quant.uv_dc_delta %d\n"
+ "quant.uv_ac_delta %d\n"
+ "coder_state.range %u\n"
+ "coder_state.value %u\n"
+ "coder_state.bit_count %u\n"
+ "width %u\n"
+ "height %u\n"
+ "horizontal_scale %u\n"
+ "vertical_scale %u\n"
+ "version %u\n"
+ "prob_skip_false %u\n"
+ "prob_intra %u\n"
+ "prob_last %u\n"
+ "prob_gf %u\n"
+ "num_dct_parts %u\n"
+ "first_part_size %u\n"
+ "first_part_header_bits %u\n"
+ "dct_part_sizes %s\n"
+ "last_frame_ts %llu\n"
+ "golden_frame_ts %llu\n"
+ "alt_frame_ts %llu\n"
+ "flags %s",
+ __print_array(__entry->f.segment.quant_update,
+ ARRAY_SIZE(__entry->f.segment.quant_update),
+ sizeof(__entry->f.segment.quant_update[0])),
+ __print_array(__entry->f.segment.lf_update,
+ ARRAY_SIZE(__entry->f.segment.lf_update),
+ sizeof(__entry->f.segment.lf_update[0])),
+ __print_array(__entry->f.segment.segment_probs,
+ ARRAY_SIZE(__entry->f.segment.segment_probs),
+ sizeof(__entry->f.segment.segment_probs[0])),
+ __print_flags(__entry->f.segment.flags, "|",
+ {V4L2_VP8_SEGMENT_FLAG_ENABLED, "SEGMENT_ENABLED"},
+ {V4L2_VP8_SEGMENT_FLAG_UPDATE_MAP, "SEGMENT_UPDATE_MAP"},
+ {V4L2_VP8_SEGMENT_FLAG_UPDATE_FEATURE_DATA, "SEGMENT_UPDATE_FEATURE_DATA"},
+ {V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE, "SEGMENT_DELTA_VALUE_MODE"}),
+ __print_array(__entry->f.lf.ref_frm_delta,
+ ARRAY_SIZE(__entry->f.lf.ref_frm_delta),
+ sizeof(__entry->f.lf.ref_frm_delta[0])),
+ __print_array(__entry->f.lf.mb_mode_delta,
+ ARRAY_SIZE(__entry->f.lf.mb_mode_delta),
+ sizeof(__entry->f.lf.mb_mode_delta[0])),
+ __entry->f.lf.sharpness_level,
+ __entry->f.lf.level,
+ __print_flags(__entry->f.lf.flags, "|",
+ {V4L2_VP8_LF_ADJ_ENABLE, "LF_ADJ_ENABLED"},
+ {V4L2_VP8_LF_DELTA_UPDATE, "LF_DELTA_UPDATE"},
+ {V4L2_VP8_LF_FILTER_TYPE_SIMPLE, "LF_FILTER_TYPE_SIMPLE"}),
+ __entry->f.quant.y_ac_qi,
+ __entry->f.quant.y_dc_delta,
+ __entry->f.quant.y2_dc_delta,
+ __entry->f.quant.y2_ac_delta,
+ __entry->f.quant.uv_dc_delta,
+ __entry->f.quant.uv_ac_delta,
+ __entry->f.coder_state.range,
+ __entry->f.coder_state.value,
+ __entry->f.coder_state.bit_count,
+ __entry->f.width,
+ __entry->f.height,
+ __entry->f.horizontal_scale,
+ __entry->f.vertical_scale,
+ __entry->f.version,
+ __entry->f.prob_skip_false,
+ __entry->f.prob_intra,
+ __entry->f.prob_last,
+ __entry->f.prob_gf,
+ __entry->f.num_dct_parts,
+ __entry->f.first_part_size,
+ __entry->f.first_part_header_bits,
+ __print_array(__entry->f.dct_part_sizes,
+ ARRAY_SIZE(__entry->f.dct_part_sizes),
+ sizeof(__entry->f.dct_part_sizes[0])),
+ __entry->f.last_frame_ts,
+ __entry->f.golden_frame_ts,
+ __entry->f.alt_frame_ts,
+ __print_flags(__entry->f.flags, "|",
+ {V4L2_VP8_FRAME_FLAG_KEY_FRAME, "KEY_FRAME"},
+ {V4L2_VP8_FRAME_FLAG_EXPERIMENTAL, "EXPERIMENTAL"},
+ {V4L2_VP8_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
+ {V4L2_VP8_FRAME_FLAG_MB_NO_SKIP_COEFF, "MB_NO_SKIP_COEFF"},
+ {V4L2_VP8_FRAME_FLAG_SIGN_BIAS_GOLDEN, "SIGN_BIAS_GOLDEN"},
+ {V4L2_VP8_FRAME_FLAG_SIGN_BIAS_ALT, "SIGN_BIAS_ALT"})
+ )
+);
+
+DEFINE_EVENT(v4l2_ctrl_vp8_frame_tmpl, v4l2_ctrl_vp8_frame,
+ TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
+ TP_ARGS(f)
+);
+
+DEFINE_EVENT(v4l2_ctrl_vp8_entropy_tmpl, v4l2_ctrl_vp8_entropy,
+ TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
+ TP_ARGS(f)
+);
+
+/* VP9 controls */
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
+ TP_ARGS(f),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_frame, f)),
+ TP_fast_assign(__entry->f = *f;),
+ TP_printk("\nlf.ref_deltas %s\n"
+ "lf.mode_deltas %s\n"
+ "lf.level %u\n"
+ "lf.sharpness %u\n"
+ "lf.flags %s\n"
+ "quant.base_q_idx %u\n"
+ "quant.delta_q_y_dc %d\n"
+ "quant.delta_q_uv_dc %d\n"
+ "quant.delta_q_uv_ac %d\n"
+ "seg.feature_data {%s}\n"
+ "seg.feature_enabled %s\n"
+ "seg.tree_probs %s\n"
+ "seg.pred_probs %s\n"
+ "seg.flags %s\n"
+ "flags %s\n"
+ "compressed_header_size %u\n"
+ "uncompressed_header_size %u\n"
+ "frame_width_minus_1 %u\n"
+ "frame_height_minus_1 %u\n"
+ "render_width_minus_1 %u\n"
+ "render_height_minus_1 %u\n"
+ "last_frame_ts %llu\n"
+ "golden_frame_ts %llu\n"
+ "alt_frame_ts %llu\n"
+ "ref_frame_sign_bias %s\n"
+ "reset_frame_context %s\n"
+ "frame_context_idx %u\n"
+ "profile %u\n"
+ "bit_depth %u\n"
+ "interpolation_filter %s\n"
+ "tile_cols_log2 %u\n"
+ "tile_rows_log_2 %u\n"
+ "reference_mode %s\n",
+ __print_array(__entry->f.lf.ref_deltas,
+ ARRAY_SIZE(__entry->f.lf.ref_deltas),
+ sizeof(__entry->f.lf.ref_deltas[0])),
+ __print_array(__entry->f.lf.mode_deltas,
+ ARRAY_SIZE(__entry->f.lf.mode_deltas),
+ sizeof(__entry->f.lf.mode_deltas[0])),
+ __entry->f.lf.level,
+ __entry->f.lf.sharpness,
+ __print_flags(__entry->f.lf.flags, "|",
+ {V4L2_VP9_LOOP_FILTER_FLAG_DELTA_ENABLED, "DELTA_ENABLED"},
+ {V4L2_VP9_LOOP_FILTER_FLAG_DELTA_UPDATE, "DELTA_UPDATE"}),
+ __entry->f.quant.base_q_idx,
+ __entry->f.quant.delta_q_y_dc,
+ __entry->f.quant.delta_q_uv_dc,
+ __entry->f.quant.delta_q_uv_ac,
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->f.seg.feature_data,
+ sizeof(__entry->f.seg.feature_data),
+ false),
+ __print_array(__entry->f.seg.feature_enabled,
+ ARRAY_SIZE(__entry->f.seg.feature_enabled),
+ sizeof(__entry->f.seg.feature_enabled[0])),
+ __print_array(__entry->f.seg.tree_probs,
+ ARRAY_SIZE(__entry->f.seg.tree_probs),
+ sizeof(__entry->f.seg.tree_probs[0])),
+ __print_array(__entry->f.seg.pred_probs,
+ ARRAY_SIZE(__entry->f.seg.pred_probs),
+ sizeof(__entry->f.seg.pred_probs[0])),
+ __print_flags(__entry->f.seg.flags, "|",
+ {V4L2_VP9_SEGMENTATION_FLAG_ENABLED, "ENABLED"},
+ {V4L2_VP9_SEGMENTATION_FLAG_UPDATE_MAP, "UPDATE_MAP"},
+ {V4L2_VP9_SEGMENTATION_FLAG_TEMPORAL_UPDATE, "TEMPORAL_UPDATE"},
+ {V4L2_VP9_SEGMENTATION_FLAG_UPDATE_DATA, "UPDATE_DATA"},
+ {V4L2_VP9_SEGMENTATION_FLAG_ABS_OR_DELTA_UPDATE, "ABS_OR_DELTA_UPDATE"}),
+ __print_flags(__entry->f.flags, "|",
+ {V4L2_VP9_FRAME_FLAG_KEY_FRAME, "KEY_FRAME"},
+ {V4L2_VP9_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
+ {V4L2_VP9_FRAME_FLAG_ERROR_RESILIENT, "ERROR_RESILIENT"},
+ {V4L2_VP9_FRAME_FLAG_INTRA_ONLY, "INTRA_ONLY"},
+ {V4L2_VP9_FRAME_FLAG_ALLOW_HIGH_PREC_MV, "ALLOW_HIGH_PREC_MV"},
+ {V4L2_VP9_FRAME_FLAG_REFRESH_FRAME_CTX, "REFRESH_FRAME_CTX"},
+ {V4L2_VP9_FRAME_FLAG_PARALLEL_DEC_MODE, "PARALLEL_DEC_MODE"},
+ {V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING, "X_SUBSAMPLING"},
+ {V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING, "Y_SUBSAMPLING"},
+ {V4L2_VP9_FRAME_FLAG_COLOR_RANGE_FULL_SWING, "COLOR_RANGE_FULL_SWING"}),
+ __entry->f.compressed_header_size,
+ __entry->f.uncompressed_header_size,
+ __entry->f.frame_width_minus_1,
+ __entry->f.frame_height_minus_1,
+ __entry->f.render_width_minus_1,
+ __entry->f.render_height_minus_1,
+ __entry->f.last_frame_ts,
+ __entry->f.golden_frame_ts,
+ __entry->f.alt_frame_ts,
+ __print_symbolic(__entry->f.ref_frame_sign_bias,
+ {V4L2_VP9_SIGN_BIAS_LAST, "SIGN_BIAS_LAST"},
+ {V4L2_VP9_SIGN_BIAS_GOLDEN, "SIGN_BIAS_GOLDEN"},
+ {V4L2_VP9_SIGN_BIAS_ALT, "SIGN_BIAS_ALT"}),
+ __print_symbolic(__entry->f.reset_frame_context,
+ {V4L2_VP9_RESET_FRAME_CTX_NONE, "RESET_FRAME_CTX_NONE"},
+ {V4L2_VP9_RESET_FRAME_CTX_SPEC, "RESET_FRAME_CTX_SPEC"},
+ {V4L2_VP9_RESET_FRAME_CTX_ALL, "RESET_FRAME_CTX_ALL"}),
+ __entry->f.frame_context_idx,
+ __entry->f.profile,
+ __entry->f.bit_depth,
+ __print_symbolic(__entry->f.interpolation_filter,
+ {V4L2_VP9_INTERP_FILTER_EIGHTTAP, "INTERP_FILTER_EIGHTTAP"},
+ {V4L2_VP9_INTERP_FILTER_EIGHTTAP_SMOOTH, "INTERP_FILTER_EIGHTTAP_SMOOTH"},
+ {V4L2_VP9_INTERP_FILTER_EIGHTTAP_SHARP, "INTERP_FILTER_EIGHTTAP_SHARP"},
+ {V4L2_VP9_INTERP_FILTER_BILINEAR, "INTERP_FILTER_BILINEAR"},
+ {V4L2_VP9_INTERP_FILTER_SWITCHABLE, "INTERP_FILTER_SWITCHABLE"}),
+ __entry->f.tile_cols_log2,
+ __entry->f.tile_rows_log2,
+ __print_symbolic(__entry->f.reference_mode,
+ {V4L2_VP9_REFERENCE_MODE_SINGLE_REFERENCE, "REFERENCE_MODE_SINGLE_REFERENCE"},
+ {V4L2_VP9_REFERENCE_MODE_COMPOUND_REFERENCE, "REFERENCE_MODE_COMPOUND_REFERENCE"},
+ {V4L2_VP9_REFERENCE_MODE_SELECT, "REFERENCE_MODE_SELECT"}))
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
+ TP_ARGS(h),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
+ TP_fast_assign(__entry->h = *h;),
+ TP_printk("\ntx_mode %s\n"
+ "tx8 {%s}\n"
+ "tx16 {%s}\n"
+ "tx32 {%s}\n"
+ "skip %s\n"
+ "inter_mode {%s}\n"
+ "interp_filter {%s}\n"
+ "is_inter %s\n"
+ "comp_mode %s\n"
+ "single_ref {%s}\n"
+ "comp_ref %s\n"
+ "y_mode {%s}\n"
+ "uv_mode {%s}\n"
+ "partition {%s}\n",
+ __print_symbolic(__entry->h.tx_mode,
+ {V4L2_VP9_TX_MODE_ONLY_4X4, "TX_MODE_ONLY_4X4"},
+ {V4L2_VP9_TX_MODE_ALLOW_8X8, "TX_MODE_ALLOW_8X8"},
+ {V4L2_VP9_TX_MODE_ALLOW_16X16, "TX_MODE_ALLOW_16X16"},
+ {V4L2_VP9_TX_MODE_ALLOW_32X32, "TX_MODE_ALLOW_32X32"},
+ {V4L2_VP9_TX_MODE_SELECT, "TX_MODE_SELECT"}),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->h.tx8,
+ sizeof(__entry->h.tx8),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->h.tx16,
+ sizeof(__entry->h.tx16),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->h.tx32,
+ sizeof(__entry->h.tx32),
+ false),
+ __print_array(__entry->h.skip,
+ ARRAY_SIZE(__entry->h.skip),
+ sizeof(__entry->h.skip[0])),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->h.inter_mode,
+ sizeof(__entry->h.inter_mode),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->h.interp_filter,
+ sizeof(__entry->h.interp_filter),
+ false),
+ __print_array(__entry->h.is_inter,
+ ARRAY_SIZE(__entry->h.is_inter),
+ sizeof(__entry->h.is_inter[0])),
+ __print_array(__entry->h.comp_mode,
+ ARRAY_SIZE(__entry->h.comp_mode),
+ sizeof(__entry->h.comp_mode[0])),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->h.single_ref,
+ sizeof(__entry->h.single_ref),
+ false),
+ __print_array(__entry->h.comp_ref,
+ ARRAY_SIZE(__entry->h.comp_ref),
+ sizeof(__entry->h.comp_ref[0])),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->h.y_mode,
+ sizeof(__entry->h.y_mode),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->h.uv_mode,
+ sizeof(__entry->h.uv_mode),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->h.partition,
+ sizeof(__entry->h.partition),
+ false)
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_coef_tmpl,
+ TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
+ TP_ARGS(h),
+ TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
+ TP_fast_assign(__entry->h = *h;),
+ TP_printk("\n coef {%s}",
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->h.coef,
+ sizeof(__entry->h.coef),
+ false)
+ )
+);
+
+DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
+ TP_PROTO(const struct v4l2_vp9_mv_probs *p),
+ TP_ARGS(p),
+ TP_STRUCT__entry(__field_struct(struct v4l2_vp9_mv_probs, p)),
+ TP_fast_assign(__entry->p = *p;),
+ TP_printk("\n joint %s\n"
+ "sign %s\n"
+ "classes {%s}\n"
+ "class0_bit %s\n"
+ "bits {%s}\n"
+ "class0_fr {%s}\n"
+ "fr {%s}\n"
+ "class0_hp %s\n"
+ "hp %s\n",
+ __print_array(__entry->p.joint,
+ ARRAY_SIZE(__entry->p.joint),
+ sizeof(__entry->p.joint[0])),
+ __print_array(__entry->p.sign,
+ ARRAY_SIZE(__entry->p.sign),
+ sizeof(__entry->p.sign[0])),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.classes,
+ sizeof(__entry->p.classes),
+ false),
+ __print_array(__entry->p.class0_bit,
+ ARRAY_SIZE(__entry->p.class0_bit),
+ sizeof(__entry->p.class0_bit[0])),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.bits,
+ sizeof(__entry->p.bits),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.class0_fr,
+ sizeof(__entry->p.class0_fr),
+ false),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+ __entry->p.fr,
+ sizeof(__entry->p.fr),
+ false),
+ __print_array(__entry->p.class0_hp,
+ ARRAY_SIZE(__entry->p.class0_hp),
+ sizeof(__entry->p.class0_hp[0])),
+ __print_array(__entry->p.hp,
+ ARRAY_SIZE(__entry->p.hp),
+ sizeof(__entry->p.hp[0]))
+ )
+);
+
+DEFINE_EVENT(v4l2_ctrl_vp9_frame_tmpl, v4l2_ctrl_vp9_frame,
+ TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
+ TP_ARGS(f)
+);
+
+DEFINE_EVENT(v4l2_ctrl_vp9_compressed_hdr_tmpl, v4l2_ctrl_vp9_compressed_hdr,
+ TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
+ TP_ARGS(h)
+);
+
+DEFINE_EVENT(v4l2_ctrl_vp9_compressed_coef_tmpl, v4l2_ctrl_vp9_compressed_coeff,
+ TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
+ TP_ARGS(h)
+);
+
+
+DEFINE_EVENT(v4l2_vp9_mv_probs_tmpl, v4l2_vp9_mv_probs,
+ TP_PROTO(const struct v4l2_vp9_mv_probs *p),
+ TP_ARGS(p)
+);
+
+#endif /* if !defined(_TRACE_V4L2_REQUESTS_H_) || defined(TRACE_HEADER_MULTI_READ) */
+
+#include <trace/define_trace.h>
--
2.53.0
^ permalink raw reply related
* [PATCH 00/11] v4l2: Add tracing for stateless codecs
From: Detlev Casanova @ 2026-02-12 16:23 UTC (permalink / raw)
To: linux-kernel
Cc: Nicolas Dufresne, Benjamin Gaignard, Philipp Zabel,
Mauro Carvalho Chehab, Heiko Stuebner, Daniel Almeida,
Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers, Hans Verkuil,
Laurent Pinchart, Ricardo Ribalda, Yunke Cao, Detlev Casanova,
Sakari Ailus, Pavan Bobba, James Cowgill, Ma Ke, Jacopo Mondi,
Daniel Scally, linux-media, linux-rockchip, linux-arm-kernel,
linux-trace-kernel, kernel
Hi !
This patchset aims to improve codec event tracing in v4l2.
The traces added in visl by Daniel Almeida are moved to the global trace
events and slightly reworked to be printed in a more consistent format.
To each trace are also added a tgid and fd fields, helping userspace track
different decoding sessions (contexts) based on the given file descriptor
used by the given process id.
Also for better tracking, stream on and stream off events are added as
well as HW run and HW done events to track decoder core usage.
Finally, add a show_fdinfo callback on video device files, allowing drivers
to expose usage information.
Currently only used for frame buffer memory usage.
The main focus is to be able to generate perfetto traces to show VPU usage,
a perfetto producer using this can be found at [1].
[1]: https://gitlab.collabora.com/detlev/hantro-perf/-/tree/hantro-improved-info
Detlev Casanova (11):
media: Move visl traces to v4l2-core
media: Reformat v4l2-requests trace event printk
media: Add tgid and fd fields in v4l2_fh struct
media: Add tgid and fd to the v4l2-requests trace fields
media: Add missing types to v4l2_ctrl_ptr
media: Trace the stateless controls when set in v4l2-ctrls-core.c
media: Add stream on/off traces and run them in the ioctl
media: Add HW run/done trace events
media: hantro: Add v4l2_hw run/done traces
media: v4l2: Add callback for show_fdinfo
media: hantro: Add fdinfo callback
drivers/media/platform/verisilicon/hantro.h | 2 +
.../media/platform/verisilicon/hantro_drv.c | 25 +
.../media/platform/verisilicon/hantro_v4l2.c | 10 +-
.../verisilicon/rockchip_vpu981_regs.h | 1 +
.../platform/verisilicon/rockchip_vpu_hw.c | 4 +
drivers/media/test-drivers/visl/Makefile | 2 +-
drivers/media/test-drivers/visl/visl-dec.c | 76 -
.../media/test-drivers/visl/visl-trace-av1.h | 314 ---
.../media/test-drivers/visl/visl-trace-fwht.h | 66 -
.../media/test-drivers/visl/visl-trace-h264.h | 349 ----
.../media/test-drivers/visl/visl-trace-hevc.h | 464 -----
.../test-drivers/visl/visl-trace-mpeg2.h | 99 -
.../test-drivers/visl/visl-trace-points.c | 11 -
.../media/test-drivers/visl/visl-trace-vp8.h | 156 --
.../media/test-drivers/visl/visl-trace-vp9.h | 292 ---
drivers/media/v4l2-core/v4l2-ctrls-api.c | 10 +
drivers/media/v4l2-core/v4l2-ctrls-core.c | 114 +
drivers/media/v4l2-core/v4l2-dev.c | 10 +
drivers/media/v4l2-core/v4l2-fh.c | 1 +
drivers/media/v4l2-core/v4l2-ioctl.c | 37 +-
drivers/media/v4l2-core/v4l2-trace.c | 48 +
include/media/v4l2-ctrls.h | 19 +
include/media/v4l2-dev.h | 1 +
include/media/v4l2-fh.h | 4 +
include/trace/events/v4l2.h | 58 +
include/trace/events/v4l2_requests.h | 1836 +++++++++++++++++
26 files changed, 2178 insertions(+), 1831 deletions(-)
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-av1.h
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-fwht.h
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-h264.h
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-hevc.h
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-mpeg2.h
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-points.c
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-vp8.h
delete mode 100644 drivers/media/test-drivers/visl/visl-trace-vp9.h
create mode 100644 include/trace/events/v4l2_requests.h
--
2.53.0
^ permalink raw reply
* Re: [PATCH] blk-mq: use NOIO context to prevent deadlock during debugfs creation
From: Nilay Shroff @ 2026-02-12 8:46 UTC (permalink / raw)
To: Yu Kuai, Jens Axboe, ming.lei, hch, Steven Rostedt,
Masami Hiramatsu
Cc: Mathieu Desnoyers, Yi Zhang, Shinichiro Kawasaki, Keith Busch,
Sagi Grimberg, linux-block, linux-nvme, linux-trace-kernel,
linux-kernel
In-Reply-To: <20260212080135.1673063-1-yukuai@fnnas.com>
On 2/12/26 1:31 PM, Yu Kuai wrote:
> Creating debugfs entries can trigger fs reclaim, which can enter back
> into the block layer request_queue. This can cause deadlock if the
> queue is frozen.
>
> Previously, a WARN_ON_ONCE check was used in debugfs_create_files()
> to detect this condition, but it was racy since the queue can be frozen
> from another context at any time.
>
> Introduce blk_debugfs_mutex_lock()/blk_debugfs_mutex_unlock() helpers
> that combine the debugfs_mutex with memalloc_noio_save()/restore() to
> prevent fs reclaim from triggering block I/O. Replace all raw
> debugfs_mutex lock/unlock pairs with these helpers.
It looks like there are still a few places where ->debugfs_mutex is
taken but the code paths do not enter fs-reclaim. For those cases,
it may not be necessary to wrap the critical section in a NOIO context.
Perhaps it would make sense to provide two separate helper APIs: one
that acquires ->debugfs_mutex and also saves/restores the NOIO context
(using memalloc_noio_save()/restore()), and another that simply acquires
and releases ->debugfs_mutex without entering NOIO. Callers could then
choose the appropriate helper depending on whether the code path may
trigger fs-reclaim.
For reference,
blk_mq_freeze_queue()/blk_mq_unfreeze_queue() vs
blk_mq_freeze_queue_nomemsave()/blk_mq_unfreeze_queue_nomemrestore()
Thanks,
--Nilay
^ permalink raw reply
* Re: [PATCH 2/5] tracing: Fix checking of freed trace_event_file for id files
From: Petr Pavlu @ 2026-02-12 8:15 UTC (permalink / raw)
To: Steven Rostedt
Cc: Masami Hiramatsu, Mathieu Desnoyers, Tom Zanussi, linux-kernel,
linux-trace-kernel
In-Reply-To: <20260211113752.54bf37e9@fedora>
On 2/11/26 5:37 PM, Steven Rostedt wrote:
> On Tue, 10 Feb 2026 12:28:17 +0100
> Petr Pavlu <petr.pavlu@suse.com> wrote:
>
>> The code for reading an event id currently uses file->f_inode->i_private to
>> store the value of trace_event_file->event_call->event.type, unlike all
>> other event files which use it to store a pointer to the associated
>> trace_event_file data. The event_id_read() function retrieves this id value
>> from i_private and checks if it is non-0/NULL to determine whether the
>> event is still valid. This approach worked in the past when
>> remove_event_file_dir() would set i_private to NULL for all files in an
>> event directory upon removal. However, with the introduction of eventfs,
>> i_private is assigned when an eventfs inode is allocated and remains set
>
>> throughout its lifetime. As a result, event_id_read() may fail to detect
>> that an event is being removed.
>
> Who cares? It's just an id. If the event is being removed, there's
> nothing wrong with still returning its id. The code currently is very
> simple, I don't want to make it complex for something nobody cares
> about.
I think one could argue that handling all event files in the same way is
less complex. It would also allow for a minor simplification where
event_callback() would no longer need to modify the data pointer and
eventfs then wouldn't need to pass it down to lookup_file() because it
could always use the default ei->data.
However, this is all minor and I can see your point of view. I'll drop
this patch.
--
Thanks,
Petr
^ permalink raw reply
* [PATCH] blk-mq: use NOIO context to prevent deadlock during debugfs creation
From: Yu Kuai @ 2026-02-12 8:01 UTC (permalink / raw)
To: Jens Axboe, nilay, ming.lei, hch, Steven Rostedt,
Masami Hiramatsu
Cc: Mathieu Desnoyers, Yi Zhang, Shinichiro Kawasaki, Keith Busch,
Sagi Grimberg, linux-block, linux-nvme, linux-trace-kernel,
linux-kernel
Creating debugfs entries can trigger fs reclaim, which can enter back
into the block layer request_queue. This can cause deadlock if the
queue is frozen.
Previously, a WARN_ON_ONCE check was used in debugfs_create_files()
to detect this condition, but it was racy since the queue can be frozen
from another context at any time.
Introduce blk_debugfs_mutex_lock()/blk_debugfs_mutex_unlock() helpers
that combine the debugfs_mutex with memalloc_noio_save()/restore() to
prevent fs reclaim from triggering block I/O. Replace all raw
debugfs_mutex lock/unlock pairs with these helpers.
Reported-by: Yi Zhang <yi.zhang@redhat.com>
Closes: https://lore.kernel.org/all/CAHj4cs9gNKEYAPagD9JADfO5UH+OiCr4P7OO2wjpfOYeM-RV=A@mail.gmail.com/
Reported-by: Shinichiro Kawasaki <shinichiro.kawasaki@wdc.com>
Closes: https://lore.kernel.org/all/aYWQR7CtYdk3K39g@shinmob/
Suggested-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Yu Kuai <yukuai@fnnas.com>
---
block/blk-mq-debugfs.c | 10 +++-------
block/blk-mq-sched.c | 10 ++++++----
block/blk-sysfs.c | 10 ++++++----
block/blk-wbt.c | 10 ++++++----
block/blk.h | 21 +++++++++++++++++++++
kernel/trace/blktrace.c | 41 ++++++++++++++++++++++++-----------------
6 files changed, 66 insertions(+), 36 deletions(-)
diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c
index faeaa1fc86a7..28167c9baa55 100644
--- a/block/blk-mq-debugfs.c
+++ b/block/blk-mq-debugfs.c
@@ -613,11 +613,6 @@ static void debugfs_create_files(struct request_queue *q, struct dentry *parent,
const struct blk_mq_debugfs_attr *attr)
{
lockdep_assert_held(&q->debugfs_mutex);
- /*
- * Creating new debugfs entries with queue freezed has the risk of
- * deadlock.
- */
- WARN_ON_ONCE(q->mq_freeze_depth != 0);
/*
* debugfs_mutex should not be nested under other locks that can be
* grabbed while queue is frozen.
@@ -693,12 +688,13 @@ void blk_mq_debugfs_unregister_hctx(struct blk_mq_hw_ctx *hctx)
void blk_mq_debugfs_register_hctxs(struct request_queue *q)
{
struct blk_mq_hw_ctx *hctx;
+ unsigned int memflags;
unsigned long i;
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
queue_for_each_hw_ctx(q, hctx, i)
blk_mq_debugfs_register_hctx(q, hctx);
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
}
void blk_mq_debugfs_unregister_hctxs(struct request_queue *q)
diff --git a/block/blk-mq-sched.c b/block/blk-mq-sched.c
index e26898128a7e..2cd07fe65e40 100644
--- a/block/blk-mq-sched.c
+++ b/block/blk-mq-sched.c
@@ -390,25 +390,27 @@ static void blk_mq_sched_tags_teardown(struct request_queue *q, unsigned int fla
void blk_mq_sched_reg_debugfs(struct request_queue *q)
{
struct blk_mq_hw_ctx *hctx;
+ unsigned int memflags;
unsigned long i;
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
blk_mq_debugfs_register_sched(q);
queue_for_each_hw_ctx(q, hctx, i)
blk_mq_debugfs_register_sched_hctx(q, hctx);
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
}
void blk_mq_sched_unreg_debugfs(struct request_queue *q)
{
struct blk_mq_hw_ctx *hctx;
+ unsigned int memflags;
unsigned long i;
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
queue_for_each_hw_ctx(q, hctx, i)
blk_mq_debugfs_unregister_sched_hctx(hctx);
blk_mq_debugfs_unregister_sched(q);
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
}
void blk_mq_free_sched_tags(struct elevator_tags *et,
diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
index 003aa684e854..31967a2867f7 100644
--- a/block/blk-sysfs.c
+++ b/block/blk-sysfs.c
@@ -891,14 +891,15 @@ const struct kobj_type blk_queue_ktype = {
static void blk_debugfs_remove(struct gendisk *disk)
{
struct request_queue *q = disk->queue;
+ unsigned int memflags;
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
blk_trace_shutdown(q);
debugfs_remove_recursive(q->debugfs_dir);
q->debugfs_dir = NULL;
q->sched_debugfs_dir = NULL;
q->rqos_debugfs_dir = NULL;
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
}
/**
@@ -908,6 +909,7 @@ static void blk_debugfs_remove(struct gendisk *disk)
int blk_register_queue(struct gendisk *disk)
{
struct request_queue *q = disk->queue;
+ unsigned int memflags;
int ret;
ret = kobject_add(&disk->queue_kobj, &disk_to_dev(disk)->kobj, "queue");
@@ -921,11 +923,11 @@ int blk_register_queue(struct gendisk *disk)
}
mutex_lock(&q->sysfs_lock);
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
q->debugfs_dir = debugfs_create_dir(disk->disk_name, blk_debugfs_root);
if (queue_is_mq(q))
blk_mq_debugfs_register(q);
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
ret = disk_register_independent_access_ranges(disk);
if (ret)
diff --git a/block/blk-wbt.c b/block/blk-wbt.c
index 1415f2bf8611..6dba71e87387 100644
--- a/block/blk-wbt.c
+++ b/block/blk-wbt.c
@@ -776,6 +776,7 @@ void wbt_init_enable_default(struct gendisk *disk)
{
struct request_queue *q = disk->queue;
struct rq_wb *rwb;
+ unsigned int memflags;
if (!__wbt_enable_default(disk))
return;
@@ -789,9 +790,9 @@ void wbt_init_enable_default(struct gendisk *disk)
return;
}
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
blk_mq_debugfs_register_rq_qos(q);
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
}
static u64 wbt_default_latency_nsec(struct request_queue *q)
@@ -1015,9 +1016,10 @@ int wbt_set_lat(struct gendisk *disk, s64 val)
blk_mq_unquiesce_queue(q);
out:
blk_mq_unfreeze_queue(q, memflags);
- mutex_lock(&q->debugfs_mutex);
+
+ memflags = blk_debugfs_lock(q);
blk_mq_debugfs_register_rq_qos(q);
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
return ret;
}
diff --git a/block/blk.h b/block/blk.h
index 401d19ed08a6..d4f193814110 100644
--- a/block/blk.h
+++ b/block/blk.h
@@ -740,4 +740,25 @@ static inline void blk_unfreeze_release_lock(struct request_queue *q)
}
#endif
+/*
+ * debugfs directory and file creation can trigger fs reclaim, which can enter
+ * back into the block layer request_queue. This can cause deadlock if the
+ * queue is frozen. Use NOIO context together with debugfs_mutex to prevent fs
+ * reclaim from triggering block I/O.
+ */
+static inline unsigned int blk_debugfs_lock(struct request_queue *q)
+{
+ unsigned int memflags = memalloc_noio_save();
+
+ mutex_lock(&q->debugfs_mutex);
+ return memflags;
+}
+
+static inline void blk_debugfs_unlock(struct request_queue *q,
+ unsigned int memflags)
+{
+ mutex_unlock(&q->debugfs_mutex);
+ memalloc_noio_restore(memflags);
+}
+
#endif /* BLK_INTERNAL_H */
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index c4db5c2e7103..bc938b80702d 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -557,11 +557,12 @@ static int __blk_trace_remove(struct request_queue *q)
int blk_trace_remove(struct request_queue *q)
{
+ unsigned int memflags;
int ret;
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
ret = __blk_trace_remove(q);
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
return ret;
}
@@ -767,6 +768,7 @@ int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
struct blk_user_trace_setup2 buts2;
struct blk_user_trace_setup buts;
struct blk_trace *bt;
+ unsigned int memflags;
int ret;
ret = copy_from_user(&buts, arg, sizeof(buts));
@@ -785,16 +787,16 @@ int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
.pid = buts.pid,
};
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
bt = blk_trace_setup_prepare(q, name, dev, buts.buf_size, buts.buf_nr,
bdev);
if (IS_ERR(bt)) {
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
return PTR_ERR(bt);
}
blk_trace_setup_finalize(q, name, 1, bt, &buts2);
strscpy(buts.name, buts2.name, BLKTRACE_BDEV_SIZE);
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
if (copy_to_user(arg, &buts, sizeof(buts))) {
blk_trace_remove(q);
@@ -809,6 +811,7 @@ static int blk_trace_setup2(struct request_queue *q, char *name, dev_t dev,
{
struct blk_user_trace_setup2 buts2;
struct blk_trace *bt;
+ unsigned int memflags;
if (copy_from_user(&buts2, arg, sizeof(buts2)))
return -EFAULT;
@@ -819,15 +822,15 @@ static int blk_trace_setup2(struct request_queue *q, char *name, dev_t dev,
if (buts2.flags != 0)
return -EINVAL;
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
bt = blk_trace_setup_prepare(q, name, dev, buts2.buf_size, buts2.buf_nr,
bdev);
if (IS_ERR(bt)) {
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
return PTR_ERR(bt);
}
blk_trace_setup_finalize(q, name, 2, bt, &buts2);
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
if (copy_to_user(arg, &buts2, sizeof(buts2))) {
blk_trace_remove(q);
@@ -844,6 +847,7 @@ static int compat_blk_trace_setup(struct request_queue *q, char *name,
struct blk_user_trace_setup2 buts2;
struct compat_blk_user_trace_setup cbuts;
struct blk_trace *bt;
+ unsigned int memflags;
if (copy_from_user(&cbuts, arg, sizeof(cbuts)))
return -EFAULT;
@@ -860,15 +864,15 @@ static int compat_blk_trace_setup(struct request_queue *q, char *name,
.pid = cbuts.pid,
};
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
bt = blk_trace_setup_prepare(q, name, dev, buts2.buf_size, buts2.buf_nr,
bdev);
if (IS_ERR(bt)) {
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
return PTR_ERR(bt);
}
blk_trace_setup_finalize(q, name, 1, bt, &buts2);
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
if (copy_to_user(arg, &buts2.name, ARRAY_SIZE(buts2.name))) {
blk_trace_remove(q);
@@ -896,11 +900,12 @@ static int __blk_trace_startstop(struct request_queue *q, int start)
int blk_trace_startstop(struct request_queue *q, int start)
{
+ unsigned int memflags;
int ret;
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
ret = __blk_trace_startstop(q, start);
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
return ret;
}
@@ -2018,9 +2023,10 @@ static ssize_t sysfs_blk_trace_attr_show(struct device *dev,
struct block_device *bdev = dev_to_bdev(dev);
struct request_queue *q = bdev_get_queue(bdev);
struct blk_trace *bt;
+ unsigned int memflags;
ssize_t ret = -ENXIO;
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
bt = rcu_dereference_protected(q->blk_trace,
lockdep_is_held(&q->debugfs_mutex));
@@ -2041,7 +2047,7 @@ static ssize_t sysfs_blk_trace_attr_show(struct device *dev,
ret = sprintf(buf, "%llu\n", bt->end_lba);
out_unlock_bdev:
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
return ret;
}
@@ -2052,6 +2058,7 @@ static ssize_t sysfs_blk_trace_attr_store(struct device *dev,
struct block_device *bdev = dev_to_bdev(dev);
struct request_queue *q = bdev_get_queue(bdev);
struct blk_trace *bt;
+ unsigned int memflags;
u64 value;
ssize_t ret = -EINVAL;
@@ -2071,7 +2078,7 @@ static ssize_t sysfs_blk_trace_attr_store(struct device *dev,
goto out;
}
- mutex_lock(&q->debugfs_mutex);
+ memflags = blk_debugfs_lock(q);
bt = rcu_dereference_protected(q->blk_trace,
lockdep_is_held(&q->debugfs_mutex));
@@ -2106,7 +2113,7 @@ static ssize_t sysfs_blk_trace_attr_store(struct device *dev,
}
out_unlock_bdev:
- mutex_unlock(&q->debugfs_mutex);
+ blk_debugfs_unlock(q, memflags);
out:
return ret ? ret : count;
}
--
2.51.0
^ permalink raw reply related
* Re: [PATCH v8 3/6] tracefs: Check file permission even if user has CAP_DAC_OVERRIDE
From: Masami Hiramatsu @ 2026-02-12 6:15 UTC (permalink / raw)
To: Steven Rostedt; +Cc: Mathieu Desnoyers, linux-kernel, linux-trace-kernel
In-Reply-To: <20260211104623.73fd4fc3@fedora>
On Wed, 11 Feb 2026 10:46:23 -0500
Steven Rostedt <rostedt@goodmis.org> wrote:
> On Tue, 10 Feb 2026 17:43:51 +0900
> "Masami Hiramatsu (Google)" <mhiramat@kernel.org> wrote:
>
> > From: Masami Hiramatsu (Google) <mhiramat@kernel.org>
> >
> > Strictly checking the file read/write permission even if the owner has
> > CAP_DAC_OVERRIDE on tracefs as same as sysfs.
> > Tracefs is a pseudo filesystem, just like sysfs, so any file that the
> > system defines as unwritable should actually be unwritable by anyone.
>
> This is getting too complex and still doesn't work. As I said in my
> other email, simply check for the trace_array being readonly on opens()
> and return -EACCES if it is and was opened for write or read-write.
yeah, I understand I confused "permission" and "possibility".
>
> With this still not working this late in the game, it will need to wait
> until the next merge window. I'll take the first two patches of this
> series now though.
OK. I will send the next version without the first 2 patches.
Thank you,
>
> -- Steve
>
--
Masami Hiramatsu (Google) <mhiramat@kernel.org>
^ permalink raw reply
* Re: [PATCH v6 2/4] tracing: Make the backup instance non-reusable
From: Masami Hiramatsu @ 2026-02-12 4:24 UTC (permalink / raw)
To: Steven Rostedt; +Cc: Mathieu Desnoyers, linux-kernel, linux-trace-kernel
In-Reply-To: <20260211104244.193953be@fedora>
On Wed, 11 Feb 2026 10:42:44 -0500
Steven Rostedt <rostedt@goodmis.org> wrote:
> On Tue, 10 Feb 2026 14:14:15 +0900
> Masami Hiramatsu (Google) <mhiramat@kernel.org> wrote:
>
> > Hmm, OK. Now I found how sysfs handles it.
> >
> > /*
> > * For regular files, if the opener has CAP_DAC_OVERRIDE, open(2)
> > * succeeds regardless of the RW permissions. sysfs had an extra
> > * layer of enforcement where open(2) fails with -EACCES regardless
> > * of CAP_DAC_OVERRIDE if the permission doesn't have the
> > * respective read or write access at all (none of S_IRUGO or
> > * S_IWUGO) or the respective operation isn't implemented. The
> > * following flag enables that behavior.
> > */
> > KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK = 0x0002,
> >
> > So for the similar reason, I will make tracefs to check the permission
> > even if CAP_DAC_OVERRIDE is set. (But this check should be done in general,
> > instead of each open() operation)
> >
>
> I don't believe this is the same. This is about an instance being truly
> read only. The instance is special, not the files. Note, permissions can
> be changed by root too.
Ah, OK. Let me add read only checks in all related .open operations.
> After applying your patches, I did the following:
>
> ~# cd /sys/kernel/tracing/instances/backup/
> ~# ls -l current_tracer
> -r--r----- 1 root root 0 Feb 11 10:29 current_tracer
>
> ~# cat current_tracer
> nop
>
> ~# cat trace
> # tracer: nop
> #
> # entries-in-buffer/entries-written: 0/0 #P:8
> #
> # _-----=> irqs-off/BH-disabled
> # / _----=> need-resched
> # | / _---=> hardirq/softirq
> # || / _--=> preempt-depth
> # ||| / _-=> migrate-disable
> # |||| / delay
> # TASK-PID CPU# ||||| TIMESTAMP FUNCTION
> # | | | ||||| | |
>
> ~# chmod 664 current_tracer
> ~# ls -l current_tracer
> -rw-rw-r-- 1 root root 0 Feb 11 10:29 current_tracer
Ah, OK...
>
> ~# echo function > current_tracer
> ~# cat current_tracer
> function
>
> ~# cat trace
> # tracer: function
> #
> # entries-in-buffer/entries-written: 1750306/2076556 #P:8
> #
> # _-----=> irqs-off/BH-disabled
> # / _----=> need-resched
> # | / _---=> hardirq/softirq
> # || / _--=> preempt-depth
> # ||| / _-=> migrate-disable
> # |||| / delay
> # TASK-PID CPU# ||||| TIMESTAMP FUNCTION
> # | | | ||||| | |
> bash-1056 [001] ..... 231.448852: mutex_unlock <-tracing_set_tracer
> <idle>-0 [002] ...1. 231.448853: arch_cpu_idle_exit <-do_idle
> ##### CPU 7 buffer started ####
> <idle>-0 [007] ...1. 231.448853: arch_cpu_idle_exit <-do_idle
> bash-1056 [001] ..... 231.448854: __mutex_unlock_slowpath <-tracing_set_tracer
> <idle>-0 [002] d..1. 231.448855: arch_cpu_idle_enter <-do_idle
> <idle>-0 [007] d..1. 231.448855: arch_cpu_idle_enter <-do_idle
> <idle>-0 [007] d..1. 231.448855: tsc_verify_tsc_adjust <-arch_cpu_idle_enter
> <idle>-0 [002] d..1. 231.448855: tsc_verify_tsc_adjust <-arch_cpu_idle_enter
> bash-1056 [001] d.... 231.448856: fpregs_assert_state_consistent <-arch_exit_to_user_mode_prepare
> <idle>-0 [007] d..1. 231.448856: local_touch_nmi <-do_idle
> <idle>-0 [002] d..1. 231.448856: local_touch_nmi <-do_idle
> bash-1056 [001] d.... 231.448856: switch_fpu_return <-arch_exit_to_user_mode_prepare
> <idle>-0 [007] d..1. 231.448856: rcu_nocb_flush_deferred_wakeup <-do_idle
> <idle>-0 [002] d..1. 231.448856: rcu_nocb_flush_deferred_wakeup <-do_idle
> <idle>-0 [007] d..1. 231.448857: cpuidle_get_cpu_driver <-do_idle
> <idle>-0 [002] d..1. 231.448857: cpuidle_get_cpu_driver <-do_idle
> <idle>-0 [007] d..1. 231.448857: cpuidle_not_available <-do_idle
> [..]
>
> Not too read only!
>
> I change permissions all the time for tracefs files, so I don't want
> that changed.
>
> This is not the same as sysfs. Let's keep it simple. Have all the open
> callers that can do writes return error -EACCES if a file allows writes
> and is open for write, but is part of the read only instance.
OK.
Thank you,
>
> -- Steve
>
--
Masami Hiramatsu (Google) <mhiramat@kernel.org>
^ permalink raw reply
* [PATCH AUTOSEL 6.19-6.18] arm64/ftrace,bpf: Fix partial regs after bpf_prog_run
From: Sasha Levin @ 2026-02-12 1:09 UTC (permalink / raw)
To: patches, stable
Cc: Jiri Olsa, Mahe Tardy, Andrii Nakryiko, Steven Rostedt (Google),
Will Deacon, Sasha Levin, song, ast, daniel, kpsingh,
mattbobrowski, mhiramat, pjw, palmer, aou, svens, bpf,
linux-kernel, linux-trace-kernel, linux-riscv
In-Reply-To: <20260212010955.3480391-1-sashal@kernel.org>
From: Jiri Olsa <jolsa@kernel.org>
[ Upstream commit 276f3b6daf6024ae2742afd161e7418a5584a660 ]
Mahe reported issue with bpf_override_return helper not working when
executed from kprobe.multi bpf program on arm.
The problem is that on arm we use alternate storage for pt_regs object
that is passed to bpf_prog_run and if any register is changed (which
is the case of bpf_override_return) it's not propagated back to actual
pt_regs object.
Fixing this by introducing and calling ftrace_partial_regs_update function
to propagate the values of changed registers (ip and stack).
Reported-by: Mahe Tardy <mahe.tardy@gmail.com>
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Reviewed-by: Steven Rostedt (Google) <rostedt@goodmis.org>
Acked-by: Will Deacon <will@kernel.org>
Link: https://lore.kernel.org/bpf/20260112121157.854473-1-jolsa@kernel.org
Signed-off-by: Sasha Levin <sashal@kernel.org>
---
LLM Generated explanations, may be completely bogus:
Now I have a complete picture. Let me provide the full analysis.
---
## Comprehensive Analysis
### 1. COMMIT MESSAGE ANALYSIS
The commit message is clear: `bpf_override_return` helper does not work
when executed from a **kprobe.multi** BPF program on arm64. This was
**reported by a real user** (Mahe Tardy), which indicates it's a real-
world bug affecting actual users. The fix has been **reviewed by Steven
Rostedt** (ftrace maintainer) and **acked by Will Deacon** (arm64
maintainer), two highly authoritative figures.
### 2. THE BUG MECHANISM (Detailed)
On arm64, the `ftrace_regs` structure (`struct __arch_ftrace_regs` in
`arch/arm64/include/asm/ftrace.h`) is **NOT** a wrapper around `pt_regs`
- it's a separate, smaller structure containing only x0-x8, fp, lr, sp,
pc. Arm64 defines `HAVE_ARCH_FTRACE_REGS`.
When `kprobe_multi_link_prog_run()` is called (in
`kernel/trace/bpf_trace.c`):
1. `ftrace_partial_regs(fregs, bpf_kprobe_multi_pt_regs_ptr())` copies
data **from** `ftrace_regs` **to** a per-CPU `pt_regs` buffer. On
arm64, this creates a **separate copy**.
2. `bpf_prog_run(link->link.prog, regs)` passes this `pt_regs` copy to
the BPF program.
3. When `bpf_override_return` is called inside the BPF program, it
modifies the `pt_regs` copy:
- `regs_set_return_value(regs, rc)` - sets the return value
- `override_function_with_return(regs)` - sets `regs->pc = regs->lr`
(on arm64), redirecting execution to skip the probed function
4. **THE BUG**: After `bpf_prog_run()` returns, the modified `pt_regs`
copy is simply discarded. The changes are **never propagated back**
to the original `ftrace_regs`, so the instruction pointer override
and return value changes are lost.
On x86_64 (and s390, powerpc, loongarch), this bug does NOT manifest
because they define `CONFIG_HAVE_FTRACE_REGS_HAVING_PT_REGS`, meaning
`ftrace_partial_regs()` returns a pointer directly into the
`ftrace_regs` structure — changes to the `pt_regs` automatically update
the `ftrace_regs`.
### 3. THE FIX
The fix introduces a new function `ftrace_partial_regs_update()` with
two variants:
- **For architectures without `HAVE_ARCH_FTRACE_REGS`** (x86, etc.):
Empty no-op, because `pt_regs` is embedded in `ftrace_regs` directly.
- **For architectures with `HAVE_ARCH_FTRACE_REGS`** (arm64, riscv):
Copies the instruction pointer and return value back from the separate
`pt_regs` to the `ftrace_regs`:
```c
ftrace_regs_set_instruction_pointer(fregs, instruction_pointer(regs));
ftrace_regs_set_return_value(fregs, regs_return_value(regs));
```
And in `bpf_trace.c`, the fix calls this function after
`bpf_prog_run()`:
```c
ftrace_partial_regs_update(fregs, bpf_kprobe_multi_pt_regs_ptr());
```
### 4. SCOPE AND RISK ASSESSMENT
- **Files changed**: 2 files
- **Lines added**: ~25 (mostly documentation)
- **Lines removed**: 0
- **Actual code changes**: ~5 lines of actual logic
- **Risk**: Very LOW. The no-op version for non-arm64 architectures
means zero impact on x86. The arm64 version just copies two values
back.
### 5. DEPENDENCY CHECK - CRITICAL ISSUE
This is where the analysis gets complex. The affected code —
`kprobe_multi_link_prog_run()` using `ftrace_regs` and
`ftrace_partial_regs()` — was introduced as part of a massive fprobe
rewrite in the **v6.14 merge window**:
- `b9b55c8912ce1` (v6.14): `tracing: Add ftrace_partial_regs() for
converting ftrace_regs to pt_regs`
- `46bc082388560` (v6.14): `fprobe: Use ftrace_regs in fprobe entry
handler`
- `8e2759da9378` (v6.14): `bpf: Enable kprobe_multi feature if
CONFIG_FPROBE is enabled`
- `4346ba1604093` (v6.14): `fprobe: Rewrite fprobe on function-graph
tracer`
In **v6.13 and earlier** (6.12 LTS, 6.6 LTS, 6.1 LTS, 5.15 LTS),
`kprobe_multi_link_prog_run()` takes `struct pt_regs *regs` directly —
there is no `ftrace_regs` / `ftrace_partial_regs()` indirection. **The
bug simply does not exist in those older stable trees.**
The bug exists in: **v6.14, v6.15, v6.18** stable trees (all currently
maintained).
### 6. BACKPORT FEASIBILITY
The patch should apply cleanly to:
- **v6.14.y**: The code at `bpf_trace.c` is very similar (just needs
adjustment for `migrate_disable/enable` which was still present in
v6.14)
- **v6.15.y**: Very similar to HEAD
- **v6.18.y**: Identical to HEAD (`include/linux/ftrace_regs.h`
unchanged since v6.14)
The `include/linux/ftrace_regs.h` change should apply cleanly to all
three. The `bpf_trace.c` change might need minor adjustment for v6.14
(which still has `migrate_disable()` calls), but the relevant line is
the same.
### 7. USER IMPACT
This bug makes `bpf_override_return` completely non-functional on arm64
when used from kprobe.multi programs. This is a significant feature
regression:
- `bpf_override_return` is used by BPF-based error injection frameworks
- arm64 is a major platform (server, embedded, Android)
- The bug was reported by an actual user
### 8. CLASSIFICATION
This is a **clear bug fix** for a **functional regression** introduced
in v6.14. It:
- Fixes a real, user-reported bug
- Is small and surgical (~5 lines of actual logic)
- Has been reviewed by the ftrace maintainer (Rostedt) and arm64
maintainer (Will Deacon)
- Has clear scope and low regression risk
- Only affects arm64 and riscv (no impact on x86)
The fix meets all stable kernel criteria:
1. Obviously correct and tested (reviewed/acked by subsystem
maintainers)
2. Fixes a real bug (user-reported, bpf_override_return completely
broken on arm64)
3. Important issue (complete feature breakage on a major architecture)
4. Small and contained (2 files, ~5 lines of logic)
5. Does not introduce new features (just propagates existing register
values back)
**YES**
include/linux/ftrace_regs.h | 25 +++++++++++++++++++++++++
kernel/trace/bpf_trace.c | 1 +
2 files changed, 26 insertions(+)
diff --git a/include/linux/ftrace_regs.h b/include/linux/ftrace_regs.h
index 15627ceea9bcc..386fa48c4a957 100644
--- a/include/linux/ftrace_regs.h
+++ b/include/linux/ftrace_regs.h
@@ -33,6 +33,31 @@ struct ftrace_regs;
#define ftrace_regs_get_frame_pointer(fregs) \
frame_pointer(&arch_ftrace_regs(fregs)->regs)
+static __always_inline void
+ftrace_partial_regs_update(struct ftrace_regs *fregs, struct pt_regs *regs) { }
+
+#else
+
+/*
+ * ftrace_partial_regs_update - update the original ftrace_regs from regs
+ * @fregs: The ftrace_regs to update from @regs
+ * @regs: The partial regs from ftrace_partial_regs() that was updated
+ *
+ * Some architectures have the partial regs living in the ftrace_regs
+ * structure, whereas other architectures need to make a different copy
+ * of the @regs. If a partial @regs is retrieved by ftrace_partial_regs() and
+ * if the code using @regs updates a field (like the instruction pointer or
+ * stack pointer) it may need to propagate that change to the original @fregs
+ * it retrieved the partial @regs from. Use this function to guarantee that
+ * update happens.
+ */
+static __always_inline void
+ftrace_partial_regs_update(struct ftrace_regs *fregs, struct pt_regs *regs)
+{
+ ftrace_regs_set_instruction_pointer(fregs, instruction_pointer(regs));
+ ftrace_regs_set_return_value(fregs, regs_return_value(regs));
+}
+
#endif /* HAVE_ARCH_FTRACE_REGS */
/* This can be overridden by the architectures */
diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c
index fe28d86f7c357..2a5dabda8b5c2 100644
--- a/kernel/trace/bpf_trace.c
+++ b/kernel/trace/bpf_trace.c
@@ -2564,6 +2564,7 @@ kprobe_multi_link_prog_run(struct bpf_kprobe_multi_link *link,
old_run_ctx = bpf_set_run_ctx(&run_ctx.session_ctx.run_ctx);
err = bpf_prog_run(link->link.prog, regs);
bpf_reset_run_ctx(old_run_ctx);
+ ftrace_partial_regs_update(fregs, bpf_kprobe_multi_pt_regs_ptr());
rcu_read_unlock();
out:
--
2.51.0
^ permalink raw reply related
* [PATCH V4] blktrace: log dropped REQ_OP_ZONE_XXX events ver1
From: Chaitanya Kulkarni @ 2026-02-11 20:47 UTC (permalink / raw)
To: axboe, dlemoal
Cc: rostedt, mhiramat, linux-block, linux-trace-kernel,
Chaitanya Kulkarni
Add informational messages during blktrace setup when version 1 tools
are used on kernels with CONFIG_BLK_DEV_ZONED enabled. This alerts users
that REQ_OP_ZONE_* events will be dropped and suggests upgrading to
blktrace tools version 2 or later.
The warning is printed once during trace setup to inform users about
the limitation without spamming the logs during tracing operations.
Version 2 blktrace tools properly handle zone management operations
(zone reset, zone open, zone close, zone finish, zone append) that
were added for zoned block devices.
* With old blktrace tool and this patch :-
blktests (master) # ./check blktrace/
blktrace/001 (blktrace zone management command tracing) [passed]
runtime 3.706s ... 3.735s
blktrace/002 (blktrace ftrace corruption with sysfs trace) [passed]
runtime 0.479s ... 0.456s
blktests (master) # dmesg -c
[ 9455.610899] null_blk: disk nullb0 created
[ 9455.610916] null_blk: module loaded
[ 9455.634103] run blktests blktrace/001 at 2026-02-02 15:02:23
[ 9455.651710] null_blk: nullb1: using native zone append
[ 9455.662852] null_blk: disk nullb1 created
*[ 9455.714998] blktrace: nullb1: blktrace events for zone operations will be dropped*
*[ 9455.715065] blktrace: use blktrace tools version >= 2 to track zone operations*
[ 9459.480181] null_blk: disk nullb0 created
[ 9459.480199] null_blk: module loaded
[ 9459.514464] run blktests blktrace/002 at 2026-02-02 15:02:27
[ 9459.541772] null_blk: disk nullb1 created
blktests (master) #
* With new blktrace tools and this patch :-
blktests (master) # ./check blktrace/
blktrace/001 (blktrace zone management command tracing) [passed]
runtime 3.735s ... 3.734s
blktrace/002 (blktrace ftrace corruption with sysfs trace) [passed]
runtime 0.456s ... 0.496s
blktests (master) # dmesg -c
[ 9490.395572] null_blk: disk nullb0 created
[ 9490.395591] null_blk: module loaded
[ 9490.419467] run blktests blktrace/001 at 2026-02-02 15:02:58
[ 9490.436416] null_blk: nullb1: using native zone append
[ 9490.447806] null_blk: disk nullb1 created
[ 9494.262176] null_blk: disk nullb0 created
[ 9494.262195] null_blk: module loaded
[ 9494.296653] run blktests blktrace/002 at 2026-02-02 15:03:02
[ 9494.322261] null_blk: disk nullb1 created
blktests (master) #
This helps users understand why zone operation traces may be missing
when using older blktrace tool versions with modern kernels that
support REQ_OP_ZONE_XXX in blktrace.
Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
Signed-off-by: Chaitanya Kulkarni <kch@nvidia.com>
---
V3->V4:-
Replace REQ_OP_ZONE_XXX with "zone operations". (Damien, Jens)
---
kernel/trace/blktrace.c | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index d031c8d80be4..04b41c698127 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -741,6 +741,12 @@ static void blk_trace_setup_finalize(struct request_queue *q,
* to underscores for this to work as expected
*/
strreplace(buts->name, '/', '_');
+ if (version == 1 && IS_ENABLED(CONFIG_BLK_DEV_ZONED)) {
+ pr_info("%s: blktrace events for zone operations will be dropped\n",
+ name);
+ pr_info("use blktrace tools version >= 2 to track zone operations\n");
+
+ }
bt->version = version;
bt->act_mask = buts->act_mask;
--
2.39.5
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox