Merge branch 'linus' into core/softlockup

Conflicts:
	kernel/sysctl.c

1 files changed, 87 insertions, 105 deletions

diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c
index 52d687b165e0..f41c6f506f42 100644
--- a/drivers/media/video/v4l2-ioctl.c
+++ b/drivers/media/video/v4l2-ioctl.c
@@ -17,6 +17,7 @@
 #include <linux/kernel.h>
 
 #define __OLD_VIDIOC_ /* To allow fixing old calls */
+#include <linux/videodev.h>
 #include <linux/videodev2.h>
 
 #ifdef CONFIG_VIDEO_V4L1
@@ -24,7 +25,7 @@
 #endif
 #include <media/v4l2-common.h>
 #include <media/v4l2-ioctl.h>
-#include <linux/video_decoder.h>
+#include <media/v4l2-chip-ident.h>
 
 #define dbgarg(cmd, fmt, arg...) \
                 do {                                                    \
@@ -100,25 +101,27 @@ const char *v4l2_norm_to_name(v4l2_std_id id)
 }
 EXPORT_SYMBOL(v4l2_norm_to_name);
 
+/* Returns frame period for the given standard */
+void v4l2_video_std_frame_period(int id, struct v4l2_fract *frameperiod)
+{
+        if (id & V4L2_STD_525_60) {
+                frameperiod->numerator = 1001;
+                frameperiod->denominator = 30000;
+        } else {
+                frameperiod->numerator = 1;
+                frameperiod->denominator = 25;
+        }
+}
+EXPORT_SYMBOL(v4l2_video_std_frame_period);
+
 /* Fill in the fields of a v4l2_standard structure according to the
    'id' and 'transmission' parameters.  Returns negative on error.  */
 int v4l2_video_std_construct(struct v4l2_standard *vs,
                              int id, const char *name)
 {
-        u32 index = vs->index;
-
-        memset(vs, 0, sizeof(struct v4l2_standard));
-        vs->index = index;
-        vs->id    = id;
-        if (id & V4L2_STD_525_60) {
-                vs->frameperiod.numerator = 1001;
-                vs->frameperiod.denominator = 30000;
-                vs->framelines = 525;
-        } else {
-                vs->frameperiod.numerator = 1;
-                vs->frameperiod.denominator = 25;
-                vs->framelines = 625;
-        }
+        vs->id = id;
+        v4l2_video_std_frame_period(id, &vs->frameperiod);
+        vs->framelines = (id & V4L2_STD_525_60) ? 525 : 625;
         strlcpy(vs->name, name, sizeof(vs->name));
         return 0;
 }
