From: sashiko-bot@kernel.org
To: "Nas Chung" <nas.chung@chipsnmedia.com>
Cc: devicetree@vger.kernel.org, imx@lists.linux.dev, robh@kernel.org,
conor+dt@kernel.org, Frank.Li@kernel.org, media-ci@linuxtv.org
Subject: Re: [PATCH v8 05/11] media: chips-media: wave6: Add Wave6 m2m decoder
Date: Thu, 19 Nov 2026 09:31:41 +0000 [thread overview]
Message-ID: <sashiko-outbox-222840@kernel.org> (raw)
In-Reply-To: <131b501b33d697b070553bb5ff9ffafcaea812d6.1795075581.git.nas.chung@chipsnmedia.com>
Thank you for your contribution! Sashiko AI review found 13 potential
issues to consider:
- [High] media: wave6: infinite job loop on failure in
wave6_vpu_dec_seek_header()
- [High] media: wave6: missing CAPTURE buffer size check after format
update
- [High] media: wave6: use-after-free of m2m_ctx in
wave6_vpu_dec_release()
- [Medium] media: wave6: unhandled query failure in
wave6_vpu_dec_finish_decode()
- [Medium] media: wave6: fbc_buf_registered not reset in
wave6_vpu_dec_release_fb()
- [Medium] media: wave6: zero pixelformat matched in
wave6_find_vpu_fmt()
- [Medium] media: wave6: skipped FBC setup in
wave6_vpu_dec_start_streaming() after seek
- [Medium] media: wave6: duplicate display buffer entries in
p_dec_info->disp_buf[]
- [Medium] media: wave6: infinite job rescheduling loop on
DEC_NOTI_FLAG_NO_FB
- [Medium] media: wave6: race between wave6_vpu_dec_finish_decode() and
timeout work
- [Medium] media: wave6: unlocked cap_q_ctx.rdy_queue traversal races
with queue ops
- [Medium] media: wave6: unlocked state updates and early event in
source change
- [Medium] media: wave6: ignored buffer registration errors in
prepare_decode()
--
commit 2d9ead557a0ff6a4de5fd71e8b36d2fcff95e3a1
Author: Nas Chung <nas.chung@chipsnmedia.com>
media: chips-media: wave6: Add Wave6 m2m decoder
This commit adds the V4L2 m2m stateful decoder driver for the Chips&Media
Wave6 video codec IP, supporting H.264 and HEVC 8-bit decoding, downscaling,
and dynamic resolution changes.
> diff --git a/drivers/media/platform/chips-media/wave6/wave6-vpu-dec.c b/drivers/media/platform/chips-media/wave6/wave6-vpu-dec.c
> new file mode 100644
> index 0000000000000..54b408922bbc2
> --- /dev/null
> +++ b/drivers/media/platform/chips-media/wave6/wave6-vpu-dec.c
> @@ -0,0 +1,1935 @@
[ ... ]
> +static const struct vpu_format wave6_vpu_dec_fmt_list[2][6] = {
> + [VPU_FMT_TYPE_CODEC] = {
> + {
> + .v4l2_pix_fmt = V4L2_PIX_FMT_HEVC,
> + .max_width = W6_MAX_DEC_PIC_WIDTH,
> + .min_width = W6_MIN_DEC_PIC_WIDTH,
> + .max_height = W6_MAX_DEC_PIC_HEIGHT,
> + .min_height = W6_MIN_DEC_PIC_HEIGHT,
> + .num_planes = 1,
> + },
> + {
> + .v4l2_pix_fmt = V4L2_PIX_FMT_H264,
> + .max_width = W6_MAX_DEC_PIC_WIDTH,
> + .min_width = W6_MIN_DEC_PIC_WIDTH,
> + .max_height = W6_MAX_DEC_PIC_HEIGHT,
> + .min_height = W6_MIN_DEC_PIC_HEIGHT,
> + .num_planes = 1,
> + },
> + },
[ ... ]
> +static const struct vpu_format *wave6_find_vpu_fmt(unsigned int v4l2_pix_fmt,
> + enum vpu_fmt_type type)
> +{
> + for (int i = 0; i < ARRAY_SIZE(wave6_vpu_dec_fmt_list[type]); i++) {
> + if (wave6_vpu_dec_fmt_list[type][i].v4l2_pix_fmt == v4l2_pix_fmt)
> + return &wave6_vpu_dec_fmt_list[type][i];
> + }
> +
> + return NULL;
> +}
[Severity: Medium]
Can wave6_find_vpu_fmt() match an unpopulated entry in
wave6_vpu_dec_fmt_list[VPU_FMT_TYPE_CODEC] when v4l2_pix_fmt is 0?
VPU_FMT_TYPE_CODEC only populates 2 of its 6 slots, leaving slots 2..5
zero-initialized. Passing pixelformat == 0 to VIDIOC_S_FMT on OUTPUT
matches slot 2 instead of falling back to inst->src_fmt, which sets
inst->src_fmt.num_planes and plane sizes to 0 and triggers WARN_ON() in
vb2_core_reqbufs() on a subsequent VIDIOC_REQBUFS.
[ ... ]
> +static void wave6_vpu_dec_release_fb(struct vpu_instance *inst)
> +{
> + for (int i = 0; i < WAVE6_MAX_FBS; i++) {
> + wave6_vdi_free_dma(&inst->frame_vbuf[i]);
> + memset(&inst->frame_buf[i], 0, sizeof(struct frame_buffer));
> + wave6_vdi_free_dma(&inst->aux_vbuf[AUX_BUF_FBC_Y_TBL][i]);
> + wave6_vdi_free_dma(&inst->aux_vbuf[AUX_BUF_FBC_C_TBL][i]);
> + wave6_vdi_free_dma(&inst->aux_vbuf[AUX_BUF_MV_COL][i]);
> + }
> +}
> +
> +static void wave6_vpu_dec_destroy_instance(struct vpu_instance *inst)
> +{
> + u32 fail_res = 0;
> + int ret;
> +
> + wave6_vpu_disable_instance(inst);
> +
> + ret = wave6_vpu_dec_close(inst, &fail_res);
> + if (ret) {
> + dev_err(inst->dev->dev, "failed destroy instance: %d (%d)\n",
> + ret, fail_res);
> + }
> +
> + scoped_guard(spinlock, &inst->dev->inst_lock)
> + list_del_init(&inst->list);
> + wave6_vpu_dec_release_fb(inst);
> + wave6_vpu_set_instance_state(inst, VPU_INST_STATE_NONE);
> +
> + pm_runtime_put_sync(inst->dev->dev);
> + wave6_vpu_core_deactivate(inst->dev);
> +}
[Severity: Medium]
Should wave6_vpu_dec_release_fb() or wave6_vpu_dec_destroy_instance()
reset inst->fbc_buf_registered to false?
When wave6_vpu_dec_queue_setup() destroys the instance in
VPU_INST_STATE_SEEK and a new instance is created on the next OUTPUT
STREAMON, inst->fbc_buf_registered remains true from the destroyed
instance even though all FBC buffers were freed. If V4L2_DEC_CMD_STOP is
then issued before a sequence header is parsed,
wave6_vpu_dec_prepare_decode() skips the !inst->fbc_buf_registered early
drain exit and issues W6_CMD_INIT_SEQ on an empty bitstream.
[ ... ]
> +static void wave6_vpu_dec_handle_dst_buffer(struct vpu_instance *inst)
> +{
> + struct vb2_v4l2_buffer *dst_buf;
> + struct v4l2_m2m_buffer *v4l2_m2m_buf;
> + struct vpu_buffer *vpu_buf;
> + u32 fb_stride = inst->dst_fmt.plane_fmt[0].bytesperline;
> + u32 luma_size = fb_stride * inst->dst_fmt.height;
> + u32 chroma_size = (fb_stride / 2) * (inst->dst_fmt.height / 2);
> + struct frame_buffer disp_buffer = { };
> + struct dec_seq_info *seq_info = &inst->codec_info->dec_info.seq_info;
> + int consumed_num = wave6_vpu_get_consumed_fb_num(inst);
> + int ret;
> +
> + v4l2_m2m_for_each_dst_buf(inst->v4l2_fh.m2m_ctx, v4l2_m2m_buf) {
[Severity: Medium]
What serializes v4l2_m2m_for_each_dst_buf() against concurrent list
modifications on cap_q_ctx.rdy_queue?
v4l2_m2m_for_each_dst_buf() iterates cap_q_ctx.rdy_queue without holding
cap_q_ctx.rdy_spinlock:
kworker CPU0 (VIDIOC_QBUF)
wave6_vpu_device_run()
wave6_vpu_dec_prepare_decode()
wave6_vpu_dec_handle_dst_buffer()
v4l2_m2m_for_each_dst_buf()
wave6_vpu_dec_buf_queue_dst()
guard(mutex)(&inst->lock)
v4l2_m2m_buf_queue()
list_add_tail(&b->list, ...)
/* unlocked list traversal */
Similarly, wave6_vpu_core_irq_thread() traverses cap_q_ctx.rdy_queue
unlocked in wave6_get_dst_buf_by_addr() and calls
v4l2_m2m_dst_buf_remove_by_buf(), which can race with
wave6_vpu_dec_buf_queue_dst() or with v4l2_m2m_for_each_dst_buf() in
wave6_vpu_dec_cmd_start() and corrupt the list traversal.
> + dst_buf = &v4l2_m2m_buf->vb;
> + vpu_buf = wave6_to_vpu_buf(dst_buf);
> +
> + if (vpu_buf->consumed)
> + continue;
> +
> + if (consumed_num >= WAVE6_MAX_FBS)
> + break;
> +
> + if (inst->dst_fmt.num_planes == 1) {
> + disp_buffer.buf_y = wave6_get_dma_addr(dst_buf, 0);
> + disp_buffer.buf_cb = disp_buffer.buf_y + luma_size;
> + disp_buffer.buf_cr = disp_buffer.buf_cb + chroma_size;
> + } else if (inst->dst_fmt.num_planes == 2) {
> + disp_buffer.buf_y = wave6_get_dma_addr(dst_buf, 0);
> + disp_buffer.buf_cb = wave6_get_dma_addr(dst_buf, 1);
> + disp_buffer.buf_cr = disp_buffer.buf_cb + chroma_size;
> + } else if (inst->dst_fmt.num_planes == 3) {
> + disp_buffer.buf_y = wave6_get_dma_addr(dst_buf, 0);
> + disp_buffer.buf_cb = wave6_get_dma_addr(dst_buf, 1);
> + disp_buffer.buf_cr = wave6_get_dma_addr(dst_buf, 2);
> + }
> + disp_buffer.height = inst->src_fmt.height;
> + disp_buffer.stride = fb_stride;
> + disp_buffer.map_type = LINEAR_FRAME_MAP;
> + disp_buffer.luma_bit_depth = seq_info->luma_bit_depth;
> + disp_buffer.chroma_bit_depth = seq_info->chroma_bit_depth;
> + disp_buffer.c_fmt_idc = seq_info->c_fmt_idc;
> +
> + ret = wave6_vpu_dec_register_display_buffer(inst, disp_buffer);
> + if (ret) {
> + dev_err(inst->dev->dev, "fail register display buffer %d", ret);
> + break;
> + }
> +
> + vpu_buf->consumed = true;
> + consumed_num++;
> + }
[Severity: Medium]
Does re-queuing a displayed CAPTURE buffer insert duplicate entries into
p_dec_info->disp_buf[] until all WAVE6_MAX_FBS slots are exhausted?
When a displayed buffer is dequeued and re-queued via VIDIOC_QBUF,
wave6_vpu_dec_buf_queue() resets vpu_buf->consumed = false, so
wave6_vpu_dec_handle_dst_buffer() calls
wave6_vpu_dec_register_display_buffer() again. In commit "media:
chips-media: wave6: Add Wave6 decoder firmware interface",
wave6_dec_set_display_buffer() always writes to the first empty
!disp_buf[i].buf_y slot without checking if fb.buf_y is already present,
and wave6_vpu_dec_get_output_info() only removes buffers on
W6_RET_DEC_RELEASE_IDC, not W6_RET_DEC_DISP_IDC:
drivers/media/platform/chips-media/wave6/wave6-hw.c:wave6_dec_set_display_buffer() {
for (int i = 0; i < WAVE6_MAX_FBS; i++) {
if (!p_dec_info->disp_buf[i].buf_y) {
p_dec_info->disp_buf[i] = fb;
break;
}
}
}
After 31 displayed frames are re-queued, p_dec_info->disp_buf[] is full of
duplicates and cannot record any new buffer address.
> +
> + if (!inst->fbc_buf_registered) {
> + ret = wave6_vpu_dec_register_frame_buffer(inst);
> + if (ret)
> + dev_err(inst->dev->dev, "register frame buffer fail %d\n", ret);
> + else
> + inst->fbc_buf_registered = true;
> + }
> +}
[Severity: Medium]
Should wave6_vpu_dec_handle_dst_buffer() propagate registration errors to
wave6_vpu_dec_prepare_decode()?
If wave6_vpu_dec_register_frame_buffer() or
wave6_vpu_dec_register_display_buffer() fails, the error is logged and
dropped, and wave6_vpu_dec_prepare_decode() still returns 0.
wave6_vpu_device_run() then arms inst->task_timer and calls
wave6_vpu_dec_start_decode() without registered FBC or display buffers.
[ ... ]
> +static void wave6_vpu_dec_handle_source_change(struct vpu_instance *inst)
> +{
> + static const struct v4l2_event vpu_event_src_ch = {
> + .type = V4L2_EVENT_SOURCE_CHANGE,
> + .u.src_change.changes = V4L2_EVENT_SRC_CH_RESOLUTION,
> + };
> + struct dec_seq_info *info = &inst->codec_info->dec_info.seq_info;
> +
> + dev_dbg(inst->dev->dev, "pic size %dx%d profile %d, min_fb_cnt : %d | min_disp_cnt : %d\n",
> + info->pic_width, info->pic_height,
> + info->profile, info->min_frame_buffer_count, info->frame_buf_delay);
> +
> + wave6_vpu_dec_retry_one_frame(inst);
> + wave6_vpu_dec_reset_frame_buffer_info(inst);
> + inst->fbc_buf_registered = false;
> +
> + wave6_vpu_set_instance_state(inst, VPU_INST_STATE_INIT_SEQ);
> +
> + inst->scaler_info.enable = false;
> + inst->crop.left = info->pic_crop_rect.left;
> + inst->crop.top = info->pic_crop_rect.top;
> + inst->crop.width = info->pic_crop_rect.right - inst->crop.left;
> + inst->crop.height = info->pic_crop_rect.bottom - inst->crop.top;
> +
> + wave6_update_v4l2_ctrls(inst, info);
> + wave6_update_color_info(inst, info);
> + wave6_update_pix_fmt(&inst->src_fmt, info->pic_width, info->pic_height);
> + wave6_update_pix_fmt_cap(&inst->dst_fmt,
> + info->pic_width, info->pic_height,
> + true);
> +
> + v4l2_event_queue_fh(&inst->v4l2_fh, &vpu_event_src_ch);
> +}
[Severity: Medium]
Can queuing V4L2_EVENT_SOURCE_CHANGE inside
wave6_vpu_dec_handle_source_change() wake userspace before the caller
finishes marking the last frame?
CPU0 (irq_thread / kworker) CPU1 (userspace)
wave6_vpu_dec_seek_header()
wave6_vpu_dec_handle_source_change()
/* updates formats unlocked */
v4l2_event_queue_fh(...)
/* wakes on SOURCE_CHANGE event */
VIDIOC_STREAMON(CAPTURE)
VIDIOC_QBUF(CAPTURE)
if (vb2_is_streaming(dst_vq))
wave6_handle_last_frame() <-- tags new buffer with LAST
In addition, wave6_vpu_dec_handle_source_change() modifies inst->state,
inst->crop, inst->src_fmt, and inst->dst_fmt without holding
core->dev_lock, so a concurrent VIDIOC_G_FMT or VIDIOC_TRY_FMT can observe
partially updated format fields (such as bytesperline temporarily set to
0). Queuing the event after wave6_handle_last_frame() and serializing the
format update would avoid this race.
[ ... ]
> +static void wave6_vpu_dec_finish_decode(struct vpu_instance *inst, bool error)
> +{
> + struct dec_output_info info;
> + int ret;
> +
> + memset(&info, 0, sizeof(info));
> +
> + ret = wave6_vpu_dec_get_output_info(inst, &info);
> + if (ret)
> + goto finish_decode;
[Severity: Medium]
What synchronizes wave6_vpu_dec_finish_decode() against inst->task_timer
(wave6_vpu_device_run_timeout())?
wave6_vpu_dec_finish_decode() does not cancel inst->task_timer on entry;
wave6_vpu_finish_job() only calls non-synchronous cancel_delayed_work() at
the very end:
CPU0 (irq_thread) CPU1 (kworker)
wave6_vpu_dec_finish_decode() wave6_vpu_device_run_timeout()
wave6_handle_decoded_frame()
src_buf = v4l2_m2m_next_src_buf()
src_buf = v4l2_m2m_src_buf_remove()
v4l2_m2m_buf_done(src_buf, ...)
wave6_vpu_dec_src_buf_done()
v4l2_m2m_src_buf_remove_by_buf()
v4l2_m2m_buf_done(src_buf) <-- double remove and buf_done
If the timeout fires while the completion interrupt is being handled, both
paths remove and complete the same source and destination buffers and both
call v4l2_m2m_job_finish().
[Severity: Medium]
If wave6_vpu_dec_get_output_info() fails here, does jumping to
finish_decode leave the consumed head OUTPUT buffer on the ready queue?
Unlike wave6_vpu_dec_start_decode(), this error path neither removes and
completes the head src_buf with VB2_BUF_STATE_ERROR nor transitions
inst->state to VPU_INST_STATE_ERROR, so v4l2_m2m_job_finish() can schedule
the next job with the already-consumed buffer still at the head of the
queue.
> +
> + dev_dbg(inst->dev->dev, "dec %d dis %d noti_flag %d stream_end %d\n",
> + info.frame_decoded, info.frame_display,
> + info.notification_flags, info.stream_end);
> +
> + if (info.notification_flags & DEC_NOTI_FLAG_NO_FB) {
> + wave6_vpu_dec_retry_one_frame(inst);
> + goto finish_decode;
> + }
[Severity: Medium]
Does DEC_NOTI_FLAG_NO_FB cause an immediate job rescheduling busy loop?
In wave6_vpu_dec_handle_dst_buffer(), queued CAPTURE buffers have
vpu_buf->consumed set to true while vpu_buf->used remains false until
wave6_handle_decoded_frame(). When DEC_NOTI_FLAG_NO_FB jumps to
finish_decode without setting vpu_buf->used, wave6_vpu_check_fb_available()
in commit "media: chips-media: wave6: Add Wave6 core driver" still sees
!vpu_buf->used and reports the job as ready:
drivers/media/platform/chips-media/wave6/wave6-vpu-v4l2.c:wave6_vpu_check_fb_available() {
v4l2_m2m_for_each_dst_buf(inst->v4l2_fh.m2m_ctx, v4l2_m2m_buf) {
vb2_v4l2_buf = &v4l2_m2m_buf->vb;
vpu_buf = wave6_to_vpu_buf(vb2_v4l2_buf);
if (!vpu_buf->used)
return true;
}
}
v4l2_m2m_job_finish() then immediately re-runs the job without waiting for
a new CAPTURE buffer, and wave6_vpu_dec_handle_dst_buffer() skips all
existing CAPTURE buffers because their vpu_buf->consumed is already true.
[ ... ]
> +static int wave6_vpu_dec_s_fmt_out(struct file *file, void *fh, struct v4l2_format *f)
> +{
[ ... ]
> + wave6_update_pix_fmt_cap(&inst->dst_fmt,
> + pix_mp->width, pix_mp->height,
> + true);
> +
> + return 0;
> +}
[Severity: High]
Can updating inst->dst_fmt in wave6_vpu_dec_s_fmt_out() or
wave6_vpu_dec_handle_source_change() allow undersized CAPTURE buffers to
be registered for DMA?
If userspace allocates and queues (or prepares via VIDIOC_PREPARE_BUF)
CAPTURE buffers at the default 720x480 format before CAPTURE STREAMON,
wave6_vpu_dec_buf_prepare() validates their sizes against 720x480 and marks
them prepared. If inst->dst_fmt is then increased (up to 4096x4096) via
VIDIOC_S_FMT on OUTPUT or sequence header parsing, VIDIOC_STREAMON on
CAPTURE calls wave6_vpu_dec_start_streaming() -> wave6_vpu_dec_prepare_fb()
without re-checking the prepared buffers' plane sizes against the new
inst->dst_fmt.plane_fmt[i].sizeimage (unlike wave6_vpu_dec_cmd_start()).
wave6_vpu_dec_handle_dst_buffer() then registers those smaller DMA buffers
with the hardware using the new stride and height, causing out-of-bounds
DMA writes.
[ ... ]
> +static int wave6_vpu_dec_seek_header(struct vpu_instance *inst)
> +{
> + struct dec_seq_info seq_info;
> + int ret;
> +
> + memset(&seq_info, 0, sizeof(struct dec_seq_info));
> +
> + ret = wave6_vpu_dec_issue_seq_init(inst);
> + if (ret) {
> + dev_err(inst->dev->dev, "failed wave6_vpu_dec_issue_seq_init %d\n", ret);
> + return ret;
> + }
> +
> + ret = wave6_vpu_wait_interrupt(inst, W6_VPU_TIMEOUT);
> + if (ret) {
> + dev_err(inst->dev->dev, "failed to call vpu_wait_interrupt()\n");
> + return ret;
> + }
> +
> + ret = wave6_vpu_dec_complete_seq_init(inst, &seq_info);
> + if (ret) {
> + dev_err(inst->dev->dev, "vpu_dec_complete_seq_init: %d, reason : 0x%x\n",
> + ret, seq_info.err_reason);
> + if ((seq_info.err_reason & WAVE6_SYSERR_NOT_SUPPORT) ||
> + (seq_info.err_reason & WAVE6_SYSERR_NOT_SUPPORT_PROFILE)) {
> + ret = -EINVAL;
> + } else if (seq_info.err_reason == HEVC_ETCERR_INIT_SEQ_SPS_NOT_FOUND ||
> + seq_info.err_reason == AVC_ETCERR_INIT_SEQ_SPS_NOT_FOUND) {
> + wave6_handle_skipped_frame(inst);
> + ret = 0;
> + }
> + } else {
> + wave6_vpu_dec_handle_source_change(inst);
> + inst->v4l2_fh.m2m_ctx->ignore_cap_streaming = false;
> + v4l2_m2m_set_dst_buffered(inst->v4l2_fh.m2m_ctx, false);
> + if (vb2_is_streaming(v4l2_m2m_get_dst_vq(inst->v4l2_fh.m2m_ctx))) {
> + scoped_guard(mutex, &inst->lock)
> + wave6_handle_last_frame(inst, NULL);
> + }
> + }
> +
> + return ret;
> +}
> +
> +static int wave6_vpu_dec_prepare_decode(struct vpu_instance *inst)
> +{
> + bool stream_end;
> +
> + scoped_guard(mutex, &inst->lock)
> + stream_end = inst->drain && !inst->drain_src_buf_num;
> +
> + if (stream_end && !inst->fbc_buf_registered) {
> + wave6_vpu_dec_finish_drain(inst);
> + return -EAGAIN;
> + }
> +
> + wave6_handle_bitstream_buffer(inst, stream_end);
> +
> + if (inst->state < VPU_INST_STATE_PIC_RUN) {
> + if (inst->state == VPU_INST_STATE_OPEN &&
> + wave6_vpu_dec_seek_header(inst)) {
> + vb2_queue_error(v4l2_m2m_get_src_vq(inst->v4l2_fh.m2m_ctx));
> + vb2_queue_error(v4l2_m2m_get_dst_vq(inst->v4l2_fh.m2m_ctx));
> + }
> +
> + return -EAGAIN;
> + }
[Severity: High]
Does a failure in wave6_vpu_dec_seek_header() trigger an infinite m2m job
loop?
When wave6_vpu_dec_seek_header() fails with any error other than
SPS_NOT_FOUND (such as WAVE6_SYSERR_NOT_SUPPORT_PROFILE on a 10-bit stream
or a timeout), the consumed head OUTPUT buffer is not removed from the
ready queue and inst->state remains VPU_INST_STATE_OPEN. Calling
vb2_queue_error() only sets q->error without stopping streaming, and
wave6_vpu_job_ready() returns 1 whenever inst->state == VPU_INST_STATE_OPEN.
When wave6_vpu_dec_prepare_decode() returns -EAGAIN,
wave6_vpu_device_run() calls v4l2_m2m_job_finish(), which immediately
re-queues and re-runs the job in an unbounded loop on the same buffer.
[ ... ]
> +static int wave6_vpu_dec_start_streaming(struct vb2_queue *q, unsigned int count)
> +{
> + struct vpu_instance *inst = vb2_get_drv_priv(q);
> + struct v4l2_pix_format_mplane *fmt;
> + int ret = 0;
> +
> + if (V4L2_TYPE_IS_OUTPUT(q->type)) {
> + fmt = &inst->src_fmt;
> + if (inst->state == VPU_INST_STATE_NONE) {
> + ret = wave6_vpu_dec_create_instance(inst);
> + if (!ret) {
> + inst->v4l2_fh.m2m_ctx->ignore_cap_streaming = true;
> + v4l2_m2m_set_dst_buffered(inst->v4l2_fh.m2m_ctx, true);
> + }
> + }
> + if (inst->state == VPU_INST_STATE_SEEK)
> + wave6_vpu_set_instance_state(inst, inst->state_in_seek);
> + } else {
> + fmt = &inst->dst_fmt;
> + if (inst->state == VPU_INST_STATE_INIT_SEQ) {
> + ret = wave6_vpu_dec_prepare_fb(inst);
> + if (ret)
> + goto exit;
> + }
> + }
[Severity: Medium]
Can wave6_vpu_dec_prepare_fb() be skipped if CAPTURE streaming starts while
inst->state is VPU_INST_STATE_SEEK?
If OUTPUT streaming is stopped while in VPU_INST_STATE_INIT_SEQ,
wave6_vpu_dec_stop_streaming() saves inst->state_in_seek =
VPU_INST_STATE_INIT_SEQ and sets inst->state = VPU_INST_STATE_SEEK. If
userspace then starts CAPTURE streaming before restarting OUTPUT streaming,
CAPTURE start_streaming sees inst->state == VPU_INST_STATE_SEEK and skips
wave6_vpu_dec_prepare_fb(), and OUTPUT start_streaming only restores
inst->state to VPU_INST_STATE_INIT_SEQ without calling
wave6_vpu_dec_prepare_fb(), leaving decoding permanently stalled in
VPU_INST_STATE_INIT_SEQ.
Also, in wave6_vpu_dec_try_fmt_cap(), checking inst->state >=
VPU_INST_STATE_INIT_SEQ evaluates to true in VPU_INST_STATE_SEEK even when
inst->state_in_seek was VPU_INST_STATE_OPEN.
[ ... ]
> +static int wave6_vpu_dec_release(struct file *filp)
> +{
> + struct vpu_instance *inst = wave6_file_to_vpu_inst(filp);
> +
> + v4l2_m2m_ctx_release(inst->v4l2_fh.m2m_ctx);
> +
> + if (inst->state != VPU_INST_STATE_NONE)
> + wave6_vpu_dec_destroy_instance(inst);
[Severity: High]
Can releasing inst->v4l2_fh.m2m_ctx before wave6_vpu_dec_destroy_instance()
cause a use-after-free on m2m_ctx?
v4l2_m2m_ctx_release() waits only for TRANS_RUNNING to clear and then frees
m2m_ctx, whereas wave6_vpu_disable_instance() (which sets inst->enable =
false, calls synchronize_irq(), and calls cancel_delayed_work_sync() on
inst->task_timer) only runs afterward inside
wave6_vpu_dec_destroy_instance():
CPU0 CPU1 (irq_thread / kworker)
wave6_vpu_dec_release()
wave6_vpu_device_run_timeout()
v4l2_m2m_job_finish()
/* clears TRANS_RUNNING */
v4l2_m2m_ctx_release()
kfree(m2m_ctx)
wave6_vpu_core_irq_thread()
wave6_vpu_dec_finish_decode()
...
v4l2_m2m_next_src_buf(m2m_ctx)
<-- use-after-free
wave6_vpu_dec_destroy_instance()
wave6_vpu_disable_instance()
A similar race happens if wave6_vpu_finish_job() calls non-synchronous
cancel_delayed_work(&inst->task_timer) and clears TRANS_RUNNING while
wave6_vpu_device_run_timeout() is already running on another CPU. Calling
wave6_vpu_disable_instance() before v4l2_m2m_ctx_release() would ensure the
IRQ thread and timeout work cannot touch m2m_ctx after it is freed.
--
Sashiko AI review · https://sashiko.dev/#/patchset/cover.1795075577.git.nas.chung@chipsnmedia.com?part=5
next prev parent reply other threads:[~2026-11-19 9:31 UTC|newest]
Thread overview: 22+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-19 8:59 [PATCH v8 00/11] Add support for Wave6 video codec driver Nas Chung
2026-11-19 8:59 ` [PATCH v8 01/11] dt-bindings: media: nxp: Add Wave6 video codec device Nas Chung
2026-11-19 8:59 ` [PATCH v8 02/11] media: chips-media: wave6: Add Wave6 control driver Nas Chung
2026-11-19 9:26 ` sashiko-bot
2026-11-19 8:59 ` [PATCH v8 03/11] media: chips-media: wave6: Add Wave6 core driver Nas Chung
2026-11-19 9:32 ` sashiko-bot
2026-11-19 8:59 ` [PATCH v8 04/11] media: chips-media: wave6: Add Wave6 decoder firmware interface Nas Chung
2026-11-19 9:22 ` sashiko-bot
2026-11-19 8:59 ` [PATCH v8 05/11] media: chips-media: wave6: Add Wave6 m2m decoder Nas Chung
2026-11-19 9:31 ` sashiko-bot [this message]
2026-11-19 9:00 ` [PATCH v8 06/11] media: chips-media: wave6: Add Wave6 encoder firmware interface Nas Chung
2026-11-19 9:10 ` sashiko-bot
2026-11-19 9:00 ` [PATCH v8 07/11] media: chips-media: wave6: Add Wave6 m2m encoder Nas Chung
2026-11-19 9:35 ` sashiko-bot
2026-11-19 9:00 ` [PATCH v8 08/11] media: chips-media: wave6: Add trace and debugfs Nas Chung
2026-11-19 9:14 ` sashiko-bot
2026-11-19 9:00 ` [PATCH v8 09/11] media: chips-media: wave6: Add performance profiling Nas Chung
2026-11-19 9:20 ` sashiko-bot
2026-11-19 9:00 ` [PATCH v8 10/11] media: chips-media: wave6: Add Wave6 thermal cooling device Nas Chung
2026-11-19 9:21 ` sashiko-bot
2026-11-19 9:00 ` [PATCH v8 11/11] arm64: dts: freescale: imx95: Add video codec node Nas Chung
2026-11-19 9:37 ` sashiko-bot
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=sashiko-outbox-222840@kernel.org \
--to=sashiko-bot@kernel.org \
--cc=Frank.Li@kernel.org \
--cc=conor+dt@kernel.org \
--cc=devicetree@vger.kernel.org \
--cc=imx@lists.linux.dev \
--cc=media-ci@linuxtv.org \
--cc=nas.chung@chipsnmedia.com \
--cc=robh@kernel.org \
--cc=sashiko-reviews@lists.linux.dev \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox