/*
* Copyright (c) 2018-2021 The strace developers.
* All rights reserved.
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "tests.h"
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include "kernel_v4l2_types.h"
static bool
fill_fmt(struct v4l2_format *f)
{
static struct v4l2_clip *clips;
switch (f->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
case V4L2_BUF_TYPE_VIDEO_OUTPUT:
f->fmt.pix.width = 0xdeadc0de;
f->fmt.pix.height = 0xfeedbeef;
f->fmt.pix.pixelformat = 0xb5315258; /* forurcc_be("XR15") */
f->fmt.pix.field = f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE
? V4L2_FIELD_ALTERNATE : 0xdec0ded1;
f->fmt.pix.bytesperline = 0xbadc0ded;
f->fmt.pix.sizeimage = 0xface1e55;
f->fmt.pix.colorspace = V4L2_COLORSPACE_REC709;
break;
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
f->fmt.win.w.left = 0xa0a1a2a3;
f->fmt.win.w.top = 0xb0b1b2b3;
f->fmt.win.w.width = 0xc0c1c2c3;
f->fmt.win.w.height = 0xd0d1d2d3;
f->fmt.win.field = f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY
? V4L2_FIELD_ANY : 10;
f->fmt.win.chromakey = 0xbeefface;
if (!clips)
clips = tail_alloc(sizeof(*clips) * 3);
f->fmt.win.clips = clips;
f->fmt.win.clips[0].c.left = 0xa4a5a6a7;
f->fmt.win.clips[0].c.top = 0xb4b5b6b7;
f->fmt.win.clips[0].c.width = 0xc4c5c6c7;
f->fmt.win.clips[0].c.height = 0xd4d5d6d7;
f->fmt.win.clips[0].next = clips;
f->fmt.win.clips[1].c.left = 0xa8a9aaab;
f->fmt.win.clips[1].c.top = 0xb8b9babb;
f->fmt.win.clips[1].c.width = 0xc8c9cacb;
f->fmt.win.clips[1].c.height = 0xd8d9dadb;
f->fmt.win.clips[2].c.left = 0xacadaeaf;
f->fmt.win.clips[2].c.top = 0xbcbdbebf;
f->fmt.win.clips[2].c.width = 0xcccdcecf;
f->fmt.win.clips[2].c.height = 0xdcdddedf;
f->fmt.win.clips[2].next = clips + 1;
f->fmt.win.clipcount = f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY
? 4 : 0;
f->fmt.win.bitmap = f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY
? NULL : clips;
break;
case V4L2_BUF_TYPE_VBI_CAPTURE:
case V4L2_BUF_TYPE_VBI_OUTPUT:
f->fmt.vbi.sampling_rate = 0xdecaffed;
f->fmt.vbi.offset = 0xcafefeed;
f->fmt.vbi.samples_per_line = 0xbeefaced;
f->fmt.vbi.sample_format = V4L2_PIX_FMT_RGB555X;
f->fmt.vbi.start[0] = 0xdec0ded0;
f->fmt.vbi.start[1] = 0xdec0ded1;
f->fmt.vbi.count[0] = 0xacceded2;
f->fmt.vbi.count[1] = 0xacceded3;
f->fmt.vbi.flags = f->type == V4L2_BUF_TYPE_VBI_CAPTURE
? 0x3 : 0x1ce50d1c;
break;
case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
f->fmt.pix_mp.width = 0xdeaffade;
f->fmt.pix_mp.height = 0xfadeb1a5;
f->fmt.pix_mp.pixelformat = 0x36314454;
f->fmt.pix_mp.field = V4L2_FIELD_NONE;
f->fmt.pix_mp.colorspace = 13;
for (size_t i = 0; i < VIDEO_MAX_PLANES; i++) {
f->fmt.pix_mp.plane_fmt[i].sizeimage = 0xd0decad0 ^ i;
if (sizeof(f->fmt.pix_mp.plane_fmt[i].bytesperline) ==
sizeof(uint32_t)) {
f->fmt.pix_mp.plane_fmt[i].bytesperline
= 0xd0decad1 ^ i;
} else {
#ifdef WORDS_BIGENDIAN
f->fmt.pix_mp.plane_fmt[i].bytesperline
= 0xd0de;
f->fmt.pix_mp.plane_fmt[i].reserved[0]
= 0xcad1 ^ i;
#else
f->fmt.pix_mp.plane_fmt[i].bytesperline
= 0xcad1 ^ i;
f->fmt.pix_mp.plane_fmt[i].reserved[0]
= 0xd0de;
#endif
}
}
f->fmt.pix_mp.num_planes = f->type ==
V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ? 0xd5 : 0;
break;
case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
f->fmt.sliced.service_set = 0xfeed;
for (size_t i = 0; i < 2; i++) {
for (size_t j = 0; j < 24; j++) {
f->fmt.sliced.service_lines[i][j] =
0xdead ^ (i << 8) ^ j;
}
}
f->fmt.sliced.io_size = 0xdefaceed;
break;
case V4L2_BUF_TYPE_SDR_CAPTURE:
case V4L2_BUF_TYPE_SDR_OUTPUT:
f->fmt.sdr.pixelformat = V4L2_SDR_FMT_CU8;
if (sizeof(f->fmt.sdr.buffersize == sizeof(uint32_t)))
f->fmt.sdr.buffersize = 0xbadc0ded;
else
((uint32_t *) &f->fmt.sdr)[1] = 0xbadc0ded;
break;
case V4L2_BUF_TYPE_META_CAPTURE:
case V4L2_BUF_TYPE_META_OUTPUT:
f->fmt.meta.dataformat = V4L2_META_FMT_VSP1_HGO;
f->fmt.meta.buffersize = 0xbadc0ded;
break;
default:
return false;
}
return true;
}
static void
print_fmt(const char *pfx, struct v4l2_format *f)
{
switch (f->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
case V4L2_BUF_TYPE_VIDEO_OUTPUT:
printf("%sfmt.pix={width=3735929054, height=4276993775"
", pixelformat=" RAW("0xb5315258")
NRAW("v4l2_fourcc('X', 'R', '1', '\\xb5')"
" /* V4L2_PIX_FMT_XRGB555X */")
", field=%s, bytesperline=3134983661"
", sizeimage=4207812181, colorspace="
XLAT_KNOWN(0x3, "V4L2_COLORSPACE_REC709") "}",
pfx, f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE
? XLAT_STR(V4L2_FIELD_ALTERNATE)
: XLAT_UNKNOWN(0xdec0ded1, "V4L2_FIELD_???"));
break;
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
printf("%sfmt.win={w={left=-1600019805, top=-1330531661"
", width=3233923779, height=3503411923}, field=%s"
", chromakey=0xbeefface, clips=[",
pfx, f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY
? XLAT_STR(V4L2_FIELD_ANY)
: XLAT_UNKNOWN(0xa, "V4L2_FIELD_???"));
if (f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY) {
printf("{c={left=-1532647769, top=-1263159625"
", width=3301295815, height=3570783959}}, "
"{c={left=-1465275733, top=-1195787589"
", width=3368667851, height=3638155995}}, "
"{c={left=-1397903697, top=-1128415553"
", width=3436039887, height=3705528031}}, "
"... /* %p */", f->fmt.win.clips + 3);
}
printf("], clipcount=%d, bitmap=",
f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY ? 4 : 0);
if (f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY)
printf("NULL");
else
printf("%p", f->fmt.win.bitmap);
printf(", global_alpha=%#hhx}", f->fmt.win.global_alpha);
break;
case V4L2_BUF_TYPE_VBI_CAPTURE:
case V4L2_BUF_TYPE_VBI_OUTPUT:
printf("%sfmt.vbi={sampling_rate=3737845741, offset=3405709037"
", samples_per_line=3203378413, sample_format="
RAW("0x51424752") NRAW("v4l2_fourcc('R', 'G', 'B', 'Q')"
" /* V4L2_PIX_FMT_RGB555X */")
", start=[-557785392, -557785391]"
", count=[2899238610, 2899238611], flags=%s}",
pfx, f->type == V4L2_BUF_TYPE_VBI_CAPTURE
? XLAT_KNOWN(0x3, "V4L2_VBI_UNSYNC|V4L2_VBI_INTERLACED")
: XLAT_UNKNOWN(0x1ce50d1c, "V4L2_VBI_???"));
break;
case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
printf("%sfmt.pix_mp={width=3736074974, height=4208898469"
", pixelformat=" RAW("0x36314454")
NRAW("v4l2_fourcc('T', 'D', '1', '6')")
", field=%s, colorspace=0xd"
NRAW(" /* V4L2_COLORSPACE_??? */") ", plane_fmt=[",
pfx, XLAT_STR(V4L2_FIELD_NONE));
if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
printf("{sizeimage=3504261840, bytesperline=3504261841}"
", "
"{sizeimage=3504261841, bytesperline=3504261840}"
", "
"{sizeimage=3504261842, bytesperline=3504261843}"
", "
"{sizeimage=3504261843, bytesperline=3504261842}"
", "
"{sizeimage=3504261844, bytesperline=3504261845}"
", "
"{sizeimage=3504261845, bytesperline=3504261844}"
", "
"{sizeimage=3504261846, bytesperline=3504261847}"
", "
"{sizeimage=3504261847, bytesperline=3504261846}"
"], num_planes=213}");
} else {
printf("], num_planes=0}");
}
break;
case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
printf("%sfmt.sliced={service_set="
XLAT_KNOWN(0xfeed, "V4L2_SLICED_VBI_625"
"|V4L2_SLICED_CAPTION_525|0xaaec")
", service_lines=[[0xdead, 0xdeac, 0xdeaf, 0xdeae"
", 0xdea9, 0xdea8, 0xdeab, 0xdeaa, 0xdea5, 0xdea4"
", 0xdea7, 0xdea6, 0xdea1, 0xdea0, 0xdea3, 0xdea2"
", 0xdebd, 0xdebc, 0xdebf, 0xdebe, 0xdeb9, 0xdeb8"
", 0xdebb, 0xdeba], [0xdfad, 0xdfac, 0xdfaf, 0xdfae"
", 0xdfa9, 0xdfa8, 0xdfab, 0xdfaa, 0xdfa5, 0xdfa4"
", 0xdfa7, 0xdfa6, 0xdfa1, 0xdfa0, 0xdfa3, 0xdfa2"
", 0xdfbd, 0xdfbc, 0xdfbf, 0xdfbe, 0xdfb9, 0xdfb8"
", 0xdfbb, 0xdfba]], io_size=3740978925}",
pfx);
break;
case V4L2_BUF_TYPE_SDR_CAPTURE:
case V4L2_BUF_TYPE_SDR_OUTPUT:
printf("%sfmt.sdr={pixelformat=" RAW("0x38305543")
NRAW("v4l2_fourcc('C', 'U', '0', '8')"
" /* V4L2_SDR_FMT_CU8 */")
", buffersize=3134983661}",
pfx);
break;
case V4L2_BUF_TYPE_META_CAPTURE:
case V4L2_BUF_TYPE_META_OUTPUT:
printf("%sfmt.meta={dataformat=" RAW("0x48505356")
NRAW("v4l2_fourcc('V', 'S', 'P', 'H')"
" /* V4L2_META_FMT_VSP1_HGO */")
", buffersize=3134983661}",
pfx);
break;
}
}
int
main(int argc, char **argv)
{
unsigned long num_skip;
long inject_retval;
bool locked = false;
if (argc == 1)
return 0;
if (argc < 3)
error_msg_and_fail("Usage: %s NUM_SKIP INJECT_RETVAL", argv[0]);
num_skip = strtoul(argv[1], NULL, 0);
inject_retval = strtol(argv[2], NULL, 0);
if (inject_retval < 0)
error_msg_and_fail("Expected non-negative INJECT_RETVAL, "
"but got %ld", inject_retval);
for (unsigned int i = 0; i < num_skip; i++) {
long rc = ioctl(-1, VIDIOC_QUERYCAP, NULL);
printf("ioctl(-1, %s, NULL) = %s%s\n",
XLAT_STR(VIDIOC_QUERYCAP), sprintrc(rc),
rc == inject_retval ? " (INJECTED)" : "");
if (rc != inject_retval)
continue;
locked = true;
break;
}
if (!locked)
error_msg_and_fail("Hasn't locked on ioctl(-1"
", VIDIOC_QUERYCAP, NULL) returning %lu",
inject_retval);
/* VIDIOC_QUERYCAP */
struct v4l2_capability *caps = tail_alloc(sizeof(*caps));
fill_memory(caps, sizeof(*caps));
caps->capabilities = 0xdeadbeef;
caps->device_caps = 0xfacefeed;
ioctl(-1, VIDIOC_QUERYCAP, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_QUERYCAP), inject_retval);
ioctl(-1, VIDIOC_QUERYCAP, (char *) caps + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_QUERYCAP), (char *) caps + 1, inject_retval);
ioctl(-1, VIDIOC_QUERYCAP, caps);
printf("ioctl(-1, %s, {driver=", XLAT_STR(VIDIOC_QUERYCAP));
print_quoted_cstring((char *) caps->driver, sizeof(caps->driver));
printf(", card=");
print_quoted_cstring((char *) caps->card, sizeof(caps->card));
printf(", bus_info=");
print_quoted_cstring((char *) caps->bus_info, sizeof(caps->bus_info));
printf(", version="
#ifdef WORDS_BIGENDIAN
XLAT_KNOWN(0xd0d1d2d3, "KERNEL_VERSION(53457, 210, 211)")
#else
XLAT_KNOWN(0xd3d2d1d0, "KERNEL_VERSION(54226, 209, 208)")
#endif
", capabilities=" XLAT_KNOWN(0xdeadbeef,
"V4L2_CAP_VIDEO_CAPTURE|V4L2_CAP_VIDEO_OUTPUT"
"|V4L2_CAP_VIDEO_OVERLAY|V4L2_CAP_VBI_OUTPUT"
"|V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_SLICED_VBI_OUTPUT"
"|V4L2_CAP_VIDEO_OUTPUT_OVERLAY|V4L2_CAP_HW_FREQ_SEEK"
"|V4L2_CAP_RDS_OUTPUT|V4L2_CAP_VIDEO_CAPTURE_MPLANE"
"|V4L2_CAP_VIDEO_OUTPUT_MPLANE|V4L2_CAP_VIDEO_M2M"
"|V4L2_CAP_TUNER|V4L2_CAP_RADIO|V4L2_CAP_MODULATOR"
"|V4L2_CAP_EXT_PIX_FORMAT|V4L2_CAP_META_CAPTURE|V4L2_CAP_ASYNCIO"
"|V4L2_CAP_STREAMING|V4L2_CAP_META_OUTPUT|V4L2_CAP_TOUCH"
"|V4L2_CAP_DEVICE_CAPS|0x40000008"));
printf(", device_caps=" XLAT_KNOWN(0xfacefeed,
"V4L2_CAP_VIDEO_CAPTURE|V4L2_CAP_VIDEO_OVERLAY"
"|V4L2_CAP_VBI_OUTPUT|V4L2_CAP_SLICED_VBI_CAPTURE"
"|V4L2_CAP_SLICED_VBI_OUTPUT|V4L2_CAP_VIDEO_OUTPUT_OVERLAY"
"|V4L2_CAP_HW_FREQ_SEEK|V4L2_CAP_RDS_OUTPUT"
"|V4L2_CAP_VIDEO_CAPTURE_MPLANE|V4L2_CAP_VIDEO_OUTPUT_MPLANE"
"|V4L2_CAP_VIDEO_M2M_MPLANE|V4L2_CAP_VIDEO_M2M|V4L2_CAP_AUDIO"
"|V4L2_CAP_RADIO|V4L2_CAP_MODULATOR|V4L2_CAP_SDR_OUTPUT"
"|V4L2_CAP_META_CAPTURE|V4L2_CAP_ASYNCIO|V4L2_CAP_META_OUTPUT"
"|V4L2_CAP_TOUCH|V4L2_CAP_DEVICE_CAPS|0x60000008"));
printf("}) = %ld (INJECTED)\n", inject_retval);
/* VIDIOC_ENUM_FMT */
static const struct strval32 buf_types[] = {
{ ARG_XLAT_UNKNOWN(0, "V4L2_BUF_TYPE_???") },
{ ARG_XLAT_KNOWN(0x1, "V4L2_BUF_TYPE_VIDEO_CAPTURE") },
{ ARG_XLAT_KNOWN(0x2, "V4L2_BUF_TYPE_VIDEO_OUTPUT") },
{ ARG_XLAT_KNOWN(0x3, "V4L2_BUF_TYPE_VIDEO_OVERLAY") },
{ ARG_XLAT_KNOWN(0x4, "V4L2_BUF_TYPE_VBI_CAPTURE") },
{ ARG_XLAT_KNOWN(0x5, "V4L2_BUF_TYPE_VBI_OUTPUT") },
{ ARG_XLAT_KNOWN(0x6, "V4L2_BUF_TYPE_SLICED_VBI_CAPTURE") },
{ ARG_XLAT_KNOWN(0x7, "V4L2_BUF_TYPE_SLICED_VBI_OUTPUT") },
{ ARG_XLAT_KNOWN(0x8, "V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY") },
{ ARG_XLAT_KNOWN(0x9, "V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE") },
{ ARG_XLAT_KNOWN(0xa, "V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE") },
{ ARG_XLAT_KNOWN(0xb, "V4L2_BUF_TYPE_SDR_CAPTURE") },
{ ARG_XLAT_KNOWN(0xc, "V4L2_BUF_TYPE_SDR_OUTPUT") },
{ ARG_XLAT_KNOWN(0xd, "V4L2_BUF_TYPE_META_CAPTURE") },
{ ARG_XLAT_KNOWN(0xe, "V4L2_BUF_TYPE_META_OUTPUT") },
{ ARG_XLAT_UNKNOWN(0xf, "V4L2_BUF_TYPE_???") },
{ ARG_XLAT_UNKNOWN(0x80, "V4L2_BUF_TYPE_???") },
{ ARG_XLAT_UNKNOWN(0xbadc0ded, "V4L2_BUF_TYPE_???") },
};
static const struct strval32 fmtdesc_flags[] = {
{ ARG_STR(0) },
{ ARG_XLAT_KNOWN(0x1, "V4L2_FMT_FLAG_COMPRESSED") },
{ ARG_XLAT_KNOWN(0x3fe, "V4L2_FMT_FLAG_EMULATED"
"|V4L2_FMT_FLAG_CONTINUOUS_BYTESTREAM"
"|V4L2_FMT_FLAG_DYN_RESOLUTION"
"|V4L2_FMT_FLAG_ENC_CAP_FRAME_INTERVAL"
"|V4L2_FMT_FLAG_CSC_COLORSPACE"
"|V4L2_FMT_FLAG_CSC_XFER_FUNC"
"|V4L2_FMT_FLAG_CSC_YCBCR_ENC"
"|V4L2_FMT_FLAG_CSC_QUANTIZATION"
"|0x200") },
{ ARG_XLAT_UNKNOWN(0xdead0000, "V4L2_FMT_FLAG_???") },
};
static const struct strval32 fmtdesc_fmts[] = {
{ 0x4c47504a, RAW("0x4c47504a")
NRAW("v4l2_fourcc('J', 'P', 'G', 'L')"
" /* V4L2_PIX_FMT_JPGL */") },
{ 0xbadc0ded, RAW("0xbadc0ded")
NRAW("v4l2_fourcc('\\xed', '\\x0d', '\\xdc',"
" '\\xba')") },
};
struct v4l2_fmtdesc *fmtdesc = tail_alloc(sizeof(*fmtdesc));
fill_memory(fmtdesc, sizeof(*fmtdesc));
fmtdesc->index = 0xdeac0de;
ioctl(-1, VIDIOC_ENUM_FMT, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUM_FMT), inject_retval);
ioctl(-1, VIDIOC_ENUM_FMT, (char *) fmtdesc + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUM_FMT), (char *) fmtdesc + 1, inject_retval);
for (size_t i = 0; i < ARRAY_SIZE(buf_types); i++) {
for (size_t j = 0; j < ARRAY_SIZE(fmtdesc_flags); j++) {
for (size_t k = 0; k < ARRAY_SIZE(fmtdesc_fmts); k++) {
fmtdesc->type = buf_types[i].val;
fmtdesc->flags = fmtdesc_flags[j].val;
fmtdesc->pixelformat = fmtdesc_fmts[k].val;
ioctl(-1, VIDIOC_ENUM_FMT, fmtdesc);
printf("ioctl(-1, %s, {index=233488606, type=%s"
", flags=%s, description=",
XLAT_STR(VIDIOC_ENUM_FMT),
buf_types[i].str,
fmtdesc_flags[j].str);
print_quoted_cstring((char *) fmtdesc->description,
sizeof(fmtdesc->description));
printf(", pixelformat=%s}) = %ld (INJECTED)\n",
fmtdesc_fmts[k].str, inject_retval);
fill_memory_ex(fmtdesc->description,
sizeof(fmtdesc->description),
(i * 9 + j) * 7 + k,
(k * 3 + j) * 11 + i + 5);
}
}
}
/* VIDIOC_REQBUFS */
static const struct strval32 reqb_mems[] = {
{ ARG_XLAT_UNKNOWN(0, "V4L2_MEMORY_???") },
{ ARG_XLAT_KNOWN(0x1, "V4L2_MEMORY_MMAP") },
{ ARG_XLAT_KNOWN(0x4, "V4L2_MEMORY_DMABUF") },
{ ARG_XLAT_UNKNOWN(0x5, "V4L2_MEMORY_???") },
{ ARG_XLAT_UNKNOWN(0xbadc0ded, "V4L2_MEMORY_???") },
};
struct v4l2_requestbuffers *reqb = tail_alloc(sizeof(*reqb));
fill_memory(reqb, sizeof(*reqb));
reqb->count = 0xfeedface;
ioctl(-1, VIDIOC_REQBUFS, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_REQBUFS), inject_retval);
ioctl(-1, VIDIOC_REQBUFS, (char *) reqb + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_REQBUFS), (char *) reqb + 1, inject_retval);
for (size_t i = 0; i < MAX(ARRAY_SIZE(buf_types),
ARRAY_SIZE(reqb_mems)); i++) {
reqb->type = buf_types[i % ARRAY_SIZE(buf_types)].val;
reqb->memory = reqb_mems[i % ARRAY_SIZE(reqb_mems)].val;
ioctl(-1, VIDIOC_REQBUFS, reqb);
printf("ioctl(-1, %s, {type=%s, memory=%s"
", count=4277009102 => 4277009102}) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_REQBUFS),
buf_types[i % ARRAY_SIZE(buf_types)].str,
reqb_mems[i % ARRAY_SIZE(reqb_mems)].str,
inject_retval);
}
/* VIDIOC_G_FMT, VIDIOC_S_FMT, VIDIOC_TRY_FMT */
static const struct strval32 fmt_cmds[] = {
{ ARG_STR(VIDIOC_G_FMT) },
{ ARG_STR(VIDIOC_S_FMT) },
{ ARG_STR(VIDIOC_TRY_FMT) },
};
struct v4l2_format *fmt = tail_alloc(sizeof(*fmt));
for (size_t i = 0; i < ARRAY_SIZE(fmt_cmds); i++) {
ioctl(-1, fmt_cmds[i].val, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
sprintxlat(fmt_cmds[i].str, fmt_cmds[i].val, NULL),
inject_retval);
ioctl(-1, fmt_cmds[i].val, (char *) fmt + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
sprintxlat(fmt_cmds[i].str, fmt_cmds[i].val, NULL),
(char *) fmt + 1, inject_retval);
for (size_t j = 0; j < ARRAY_SIZE(buf_types); j++) {
fill_memory(fmt, sizeof(*fmt));
fmt->type = buf_types[j].val;
if (!fill_fmt(fmt))
continue;
ioctl(-1, fmt_cmds[i].val, fmt);
printf("ioctl(-1, %s, {type=%s",
sprintxlat(fmt_cmds[i].str, fmt_cmds[i].val,
NULL),
buf_types[j].str);
print_fmt(", ", fmt);
if (fmt_cmds[i].val != VIDIOC_G_FMT &&
buf_types[j].val != V4L2_BUF_TYPE_VIDEO_OVERLAY &&
buf_types[j].val != 8)
print_fmt("} => {", fmt);
printf("}) = %ld (INJECTED)\n", inject_retval);
}
}
/* VIDIOC_QUERYBUF, VIDIOC_QBUF, VIDIOC_DQBUF */
static const struct strval32 buf_cmds[] = {
{ ARG_STR(VIDIOC_QUERYBUF) },
{ ARG_STR(VIDIOC_QBUF) },
{ ARG_STR(VIDIOC_DQBUF) },
};
kernel_v4l2_buffer_t *buf = tail_alloc(sizeof(*buf));
for (size_t i = 0; i < ARRAY_SIZE(buf_cmds); i++) {
ioctl(-1, buf_cmds[i].val, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
sprintxlat(buf_cmds[i].str, buf_cmds[i].val, NULL),
inject_retval);
ioctl(-1, buf_cmds[i].val, (char *) buf + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
sprintxlat(buf_cmds[i].str, buf_cmds[i].val, NULL),
(char *) buf + 1, inject_retval);
fill_memory(buf, sizeof(*buf));
buf->index = 0xdeadc0de;
buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf->bytesused = 0xdecaffee;
buf->flags = 0x1ff; /* TODO: update */
buf->field = V4L2_FIELD_TOP;
buf->timestamp.tv_sec = 0x1e55c0de;
buf->timestamp.tv_usec = 999999;
buf->timecode.type = V4L2_TC_TYPE_24FPS;
buf->timecode.flags = 0xbeefdeaf;
buf->memory = V4L2_MEMORY_MMAP;
buf->m.offset = 0xfacefeed;
buf->length = 0xcafebed5;
buf->reserved = 0xdeefaced;
ioctl(-1, buf_cmds[i].val, buf);
printf("ioctl(-1, %s, {type="
XLAT_KNOWN(0x1, "V4L2_BUF_TYPE_VIDEO_CAPTURE")
", index=3735929054, memory="
XLAT_KNOWN(0x1, "V4L2_MEMORY_MMAP")
", m.offset=0xfacefeed, length=3405692629"
", bytesused=3737845742, flags=" RAW("0x1ff")
#if !XLAT_RAW
XLAT_KNOWN(0x1ff, "V4L2_BUF_FLAG_MAPPED"
"|V4L2_BUF_FLAG_QUEUED|V4L2_BUF_FLAG_DONE"
"|V4L2_BUF_FLAG_KEYFRAME|V4L2_BUF_FLAG_PFRAME"
"|V4L2_BUF_FLAG_BFRAME|V4L2_BUF_FLAG_ERROR"
"|V4L2_BUF_FLAG_IN_REQUEST|V4L2_BUF_FLAG_TIMECODE") "|"
XLAT_KNOWN(0, "V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN") "|"
XLAT_KNOWN(0, "V4L2_BUF_FLAG_TSTAMP_SRC_EOF")
#endif
"%s, ...}) = %ld (INJECTED)\n",
sprintxlat(buf_cmds[i].str, buf_cmds[i].val, NULL),
buf_cmds[i].val == VIDIOC_DQBUF
? ", timestamp={tv_sec=508936414, tv_usec=999999}" : "",
inject_retval);
buf->type = V4L2_BUF_TYPE_VBI_CAPTURE;
buf->flags = 0x268040;
buf->field = 0xb;
buf->memory = V4L2_MEMORY_USERPTR;
buf->m.userptr = (long) 0xdefaced0dec0ded1LL;
ioctl(-1, buf_cmds[i].val, buf);
printf("ioctl(-1, %s, {type="
XLAT_KNOWN(0x4, "V4L2_BUF_TYPE_VBI_CAPTURE")
", index=3735929054, memory="
XLAT_KNOWN(0x2, "V4L2_MEMORY_USERPTR")
", m.userptr=%p, length=3405692629"
", bytesused=3737845742, flags=" RAW("0x268040")
#if !XLAT_RAW
XLAT_KNOWN(0x200040, "V4L2_BUF_FLAG_ERROR|0x200000") "|"
XLAT_UNKNOWN(0x8000, "V4L2_BUF_FLAG_TIMESTAMP_???") "|"
XLAT_UNKNOWN(0x60000, "V4L2_BUF_FLAG_TSTAMP_SRC_???")
#endif
"%s, ...}) = %ld (INJECTED)\n",
sprintxlat(buf_cmds[i].str, buf_cmds[i].val, NULL),
(void *) (intptr_t) 0xdefaced0dec0ded1LL,
buf_cmds[i].val == VIDIOC_DQBUF
? ", timestamp={tv_sec=508936414, tv_usec=999999}" : "",
inject_retval);
buf->type = 0x9;
buf->flags = 0;
ioctl(-1, buf_cmds[i].val, buf);
printf("ioctl(-1, %s, {type="
XLAT_KNOWN(0x9, "V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE")
", index=3735929054, memory="
XLAT_KNOWN(0x2, "V4L2_MEMORY_USERPTR")
", m.userptr=%p, length=3405692629"
", bytesused=3737845742, flags=" RAW("0")
#if !XLAT_RAW
XLAT_KNOWN(0, "V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN") "|"
XLAT_KNOWN(0, "V4L2_BUF_FLAG_TSTAMP_SRC_EOF")
#endif
"%s, ...}) = %ld (INJECTED)\n",
sprintxlat(buf_cmds[i].str, buf_cmds[i].val, NULL),
(void *) (intptr_t) 0xdefaced0dec0ded1LL,
buf_cmds[i].val == VIDIOC_DQBUF
? ", timestamp={tv_sec=508936414, tv_usec=999999}" : "",
inject_retval);
buf->type = 0xa;
buf->memory = V4L2_MEMORY_OVERLAY;
buf->flags = 0x2000;
ioctl(-1, buf_cmds[i].val, buf);
printf("ioctl(-1, %s, {type="
XLAT_KNOWN(0xa, "V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE")
", index=3735929054, memory="
XLAT_KNOWN(0x3, "V4L2_MEMORY_OVERLAY")
", length=3405692629, bytesused=3737845742"
", flags=" RAW("0x2000")
#if !XLAT_RAW
XLAT_KNOWN(0x2000, "V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC")
"|" XLAT_KNOWN(0, "V4L2_BUF_FLAG_TSTAMP_SRC_EOF")
#endif
"%s, ...}) = %ld (INJECTED)\n",
sprintxlat(buf_cmds[i].str, buf_cmds[i].val, NULL),
buf_cmds[i].val == VIDIOC_DQBUF
? ", timestamp={tv_sec=508936414, tv_usec=999999}" : "",
inject_retval);
}
/* VIDIOC_G_FBUF, VIDIOC_S_FBUF */
static const struct strval32 fbuf_cmds[] = {
{ ARG_STR(VIDIOC_G_FBUF) },
{ ARG_STR(VIDIOC_S_FBUF) },
};
struct v4l2_framebuffer *fbuf = tail_alloc(sizeof(*fbuf));
for (size_t i = 0; i < ARRAY_SIZE(fbuf_cmds); i++) {
ioctl(-1, fbuf_cmds[i].val, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
sprintxlat(fbuf_cmds[i].str, fbuf_cmds[i].val, NULL),
inject_retval);
ioctl(-1, fbuf_cmds[i].val, (char *) fbuf + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
sprintxlat(fbuf_cmds[i].str, fbuf_cmds[i].val, NULL),
(char *) fbuf + 1, inject_retval);
fill_memory32(fbuf, sizeof(*fbuf));
fbuf->base = NULL;
ioctl(-1, fbuf_cmds[i].val, fbuf);
printf("ioctl(-1, %s, {capability=0x80a0c0e0, flags=0x80a0c0e1"
", base=NULL}) = %ld (INJECTED)\n",
sprintxlat(fbuf_cmds[i].str, fbuf_cmds[i].val, NULL),
inject_retval);
}
/* VIDIOC_G_PARM, VIDIOC_S_PARM */
static const struct strval32 sparm_cmds[] = {
{ ARG_STR(VIDIOC_G_PARM) },
{ ARG_STR(VIDIOC_S_PARM) },
};
struct v4l2_streamparm *sparm = tail_alloc(sizeof(*sparm));
for (size_t i = 0; i < ARRAY_SIZE(sparm_cmds); i++) {
ioctl(-1, sparm_cmds[i].val, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
inject_retval);
ioctl(-1, sparm_cmds[i].val, (char *) sparm + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
(char *) sparm + 1, inject_retval);
fill_memory32(sparm, sizeof(*sparm));
ioctl(-1, sparm_cmds[i].val, sparm);
printf("ioctl(-1, %s, {type="
XLAT_UNKNOWN(0x80a0c0e0, "V4L2_BUF_TYPE_???")
"}) = %ld (INJECTED)\n",
sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
inject_retval);
sparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
static const char *parm_str1 = "parm.capture={capability="
XLAT_UNKNOWN(0x80a0c0e1, "V4L2_CAP_???")
", capturemode="
XLAT_UNKNOWN(0x80a0c0e2, "V4L2_MODE_???")
", timeperframe=2158018787/2158018788"
", extendedmode=0x80a0c0e5, readbuffers=2158018790}";
ioctl(-1, sparm_cmds[i].val, sparm);
printf("ioctl(-1, %s, {type="
XLAT_KNOWN(0x1, "V4L2_BUF_TYPE_VIDEO_CAPTURE")
", %s}%s%s%s) = %ld (INJECTED)\n",
sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
parm_str1,
sparm_cmds[i].val == VIDIOC_S_PARM ? " => {" : "",
sparm_cmds[i].val == VIDIOC_S_PARM ? parm_str1 : "",
sparm_cmds[i].val == VIDIOC_S_PARM ? "}" : "",
inject_retval);
sparm->parm.capture.capability = 0x1000;
sparm->parm.capture.capturemode = 0x1;
static const char *parm_str2 = "parm.capture={capability="
XLAT_KNOWN(0x1000, "V4L2_CAP_TIMEPERFRAME")
", capturemode="
XLAT_KNOWN(0x1, "V4L2_MODE_HIGHQUALITY")
", timeperframe=2158018787/2158018788"
", extendedmode=0x80a0c0e5, readbuffers=2158018790}";
ioctl(-1, sparm_cmds[i].val, sparm);
printf("ioctl(-1, %s, {type="
XLAT_KNOWN(0x1, "V4L2_BUF_TYPE_VIDEO_CAPTURE")
", %s}%s%s%s) = %ld (INJECTED)\n",
sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
parm_str2,
sparm_cmds[i].val == VIDIOC_S_PARM ? " => {" : "",
sparm_cmds[i].val == VIDIOC_S_PARM ? parm_str2 : "",
sparm_cmds[i].val == VIDIOC_S_PARM ? "}" : "",
inject_retval);
sparm->type = 0x9;
sparm->parm.capture.capability = 0xdeadbeef;
sparm->parm.capture.capturemode = 0xadec0ded;
ioctl(-1, sparm_cmds[i].val, sparm);
printf("ioctl(-1, %s, {type="
XLAT_KNOWN(0x9, "V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE")
"}) = %ld (INJECTED)\n",
sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
inject_retval);
fill_memory32(sparm, sizeof(*sparm));
sparm->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
static const char *parm_str3 = "parm.output={capability="
XLAT_UNKNOWN(0x80a0c0e1, "V4L2_CAP_???")
", outputmode="
XLAT_UNKNOWN(0x80a0c0e2, "V4L2_MODE_???")
", timeperframe=2158018787/2158018788"
", extendedmode=0x80a0c0e5, writebuffers=2158018790}";
ioctl(-1, sparm_cmds[i].val, sparm);
printf("ioctl(-1, %s, {type="
XLAT_KNOWN(0x2, "V4L2_BUF_TYPE_VIDEO_OUTPUT")
", %s}%s%s%s) = %ld (INJECTED)\n",
sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
parm_str3,
sparm_cmds[i].val == VIDIOC_S_PARM ? " => {" : "",
sparm_cmds[i].val == VIDIOC_S_PARM ? parm_str3 : "",
sparm_cmds[i].val == VIDIOC_S_PARM ? "}" : "",
inject_retval);
}
/* VIDIOC_G_STD, VIDIOC_S_STD */
static const struct strval32 stdid_cmds[] = {
{ ARG_STR(VIDIOC_G_STD) },
{ ARG_STR(VIDIOC_S_STD) },
};
static const struct strval64 stdids[] = {
{ ARG_STR(0) },
{ ARG_STR(0x1) },
{ ARG_STR(0xb000) },
{ ARG_STR(0x3ffffff) },
{ ARG_STR(0xffffffff) },
{ ARG_ULL_STR(0xbadc0deddeadface) },
};
v4l2_std_id *stdid = tail_alloc(sizeof(*stdid));
for (size_t i = 0; i < ARRAY_SIZE(stdid_cmds); i++) {
ioctl(-1, stdid_cmds[i].val, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
sprintxlat(stdid_cmds[i].str, stdid_cmds[i].val, NULL),
inject_retval);
ioctl(-1, stdid_cmds[i].val, (char *) stdid + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
sprintxlat(stdid_cmds[i].str, stdid_cmds[i].val, NULL),
(char *) stdid + 1, inject_retval);
for (size_t j = 0; j < ARRAY_SIZE(stdids); j++) {
*stdid = stdids[j].val;
ioctl(-1, stdid_cmds[i].val, stdid);
printf("ioctl(-1, %s, [%s]) = %ld (INJECTED)\n",
sprintxlat(stdid_cmds[i].str, stdid_cmds[i].val, NULL),
stdids[j].str, inject_retval);
}
}
/* VIDIOC_ENUMSTD */
struct v4l2_standard *std = tail_alloc(sizeof(*std));
ioctl(-1, VIDIOC_ENUMSTD, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUMSTD), inject_retval);
ioctl(-1, VIDIOC_ENUMSTD, (char *) std + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUMSTD), (char *) std + 1, inject_retval);
for (size_t i = 0; i < ARRAY_SIZE(stdids); i++) {
fill_memory32(&std->frameperiod, sizeof(*std) -
offsetof(struct v4l2_standard, frameperiod));
fill_memory_ex(std->name, sizeof(std->name), i * 47 + 1, 255);
std->index = 0xdeadface;
std->id = stdids[i].val;
ioctl(-1, VIDIOC_ENUMSTD, std);
printf("ioctl(-1, %s, {index=3735943886, name=",
XLAT_STR(VIDIOC_ENUMSTD));
print_quoted_cstring((char *) std->name, sizeof(std->name));
printf(", frameperiod=2158018784/2158018785"
", framelines=2158018786}) = %ld (INJECTED)\n",
inject_retval);
}
/* VIDIOC_ENUMINPUT */
static const struct strval32 input_types[] = {
{ ARG_XLAT_UNKNOWN(0, "V4L2_INPUT_TYPE_???") },
{ V4L2_INPUT_TYPE_TUNER,
XLAT_KNOWN(0x1, "V4L2_INPUT_TYPE_TUNER") },
{ V4L2_INPUT_TYPE_CAMERA,
XLAT_KNOWN(0x2, "V4L2_INPUT_TYPE_CAMERA") },
{ ARG_XLAT_UNKNOWN(0x4, "V4L2_INPUT_TYPE_???") },
{ ARG_XLAT_UNKNOWN(0xdeadc0de, "V4L2_INPUT_TYPE_???") },
};
struct v4l2_input *input = tail_alloc(sizeof(*input));
ioctl(-1, VIDIOC_ENUMINPUT, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUMINPUT), inject_retval);
ioctl(-1, VIDIOC_ENUMINPUT, (char *) input + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUMINPUT), (char *) input + 1, inject_retval);
for (size_t i = 0; i < ARRAY_SIZE(stdids); i++) {
for (size_t j = 0; j < ARRAY_SIZE(input_types); j++) {
fill_memory32(input, sizeof(*input));
fill_memory_ex(input->name, sizeof(input->name),
i * 47 + 13, 255);
input->type = input_types[j].val;
input->std = stdids[i].val;
ioctl(-1, VIDIOC_ENUMINPUT, input);
printf("ioctl(-1, %s, {index=2158018784, name=",
XLAT_STR(VIDIOC_ENUMINPUT));
print_quoted_cstring((char *) input->name,
sizeof(input->name));
printf(", type=%s}) = %ld (INJECTED)\n",
input_types[j].str, inject_retval);
}
}
/* VIDIOC_G_CTRL, VIDIOC_S_CTRL */
static const struct strval32 ctrl_cmds[] = {
{ ARG_STR(VIDIOC_G_CTRL) },
{ ARG_STR(VIDIOC_S_CTRL) },
};
struct v4l2_control *ctrl = tail_alloc(sizeof(*ctrl));
for (size_t i = 0; i < ARRAY_SIZE(ctrl_cmds); i++) {
ioctl(-1, ctrl_cmds[i].val, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
sprintxlat(ctrl_cmds[i].str, ctrl_cmds[i].val, NULL),
inject_retval);
ioctl(-1, ctrl_cmds[i].val, (char *) ctrl + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
sprintxlat(ctrl_cmds[i].str, ctrl_cmds[i].val, NULL),
(char *) ctrl + 1, inject_retval);
/* NB: cid printing is mostly tested in ioctl_v4l2.c */
fill_memory32(ctrl, sizeof(*ctrl));
ioctl(-1, ctrl_cmds[i].val, ctrl);
printf("ioctl(-1, %s, {id=0x80a0c0e0"
NRAW(" /* V4L2_CID_??? */")
", value=-2136948511%s}) = %ld (INJECTED)\n",
sprintxlat(ctrl_cmds[i].str, ctrl_cmds[i].val, NULL),
ctrl_cmds[i].val == VIDIOC_S_CTRL
? " => -2136948511" : "",
inject_retval);
}
/* VIDIOC_G_TUNER, VIDIOC_S_TUNER */
static const struct strval32 tuner_cmds[] = {
{ ARG_STR(VIDIOC_G_TUNER) },
{ ARG_STR(VIDIOC_S_TUNER) },
};
static const struct strval32 tuner_types[] = {
{ ARG_XLAT_UNKNOWN(0, "V4L2_TUNER_???") },
{ ARG_XLAT_KNOWN(0x1, "V4L2_TUNER_RADIO") },
{ ARG_XLAT_KNOWN(0x5, "V4L2_TUNER_RF") },
{ ARG_XLAT_UNKNOWN(0x6, "V4L2_TUNER_???") },
{ ARG_XLAT_UNKNOWN(0xdeadc0de, "V4L2_TUNER_???") },
};
static const struct strval32 tuner_caps[] = {
{ ARG_STR(0) },
{ ARG_XLAT_KNOWN(0x1fff, "V4L2_TUNER_CAP_LOW"
"|V4L2_TUNER_CAP_NORM"
"|V4L2_TUNER_CAP_HWSEEK_BOUNDED"
"|V4L2_TUNER_CAP_HWSEEK_WRAP"
"|V4L2_TUNER_CAP_STEREO|V4L2_TUNER_CAP_LANG2"
"|V4L2_TUNER_CAP_LANG1|V4L2_TUNER_CAP_RDS"
"|V4L2_TUNER_CAP_RDS_BLOCK_IO"
"|V4L2_TUNER_CAP_RDS_CONTROLS"
"|V4L2_TUNER_CAP_FREQ_BANDS"
"|V4L2_TUNER_CAP_HWSEEK_PROG_LIM"
"|V4L2_TUNER_CAP_1HZ") },
{ ARG_XLAT_KNOWN(0xdeadc0de, "V4L2_TUNER_CAP_NORM"
"|V4L2_TUNER_CAP_HWSEEK_BOUNDED"
"|V4L2_TUNER_CAP_HWSEEK_WRAP"
"|V4L2_TUNER_CAP_STEREO|V4L2_TUNER_CAP_LANG1"
"|V4L2_TUNER_CAP_RDS|0xdeadc000") },
{ ARG_XLAT_UNKNOWN(0xffffe000, "V4L2_TUNER_CAP_???") },
};
static const struct strval32 tuner_rxsc[] = {
{ ARG_STR(0) },
{ ARG_XLAT_KNOWN(0x1f, "V4L2_TUNER_SUB_MONO"
"|V4L2_TUNER_SUB_STEREO|V4L2_TUNER_SUB_LANG2"
"|V4L2_TUNER_SUB_LANG1|V4L2_TUNER_SUB_RDS") },
{ ARG_XLAT_KNOWN(0xbeefface, "V4L2_TUNER_SUB_STEREO"
"|V4L2_TUNER_SUB_LANG2|V4L2_TUNER_SUB_LANG1"
"|0xbeeffac0") },
{ ARG_XLAT_UNKNOWN(0xffffffe0, "V4L2_TUNER_SUB_???") },
};
static const struct strval32 tuner_amodes[] = {
{ ARG_XLAT_KNOWN(0, "V4L2_TUNER_MODE_MONO") },
{ ARG_XLAT_KNOWN(0x2, "V4L2_TUNER_MODE_LANG2") },
{ ARG_XLAT_KNOWN(0x4, "V4L2_TUNER_MODE_LANG1_LANG2") },
{ ARG_XLAT_UNKNOWN(0x5, "V4L2_TUNER_MODE_???") },
{ ARG_XLAT_UNKNOWN(0xcaffeeed, "V4L2_TUNER_MODE_???") },
};
static const size_t tuner_iters = MAX(MAX(MAX(ARRAY_SIZE(tuner_types),
ARRAY_SIZE(tuner_caps)),
ARRAY_SIZE(tuner_rxsc)),
ARRAY_SIZE(tuner_amodes));
struct v4l2_tuner *tuner = tail_alloc(sizeof(*tuner));
for (size_t i = 0; i < ARRAY_SIZE(tuner_cmds); i++) {
ioctl(-1, tuner_cmds[i].val, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
sprintxlat(tuner_cmds[i].str, tuner_cmds[i].val, NULL),
inject_retval);
ioctl(-1, tuner_cmds[i].val, (char *) tuner + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
sprintxlat(tuner_cmds[i].str, tuner_cmds[i].val, NULL),
(char *) tuner + 1, inject_retval);
for (size_t j = 0; j < tuner_iters; j++) {
fill_memory32(tuner, sizeof(*tuner));
fill_memory_ex(tuner->name, sizeof(tuner->name),
j * 47 + 7, 255);
tuner->type =
tuner_types[j % ARRAY_SIZE(tuner_types)].val;
tuner->capability =
tuner_caps[j % ARRAY_SIZE(tuner_caps)].val;
tuner->rxsubchans =
tuner_rxsc[j % ARRAY_SIZE(tuner_rxsc)].val;
tuner->audmode =
tuner_amodes[j % ARRAY_SIZE(tuner_amodes)].val;
ioctl(-1, tuner_cmds[i].val, tuner);
printf("ioctl(-1, %s, {index=2158018784",
sprintxlat(tuner_cmds[i].str,
tuner_cmds[i].val, NULL));
for (size_t k = 0;
k < (tuner_cmds[i].val == VIDIOC_S_TUNER ? 2 : 1);
k++) {
printf("%sname=", k ? "} => {" : ", ");
print_quoted_cstring((char *) tuner->name,
sizeof(tuner->name));
printf(", type=%s, capability=%s"
", rangelow=2158018795"
", rangehigh=2158018796, rxsubchans=%s"
", audmode=%s, signal=-2136948497"
", afc=-2136948496",
tuner_types[j %
ARRAY_SIZE(tuner_types)].str,
tuner_caps[j %
ARRAY_SIZE(tuner_caps)].str,
tuner_rxsc[j %
ARRAY_SIZE(tuner_rxsc)].str,
tuner_amodes[j %
ARRAY_SIZE(tuner_amodes)].str);
}
printf("}) = %ld (INJECTED)\n", inject_retval);
}
}
/* VIDIOC_QUERYCTRL */
static const struct strval32 cids[] = {
{ ARG_XLAT_UNKNOWN(0, "V4L2_CID_???") },
{ ARG_XLAT_UNKNOWN(0x97abcd, "V4L2_CID_???") },
{ ARG_XLAT_KNOWN(0x980000, "V4L2_CTRL_CLASS_USER+0") },
{ ARG_XLAT_KNOWN(0x990a64,
"V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE") },
{ ARG_XLAT_KNOWN(0xa31234, "V4L2_CTRL_CLASS_DETECT+0x1234") },
{ ARG_XLAT_UNKNOWN(0xa60000, "V4L2_CID_???") },
{ 0xdeadc0de,
#if XLAT_RAW
"0xdeadc0de"
#else
XLAT_KNOWN(0xc0000000, "V4L2_CTRL_FLAG_NEXT_CTRL"
"|V4L2_CTRL_FLAG_NEXT_COMPOUND")
"|0x1eadc0de /* V4L2_CID_??? */"
#endif
},
};
static const struct strval32 ctrl_types[] = {
{ ARG_XLAT_UNKNOWN(0, "V4L2_CTRL_TYPE_???") },
{ ARG_XLAT_KNOWN(0x1, "V4L2_CTRL_TYPE_INTEGER") },
{ ARG_XLAT_KNOWN(0x2, "V4L2_CTRL_TYPE_BOOLEAN") },
{ ARG_XLAT_KNOWN(0x3, "V4L2_CTRL_TYPE_MENU") },
{ ARG_XLAT_KNOWN(0x4, "V4L2_CTRL_TYPE_BUTTON") },
{ ARG_XLAT_KNOWN(0x5, "V4L2_CTRL_TYPE_INTEGER64") },
{ ARG_XLAT_KNOWN(0x6, "V4L2_CTRL_TYPE_CTRL_CLASS") },
{ ARG_XLAT_KNOWN(0x7, "V4L2_CTRL_TYPE_STRING") },
{ ARG_XLAT_KNOWN(0x8, "V4L2_CTRL_TYPE_BITMASK") },
{ ARG_XLAT_KNOWN(0x9, "V4L2_CTRL_TYPE_INTEGER_MENU") },
{ ARG_XLAT_UNKNOWN(0xa, "V4L2_CTRL_TYPE_???") },
{ ARG_XLAT_UNKNOWN(0xff, "V4L2_CTRL_TYPE_???") },
{ ARG_XLAT_KNOWN(0x100, "V4L2_CTRL_TYPE_U8") },
{ ARG_XLAT_KNOWN(0x101, "V4L2_CTRL_TYPE_U16") },
{ ARG_XLAT_KNOWN(0x102, "V4L2_CTRL_TYPE_U32") },
{ ARG_XLAT_UNKNOWN(0x103, "V4L2_CTRL_TYPE_???") },
{ ARG_XLAT_UNKNOWN(0x104, "V4L2_CTRL_TYPE_???") },
{ ARG_XLAT_UNKNOWN(0x105, "V4L2_CTRL_TYPE_???") },
{ ARG_XLAT_KNOWN(0x106, "V4L2_CTRL_TYPE_AREA") },
{ ARG_XLAT_UNKNOWN(0x107, "V4L2_CTRL_TYPE_???") },
{ ARG_XLAT_UNKNOWN(0xdeadc0de, "V4L2_CTRL_TYPE_???") },
};
static const struct strval32 ctrl_flags[] = {
{ ARG_STR(0) },
{ ARG_XLAT_KNOWN(0x7ff, "V4L2_CTRL_FLAG_DISABLED"
"|V4L2_CTRL_FLAG_GRABBED"
"|V4L2_CTRL_FLAG_READ_ONLY"
"|V4L2_CTRL_FLAG_UPDATE"
"|V4L2_CTRL_FLAG_INACTIVE"
"|V4L2_CTRL_FLAG_SLIDER"
"|V4L2_CTRL_FLAG_WRITE_ONLY"
"|V4L2_CTRL_FLAG_VOLATILE"
"|V4L2_CTRL_FLAG_HAS_PAYLOAD"
"|V4L2_CTRL_FLAG_EXECUTE_ON_WRITE"
"|V4L2_CTRL_FLAG_MODIFY_LAYOUT") },
{ ARG_XLAT_KNOWN(0xbeefface, "V4L2_CTRL_FLAG_GRABBED"
"|V4L2_CTRL_FLAG_READ_ONLY"
"|V4L2_CTRL_FLAG_UPDATE"
"|V4L2_CTRL_FLAG_WRITE_ONLY"
"|V4L2_CTRL_FLAG_VOLATILE"
"|V4L2_CTRL_FLAG_EXECUTE_ON_WRITE"
"|0xbeeff800") },
{ ARG_XLAT_UNKNOWN(0xfffff800, "V4L2_CTRL_FLAG_???") },
};
static const size_t qctrl_iters = MAX(MAX(ARRAY_SIZE(cids),
ARRAY_SIZE(ctrl_types)),
ARRAY_SIZE(ctrl_flags));
struct v4l2_queryctrl *qctrl = tail_alloc(sizeof(*qctrl));
ioctl(-1, VIDIOC_QUERYCTRL, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_QUERYCTRL), inject_retval);
ioctl(-1, VIDIOC_QUERYCTRL, (char *) qctrl + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_QUERYCTRL), (char *) qctrl + 1, inject_retval);
for (size_t i = 0; i < qctrl_iters; i++) {
fill_memory32(qctrl, sizeof(*qctrl));
fill_memory_ex(qctrl->name, sizeof(qctrl->name),
i * 47 + 5, 255);
qctrl->id = cids[i % ARRAY_SIZE(cids)].val;
qctrl->type = ctrl_types[i % ARRAY_SIZE(ctrl_types)].val;
qctrl->flags = ctrl_flags[i % ARRAY_SIZE(ctrl_flags)].val;
if (i % 2)
memset(qctrl->reserved, 0, sizeof(qctrl->reserved));
ioctl(-1, VIDIOC_QUERYCTRL, qctrl);
printf("ioctl(-1, %s, {id=%s, type=%s, name=",
XLAT_STR(VIDIOC_QUERYCTRL),
cids[i % ARRAY_SIZE(cids)].str,
ctrl_types[i % ARRAY_SIZE(ctrl_types)].str);
print_quoted_cstring((char *) qctrl->name, sizeof(qctrl->name));
#if VERBOSE
printf(", minimum=-2136948502, maximum=-2136948501"
", step=-2136948500, default_value=-2136948499"
", flags=%s%s",
ctrl_flags[i % ARRAY_SIZE(ctrl_flags)].str,
i % 2 ? "" : ", reserved=[0x80a0c0ef, 0x80a0c0f0]");
#else
printf(", ...");
#endif
printf("}) = %ld (INJECTED)\n", inject_retval);
}
/* VIDIOC_G_INPUT, VIDIOC_S_INPUT */
static const struct strval32 input_cmds[] = {
{ ARG_STR(VIDIOC_G_INPUT) },
{ ARG_STR(VIDIOC_S_INPUT) },
};
static const struct strval32 inputids[] = {
{ ARG_STR(0) },
{ ARG_STR(1) },
{ ARG_STR(1578221295) },
{ ARG_STR(31415926) },
{ ARG_STR(4294967295) },
};
int *inputid = tail_alloc(sizeof(*inputid));
for (size_t i = 0; i < ARRAY_SIZE(input_cmds); i++) {
ioctl(-1, input_cmds[i].val, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
sprintxlat(input_cmds[i].str, input_cmds[i].val, NULL),
inject_retval);
ioctl(-1, input_cmds[i].val, (char *) inputid + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
sprintxlat(input_cmds[i].str, input_cmds[i].val, NULL),
(char *) inputid + 1, inject_retval);
for (size_t j = 0; j < ARRAY_SIZE(inputids); j++) {
*inputid = inputids[j].val;
ioctl(-1, input_cmds[i].val, inputid);
printf("ioctl(-1, %s, [%s]) = %ld (INJECTED)\n",
sprintxlat(input_cmds[i].str, input_cmds[i].val,
NULL),
inputids[j].str, inject_retval);
}
}
/* VIDIOC_CROPCAP */
struct v4l2_cropcap *ccap = tail_alloc(sizeof(*ccap));
fill_memory32(ccap, sizeof(*ccap));
ioctl(-1, VIDIOC_CROPCAP, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_CROPCAP), inject_retval);
ioctl(-1, VIDIOC_CROPCAP, (char *) ccap + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_CROPCAP), (char *) ccap + 1, inject_retval);
for (size_t i = 0; i < ARRAY_SIZE(buf_types); i++) {
ccap->type = buf_types[i].val;
ioctl(-1, VIDIOC_CROPCAP, ccap);
printf("ioctl(-1, %s, {type=%s"
", bounds={left=-2136948511, top=-2136948510"
", width=2158018787, height=2158018788}"
", defrect={left=-2136948507, top=-2136948506"
", width=2158018791, height=2158018792}"
", pixelaspect=2158018793/2158018794})"
" = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_CROPCAP),
buf_types[i].str, inject_retval);
}
/* VIDIOC_G_CROP, VIDIOC_S_CROP */
static const struct strval32 crop_cmds[] = {
{ ARG_STR(VIDIOC_G_CROP) },
{ ARG_STR(VIDIOC_S_CROP) },
};
struct v4l2_crop *crop = tail_alloc(sizeof(*crop));
for (size_t i = 0; i < ARRAY_SIZE(crop_cmds); i++) {
fill_memory32(crop, sizeof(*crop));
ioctl(-1, crop_cmds[i].val, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
sprintxlat(crop_cmds[i].str, crop_cmds[i].val, NULL),
inject_retval);
ioctl(-1, crop_cmds[i].val, (char *) crop + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
sprintxlat(crop_cmds[i].str, crop_cmds[i].val, NULL),
(char *) crop + 1, inject_retval);
for (size_t j = 0; j < ARRAY_SIZE(buf_types); j++) {
crop->type = buf_types[j].val;
ioctl(-1, crop_cmds[i].val, crop);
printf("ioctl(-1, %s, {type=%s, c={left=-2136948511"
", top=-2136948510, width=2158018787"
", height=2158018788}}) = %ld (INJECTED)\n",
sprintxlat(crop_cmds[i].str, crop_cmds[i].val,
NULL),
buf_types[j].str, inject_retval);
}
}
/* VIDIOC_S_EXT_CTRLS, VIDIOC_TRY_EXT_CTRLS, VIDIOC_G_EXT_CTRLS */
static const struct strval32 ectrl_cmds[] = {
{ ARG_STR(VIDIOC_S_EXT_CTRLS) },
{ ARG_STR(VIDIOC_TRY_EXT_CTRLS) },
{ ARG_STR(VIDIOC_G_EXT_CTRLS) },
};
/* static const struct strval32 ectrl_which = {
}; */
struct v4l2_ext_controls *ectrls = tail_alloc(sizeof(*ectrls));
/* struct v4l2_ext_control *ectrl = tail_alloc(sizeof(*ectrl) * 2); */
for (size_t i = 0; i < ARRAY_SIZE(ectrl_cmds); i++) {
fill_memory32(ectrls, sizeof(*ectrls));
ioctl(-1, ectrl_cmds[i].val, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
sprintxlat(ectrl_cmds[i].str, ectrl_cmds[i].val, NULL),
inject_retval);
ioctl(-1, ectrl_cmds[i].val, (char *) ectrls + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
sprintxlat(ectrl_cmds[i].str, ectrl_cmds[i].val, NULL),
(char *) ectrls + 1, inject_retval);
}
/* VIDIOC_ENUM_FRAMESIZES */
static const struct strval32 frmsz_simple_types[] = {
{ ARG_XLAT_UNKNOWN(0, "V4L2_FRMSIZE_TYPE_???") },
{ ARG_XLAT_KNOWN(0x2, "V4L2_FRMSIZE_TYPE_CONTINUOUS") },
{ ARG_XLAT_UNKNOWN(0x4, "V4L2_FRMSIZE_TYPE_???") },
{ ARG_XLAT_UNKNOWN(0xdeadf157, "V4L2_FRMSIZE_TYPE_???") },
};
struct v4l2_frmsizeenum *fse = tail_alloc(sizeof(*fse));
ioctl(-1, VIDIOC_ENUM_FRAMESIZES, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUM_FRAMESIZES), inject_retval);
ioctl(-1, VIDIOC_ENUM_FRAMESIZES, (char *) fse + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUM_FRAMESIZES), (char *) fse + 1,
inject_retval);
fill_memory32(fse, sizeof(*fse));
fse->type = V4L2_FRMSIZE_TYPE_DISCRETE;
ioctl(-1, VIDIOC_ENUM_FRAMESIZES, fse);
printf("ioctl(-1, %s, {index=2158018784, pixel_format="
RAW("0x80a0c0e1")
NRAW("v4l2_fourcc('\\xe1', '\\xc0', '\\xa0', '\\x80')")
", type=" XLAT_KNOWN(0x1, "V4L2_FRMSIZE_TYPE_DISCRETE")
", discrete={width=2158018787, height=2158018788}"
"}) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUM_FRAMESIZES), inject_retval);
fse->pixel_format = 0x5c22270d;
fse->type = V4L2_FRMSIZE_TYPE_STEPWISE;
ioctl(-1, VIDIOC_ENUM_FRAMESIZES, fse);
printf("ioctl(-1, %s, {index=2158018784, pixel_format="
RAW("0x5c22270d")
NRAW("v4l2_fourcc('\\x0d', '\\\'', '\"', '\\\\')")
", type=" XLAT_KNOWN(0x3, "V4L2_FRMSIZE_TYPE_STEPWISE")
", stepwise={min_width=2158018787, max_width=2158018788"
", step_width=2158018789, min_height=2158018790"
", max_height=2158018791, step_height=2158018792}"
"}) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUM_FRAMESIZES), inject_retval);
for (size_t i = 0; i < ARRAY_SIZE(frmsz_simple_types); i++) {
fill_memory32(fse, sizeof(*fse));
fse->type = frmsz_simple_types[i].val;
ioctl(-1, VIDIOC_ENUM_FRAMESIZES, fse);
printf("ioctl(-1, %s, {index=2158018784, pixel_format="
RAW("0x80a0c0e1")
NRAW("v4l2_fourcc('\\xe1', '\\xc0', '\\xa0', '\\x80')")
", type=%s}) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUM_FRAMESIZES),
frmsz_simple_types[i].str, inject_retval);
}
/* VIDIOC_ENUM_FRAMEINTERVALS */
static const struct strval32 frmival_simple_types[] = {
{ ARG_XLAT_UNKNOWN(0, "V4L2_FRMIVAL_TYPE_???") },
{ ARG_XLAT_UNKNOWN(0x4, "V4L2_FRMIVAL_TYPE_???") },
{ ARG_XLAT_UNKNOWN(0xdeadf157, "V4L2_FRMIVAL_TYPE_???") },
};
static const struct strval32 frmival_step_types[] = {
{ ARG_XLAT_KNOWN(0x2, "V4L2_FRMIVAL_TYPE_CONTINUOUS") },
{ ARG_XLAT_KNOWN(0x3, "V4L2_FRMIVAL_TYPE_STEPWISE") },
};
struct v4l2_frmivalenum *fie = tail_alloc(sizeof(*fie));
ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS), inject_retval);
ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, (char *) fie + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS), (char *) fie + 1,
inject_retval);
fill_memory32(fie, sizeof(*fie));
fie->type = V4L2_FRMIVAL_TYPE_DISCRETE;
ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, fie);
printf("ioctl(-1, %s, {index=2158018784, pixel_format="
RAW("0x80a0c0e1")
NRAW("v4l2_fourcc('\\xe1', '\\xc0', '\\xa0', '\\x80')")
", width=2158018786, height=2158018787"
", type=" XLAT_KNOWN(0x1, "V4L2_FRMIVAL_TYPE_DISCRETE")
", discrete=2158018789/2158018790}) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS), inject_retval);
fie->pixel_format = 0x5c22270d;
for (size_t i = 0; i < ARRAY_SIZE(frmival_step_types); i++) {
fie->type = frmival_step_types[i].val;
ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, fie);
printf("ioctl(-1, %s, {index=2158018784, pixel_format="
RAW("0x5c22270d")
NRAW("v4l2_fourcc('\\x0d', '\\\'', '\"', '\\\\')")
", width=2158018786, height=2158018787, type=%s"
", stepwise={min=2158018789/2158018790"
", max=2158018791/2158018792"
", step=2158018793/2158018794}}) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS),
frmival_step_types[i].str, inject_retval);
}
for (size_t i = 0; i < ARRAY_SIZE(frmival_simple_types); i++) {
fill_memory32(fie, sizeof(*fie));
fie->type = frmival_simple_types[i].val;
ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, fie);
printf("ioctl(-1, %s, {index=2158018784, pixel_format="
RAW("0x80a0c0e1")
NRAW("v4l2_fourcc('\\xe1', '\\xc0', '\\xa0', '\\x80')")
", width=2158018786, height=2158018787, type=%s})"
" = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS),
frmival_simple_types[i].str, inject_retval);
}
/* VIDIOC_CREATE_BUFS */
struct v4l2_create_buffers *cbuf = tail_alloc(sizeof(*cbuf));
fill_memory32(cbuf, sizeof(*cbuf));
ioctl(-1, VIDIOC_CREATE_BUFS, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_CREATE_BUFS), inject_retval);
ioctl(-1, VIDIOC_CREATE_BUFS, (char *) cbuf + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_CREATE_BUFS), (char *) cbuf + 1, inject_retval);
for (size_t i = 0; i < MAX(ARRAY_SIZE(buf_types),
ARRAY_SIZE(reqb_mems)); i++) {
cbuf->memory = reqb_mems[i % ARRAY_SIZE(reqb_mems)].val;
cbuf->format.type = buf_types[i % ARRAY_SIZE(buf_types)].val;
if (!fill_fmt(&cbuf->format))
continue;
ioctl(-1, VIDIOC_CREATE_BUFS, cbuf);
printf("ioctl(-1, %s, {count=2158018785, memory=%s"
", format={type=%s",
XLAT_STR(VIDIOC_CREATE_BUFS),
reqb_mems[i % ARRAY_SIZE(reqb_mems)].str,
buf_types[i % ARRAY_SIZE(buf_types)].str);
print_fmt(", ", &cbuf->format);
printf("}}) = %ld ({index=2158018784, count=2158018785})"
" (INJECTED)\n", inject_retval);
}
/* VIDIOC_QUERY_EXT_CTRL */
static const struct strval32 qextc_nrdims[] = {
{ ARG_STR(0) },
{ ARG_STR(3) },
{ ARG_STR(4) },
{ ARG_STR(5) },
{ ARG_STR(3141592653) },
};
static const size_t qextc_iters = MAX(MAX(MAX(ARRAY_SIZE(cids),
ARRAY_SIZE(ctrl_types)),
ARRAY_SIZE(ctrl_flags)),
ARRAY_SIZE(qextc_nrdims));
struct v4l2_query_ext_ctrl *qextc = tail_alloc(sizeof(*qextc));
fill_memory32(qextc, sizeof(*qextc));
ioctl(-1, VIDIOC_QUERY_EXT_CTRL, 0);
printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_QUERY_EXT_CTRL), inject_retval);
ioctl(-1, VIDIOC_QUERY_EXT_CTRL, (char *) qextc + 1);
printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
XLAT_STR(VIDIOC_QUERY_EXT_CTRL),
(char *) qextc + 1, inject_retval);
for (size_t i = 0; i < qextc_iters; i++) {
fill_memory32(qextc, sizeof(*qextc));
fill_memory_ex(qextc->name, sizeof(qextc->name),
i * 49 + 23, 255);
qextc->id = cids[i % ARRAY_SIZE(cids)].val;
qextc->type = ctrl_types[i % ARRAY_SIZE(ctrl_types)].val;
qextc->flags = ctrl_flags[i % ARRAY_SIZE(ctrl_flags)].val;
qextc->nr_of_dims =
qextc_nrdims[ i % ARRAY_SIZE(qextc_nrdims)].val;
qextc->minimum = 0xbadc0deddeadfaceULL;
qextc->maximum = 0xdecaffedbeeff00dULL;
qextc->step = 0xbeaded1dea5a51deULL;
qextc->default_value = 0xca5efade1cedbeefULL;
for (size_t j = 0; j < 2; j++) {
ioctl(-1, VIDIOC_QUERY_EXT_CTRL, qextc);
printf("ioctl(-1, %s, {id=%s, type=%s, name=",
XLAT_STR(VIDIOC_QUERY_EXT_CTRL),
cids[i % ARRAY_SIZE(cids)].str,
ctrl_types[i % ARRAY_SIZE(ctrl_types)].str);
print_quoted_cstring((char *) qextc->name,
sizeof(qextc->name));
#if VERBOSE
printf(", minimum=-4982091772484257074"
", maximum=-2392818855418269683"
", step=13739898750918873566"
", default_value=-3864375598362280209, flags=%s"
", elem_size=2158018803, elems=2158018804"
", nr_of_dims=%s, dims=[%s%s]%s",
ctrl_flags[i % ARRAY_SIZE(ctrl_flags)].str,
qextc_nrdims[i % ARRAY_SIZE(qextc_nrdims)].str,
qextc_nrdims[i % ARRAY_SIZE(qextc_nrdims)].val
? "2158018806, 2158018807, 2158018808" : "",
qextc_nrdims[i % ARRAY_SIZE(qextc_nrdims)].val >
3 ? ", 2158018809" : "",
j ? "" : ", reserved=[0x80a0c0fa"
", 0x80a0c0fb, 0x80a0c0fc, 0x80a0c0fd"
", 0x80a0c0fe, 0x80a0c0ff, 0x80a0c100"
", 0x80a0c101, 0x80a0c102, 0x80a0c103"
", 0x80a0c104, 0x80a0c105, 0x80a0c106"
", 0x80a0c107, 0x80a0c108, 0x80a0c109"
", 0x80a0c10a, 0x80a0c10b, 0x80a0c10c"
", 0x80a0c10d, 0x80a0c10e, 0x80a0c10f"
", 0x80a0c110, 0x80a0c111, 0x80a0c112"
", 0x80a0c113, 0x80a0c114, 0x80a0c115"
", 0x80a0c116, 0x80a0c117, 0x80a0c118"
", 0x80a0c119]"
);
#else
printf(", ...");
#endif
printf("}) = %ld (INJECTED)\n", inject_retval);
memset(qextc->reserved, 0, sizeof(qextc->reserved));
}
}
puts("+++ exited with 0 +++");
return 0;
}