@@ -273,19 +276,6 @@ static const char *v4l2_ioctls[] = {
 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
 
 static const char *v4l2_int_ioctls[] = {
-#ifdef CONFIG_VIDEO_V4L1_COMPAT
-        [_IOC_NR(DECODER_GET_CAPABILITIES)]    = "DECODER_GET_CAPABILITIES",
-        [_IOC_NR(DECODER_GET_STATUS)]          = "DECODER_GET_STATUS",
-        [_IOC_NR(DECODER_SET_NORM)]            = "DECODER_SET_NORM",
-        [_IOC_NR(DECODER_SET_INPUT)]           = "DECODER_SET_INPUT",
-        [_IOC_NR(DECODER_SET_OUTPUT)]          = "DECODER_SET_OUTPUT",
-        [_IOC_NR(DECODER_ENABLE_OUTPUT)]       = "DECODER_ENABLE_OUTPUT",
-        [_IOC_NR(DECODER_SET_PICTURE)]         = "DECODER_SET_PICTURE",
-        [_IOC_NR(DECODER_SET_GPIO)]            = "DECODER_SET_GPIO",
-        [_IOC_NR(DECODER_INIT)]                = "DECODER_INIT",
-        [_IOC_NR(DECODER_SET_VBI_BYPASS)]      = "DECODER_SET_VBI_BYPASS",
-        [_IOC_NR(DECODER_DUMP)]                = "DECODER_DUMP",
-#endif
         [_IOC_NR(AUDC_SET_RADIO)]              = "AUDC_SET_RADIO",
 
         [_IOC_NR(TUNER_SET_TYPE_ADDR)]         = "TUNER_SET_TYPE_ADDR",
@@ -654,8 +644,6 @@ static long __video_do_ioctl(struct file *file,
         if (cmd == VIDIOCGMBUF) {
                 struct video_mbuf *p = arg;
 
-                memset(p, 0, sizeof(*p));
-
                 if (!ops->vidiocgmbuf)
                         return ret;
                 ret = ops->vidiocgmbuf(file, fh, p);
@@ -682,7 +670,6 @@ static long __video_do_ioctl(struct file *file,
         case VIDIOC_QUERYCAP:
         {
                 struct v4l2_capability *cap = (struct v4l2_capability *)arg;
-                memset(cap, 0, sizeof(*cap));
 
                 if (!ops->vidioc_querycap)
                         break;
@@ -725,16 +712,8 @@ static long __video_do_ioctl(struct file *file,
         case VIDIOC_ENUM_FMT:
         {
                 struct v4l2_fmtdesc *f = arg;
-                enum v4l2_buf_type type;
-                unsigned int index;
-
-                index = f->index;
-                type  = f->type;
-                memset(f, 0, sizeof(*f));
-                f->index = index;
-                f->type  = type;
 
-                switch (type) {
+                switch (f->type) {
                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
                         if (ops->vidioc_enum_fmt_vid_cap)
                                 ret = ops->vidioc_enum_fmt_vid_cap(file, fh, f);
@@ -771,8 +750,6 @@ static long __video_do_ioctl(struct file *file,
         {
                 struct v4l2_format *f = (struct v4l2_format *)arg;
 
-                memset(f->fmt.raw_data, 0, sizeof(f->fmt.raw_data));
-
                 /* FIXME: Should be one dump per type */
                 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
 
@@ -1088,7 +1065,6 @@ static long __video_do_ioctl(struct file *file,
                         return -EINVAL;
 
                 v4l2_video_std_construct(p, curr_id, descr);
-                p->index = index;
 
                 dbgarg(cmd, "index=%d, id=0x%Lx, name=%s, fps=%d/%d, "
                                 "framelines=%d\n", p->index,
@@ -1153,12 +1129,9 @@ static long __video_do_ioctl(struct file *file,
         case VIDIOC_ENUMINPUT:
         {
                 struct v4l2_input *p = arg;
-                int i = p->index;
 
                 if (!ops->vidioc_enum_input)
                         break;
-                memset(p, 0, sizeof(*p));
-                p->index = i;
 
                 ret = ops->vidioc_enum_input(file, fh, p);
                 if (!ret)
@@ -1197,12 +1170,9 @@ static long __video_do_ioctl(struct file *file,
         case VIDIOC_ENUMOUTPUT:
         {
                 struct v4l2_output *p = arg;
-                int i = p->index;
 
                 if (!ops->vidioc_enum_output)
                         break;
-                memset(p, 0, sizeof(*p));
-                p->index = i;
 
                 ret = ops->vidioc_enum_output(file, fh, p);
                 if (!ret)
@@ -1378,13 +1348,10 @@ static long __video_do_ioctl(struct file *file,
         case VIDIOC_G_AUDIO:
         {
                 struct v4l2_audio *p = arg;
-                __u32 index = p->index;
 
                 if (!ops->vidioc_g_audio)
                         break;
 
-                memset(p, 0, sizeof(*p));
-                p->index = index;
                 ret = ops->vidioc_g_audio(file, fh, p);
                 if (!ret)
                         dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
@@ -1426,7 +1393,7 @@ static long __video_do_ioctl(struct file *file,
 
                 if (!ops->vidioc_g_audout)
                         break;
-                dbgarg(cmd, "Enum for index=%d\n", p->index);
+
                 ret = ops->vidioc_g_audout(file, fh, p);
                 if (!ret)
                         dbgarg2("index=%d, name=%s, capability=%d, "
@@ -1479,15 +1446,10 @@ static long __video_do_ioctl(struct file *file,
         case VIDIOC_G_CROP:
         {
                 struct v4l2_crop *p = arg;
-                __u32 type;
 
                 if (!ops->vidioc_g_crop)
                         break;
 
-                type = p->type;
-                memset(p, 0, sizeof(*p));
-                p->type = type;
-
                 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
                 ret = ops->vidioc_g_crop(file, fh, p);
                 if (!ret)
@@ -1508,16 +1470,11 @@ static long __video_do_ioctl(struct file *file,
         case VIDIOC_CROPCAP:
         {
                 struct v4l2_cropcap *p = arg;
-                __u32 type;
 
                 /*FIXME: Should also show v4l2_fract pixelaspect */
                 if (!ops->vidioc_cropcap)
                         break;
 
-                type = p->type;
-                memset(p, 0, sizeof(*p));
-                p->type = type;
-
                 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
                 ret = ops->vidioc_cropcap(file, fh, p);
                 if (!ret) {
@@ -1533,8 +1490,6 @@ static long __video_do_ioctl(struct file *file,
                 if (!ops->vidioc_g_jpegcomp)
                         break;
 
-                memset(p, 0, sizeof(*p));
-
                 ret = ops->vidioc_g_jpegcomp(file, fh, p);
                 if (!ret)
                         dbgarg(cmd, "quality=%d, APPn=%d, "
@@ -1575,7 +1530,6 @@ static long __video_do_ioctl(struct file *file,
 
                 if (!ops->vidioc_encoder_cmd)
                         break;
-                memset(&p->raw, 0, sizeof(p->raw));
                 ret = ops->vidioc_encoder_cmd(file, fh, p);
                 if (!ret)
                         dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
@@ -1587,7 +1541,6 @@ static long __video_do_ioctl(struct file *file,
 
                 if (!ops->vidioc_try_encoder_cmd)
                         break;
-                memset(&p->raw, 0, sizeof(p->raw));
                 ret = ops->vidioc_try_encoder_cmd(file, fh, p);
                 if (!ret)
                         dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
@@ -1596,23 +1549,18 @@ static long __video_do_ioctl(struct file *file,
         case VIDIOC_G_PARM:
         {
                 struct v4l2_streamparm *p = arg;
-                __u32 type = p->type;
-
-                memset(p, 0, sizeof(*p));
-                p->type = type;
 
                 if (ops->vidioc_g_parm) {
+                        ret = check_fmt(ops, p->type);
+                        if (ret)
+                                break;
                         ret = ops->vidioc_g_parm(file, fh, p);
                 } else {
-                        struct v4l2_standard s;
-
                         if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                                 return -EINVAL;
 
-                        v4l2_video_std_construct(&s, vfd->current_norm,
-                                                 v4l2_norm_to_name(vfd->current_norm));
-
-                        p->parm.capture.timeperframe = s.frameperiod;
+                        v4l2_video_std_frame_period(vfd->current_norm,
+                                                    &p->parm.capture.timeperframe);
                         ret = 0;
                 }
 
@@ -1625,6 +1573,10 @@ static long __video_do_ioctl(struct file *file,
 
                 if (!ops->vidioc_s_parm)
                         break;
+                ret = check_fmt(ops, p->type);
+                if (ret)
+                        break;
+
                 dbgarg(cmd, "type=%d\n", p->type);
                 ret = ops->vidioc_s_parm(file, fh, p);
                 break;
@@ -1632,14 +1584,10 @@ static long __video_do_ioctl(struct file *file,
         case VIDIOC_G_TUNER:
         {
                 struct v4l2_tuner *p = arg;
-                __u32 index = p->index;
 
                 if (!ops->vidioc_g_tuner)
                         break;
 
-                memset(p, 0, sizeof(*p));
-                p->index = index;
-
                 ret = ops->vidioc_g_tuner(file, fh, p);
                 if (!ret)
                         dbgarg(cmd, "index=%d, name=%s, type=%d, "
@@ -1676,8 +1624,6 @@ static long __video_do_ioctl(struct file *file,
                 if (!ops->vidioc_g_frequency)
                         break;
 
-                memset(p->reserved, 0, sizeof(p->reserved));
-
                 ret = ops->vidioc_g_frequency(file, fh, p);
                 if (!ret)
                         dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
@@ -1698,12 +1644,13 @@ static long __video_do_ioctl(struct file *file,
         case VIDIOC_G_SLICED_VBI_CAP:
         {
                 struct v4l2_sliced_vbi_cap *p = arg;
-                __u32 type = p->type;
 
                 if (!ops->vidioc_g_sliced_vbi_cap)
                         break;
-                memset(p, 0, sizeof(*p));
-                p->type = type;
+
+                /* Clear up to type, everything after type is zerod already */
+                memset(p, 0, offsetof(struct v4l2_sliced_vbi_cap, type));
+
                 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
                 ret = ops->vidioc_g_sliced_vbi_cap(file, fh, p);
                 if (!ret)
@@ -1745,16 +1692,13 @@ static long __video_do_ioctl(struct file *file,
 
                 if (!ops->vidioc_g_chip_ident)
                         break;
+                p->ident = V4L2_IDENT_NONE;
+                p->revision = 0;
                 ret = ops->vidioc_g_chip_ident(file, fh, p);
                 if (!ret)
                         dbgarg(cmd, "chip_ident=%u, revision=0x%x\n", p->ident, p->revision);
                 break;
         }
-        case VIDIOC_G_CHIP_IDENT_OLD:
-                printk(KERN_ERR "VIDIOC_G_CHIP_IDENT has been deprecated and will disappear in 2.6.30.\n");
-                printk(KERN_ERR "It is a debugging ioctl and must not be used in applications!\n");
-                return -EINVAL;
-
         case VIDIOC_S_HW_FREQ_SEEK:
         {
                 struct v4l2_hw_freq_seek *p = arg;
@@ -1774,8 +1718,6 @@ static long __video_do_ioctl(struct file *file,
                 if (!ops->vidioc_enum_framesizes)
                         break;
 
-                memset(p, 0, sizeof(*p));
-
                 ret = ops->vidioc_enum_framesizes(file, fh, p);
                 dbgarg(cmd,
                         "index=%d, pixelformat=%d, type=%d ",
@@ -1807,8 +1749,6 @@ static long __video_do_ioctl(struct file *file,
                 if (!ops->vidioc_enum_frameintervals)
                         break;
 
-                memset(p, 0, sizeof(*p));
-
                 ret = ops->vidioc_enum_frameintervals(file, fh, p);
                 dbgarg(cmd,
                         "index=%d, pixelformat=%d, width=%d, height=%d, type=%d ",
@@ -1857,6 +1797,45 @@ static long __video_do_ioctl(struct file *file,
         return ret;
 }
 
+/* In some cases, only a few fields are used as input, i.e. when the app sets
+ * "index" and then the driver fills in the rest of the structure for the thing
+ * with that index.  We only need to copy up the first non-input field.  */
+static unsigned long cmd_input_size(unsigned int cmd)
+{
+        /* Size of structure up to and including 'field' */
+#define CMDINSIZE(cmd, type, field)                             \
+        case VIDIOC_##cmd:                                      \
+                return offsetof(struct v4l2_##type, field) +    \
+                        sizeof(((struct v4l2_##type *)0)->field);
+
+        switch (cmd) {
+                CMDINSIZE(ENUM_FMT,             fmtdesc,        type);
+                CMDINSIZE(G_FMT,                format,         type);
+                CMDINSIZE(QUERYBUF,             buffer,         type);
+                CMDINSIZE(G_PARM,               streamparm,     type);
+                CMDINSIZE(ENUMSTD,              standard,       index);
+                CMDINSIZE(ENUMINPUT,            input,          index);
+                CMDINSIZE(G_CTRL,               control,        id);
+                CMDINSIZE(G_TUNER,              tuner,          index);
+                CMDINSIZE(QUERYCTRL,            queryctrl,      id);
+                CMDINSIZE(QUERYMENU,            querymenu,      index);
+                CMDINSIZE(ENUMOUTPUT,           output,         index);
+                CMDINSIZE(G_MODULATOR,          modulator,      index);
+                CMDINSIZE(G_FREQUENCY,          frequency,      tuner);
+                CMDINSIZE(CROPCAP,              cropcap,        type);
+                CMDINSIZE(G_CROP,               crop,           type);
+                CMDINSIZE(ENUMAUDIO,            audio,          index);
+                CMDINSIZE(ENUMAUDOUT,           audioout,       index);
+                CMDINSIZE(ENCODER_CMD,          encoder_cmd,    flags);
+                CMDINSIZE(TRY_ENCODER_CMD,      encoder_cmd,    flags);
+                CMDINSIZE(G_SLICED_VBI_CAP,     sliced_vbi_cap, type);
+                CMDINSIZE(ENUM_FRAMESIZES,      frmsizeenum,    pixel_format);
+                CMDINSIZE(ENUM_FRAMEINTERVALS,  frmivalenum,    height);
+        default:
+                return _IOC_SIZE(cmd);
+        }
+}
+
 long video_ioctl2(struct file *file,
                unsigned int cmd, unsigned long arg)
 {
@@ -1875,13 +1854,7 @@ long video_ioctl2(struct file *file,
                        cmd == VIDIOC_TRY_EXT_CTRLS);
 
         /*  Copy arguments into temp kernel buffer  */
-        switch (_IOC_DIR(cmd)) {
-        case _IOC_NONE:
-                parg = NULL;
-                break;
-        case _IOC_READ:
-        case _IOC_WRITE:
-        case (_IOC_WRITE | _IOC_READ):
+        if (_IOC_DIR(cmd) != _IOC_NONE) {
                 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
                         parg = sbuf;
                 } else {
@@ -1893,10 +1866,19 @@ long video_ioctl2(struct file *file,
                 }
 
                 err = -EFAULT;
-                if (_IOC_DIR(cmd) & _IOC_WRITE)
-                        if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
+                if (_IOC_DIR(cmd) & _IOC_WRITE) {
+                        unsigned long n = cmd_input_size(cmd);
+
+                        if (copy_from_user(parg, (void __user *)arg, n))
                                 goto out;
-                break;
+
+                        /* zero out anything we don't copy from userspace */
+                        if (n < _IOC_SIZE(cmd))
+                                memset((u8 *)parg + n, 0, _IOC_SIZE(cmd) - n);
+                } else {
+                        /* read-only ioctl */
+                        memset(parg, 0, _IOC_SIZE(cmd));
+                }
         }
 
         if (is_ext_ctrl) {