Skip to content

L
linux
Commit 0625b6b8 authored by Xiu Jianfeng's avatar Xiu Jianfeng Committed by Mauro Carvalho Chehab
Browse files
Options

media: v4l: Use memset_after() helper 

The CLEAR_AFTER_FIELD defined here is functionally the same as
memset_after() helper, so replace it with memset_after() to simplify the
code, no functional change in this patch.
Signed-off-by: default avatarXiu Jianfeng <xiujianfeng@huawei.com>
Reviewed-by: default avatarLaurent Pinchart <laurent.pinchart@ideasonboard.com>
Acked-by: default avatarSakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: default avatarHans Verkuil <hverkuil-cisco@xs4all.nl>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@kernel.org>
parent 928a6ea4
Hide whitespace changes
Inline Side-by-side
Showing with 39 additions and 45 deletions
drivers/media/v4l2-core/v4l2-ioctl.c
View file @ 0625b6b8
...@@ -31,12 +31,6 @@ ...@@ -31,12 +31,6 @@
#include <trace/events/v4l2.h> #include <trace/events/v4l2.h>
/* Zero out the end of the struct pointed to by p. Everything after, but
* not including, the specified field is cleared. */
#define CLEAR_AFTER_FIELD(p, field) \
memset((u8 *)(p) + offsetof(typeof(*(p)), field) + sizeof((p)->field), \
0, sizeof(*(p)) - offsetof(typeof(*(p)), field) - sizeof((p)->field))
#define is_valid_ioctl(vfd, cmd) test_bit(_IOC_NR(cmd), (vfd)->valid_ioctls) #define is_valid_ioctl(vfd, cmd) test_bit(_IOC_NR(cmd), (vfd)->valid_ioctls)
struct std_descr { struct std_descr {
...@@ -1531,7 +1525,7 @@ static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops, ...@@ -1531,7 +1525,7 @@ static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops,
p->mbus_code = 0; p->mbus_code = 0;
mbus_code = p->mbus_code; mbus_code = p->mbus_code;
CLEAR_AFTER_FIELD(p, type); memset_after(p, 0, type);
p->mbus_code = mbus_code; p->mbus_code = mbus_code;
switch (p->type) { switch (p->type) {
...@@ -1706,7 +1700,7 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, ...@@ -1706,7 +1700,7 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops,
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (unlikely(!ops->vidioc_s_fmt_vid_cap)) if (unlikely(!ops->vidioc_s_fmt_vid_cap))
break; break;
CLEAR_AFTER_FIELD(p, fmt.pix); memset_after(p, 0, fmt.pix);
ret = ops->vidioc_s_fmt_vid_cap(file, fh, arg); ret = ops->vidioc_s_fmt_vid_cap(file, fh, arg);
/* just in case the driver zeroed it again */ /* just in case the driver zeroed it again */
p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC; p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
...@@ -1716,30 +1710,30 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, ...@@ -1716,30 +1710,30 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops,
case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
if (unlikely(!ops->vidioc_s_fmt_vid_cap_mplane)) if (unlikely(!ops->vidioc_s_fmt_vid_cap_mplane))
break; break;
CLEAR_AFTER_FIELD(p, fmt.pix_mp.xfer_func); memset_after(p, 0, fmt.pix_mp.xfer_func);
for (i = 0; i < p->fmt.pix_mp.num_planes; i++) for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
CLEAR_AFTER_FIELD(&p->fmt.pix_mp.plane_fmt[i], memset_after(&p->fmt.pix_mp.plane_fmt[i],
bytesperline); 0, bytesperline);
return ops->vidioc_s_fmt_vid_cap_mplane(file, fh, arg); return ops->vidioc_s_fmt_vid_cap_mplane(file, fh, arg);
case V4L2_BUF_TYPE_VIDEO_OVERLAY: case V4L2_BUF_TYPE_VIDEO_OVERLAY:
if (unlikely(!ops->vidioc_s_fmt_vid_overlay)) if (unlikely(!ops->vidioc_s_fmt_vid_overlay))
break; break;
CLEAR_AFTER_FIELD(p, fmt.win); memset_after(p, 0, fmt.win);
return ops->vidioc_s_fmt_vid_overlay(file, fh, arg); return ops->vidioc_s_fmt_vid_overlay(file, fh, arg);
case V4L2_BUF_TYPE_VBI_CAPTURE: case V4L2_BUF_TYPE_VBI_CAPTURE:
if (unlikely(!ops->vidioc_s_fmt_vbi_cap)) if (unlikely(!ops->vidioc_s_fmt_vbi_cap))
break; break;
CLEAR_AFTER_FIELD(p, fmt.vbi.flags); memset_after(p, 0, fmt.vbi.flags);
return ops->vidioc_s_fmt_vbi_cap(file, fh, arg); return ops->vidioc_s_fmt_vbi_cap(file, fh, arg);
case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
if (unlikely(!ops->vidioc_s_fmt_sliced_vbi_cap)) if (unlikely(!ops->vidioc_s_fmt_sliced_vbi_cap))
break; break;
CLEAR_AFTER_FIELD(p, fmt.sliced.io_size); memset_after(p, 0, fmt.sliced.io_size);
return ops->vidioc_s_fmt_sliced_vbi_cap(file, fh, arg); return ops->vidioc_s_fmt_sliced_vbi_cap(file, fh, arg);
case V4L2_BUF_TYPE_VIDEO_OUTPUT: case V4L2_BUF_TYPE_VIDEO_OUTPUT:
if (unlikely(!ops->vidioc_s_fmt_vid_out)) if (unlikely(!ops->vidioc_s_fmt_vid_out))
break; break;
CLEAR_AFTER_FIELD(p, fmt.pix); memset_after(p, 0, fmt.pix);
ret = ops->vidioc_s_fmt_vid_out(file, fh, arg); ret = ops->vidioc_s_fmt_vid_out(file, fh, arg);
/* just in case the driver zeroed it again */ /* just in case the driver zeroed it again */
p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC; p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
...@@ -1747,45 +1741,45 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, ...@@ -1747,45 +1741,45 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops,
case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
if (unlikely(!ops->vidioc_s_fmt_vid_out_mplane)) if (unlikely(!ops->vidioc_s_fmt_vid_out_mplane))
break; break;
CLEAR_AFTER_FIELD(p, fmt.pix_mp.xfer_func); memset_after(p, 0, fmt.pix_mp.xfer_func);
for (i = 0; i < p->fmt.pix_mp.num_planes; i++) for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
CLEAR_AFTER_FIELD(&p->fmt.pix_mp.plane_fmt[i], memset_after(&p->fmt.pix_mp.plane_fmt[i],
bytesperline); 0, bytesperline);
return ops->vidioc_s_fmt_vid_out_mplane(file, fh, arg); return ops->vidioc_s_fmt_vid_out_mplane(file, fh, arg);
case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
if (unlikely(!ops->vidioc_s_fmt_vid_out_overlay)) if (unlikely(!ops->vidioc_s_fmt_vid_out_overlay))
break; break;
CLEAR_AFTER_FIELD(p, fmt.win); memset_after(p, 0, fmt.win);
return ops->vidioc_s_fmt_vid_out_overlay(file, fh, arg); return ops->vidioc_s_fmt_vid_out_overlay(file, fh, arg);
case V4L2_BUF_TYPE_VBI_OUTPUT: case V4L2_BUF_TYPE_VBI_OUTPUT:
if (unlikely(!ops->vidioc_s_fmt_vbi_out)) if (unlikely(!ops->vidioc_s_fmt_vbi_out))
break; break;
CLEAR_AFTER_FIELD(p, fmt.vbi.flags); memset_after(p, 0, fmt.vbi.flags);
return ops->vidioc_s_fmt_vbi_out(file, fh, arg); return ops->vidioc_s_fmt_vbi_out(file, fh, arg);
case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
if (unlikely(!ops->vidioc_s_fmt_sliced_vbi_out)) if (unlikely(!ops->vidioc_s_fmt_sliced_vbi_out))
break; break;
CLEAR_AFTER_FIELD(p, fmt.sliced.io_size); memset_after(p, 0, fmt.sliced.io_size);
return ops->vidioc_s_fmt_sliced_vbi_out(file, fh, arg); return ops->vidioc_s_fmt_sliced_vbi_out(file, fh, arg);
case V4L2_BUF_TYPE_SDR_CAPTURE: case V4L2_BUF_TYPE_SDR_CAPTURE:
if (unlikely(!ops->vidioc_s_fmt_sdr_cap)) if (unlikely(!ops->vidioc_s_fmt_sdr_cap))
break; break;
CLEAR_AFTER_FIELD(p, fmt.sdr.buffersize); memset_after(p, 0, fmt.sdr.buffersize);
return ops->vidioc_s_fmt_sdr_cap(file, fh, arg); return ops->vidioc_s_fmt_sdr_cap(file, fh, arg);
case V4L2_BUF_TYPE_SDR_OUTPUT: case V4L2_BUF_TYPE_SDR_OUTPUT:
if (unlikely(!ops->vidioc_s_fmt_sdr_out)) if (unlikely(!ops->vidioc_s_fmt_sdr_out))
break; break;
CLEAR_AFTER_FIELD(p, fmt.sdr.buffersize); memset_after(p, 0, fmt.sdr.buffersize);
return ops->vidioc_s_fmt_sdr_out(file, fh, arg); return ops->vidioc_s_fmt_sdr_out(file, fh, arg);
case V4L2_BUF_TYPE_META_CAPTURE: case V4L2_BUF_TYPE_META_CAPTURE:
if (unlikely(!ops->vidioc_s_fmt_meta_cap)) if (unlikely(!ops->vidioc_s_fmt_meta_cap))
break; break;
CLEAR_AFTER_FIELD(p, fmt.meta); memset_after(p, 0, fmt.meta);
return ops->vidioc_s_fmt_meta_cap(file, fh, arg); return ops->vidioc_s_fmt_meta_cap(file, fh, arg);
case V4L2_BUF_TYPE_META_OUTPUT: case V4L2_BUF_TYPE_META_OUTPUT:
if (unlikely(!ops->vidioc_s_fmt_meta_out)) if (unlikely(!ops->vidioc_s_fmt_meta_out))
break; break;
CLEAR_AFTER_FIELD(p, fmt.meta); memset_after(p, 0, fmt.meta);
return ops->vidioc_s_fmt_meta_out(file, fh, arg); return ops->vidioc_s_fmt_meta_out(file, fh, arg);
} }
return -EINVAL; return -EINVAL;
...@@ -1808,7 +1802,7 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, ...@@ -1808,7 +1802,7 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops,
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (unlikely(!ops->vidioc_try_fmt_vid_cap)) if (unlikely(!ops->vidioc_try_fmt_vid_cap))
break; break;
CLEAR_AFTER_FIELD(p, fmt.pix); memset_after(p, 0, fmt.pix);
ret = ops->vidioc_try_fmt_vid_cap(file, fh, arg); ret = ops->vidioc_try_fmt_vid_cap(file, fh, arg);
/* just in case the driver zeroed it again */ /* just in case the driver zeroed it again */
p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC; p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
...@@ -1818,30 +1812,30 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, ...@@ -1818,30 +1812,30 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops,
case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
if (unlikely(!ops->vidioc_try_fmt_vid_cap_mplane)) if (unlikely(!ops->vidioc_try_fmt_vid_cap_mplane))
break; break;
CLEAR_AFTER_FIELD(p, fmt.pix_mp.xfer_func); memset_after(p, 0, fmt.pix_mp.xfer_func);
for (i = 0; i < p->fmt.pix_mp.num_planes; i++) for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
CLEAR_AFTER_FIELD(&p->fmt.pix_mp.plane_fmt[i], memset_after(&p->fmt.pix_mp.plane_fmt[i],
bytesperline); 0, bytesperline);
return ops->vidioc_try_fmt_vid_cap_mplane(file, fh, arg); return ops->vidioc_try_fmt_vid_cap_mplane(file, fh, arg);
case V4L2_BUF_TYPE_VIDEO_OVERLAY: case V4L2_BUF_TYPE_VIDEO_OVERLAY:
if (unlikely(!ops->vidioc_try_fmt_vid_overlay)) if (unlikely(!ops->vidioc_try_fmt_vid_overlay))
break; break;
CLEAR_AFTER_FIELD(p, fmt.win); memset_after(p, 0, fmt.win);
return ops->vidioc_try_fmt_vid_overlay(file, fh, arg); return ops->vidioc_try_fmt_vid_overlay(file, fh, arg);
case V4L2_BUF_TYPE_VBI_CAPTURE: case V4L2_BUF_TYPE_VBI_CAPTURE:
if (unlikely(!ops->vidioc_try_fmt_vbi_cap)) if (unlikely(!ops->vidioc_try_fmt_vbi_cap))
break; break;
CLEAR_AFTER_FIELD(p, fmt.vbi.flags); memset_after(p, 0, fmt.vbi.flags);
return ops->vidioc_try_fmt_vbi_cap(file, fh, arg); return ops->vidioc_try_fmt_vbi_cap(file, fh, arg);
case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
if (unlikely(!ops->vidioc_try_fmt_sliced_vbi_cap)) if (unlikely(!ops->vidioc_try_fmt_sliced_vbi_cap))
break; break;
CLEAR_AFTER_FIELD(p, fmt.sliced.io_size); memset_after(p, 0, fmt.sliced.io_size);
return ops->vidioc_try_fmt_sliced_vbi_cap(file, fh, arg); return ops->vidioc_try_fmt_sliced_vbi_cap(file, fh, arg);
case V4L2_BUF_TYPE_VIDEO_OUTPUT: case V4L2_BUF_TYPE_VIDEO_OUTPUT:
if (unlikely(!ops->vidioc_try_fmt_vid_out)) if (unlikely(!ops->vidioc_try_fmt_vid_out))
break; break;
CLEAR_AFTER_FIELD(p, fmt.pix); memset_after(p, 0, fmt.pix);
ret = ops->vidioc_try_fmt_vid_out(file, fh, arg); ret = ops->vidioc_try_fmt_vid_out(file, fh, arg);
/* just in case the driver zeroed it again */ /* just in case the driver zeroed it again */
p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC; p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
...@@ -1849,45 +1843,45 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, ...@@ -1849,45 +1843,45 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops,
case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
if (unlikely(!ops->vidioc_try_fmt_vid_out_mplane)) if (unlikely(!ops->vidioc_try_fmt_vid_out_mplane))
break; break;
CLEAR_AFTER_FIELD(p, fmt.pix_mp.xfer_func); memset_after(p, 0, fmt.pix_mp.xfer_func);
for (i = 0; i < p->fmt.pix_mp.num_planes; i++) for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
CLEAR_AFTER_FIELD(&p->fmt.pix_mp.plane_fmt[i], memset_after(&p->fmt.pix_mp.plane_fmt[i],
bytesperline); 0, bytesperline);
return ops->vidioc_try_fmt_vid_out_mplane(file, fh, arg); return ops->vidioc_try_fmt_vid_out_mplane(file, fh, arg);
case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
if (unlikely(!ops->vidioc_try_fmt_vid_out_overlay)) if (unlikely(!ops->vidioc_try_fmt_vid_out_overlay))
break; break;
CLEAR_AFTER_FIELD(p, fmt.win); memset_after(p, 0, fmt.win);
return ops->vidioc_try_fmt_vid_out_overlay(file, fh, arg); return ops->vidioc_try_fmt_vid_out_overlay(file, fh, arg);
case V4L2_BUF_TYPE_VBI_OUTPUT: case V4L2_BUF_TYPE_VBI_OUTPUT:
if (unlikely(!ops->vidioc_try_fmt_vbi_out)) if (unlikely(!ops->vidioc_try_fmt_vbi_out))
break; break;
CLEAR_AFTER_FIELD(p, fmt.vbi.flags); memset_after(p, 0, fmt.vbi.flags);
return ops->vidioc_try_fmt_vbi_out(file, fh, arg); return ops->vidioc_try_fmt_vbi_out(file, fh, arg);
case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
if (unlikely(!ops->vidioc_try_fmt_sliced_vbi_out)) if (unlikely(!ops->vidioc_try_fmt_sliced_vbi_out))
break; break;
CLEAR_AFTER_FIELD(p, fmt.sliced.io_size); memset_after(p, 0, fmt.sliced.io_size);
return ops->vidioc_try_fmt_sliced_vbi_out(file, fh, arg); return ops->vidioc_try_fmt_sliced_vbi_out(file, fh, arg);
case V4L2_BUF_TYPE_SDR_CAPTURE: case V4L2_BUF_TYPE_SDR_CAPTURE:
if (unlikely(!ops->vidioc_try_fmt_sdr_cap)) if (unlikely(!ops->vidioc_try_fmt_sdr_cap))
break; break;
CLEAR_AFTER_FIELD(p, fmt.sdr.buffersize); memset_after(p, 0, fmt.sdr.buffersize);
return ops->vidioc_try_fmt_sdr_cap(file, fh, arg); return ops->vidioc_try_fmt_sdr_cap(file, fh, arg);
case V4L2_BUF_TYPE_SDR_OUTPUT: case V4L2_BUF_TYPE_SDR_OUTPUT:
if (unlikely(!ops->vidioc_try_fmt_sdr_out)) if (unlikely(!ops->vidioc_try_fmt_sdr_out))
break; break;
CLEAR_AFTER_FIELD(p, fmt.sdr.buffersize); memset_after(p, 0, fmt.sdr.buffersize);
return ops->vidioc_try_fmt_sdr_out(file, fh, arg); return ops->vidioc_try_fmt_sdr_out(file, fh, arg);
case V4L2_BUF_TYPE_META_CAPTURE: case V4L2_BUF_TYPE_META_CAPTURE:
if (unlikely(!ops->vidioc_try_fmt_meta_cap)) if (unlikely(!ops->vidioc_try_fmt_meta_cap))
break; break;
CLEAR_AFTER_FIELD(p, fmt.meta); memset_after(p, 0, fmt.meta);
return ops->vidioc_try_fmt_meta_cap(file, fh, arg); return ops->vidioc_try_fmt_meta_cap(file, fh, arg);
case V4L2_BUF_TYPE_META_OUTPUT: case V4L2_BUF_TYPE_META_OUTPUT:
if (unlikely(!ops->vidioc_try_fmt_meta_out)) if (unlikely(!ops->vidioc_try_fmt_meta_out))
break; break;
CLEAR_AFTER_FIELD(p, fmt.meta); memset_after(p, 0, fmt.meta);
return ops->vidioc_try_fmt_meta_out(file, fh, arg); return ops->vidioc_try_fmt_meta_out(file, fh, arg);
} }
return -EINVAL; return -EINVAL;
...@@ -2086,7 +2080,7 @@ static int v4l_reqbufs(const struct v4l2_ioctl_ops *ops, ...@@ -2086,7 +2080,7 @@ static int v4l_reqbufs(const struct v4l2_ioctl_ops *ops,
if (ret) if (ret)
return ret; return ret;
CLEAR_AFTER_FIELD(p, flags); memset_after(p, 0, flags);
return ops->vidioc_reqbufs(file, fh, p); return ops->vidioc_reqbufs(file, fh, p);
} }
...@@ -2127,7 +2121,7 @@ static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops, ...@@ -2127,7 +2121,7 @@ static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
if (ret) if (ret)
return ret; return ret;
CLEAR_AFTER_FIELD(create, flags); memset_after(create, 0, flags);
v4l_sanitize_format(&create->format); v4l_sanitize_format(&create->format);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7