From patchwork Mon Dec 16 14:14:59 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Arnd Bergmann X-Patchwork-Id: 181722 Delivered-To: patch@linaro.org Received: by 2002:a92:3001:0:0:0:0:0 with SMTP id x1csp4364532ile; Mon, 16 Dec 2019 06:15:26 -0800 (PST) X-Google-Smtp-Source: APXvYqz7P5It6NJfUseUimHNKYXftSNAnaAzL3IpNOcQAsrO+nb5nr2X1CkkA2YaLm1+N8qMCvVZ X-Received: by 2002:a9d:6f07:: with SMTP id n7mr31118056otq.112.1576505726053; Mon, 16 Dec 2019 06:15:26 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1576505726; cv=none; d=google.com; s=arc-20160816; b=HaKMlbkdYEChMZ04T9T5G1WZtdTQOVmtb74+UPQs1zN1O1ALgGYnCLnxo+p6caJdGP E4d0NPLxZ4vA1Xd2oN/I64iHVf4r1Mbg+rK4D268UG9tsqfoHUphjJFfzQng34tB6Uf1 p8kGzhZ8PsSNtt0XIGCYYJC86d+xH4DWY4x1gS11eFkYX1Ea/KpimhQ9eTaM9Wd/gS1e k93KL9rSgsfihHYN4OBx1uk/5NWhIZ8wwOrVLeOKOhh2p36aSeLMI3k0gSBCdnb1WdhU 8ExZBbwTBIXTWVC5M5FBXeCtPGQdWxjDuMEYZmLnpS9sM6EcNye+sWQ2Mvc6fb+TUuvW FQ0A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from; bh=FGnEuULmOQEosccT0MbJQIQkxw04fjuhnBMHKGgkags=; b=bVL7vK2EXpfM+N2yxRYxPhAT7+yvWTnYeJ5OhNV+kcE58BMFiWj1aamS2Vab7xOk/n RC6kZ84Zd/QpzLAT3IMrub53IPhtAAHOeTk/0f8CcfRf0NiuPr6oXPiJ16CG8iyv2U7I P61xHUTPNrktNp+qDshlk0DX9zUoPf6bm2/v6lLtCFahLD7SfhOK37SNThVkyTLr1hpK KRDmwYJf3p9j216AtlHwEFIgikYPDbDgt7bB1hnwYywIx1GjhziR0w8eYJIx/XlovqFE lu3GZvUwpSfXbTkkxMf9MsT4xs20GNrI+ehAIPo3V5FvCzgHAHf7WfMTn5JjJflY3oKS iWEQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id c6si10290958oto.283.2019.12.16.06.15.25; Mon, 16 Dec 2019 06:15:26 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728141AbfLPOPY (ORCPT + 27 others); Mon, 16 Dec 2019 09:15:24 -0500 Received: from mout.kundenserver.de ([212.227.17.24]:46103 "EHLO mout.kundenserver.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727916AbfLPOPW (ORCPT ); Mon, 16 Dec 2019 09:15:22 -0500 Received: from threadripper.lan ([149.172.19.189]) by mrelayeu.kundenserver.de (mreue106 [212.227.15.145]) with ESMTPA (Nemesis) id 1N5n81-1heC4G3ZV5-017ASQ; Mon, 16 Dec 2019 15:15:15 +0100 From: Arnd Bergmann To: Hans Verkuil Cc: linux-media@vger.kernel.org, mchehab@kernel.org, y2038@lists.linaro.org, linux-kernel@vger.kernel.org, arnd@arndb.de Subject: [PATCH v6 1/8] media: documentation: fix video_event description Date: Mon, 16 Dec 2019 15:14:59 +0100 Message-Id: <20191216141506.121728-2-arnd@arndb.de> X-Mailer: git-send-email 2.20.0 In-Reply-To: <20191216141506.121728-1-arnd@arndb.de> References: <20191216141506.121728-1-arnd@arndb.de> MIME-Version: 1.0 X-Provags-ID: V03:K1:l65Lc1/FkWPwDQ+nv9GAC8gMZdZcNTsq7qLr/PeIeNXZa9/XQIc oHOZWL23uwgQVPrt/tC03iMLEaz1Q8YX37wJOlKdHMvYQml0tfYFTVKH/lQfTPrrrssRplC Zzio32EYpfRM/kf69UDAq69KRnvoEHiIhv3jH2vnd9e50ftDVK2e+7QzOwq4/4goCKg8fz2 w03lYTlYR2bcVMym+7abQ== X-Spam-Flag: NO X-UI-Out-Filterresults: notjunk:1; V03:K0:5tOPNtrtlPc=:JAPgd2SD6cMSpFBDwA1Kif mx8vcZ8aoyEoLc5X9F6yqyBxsf7Jch+idU7Ae1Mp7QLm1tBzaoG7a2hQ1OKDwfUNIldR1e1RU 5JxOCJTQxGK6zGqk+HOL6iEIlJ9Jd1XsBXZWIYUUP5we4PCnL9eeSRZpkmi1Q0I2TaUVF9BF3 KcAzvQc28zUA/rBpBuO6o2M1hhK+dFgrVwF6PK6Z+B1Pae2qOfgwfZNN0wYU63fTZwxOSqu7/ 2IZ91VZ2pEthdaayS+uFRriVOQ+CuRRCUiE78sXnsaP1pZmJDfOwuMRhpFZHyh0uoZ8ebcwa9 X/ZLwgQd9+nQ20Eidplk5mb19UvNV0FXDG1ovj7qwdBEg9xv8WpVccpVWpoGormKoIUUk/To4 1KBYIQVGx4Nzf3tucyG6uakdjo4kYWGOxejT+FJaH6mON47trvOb4qH9xaKDW9YPr78oy3Ew2 cWOVeww4WrmVfx+a83VBG3sNalc6r4w/82F0KUzKQNOp4ZgEoaQiE2YR0CTlv711+a3ywAb+8 o6YsR760R6EglHIUk57T/epBOTPgCk7mwVrcmnqGXosSBhikmn/9/XuBTFTPhHXYWbVvcCZeq aylAHL7X9gypw1Reb4DAK5TRAdIwW0CE4EDOUCACVrR5OAyArNZ0qvXL+fZZJK7A0TuwEg5Kh 0rELkiK8nS2uLisbXLBvdc7edY7Hxes8DMOMAsV67yDQKEMQaKOG6+xymGzEbuNi8d0/Pdez4 I8d7mvNpN80PIM26bRu/6+zoE5O5Dw46PINc8iRDGr4bX7saatIW/nrRHQan4SpUyqHSPUxBU Aqaec4SNhCtoX6/m/oqNrL3PMTfsAG7RSyHZkYiTM3U30mPU2DyYtZ7a/fgdqcv3gtw5JAR98 wFEoTosBjaoxvhuVPG7g== Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The type for the timestamp in video_event was changed to 'long' a long time ago, change the documentation to match. Signed-off-by: Arnd Bergmann --- Documentation/media/uapi/dvb/video-get-event.rst | 2 +- Documentation/media/uapi/dvb/video_types.rst | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) -- 2.20.0 diff --git a/Documentation/media/uapi/dvb/video-get-event.rst b/Documentation/media/uapi/dvb/video-get-event.rst index def6c40db601..7f03fbe3d3b0 100644 --- a/Documentation/media/uapi/dvb/video-get-event.rst +++ b/Documentation/media/uapi/dvb/video-get-event.rst @@ -81,7 +81,7 @@ for this ioctl call. #define VIDEO_EVENT_FRAME_RATE_CHANGED 2 #define VIDEO_EVENT_DECODER_STOPPED 3 #define VIDEO_EVENT_VSYNC 4 - __kernel_time_t timestamp; + long timestamp; union { video_size_t size; unsigned int frame_rate; /* in frames per 1000sec */ diff --git a/Documentation/media/uapi/dvb/video_types.rst b/Documentation/media/uapi/dvb/video_types.rst index 479942ce6fb8..2697400ccf62 100644 --- a/Documentation/media/uapi/dvb/video_types.rst +++ b/Documentation/media/uapi/dvb/video_types.rst @@ -170,7 +170,7 @@ VIDEO_GET_EVENT call. #define VIDEO_EVENT_FRAME_RATE_CHANGED 2 #define VIDEO_EVENT_DECODER_STOPPED 3 #define VIDEO_EVENT_VSYNC 4 - __kernel_time_t timestamp; + long timestamp; union { video_size_t size; unsigned int frame_rate; /* in frames per 1000sec */ From patchwork Mon Dec 16 14:15:02 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Arnd Bergmann X-Patchwork-Id: 181728 Delivered-To: patch@linaro.org Received: by 2002:a92:3001:0:0:0:0:0 with SMTP id x1csp4365234ile; Mon, 16 Dec 2019 06:15:55 -0800 (PST) X-Google-Smtp-Source: APXvYqzzQ5kdosHw8OovU/MluKUYN5pVfSYy5pu1sNkgPGiZmQr3oIgV7Sj7yjy5goq2b3n+Fc0/ X-Received: by 2002:a9d:7410:: with SMTP id n16mr33017791otk.23.1576505755284; Mon, 16 Dec 2019 06:15:55 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1576505755; cv=none; d=google.com; s=arc-20160816; b=Z43y5q+3RrOJUHoG+my8MzsxchpEnEB72GR2gymi6YIn1G9dbUQjtWl3VWaoYxfoCq AcOaZvwKGDF3CBU1gra+iLirBbJQBhTG4V1A97dN/VgrB9bBbDkql3sMljfw8LHS8BwF FukMKHe7NSMetnSDV77h5hdXLETQXW6lSXtyvZNvy2Ta9DIBITozhvfzoo8qHZHp/vVD 3ISm3bpyzXeRzNDz9VD35iEoomtngqL6MkgrFLPf8Pecc8orejfSBe0b2qbwF1wCtM1/ L0DxJF4vft6mCAPzIunMG8VEDtZA7cP3aRdqZ+jrUM87pqBeIF+qYxUOxf52TI3JZwio 3bDQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from; bh=+RvwWob/3fO3kIKeSqhvMFrSgdAdEGAi7adKfZtzJao=; b=SHLyE/Jq5L8mx0vFXw+6KC1qJP7l+OOMeP2Yqyb/Oe0nqchQEUUL3EMn7d60hmzOag 08W4kcv36VwRiuvocbboMfV0mm0TsFsMz26DvDYacXdh47oFIrc+tsLBi8ry7XOvIkKu k6OAUKyuQvdb/FuLP+nozLRSbEqOpjgr0wDGeKhue69dTo1JnW3UsYSkxJO5qZlgCmaJ i8w8kxbrYq7wLc7YHvA3dr9DgoDxdgiT8DitRftDL/PgJaYQm4zycKb32zhnYGZ99BLP l0/lbu1JPlrGomvY0VzVyCYfuqGgDPBXKzyXTIAoZNc14W3L3Je94+ECVR68nhvKGue0 /w3A== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id s26si10052352otr.38.2019.12.16.06.15.54; Mon, 16 Dec 2019 06:15:55 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728257AbfLPOPy (ORCPT + 27 others); Mon, 16 Dec 2019 09:15:54 -0500 Received: from mout.kundenserver.de ([217.72.192.75]:50961 "EHLO mout.kundenserver.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728087AbfLPOPX (ORCPT ); Mon, 16 Dec 2019 09:15:23 -0500 Received: from threadripper.lan ([149.172.19.189]) by mrelayeu.kundenserver.de (mreue106 [212.227.15.145]) with ESMTPA (Nemesis) id 1N2mS2-1hiL4S2aQW-01347x; Mon, 16 Dec 2019 15:15:16 +0100 From: Arnd Bergmann To: Hans Verkuil Cc: linux-media@vger.kernel.org, mchehab@kernel.org, y2038@lists.linaro.org, linux-kernel@vger.kernel.org, arnd@arndb.de Subject: [PATCH v6 4/8] media: v4l2-core: split out data copy from video_usercopy Date: Mon, 16 Dec 2019 15:15:02 +0100 Message-Id: <20191216141506.121728-5-arnd@arndb.de> X-Mailer: git-send-email 2.20.0 In-Reply-To: <20191216141506.121728-1-arnd@arndb.de> References: <20191216141506.121728-1-arnd@arndb.de> MIME-Version: 1.0 X-Provags-ID: V03:K1:7JSUzHfz/mbuQfJNavPjiqCzsXGd9fJEom9KwECjrbOwLFc6TMp Gj5Yste2o4h31yzfmrpmkyiRypci3Q4f4AaBDHDCMVtMwJzz8J6UjjNEknexRZvyTuUtkJs YJ7cAY9P+OzZrpzTkwlzA+B759mTBD9eTQJkqhGxdiHjYtFNWVZN6NZSUNtJiTkSWhNwESD mOQUR+cjtUU9feZ50vmlA== X-Spam-Flag: NO X-UI-Out-Filterresults: notjunk:1; V03:K0:6Nv+ryBJKpw=:nAQQwoyLzZ9/6s8J8JNNLb mGDeh9Otfxwg+rBZ9M2vJOWW+88D6/tw6rPvaU9bgwBYN+MYBLsldvAn5TE6pxCLc4lJq9H6H VCaISPOswiNyWorwtxGHJ/BzXt7KXwzQg5c8jIvinIqTI4zjKgnUc54vdf5sGKHZ7N1YT1LWQ U4vHGbDvYsWzsti455fEncN9MrhvNklWj67tRlaKJ7GhUkBxvleUz9r4xuRsnJvqfXGuXdUWu NFuPctBEPAOXdWef0Pq53Myj1SxsAUyiyeSkZKidRPfQhUZc8xiN1amBCBsq8E1t2ERMRBKXj 2iC4hLwjbLrKBPRMODst0dg7SvXLGSMjhL0VXfUIaa8Pjjr6wynW27hiRpqV5FBkhSDtN9g0p 8ao9mlKTkVbci8qyg/5immco3F9YJBNgC04AUYH4rz+zqhrwGROqBWNTzWui59Zaq9Q9r93nQ o6SRppmdKuGfy/CPBLYI7eZ94SVojVB5gUTgvZoGLklxzDvGGvVV+J3husVL8y4TiW1NZcguo QODLRBjZRV6MMxryz2n0zEFWxU94L5Eg/QHGWAB43UbHKOp5DwU23EDbW6/Ac7H132cRwkMGE N55LLYjFgUqoy4W33ZIAE7zxrcaSpIV+TvOZV6v/UFiv9CZTcvGFuhJZgQ94M+uATKrOc2wGw r611rU3CZJcRSCUs+Kmlxjxj0xnXtWiZiTjeOpvzhhJHCr1E4pRF4xYeG0veKolFQrjGd+k3B m/lM9+yXlEMPuk4OgGZsS01iBVZbyKO0XgAiKSSDP4MbtqTN3YjMEpxwZDuHfAR9oWj99RYCy zrC9KtbDCpnQSjqBzvD0t/ndN/kvvENDo3nJsmYpdatY8JGaqKbAlL6n+1AoZM/zBw+hvS1Sf Tfq4nNqbJK4djw8eAtZQ== Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The copy-in/out portions of video_usercopy() are about to get more complex, so turn then into separate functions as a cleanup first. Signed-off-by: Arnd Bergmann --- drivers/media/v4l2-core/v4l2-ioctl.c | 108 +++++++++++++++++---------- 1 file changed, 69 insertions(+), 39 deletions(-) -- 2.20.0 diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c index 4e700583659b..fe4678965e1b 100644 --- a/drivers/media/v4l2-core/v4l2-ioctl.c +++ b/drivers/media/v4l2-core/v4l2-ioctl.c @@ -3023,8 +3023,69 @@ static int check_array_args(unsigned int cmd, void *parg, size_t *array_size, return ret; } +static unsigned int video_translate_cmd(unsigned int cmd) +{ + return cmd; +} + +static int video_get_user(void __user *arg, void *parg, unsigned int cmd, + bool *always_copy) +{ + unsigned int n = _IOC_SIZE(cmd); + + if (!(_IOC_DIR(cmd) & _IOC_WRITE)) { + /* read-only ioctl */ + memset(parg, 0, n); + return 0; + } + + switch (cmd) { + default: + /* + * 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. + */ + if (v4l2_is_known_ioctl(cmd)) { + u32 flags = v4l2_ioctls[_IOC_NR(cmd)].flags; + + if (flags & INFO_FL_CLEAR_MASK) + n = (flags & INFO_FL_CLEAR_MASK) >> 16; + *always_copy = flags & INFO_FL_ALWAYS_COPY; + } + + if (copy_from_user(parg, (void __user *)arg, n)) + return -EFAULT; + + /* zero out anything we don't copy from userspace */ + if (n < _IOC_SIZE(cmd)) + memset((u8 *)parg + n, 0, _IOC_SIZE(cmd) - n); + break; + } + + return 0; +} + +static int video_put_user(void __user *arg, void *parg, unsigned int cmd) +{ + if (!(_IOC_DIR(cmd) & _IOC_READ)) + return 0; + + switch (cmd) { + default: + /* Copy results into user buffer */ + if (copy_to_user(arg, parg, _IOC_SIZE(cmd))) + return -EFAULT; + break; + } + + return 0; +} + long -video_usercopy(struct file *file, unsigned int cmd, unsigned long arg, +video_usercopy(struct file *file, unsigned int orig_cmd, unsigned long arg, v4l2_kioctl func) { char sbuf[128]; @@ -3036,6 +3097,7 @@ video_usercopy(struct file *file, unsigned int cmd, unsigned long arg, size_t array_size = 0; void __user *user_ptr = NULL; void **kernel_ptr = NULL; + unsigned int cmd = video_translate_cmd(orig_cmd); const size_t ioc_size = _IOC_SIZE(cmd); /* Copy arguments into temp kernel buffer */ @@ -3050,37 +3112,12 @@ video_usercopy(struct file *file, unsigned int cmd, unsigned long arg, parg = mbuf; } - err = -EFAULT; - if (_IOC_DIR(cmd) & _IOC_WRITE) { - unsigned int n = ioc_size; - - /* - * 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. - */ - if (v4l2_is_known_ioctl(cmd)) { - u32 flags = v4l2_ioctls[_IOC_NR(cmd)].flags; - - if (flags & INFO_FL_CLEAR_MASK) - n = (flags & INFO_FL_CLEAR_MASK) >> 16; - always_copy = flags & INFO_FL_ALWAYS_COPY; - } - - if (copy_from_user(parg, (void __user *)arg, n)) - goto out; - - /* zero out anything we don't copy from userspace */ - if (n < ioc_size) - memset((u8 *)parg + n, 0, ioc_size - n); - } else { - /* read-only ioctl */ - memset(parg, 0, ioc_size); - } } + err = video_get_user((void __user *)arg, parg, orig_cmd, &always_copy); + if (err) + goto out; + err = check_array_args(cmd, parg, &array_size, &user_ptr, &kernel_ptr); if (err < 0) goto out; @@ -3131,15 +3168,8 @@ video_usercopy(struct file *file, unsigned int cmd, unsigned long arg, goto out; out_array_args: - /* Copy results into user buffer */ - switch (_IOC_DIR(cmd)) { - case _IOC_READ: - case (_IOC_WRITE | _IOC_READ): - if (copy_to_user((void __user *)arg, parg, ioc_size)) - err = -EFAULT; - break; - } - + if (video_put_user((void __user *)arg, parg, orig_cmd)) + err = -EFAULT; out: kvfree(mbuf); return err; From patchwork Mon Dec 16 14:15:04 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Arnd Bergmann X-Patchwork-Id: 181726 Delivered-To: patch@linaro.org Received: by 2002:a92:3001:0:0:0:0:0 with SMTP id x1csp4364957ile; Mon, 16 Dec 2019 06:15:43 -0800 (PST) X-Google-Smtp-Source: APXvYqy4Z5R0ddIXrns1CrrocTj3G1lrghzd/MPn7xJYy0j2zylYP3tcU72jSri7n/gNaLqK+lVy X-Received: by 2002:aca:3a06:: with SMTP id h6mr9628903oia.137.1576505742829; Mon, 16 Dec 2019 06:15:42 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1576505742; cv=none; d=google.com; s=arc-20160816; b=HtF6fhTwEhWV3kOlAN0oGIDBYV/4FcxJ6u/1pD7n9Ax2m8+V5U1dRGSaO8fyRXBnB3 43oI8L0KGsv3GFg2I2Ibiwym2RXESCv/NIDM85vtanBWzt5R928pZxXVLdYNCXiparBM j2sBDgub5nV4PRTklP9dH2nyrZdRAVL+RaAY4j2E4wpCDH5DjjUuvu9RtKfdbc163K9/ BuFMoqvxL6lkxxi1sc8FU096y685B9YtHtM0PubMIrd/IIujdsagHF3E+0jTFCY9G6K7 FowNN1Ymm1z4FOPylkTOL3TwwuxI7xH517pY2SNbc1QT8NqlCVCTZMYHLqkHWMUkUJXW i8+w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from; bh=xUj0jPOVnaL+Chk+FLVO7nAfRHU8GpsN1NL0vCosaAI=; b=uFVATnwNyF5k4nLt/b5lGk39vrO4FkWxn5CKva8hgMCq9WHaRlIs7m+8QVs7Hr9IJQ 0pJsbQka+WVlZzKR4X+gpgTr3m265a5QDwKa8R/fobR/sGm663jRvKVO1R7wcIHUpMcm uHbZs1latWjUq+20WZho3YVN2j3XY8Tw2q938Bu0AZ5W8l/KIdLYCFwLf9qU8Kjcsn8e G57CxTA9IzbmHNjrtalYGxCH+ssbvidB6kRtIA97pZZGnx+IrZrRTng/GW6D4TYM/U/f wOXrBJgW2cok4tyRCiM8ZcQYLzWBWeHMIFN7ThGN7QAK9ccTUaFgTSxj6GfiIFBJTNGG RVfw== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id k17si10394599oiw.238.2019.12.16.06.15.42; Mon, 16 Dec 2019 06:15:42 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728206AbfLPOPk (ORCPT + 27 others); Mon, 16 Dec 2019 09:15:40 -0500 Received: from mout.kundenserver.de ([217.72.192.74]:33683 "EHLO mout.kundenserver.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728102AbfLPOPY (ORCPT ); Mon, 16 Dec 2019 09:15:24 -0500 Received: from threadripper.lan ([149.172.19.189]) by mrelayeu.kundenserver.de (mreue106 [212.227.15.145]) with ESMTPA (Nemesis) id 1MPGmZ-1iLkIS0Nvp-00PchA; Mon, 16 Dec 2019 15:15:17 +0100 From: Arnd Bergmann To: Hans Verkuil Cc: linux-media@vger.kernel.org, mchehab@kernel.org, y2038@lists.linaro.org, linux-kernel@vger.kernel.org, arnd@arndb.de Subject: [PATCH v6 6/8] media: v4l2-core: fix v4l2_buffer handling for time64 ABI Date: Mon, 16 Dec 2019 15:15:04 +0100 Message-Id: <20191216141506.121728-7-arnd@arndb.de> X-Mailer: git-send-email 2.20.0 In-Reply-To: <20191216141506.121728-1-arnd@arndb.de> References: <20191216141506.121728-1-arnd@arndb.de> MIME-Version: 1.0 X-Provags-ID: V03:K1:ZzV+/SPxEr7IXPzJzPpYUMVeFASoyIg8UxJ2Se0Ka2Peh56qs/M 7tNIapml3ssEA+NgtSlbky8S3z7OCp3Bpggi6t7lhYGO84st0RgxyzODY+GTTzHu4oU85kt /42euk9llt499O9sSxr3JflYCV0S4Y3817RC8EnAOBbfbjWyYIIrro9yc0cdUPfBNKEwLLU 7X4Gk3zaQVT/Uv3aI3/nQ== X-Spam-Flag: NO X-UI-Out-Filterresults: notjunk:1; V03:K0:LqGQjlxwTkQ=:6Pw+0vroXxibuqqglVYvV3 0mWVEMugmcBpqmTu8doft6pPViJldKnPFTphZi/5YzZDSqBrw/CJoUWaZJm/q/TtthYyh478H JBzw5lu8k+seoENVWdIoMCUZDVLrDgC3AscX5nmZ/0VItMjCr037tDCLXeP/cnn4M34RbDiQX PlJ702IDHuZi3Z7P3TcaNYuEqlyQXeM+HHJ45B5Pj/A3FpPT9ZxpkM7/xQVr4nNIpMIIoweRz qiL49C4+W+b73X1r15NZl/G3JX6ZuoARuqdBgX9hG5bjVh/mWpqo9xNunolj0jVdd0mepO+hb TmbIvWgsBTcjtVC14bZksmqx+2MZX67zlQxL3j/7TWiPilzXNtJHcG1mRUyyR0gM4/7mtQ73N kCMNK/YSmaBUzDrtKdOPSeM+j5dDLIXb4Up6dHQowuhFC0D/ZSHdJQ3M2UuaxY368fZ5rRoYq GZiOzx94wu/JaF3oWRHi6Nu6eLbbdqijmcBXJr+stMzQgFfKBdluJWdKIStIhrFECyiPoYtDQ 2hFsJVx2mI6fRcIKO+zp6tDOc6w4zQ0jwrXJ20RN2CgqXNABg1xIGjmzVPjUVD6p2/aWhWF5U FksoEeOxB5ofINheeGmC1ZOLcHHJHNEgkfZdXGKW5+G9kmAckwL4ZMTucsFcXbubnhnEEVRK2 wgQBzjUqjuJQMygibtYZRT6MIWjS2hwbErUh5sSr3MO/mq9GTQwf2LzJS/DFw6AmWShXCdEza Xk2MdpRA7oof4AnxFEGGaNrApcuzmxhsc/w0bqIq82I3jJwZp/OEAo7VsT1CX8m+diswab5zp xODlBfR9+mckmU/VwFW4QRBus5eO5oRTPDkL3D9/Tc7l7hDeDjQBJAOh9HStrje+Qo9Y0ayhr hNXZMJsunlgfnthaOb3Q== Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The v4l2_buffer structure contains a 'struct timeval' member that is defined by the user space C library, creating an ABI incompatibility when that gets updated to a 64-bit time_t. As in v4l2_event, handle this with a special case in video_put_user() and video_get_user() to replace the memcpy there. Since the structure also contains a pointer, there are now two native versions (on 32-bit systems) as well as two compat versions (on 64-bit systems), which unfortunately complicates the compat handler quite a bit. Duplicating the existing handlers for the new types is a safe conversion for now, but unfortunately this may turn into a maintenance burden later. A larger-scale rework of the compat code might be a better alternative, but is out of scope of the y2038 work. Sparc64 needs a special case because of their special suseconds_t definition. Signed-off-by: Arnd Bergmann --- drivers/media/v4l2-core/v4l2-ioctl.c | 74 ++++++++++++++++++++++++++-- include/media/v4l2-ioctl.h | 30 +++++++++++ include/uapi/linux/videodev2.h | 23 +++++++++ 3 files changed, 123 insertions(+), 4 deletions(-) -- 2.20.0 diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c index b066e27e99a2..667225712343 100644 --- a/drivers/media/v4l2-core/v4l2-ioctl.c +++ b/drivers/media/v4l2-core/v4l2-ioctl.c @@ -474,10 +474,10 @@ static void v4l_print_buffer(const void *arg, bool write_only) const struct v4l2_plane *plane; int i; - pr_cont("%02ld:%02d:%02d.%08ld index=%d, type=%s, request_fd=%d, flags=0x%08x, field=%s, sequence=%d, memory=%s", - p->timestamp.tv_sec / 3600, - (int)(p->timestamp.tv_sec / 60) % 60, - (int)(p->timestamp.tv_sec % 60), + pr_cont("%02d:%02d:%02d.%09ld index=%d, type=%s, request_fd=%d, flags=0x%08x, field=%s, sequence=%d, memory=%s", + (int)p->timestamp.tv_sec / 3600, + ((int)p->timestamp.tv_sec / 60) % 60, + ((int)p->timestamp.tv_sec % 60), (long)p->timestamp.tv_usec, p->index, prt_names(p->type, v4l2_type_names), p->request_fd, @@ -3029,6 +3029,14 @@ static unsigned int video_translate_cmd(unsigned int cmd) #ifdef CONFIG_COMPAT_32BIT_TIME case VIDIOC_DQEVENT_TIME32: return VIDIOC_DQEVENT; + case VIDIOC_QUERYBUF_TIME32: + return VIDIOC_QUERYBUF; + case VIDIOC_QBUF_TIME32: + return VIDIOC_QBUF; + case VIDIOC_DQBUF_TIME32: + return VIDIOC_DQBUF; + case VIDIOC_PREPARE_BUF_TIME32: + return VIDIOC_PREPARE_BUF; #endif } @@ -3047,6 +3055,39 @@ static int video_get_user(void __user *arg, void *parg, unsigned int cmd, } switch (cmd) { +#ifdef CONFIG_COMPAT_32BIT_TIME + case VIDIOC_QUERYBUF_TIME32: + case VIDIOC_QBUF_TIME32: + case VIDIOC_DQBUF_TIME32: + case VIDIOC_PREPARE_BUF_TIME32: { + struct v4l2_buffer_time32 vb32; + struct v4l2_buffer *vb = parg; + + if (copy_from_user(&vb32, arg, sizeof(vb32))) + return -EFAULT; + + *vb = (struct v4l2_buffer) { + .index = vb32.index, + .type = vb32.type, + .bytesused = vb32.bytesused, + .flags = vb32.flags, + .field = vb32.field, + .timestamp.tv_sec = vb32.timestamp.tv_sec, + .timestamp.tv_usec = vb32.timestamp.tv_usec, + .timecode = vb32.timecode, + .sequence = vb32.sequence, + .memory = vb32.memory, + .m.userptr = vb32.m.userptr, + .length = vb32.length, + .request_fd = vb32.request_fd, + }; + + if (cmd == VIDIOC_QUERYBUF_TIME32) + vb->request_fd = 0; + + break; + } +#endif default: /* * In some cases, only a few fields are used as input, @@ -3100,6 +3141,31 @@ static int video_put_user(void __user *arg, void *parg, unsigned int cmd) return -EFAULT; break; } + case VIDIOC_QUERYBUF_TIME32: + case VIDIOC_QBUF_TIME32: + case VIDIOC_DQBUF_TIME32: + case VIDIOC_PREPARE_BUF_TIME32: { + struct v4l2_buffer *vb = parg; + struct v4l2_buffer_time32 vb32 = { + .index = vb->index, + .type = vb->type, + .bytesused = vb->bytesused, + .flags = vb->flags, + .field = vb->field, + .timestamp.tv_sec = vb->timestamp.tv_sec, + .timestamp.tv_usec = vb->timestamp.tv_usec, + .timecode = vb->timecode, + .sequence = vb->sequence, + .memory = vb->memory, + .m.userptr = vb->m.userptr, + .length = vb->length, + .request_fd = vb->request_fd, + }; + + if (copy_to_user(arg, &vb32, sizeof(vb32))) + return -EFAULT; + break; + } #endif default: /* Copy results into user buffer */ diff --git a/include/media/v4l2-ioctl.h b/include/media/v4l2-ioctl.h index 05c1ec93a911..86878fba332b 100644 --- a/include/media/v4l2-ioctl.h +++ b/include/media/v4l2-ioctl.h @@ -749,4 +749,34 @@ struct v4l2_event_time32 { #define VIDIOC_DQEVENT_TIME32 _IOR('V', 89, struct v4l2_event_time32) +struct v4l2_buffer_time32 { + __u32 index; + __u32 type; + __u32 bytesused; + __u32 flags; + __u32 field; + struct old_timeval32 timestamp; + struct v4l2_timecode timecode; + __u32 sequence; + + /* memory location */ + __u32 memory; + union { + __u32 offset; + unsigned long userptr; + struct v4l2_plane *planes; + __s32 fd; + } m; + __u32 length; + __u32 reserved2; + union { + __s32 request_fd; + __u32 reserved; + }; +}; +#define VIDIOC_QUERYBUF_TIME32 _IOWR('V', 9, struct v4l2_buffer_time32) +#define VIDIOC_QBUF_TIME32 _IOWR('V', 15, struct v4l2_buffer_time32) +#define VIDIOC_DQBUF_TIME32 _IOWR('V', 17, struct v4l2_buffer_time32) +#define VIDIOC_PREPARE_BUF_TIME32 _IOWR('V', 93, struct v4l2_buffer_time32) + #endif /* _V4L2_IOCTL_H */ diff --git a/include/uapi/linux/videodev2.h b/include/uapi/linux/videodev2.h index caf156d45842..5f9357dcb060 100644 --- a/include/uapi/linux/videodev2.h +++ b/include/uapi/linux/videodev2.h @@ -912,6 +912,25 @@ struct v4l2_jpegcompression { /* * M E M O R Y - M A P P I N G B U F F E R S */ + +#ifdef __KERNEL__ +/* + * This corresponds to the user space version of timeval + * for 64-bit time_t. sparc64 is different from everyone + * else, using the microseconds in the wrong half of the + * second 64-bit word. + */ +struct __kernel_v4l2_timeval { + long long tv_sec; +#if defined(__sparc__) && defined(__arch64__) + int tv_usec; + int __pad; +#else + long long tv_usec; +#endif +}; +#endif + struct v4l2_requestbuffers { __u32 count; __u32 type; /* enum v4l2_buf_type */ @@ -997,7 +1016,11 @@ struct v4l2_buffer { __u32 bytesused; __u32 flags; __u32 field; +#ifdef __KERNEL__ + struct __kernel_v4l2_timeval timestamp; +#else struct timeval timestamp; +#endif struct v4l2_timecode timecode; __u32 sequence; From patchwork Mon Dec 16 14:15:05 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Arnd Bergmann X-Patchwork-Id: 181723 Delivered-To: patch@linaro.org Received: by 2002:a92:3001:0:0:0:0:0 with SMTP id x1csp4364665ile; Mon, 16 Dec 2019 06:15:29 -0800 (PST) X-Google-Smtp-Source: APXvYqyQHo2FuXu3z74j9yQh1qZAsTDND/ylD3/0A39i0PLe0f9jFJR4ZXBrCeV6bqXfozGQ612B X-Received: by 2002:aca:111a:: with SMTP id 26mr8741318oir.145.1576505729853; Mon, 16 Dec 2019 06:15:29 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1576505729; cv=none; d=google.com; s=arc-20160816; b=OzzDkOS2zNsClQwybsa2Jev71WlNlXkP1PxptV08PldFObLDMam9WWsQp5GgG3e3jo ii8xqSger3HvYihwJ/9Be3YH6H4/j4bKLXfItsUTfXBvQubNv1X+jgba6057l03vNiRK txrw/PRc+L8Cf6BWI/F3nwyyiJp7x/RORP13g8/OYWSaOeO5f6EJBpIKkWvD2QuqE0bQ HsTXvQp1FV3gc6tYbE6/SS+zg9HgPmOVB6PV2+MuPXgebhTXZwHGJb/sgbVXIX3YJK6R AqQeRcII2KyTuyAEjHHcFGUm5JKfsXool043H3HoKJ27j/CBh5w5plwXqvHO9PsKs+T1 txkw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from; bh=4HBxY9wUXN3nhLf71ju/iSVsP8y9Nux+Xc1sZpjROI4=; b=MsjgQoQkd9uyYAT0nmah3G78ocLiVLW8FgQd9jJOkCmQjdw2otKC6R/fkbHe5sXFRP MO2tB33GuwUl74p9MRnKnqk2DyHYnIyot9MjHzFR7c/iet8mck5WR20LJYmGN2g89b05 mr2jwX8AYKOJinnVvxzRj0uHLGDsEHbUDmxfR6OtwDxVM6RZJYIvS29DpPGmvL8w/07k M5bPC/9AUZdRgOC29HRmr7wfn8DTFYuB6qhQo0pQhhrxTnxQsuQSU6MjrGX2TlPW10d0 JKAR6a/fxHQhDF6B4GMBevD0fn6GIsqxQ7dP0a2nbgJpWXpGoUxkDrbwG0SGENq/pgiZ y+Gw== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id b10si10104815oic.153.2019.12.16.06.15.29; Mon, 16 Dec 2019 06:15:29 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728183AbfLPOP2 (ORCPT + 27 others); Mon, 16 Dec 2019 09:15:28 -0500 Received: from mout.kundenserver.de ([217.72.192.74]:59529 "EHLO mout.kundenserver.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727807AbfLPOPZ (ORCPT ); Mon, 16 Dec 2019 09:15:25 -0500 Received: from threadripper.lan ([149.172.19.189]) by mrelayeu.kundenserver.de (mreue106 [212.227.15.145]) with ESMTPA (Nemesis) id 1M894P-1ibcDm1OFP-005KOI; Mon, 16 Dec 2019 15:15:17 +0100 From: Arnd Bergmann To: Hans Verkuil Cc: linux-media@vger.kernel.org, mchehab@kernel.org, y2038@lists.linaro.org, linux-kernel@vger.kernel.org, arnd@arndb.de Subject: [PATCH v6 7/8] media: v4l2-core: fix compat VIDIOC_DQEVENT for time64 ABI Date: Mon, 16 Dec 2019 15:15:05 +0100 Message-Id: <20191216141506.121728-8-arnd@arndb.de> X-Mailer: git-send-email 2.20.0 In-Reply-To: <20191216141506.121728-1-arnd@arndb.de> References: <20191216141506.121728-1-arnd@arndb.de> MIME-Version: 1.0 X-Provags-ID: V03:K1:6/Fv6ggGFhH/R+vNLGnpTlSqPnd/sm8+U+BgV4J+uwpVhtjl9n0 XfDPsYEZywmDNVNvIe8jRn9OvbCXS+XlLFPO4eyExB/kSCLIzMPyTS1IhB49pJ2FVE6zMKK OWkmW+RraCPwVW9eg8ImQzQdjcCm1lQqhCJejrN0qIwVk7X90shGY16z8Sk/LBLGwcl/bvW LyntoNzuPHC2iYYV9sqlw== X-Spam-Flag: NO X-UI-Out-Filterresults: notjunk:1; V03:K0:MhiY5j4G9c0=:8EARmMqyLNGkR0MUZlXQY+ Q9ugx9FU/93OE1JdiY3QgAnjxt1ukceF6ZxcRVeQfGX2SrXYq+P57DrDzJLFWMe5psVDhzlaq D5PrgN91kn9wdu5xhMA77LYUz2jxV3QbvV14Bfk+0dSRIKMgCrZ6shLtfUcg7CJqtZJNldxCX LH4W6yqFzfCTy5Nd7Mb9fHAUClqgURLzcp/iG39sPU3wofjeN6i81bFqrS5/jgJowRXB8khZh 9cGBqDpm2tpeM3v6FTH4XimZhKePoshpY2bmbPNnVcsVfLhZxZfrN5kUNtFx5HxWcc6oreens 6kXFdQDISYYCEdti9DQ84EKwaiVrZM4MqkFH/pxYiwIaYBHXXT3rUYbsKqufInMUA4OlEaYWO t411DLaiy1n+6syaZiwyaQ9HWVCeCbNfmZZNHLyB9kv2Fi5weYqIaJl5sCXgk5dNFH28uZJf/ DXYqrBwn35cQ4lrm+VJVYSP3HItgVBICKBdf1PkcUFnK/Sd0iQ4Op+NKb3SgLVr4bVc13CDVW 36v5ZBaPHdwlgVZepkCzDNMOMZNlqIPu+xGyqEzZyrzeRIRedRUDiOsja+28i3AM6YdAsH+co n7eD/cLhMihCtJyAAf4J+eEyrUIQweNi4r/gbrVyaZ/Dx6ayODf53bWaNny1YjP3Gx0zWGm2A +zr8F6n9YRCA0pmimy3raSEk2uSzcCRwHlc0wojOER63S5TIeNL8CMxnIo4dC9Ov0c2w74TTn +BAu3MHKjWYXZ2/pLnUxAywCU7iVZCeBMGf3klAw3MDPBZmpWZro/Rv4EngLspK034mCk1jdR zQdVj9oV3c1o9YqQPYv5xf8avlrM3jj+Fc97ilTu53k0Ik73cdGBW7lRw3gzGgRcxYKCXJRPV wLJcc3yTwg/mDjy4ZpsA== Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The native code supports the variant of struct v4l2_event for 64-bit time_t, so add the compat version as well. Here, a new incompatibility arises: while almost all 32-bit architectures now use the same layout as 64-bit architectures and the commands can simply be passed through, on x86 the internal alignment of v4l2_event is different because of the 64-bit member in v4l2_event_ctrl. To handle all architectures, this now requires defining four different versions of the structure to cover all possible combinations. The compat handling for VIDIOC_DQEVENT32 and VIDIOC_DQEVENT32_TIME32 is now inside of an #ifdef so it does not get used on architectures other than x86. Signed-off-by: Arnd Bergmann --- drivers/media/v4l2-core/v4l2-compat-ioctl32.c | 60 ++++++++++++++++++- 1 file changed, 59 insertions(+), 1 deletion(-) -- 2.20.0 diff --git a/drivers/media/v4l2-core/v4l2-compat-ioctl32.c b/drivers/media/v4l2-core/v4l2-compat-ioctl32.c index 7ad6db8dd9f6..f8a4b0ddd47d 100644 --- a/drivers/media/v4l2-core/v4l2-compat-ioctl32.c +++ b/drivers/media/v4l2-core/v4l2-compat-ioctl32.c @@ -1028,6 +1028,15 @@ static int put_v4l2_ext_controls32(struct file *file, return 0; } +#ifdef CONFIG_X86_64 +/* + * x86 is the only compat architecture with different struct alignment + * between 32-bit and 64-bit tasks. + * + * On all other architectures, v4l2_event32 and v4l2_event32_time32 are + * the same as v4l2_event and v4l2_event_time32, so we can use the native + * handlers, converting v4l2_event to v4l2_event_time32 if necessary. + */ struct v4l2_event32 { __u32 type; union { @@ -1036,7 +1045,23 @@ struct v4l2_event32 { } u; __u32 pending; __u32 sequence; - struct compat_timespec timestamp; + struct { + compat_s64 tv_sec; + compat_s64 tv_nsec; + } timestamp; + __u32 id; + __u32 reserved[8]; +}; + +struct v4l2_event32_time32 { + __u32 type; + union { + compat_s64 value64; + __u8 data[64]; + } u; + __u32 pending; + __u32 sequence; + struct old_timespec32 timestamp; __u32 id; __u32 reserved[8]; }; @@ -1057,6 +1082,23 @@ static int put_v4l2_event32(struct v4l2_event __user *p64, return 0; } +static int put_v4l2_event32_time32(struct v4l2_event_time32 __user *p64, + struct v4l2_event32_time32 __user *p32) +{ + if (!access_ok(p32, sizeof(*p32)) || + assign_in_user(&p32->type, &p64->type) || + copy_in_user(&p32->u, &p64->u, sizeof(p64->u)) || + assign_in_user(&p32->pending, &p64->pending) || + assign_in_user(&p32->sequence, &p64->sequence) || + assign_in_user(&p32->timestamp.tv_sec, &p64->timestamp.tv_sec) || + assign_in_user(&p32->timestamp.tv_nsec, &p64->timestamp.tv_nsec) || + assign_in_user(&p32->id, &p64->id) || + copy_in_user(p32->reserved, p64->reserved, sizeof(p32->reserved))) + return -EFAULT; + return 0; +} +#endif + struct v4l2_edid32 { __u32 pad; __u32 start_block; @@ -1121,6 +1163,7 @@ static int put_v4l2_edid32(struct v4l2_edid __user *p64, #define VIDIOC_S_EXT_CTRLS32 _IOWR('V', 72, struct v4l2_ext_controls32) #define VIDIOC_TRY_EXT_CTRLS32 _IOWR('V', 73, struct v4l2_ext_controls32) #define VIDIOC_DQEVENT32 _IOR ('V', 89, struct v4l2_event32) +#define VIDIOC_DQEVENT32_TIME32 _IOR ('V', 89, struct v4l2_event32_time32) #define VIDIOC_CREATE_BUFS32 _IOWR('V', 92, struct v4l2_create_buffers32) #define VIDIOC_PREPARE_BUF32 _IOWR('V', 93, struct v4l2_buffer32) @@ -1202,7 +1245,10 @@ static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long ar case VIDIOC_G_EXT_CTRLS32: ncmd = VIDIOC_G_EXT_CTRLS; break; case VIDIOC_S_EXT_CTRLS32: ncmd = VIDIOC_S_EXT_CTRLS; break; case VIDIOC_TRY_EXT_CTRLS32: ncmd = VIDIOC_TRY_EXT_CTRLS; break; +#ifdef CONFIG_X86_64 case VIDIOC_DQEVENT32: ncmd = VIDIOC_DQEVENT; break; + case VIDIOC_DQEVENT32_TIME32: ncmd = VIDIOC_DQEVENT_TIME32; break; +#endif case VIDIOC_OVERLAY32: ncmd = VIDIOC_OVERLAY; break; case VIDIOC_STREAMON32: ncmd = VIDIOC_STREAMON; break; case VIDIOC_STREAMOFF32: ncmd = VIDIOC_STREAMOFF; break; @@ -1336,10 +1382,16 @@ static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long ar } compatible_arg = 0; break; +#ifdef CONFIG_X86_64 case VIDIOC_DQEVENT32: err = alloc_userspace(sizeof(struct v4l2_event), 0, &new_p64); compatible_arg = 0; break; + case VIDIOC_DQEVENT32_TIME32: + err = alloc_userspace(sizeof(struct v4l2_event_time32), 0, &new_p64); + compatible_arg = 0; + break; +#endif } if (err) return err; @@ -1404,10 +1456,16 @@ static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long ar err = put_v4l2_framebuffer32(new_p64, p32); break; +#ifdef CONFIG_X86_64 case VIDIOC_DQEVENT32: err = put_v4l2_event32(new_p64, p32); break; + case VIDIOC_DQEVENT32_TIME32: + err = put_v4l2_event32_time32(new_p64, p32); + break; +#endif + case VIDIOC_G_EDID32: err = put_v4l2_edid32(new_p64, p32); break; From patchwork Mon Dec 16 14:15:06 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Arnd Bergmann X-Patchwork-Id: 181724 Delivered-To: patch@linaro.org Received: by 2002:a92:3001:0:0:0:0:0 with SMTP id x1csp4364715ile; Mon, 16 Dec 2019 06:15:31 -0800 (PST) X-Google-Smtp-Source: APXvYqyXd/Y9WQWwoXH/raFXGhU+7Mc0hEGfEbRSMVdNWr+/5oCMzFJnR8BQtNIiCekI+OZFxsTp X-Received: by 2002:aca:8d5:: with SMTP id 204mr9025578oii.141.1576505731738; Mon, 16 Dec 2019 06:15:31 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1576505731; cv=none; d=google.com; s=arc-20160816; b=jyQewh31GvgI0O67Bjiz1NnBIePlrF+IaMQo7yoTsgmu6jgwNT8Fc/dFED/1sXLf7e JK9xtleZis6KetJNGGyLB6utqABk+QBknmVW+trPD3M6P3p/TFxJPw8VDe9b4GqrIe3Y MlPikl51v7tHyfRSyWTIvp731x4TD/gN6yeg1ajh3dgl7a0CSmS70KlmKQXRtV199ja+ tVmHVSANWOZ0QgN77a35Nlk+Ov2oP0kgJvUB41vEJ4ZNKYm/sK4tBHOVACb5nwjA/vUs eyJ37vngm55sRYhHtS7e8vhS0AF4Os57dn9YbnzBrd7V/uBs+Fhigth86elysEPOwzw0 uCcg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from; bh=Bt4PhmygJ6ZVro6K7YLXzVvALavxqB6Aes0+vfx/D60=; b=RlGmg0rXCATh917xBKtRR5xrIoZpRzcCQbxmF5wu43ydZdZEiChqSsgnLHtpZa+UiR pZmJNo+dUlQsS0QEPsfRd+/XBDFJfHE574mEhglgwPE27XxNySZB3wqWKUopSj79r48h Gto2vr0oHPDigE+JTjZDcK4b/3fbVxZNkRR64e1y+N2T+ik78HSyhPiTw9xRuPmeNSsO x8Esi52FjO+dylizRd8OO6k9jgFV4DWmb9AY053X93bH/RZqbH/QsulJHQrlaIpVk+QK YMSOC+/wsi3Wwrv7+dAfQraCiWUIhAsFnew6n6DIhChHOqNynfu/OX2qu5d2woAlr4Mq qdlA== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id b10si10104815oic.153.2019.12.16.06.15.31; Mon, 16 Dec 2019 06:15:31 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728192AbfLPOPb (ORCPT + 27 others); Mon, 16 Dec 2019 09:15:31 -0500 Received: from mout.kundenserver.de ([212.227.17.24]:41585 "EHLO mout.kundenserver.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728117AbfLPOP0 (ORCPT ); Mon, 16 Dec 2019 09:15:26 -0500 Received: from threadripper.lan ([149.172.19.189]) by mrelayeu.kundenserver.de (mreue106 [212.227.15.145]) with ESMTPA (Nemesis) id 1N94uf-1hatDG2NuR-0163zy; Mon, 16 Dec 2019 15:15:17 +0100 From: Arnd Bergmann To: Hans Verkuil Cc: linux-media@vger.kernel.org, mchehab@kernel.org, y2038@lists.linaro.org, linux-kernel@vger.kernel.org, arnd@arndb.de Subject: [PATCH v6 8/8] media: v4l2-core: fix compat v4l2_buffer handling for time64 ABI Date: Mon, 16 Dec 2019 15:15:06 +0100 Message-Id: <20191216141506.121728-9-arnd@arndb.de> X-Mailer: git-send-email 2.20.0 In-Reply-To: <20191216141506.121728-1-arnd@arndb.de> References: <20191216141506.121728-1-arnd@arndb.de> MIME-Version: 1.0 X-Provags-ID: V03:K1:K7RdIe5XuU3l5a8tW8CoHF/dAYBWzcUTSNj1wVftXzQ4NLfECmh 9PRy4zE2H1HoX53vP9MqU5cwsZvivBx2/16gp0r7VVLRH//z05sFq9SNuNXyyl38XZworzx 53w+LT6LmNiRzccoJdUwKO2wUgQvFHFYzMuD24EvStQUAww/4kuK6j+INwrVn3OqpefL/+j L3PZ19VImb530W05hswMA== X-Spam-Flag: NO X-UI-Out-Filterresults: notjunk:1; V03:K0:8c8UypDb5sg=:4nqV0Mrs3JFU7UBiG8J0rR unuIZHj07pchqwCcnwGeYiDTcdKQ0hVUd94Ue547eXwbVa9Y+Q1up+cO3nv3LJEcdnXMq2bG/ X0lEHyplDlwJtZS6rKYEf+7ndkrFaDcYr9keVkmY+Dxgl0WU/qO7BVhbfOm3tjWVJLYxfmxKV NiVHfn1Aiae4a6tlECcAk5QzjupUjUXsgGl/3qXJMBmefz0pYUC508ZhCJUXdia1vjqUtXQzV V+GEfAejqCepfN/1DQn4shGmAymPaSZUvU9BrsjmwRdx2cGQfPAEXDMzT9Alt6QcrwUY1/ycB oMVpoe29e+epsIrQ6V64LdpjB/avq74UOjmn2qKweyKKUItVjFeKdiokavclzUSOaKbxPMxmk lb0VUnbg4ICD5t18Z6GZ4+dV4YHjfKta+CHweKlQUf58egQ/lmEAXUc+nfAdUi9pAsrJ9lWaj 7/rzGlLU6SOeezTGBcSUEgRIq/p+waCXOG/AUnXoNPhe/WPZUmU+uxSvwAOVQqve45lXkS70m 5pqOtdrPxJg6ibJiNmm5Upk9Jgo97MNzqUfvom0bLsZeZA3Uc6Hw48rSOAQhjoOh0VioTN0Hl 3brrm5HMm85XbA7cCl/Aaao1NPt0U8E0bh71ir3BF7GOA6h1PY6dH6rwRwzb82/DOV6K/8zAH Qa8mu++KA6vIl4nnYz1DoWio+REXjNQgyFSgoblsE66J1gNV4AoEhSgoFdM7OmaUQEPwO2Gaf UxoLcpv5bufEm/V39SOCpsp9HHOxs7chvmXb/7/IGNT0J1tE1jEokYEEjtl5o9KxR95B87Hej ++0nhqtu3nZn249shFRk1C8Qh6Y22yp1VkxplIrPz5evfCCbn7etgYfBcbbyH3LiVTTPR1C3C 75nrFNxRsud8XNUTL9ug== Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Add support for the four new variants of ioctl commands for 64-bit time_t in v4l2_buffer. The existing v4l2_buffer32 structure for the traditional format gets changed to match the new v4l2_buffer format, and the old layout is now called v4l2_buffer32_time32. Neither of these matches the native 64-bit architecture format of v4l2_buffer, so both require special handling in compat code. Duplicating the existing handlers for the new types is a safe conversion for now, but unfortunately this may turn into a maintenance burden later. A larger-scale rework of the compat code might be a better alternative, but is out of scope of the y2038 work. Note: x32 support for v4l2_buffer32 has always been broken and remains so after this change, fixing it would have required even more duplication, and apparently nobody has cared so far. Signed-off-by: Arnd Bergmann --- drivers/media/v4l2-core/v4l2-compat-ioctl32.c | 269 +++++++++++++++++- 1 file changed, 268 insertions(+), 1 deletion(-) -- 2.20.0 diff --git a/drivers/media/v4l2-core/v4l2-compat-ioctl32.c b/drivers/media/v4l2-core/v4l2-compat-ioctl32.c index f8a4b0ddd47d..381d29e45a49 100644 --- a/drivers/media/v4l2-core/v4l2-compat-ioctl32.c +++ b/drivers/media/v4l2-core/v4l2-compat-ioctl32.c @@ -468,13 +468,43 @@ struct v4l2_plane32 { __u32 reserved[11]; }; +/* + * This is correct for all architectures including i386, but not x32, + * which has different alignment requirements for timestamp + */ struct v4l2_buffer32 { __u32 index; __u32 type; /* enum v4l2_buf_type */ __u32 bytesused; __u32 flags; __u32 field; /* enum v4l2_field */ - struct compat_timeval timestamp; + struct { + compat_s64 tv_sec; + compat_s64 tv_usec; + } timestamp; + struct v4l2_timecode timecode; + __u32 sequence; + + /* memory location */ + __u32 memory; /* enum v4l2_memory */ + union { + __u32 offset; + compat_long_t userptr; + compat_caddr_t planes; + __s32 fd; + } m; + __u32 length; + __u32 reserved2; + __s32 request_fd; +}; + +struct v4l2_buffer32_time32 { + __u32 index; + __u32 type; /* enum v4l2_buf_type */ + __u32 bytesused; + __u32 flags; + __u32 field; /* enum v4l2_field */ + struct old_timeval32 timestamp; struct v4l2_timecode timecode; __u32 sequence; @@ -581,6 +611,31 @@ static int bufsize_v4l2_buffer(struct v4l2_buffer32 __user *p32, u32 *size) return 0; } +static int bufsize_v4l2_buffer_time32(struct v4l2_buffer32_time32 __user *p32, u32 *size) +{ + u32 type; + u32 length; + + if (!access_ok(p32, sizeof(*p32)) || + get_user(type, &p32->type) || + get_user(length, &p32->length)) + return -EFAULT; + + if (V4L2_TYPE_IS_MULTIPLANAR(type)) { + if (length > VIDEO_MAX_PLANES) + return -EINVAL; + + /* + * We don't really care if userspace decides to kill itself + * by passing a very big length value + */ + *size = length * sizeof(struct v4l2_plane); + } else { + *size = 0; + } + return 0; +} + static int get_v4l2_buffer32(struct v4l2_buffer __user *p64, struct v4l2_buffer32 __user *p32, void __user *aux_buf, u32 aux_space) @@ -681,6 +736,106 @@ static int get_v4l2_buffer32(struct v4l2_buffer __user *p64, return 0; } +static int get_v4l2_buffer32_time32(struct v4l2_buffer_time32 __user *p64, + struct v4l2_buffer32_time32 __user *p32, + void __user *aux_buf, u32 aux_space) +{ + u32 type; + u32 length; + s32 request_fd; + enum v4l2_memory memory; + struct v4l2_plane32 __user *uplane32; + struct v4l2_plane __user *uplane; + compat_caddr_t p; + int ret; + + if (!access_ok(p32, sizeof(*p32)) || + assign_in_user(&p64->index, &p32->index) || + get_user(type, &p32->type) || + put_user(type, &p64->type) || + assign_in_user(&p64->flags, &p32->flags) || + get_user(memory, &p32->memory) || + put_user(memory, &p64->memory) || + get_user(length, &p32->length) || + put_user(length, &p64->length) || + get_user(request_fd, &p32->request_fd) || + put_user(request_fd, &p64->request_fd)) + return -EFAULT; + + if (V4L2_TYPE_IS_OUTPUT(type)) + if (assign_in_user(&p64->bytesused, &p32->bytesused) || + assign_in_user(&p64->field, &p32->field) || + assign_in_user(&p64->timestamp.tv_sec, + &p32->timestamp.tv_sec) || + assign_in_user(&p64->timestamp.tv_usec, + &p32->timestamp.tv_usec)) + return -EFAULT; + + if (V4L2_TYPE_IS_MULTIPLANAR(type)) { + u32 num_planes = length; + + if (num_planes == 0) { + /* + * num_planes == 0 is legal, e.g. when userspace doesn't + * need planes array on DQBUF + */ + return put_user(NULL, &p64->m.planes); + } + if (num_planes > VIDEO_MAX_PLANES) + return -EINVAL; + + if (get_user(p, &p32->m.planes)) + return -EFAULT; + + uplane32 = compat_ptr(p); + if (!access_ok(uplane32, + num_planes * sizeof(*uplane32))) + return -EFAULT; + + /* + * We don't really care if userspace decides to kill itself + * by passing a very big num_planes value + */ + if (aux_space < num_planes * sizeof(*uplane)) + return -EFAULT; + + uplane = aux_buf; + if (put_user_force(uplane, &p64->m.planes)) + return -EFAULT; + + while (num_planes--) { + ret = get_v4l2_plane32(uplane, uplane32, memory); + if (ret) + return ret; + uplane++; + uplane32++; + } + } else { + switch (memory) { + case V4L2_MEMORY_MMAP: + case V4L2_MEMORY_OVERLAY: + if (assign_in_user(&p64->m.offset, &p32->m.offset)) + return -EFAULT; + break; + case V4L2_MEMORY_USERPTR: { + compat_ulong_t userptr; + + if (get_user(userptr, &p32->m.userptr) || + put_user((unsigned long)compat_ptr(userptr), + &p64->m.userptr)) + return -EFAULT; + break; + } + case V4L2_MEMORY_DMABUF: + if (assign_in_user(&p64->m.fd, &p32->m.fd)) + return -EFAULT; + break; + } + } + + return 0; +} + static int put_v4l2_buffer32(struct v4l2_buffer __user *p64, struct v4l2_buffer32 __user *p32) { @@ -761,6 +916,87 @@ static int put_v4l2_buffer32(struct v4l2_buffer __user *p64, return 0; } + +static int put_v4l2_buffer32_time32(struct v4l2_buffer_time32 __user *p64, + struct v4l2_buffer32_time32 __user *p32) +{ + u32 type; + u32 length; + enum v4l2_memory memory; + struct v4l2_plane32 __user *uplane32; + struct v4l2_plane *uplane; + compat_caddr_t p; + int ret; + + if (!access_ok(p32, sizeof(*p32)) || + assign_in_user(&p32->index, &p64->index) || + get_user(type, &p64->type) || + put_user(type, &p32->type) || + assign_in_user(&p32->flags, &p64->flags) || + get_user(memory, &p64->memory) || + put_user(memory, &p32->memory)) + return -EFAULT; + + if (assign_in_user(&p32->bytesused, &p64->bytesused) || + assign_in_user(&p32->field, &p64->field) || + assign_in_user(&p32->timestamp.tv_sec, &p64->timestamp.tv_sec) || + assign_in_user(&p32->timestamp.tv_usec, &p64->timestamp.tv_usec) || + copy_in_user(&p32->timecode, &p64->timecode, sizeof(p64->timecode)) || + assign_in_user(&p32->sequence, &p64->sequence) || + assign_in_user(&p32->reserved2, &p64->reserved2) || + assign_in_user(&p32->request_fd, &p64->request_fd) || + get_user(length, &p64->length) || + put_user(length, &p32->length)) + return -EFAULT; + + if (V4L2_TYPE_IS_MULTIPLANAR(type)) { + u32 num_planes = length; + + if (num_planes == 0) + return 0; + /* We need to define uplane without __user, even though + * it does point to data in userspace here. The reason is + * that v4l2-ioctl.c copies it from userspace to kernelspace, + * so its definition in videodev2.h doesn't have a + * __user markup. Defining uplane with __user causes + * smatch warnings, so instead declare it without __user + * and cast it as a userspace pointer to put_v4l2_plane32(). + */ + if (get_user(uplane, &p64->m.planes)) + return -EFAULT; + if (get_user(p, &p32->m.planes)) + return -EFAULT; + uplane32 = compat_ptr(p); + + while (num_planes--) { + ret = put_v4l2_plane32((void __user *)uplane, + uplane32, memory); + if (ret) + return ret; + ++uplane; + ++uplane32; + } + } else { + switch (memory) { + case V4L2_MEMORY_MMAP: + case V4L2_MEMORY_OVERLAY: + if (assign_in_user(&p32->m.offset, &p64->m.offset)) + return -EFAULT; + break; + case V4L2_MEMORY_USERPTR: + if (assign_in_user(&p32->m.userptr, &p64->m.userptr)) + return -EFAULT; + break; + case V4L2_MEMORY_DMABUF: + if (assign_in_user(&p32->m.fd, &p64->m.fd)) + return -EFAULT; + break; + } + } + + return 0; +} + struct v4l2_framebuffer32 { __u32 capability; __u32 flags; @@ -1150,10 +1386,13 @@ static int put_v4l2_edid32(struct v4l2_edid __user *p64, #define VIDIOC_G_FMT32 _IOWR('V', 4, struct v4l2_format32) #define VIDIOC_S_FMT32 _IOWR('V', 5, struct v4l2_format32) #define VIDIOC_QUERYBUF32 _IOWR('V', 9, struct v4l2_buffer32) +#define VIDIOC_QUERYBUF32_TIME32 _IOWR('V', 9, struct v4l2_buffer32_time32) #define VIDIOC_G_FBUF32 _IOR ('V', 10, struct v4l2_framebuffer32) #define VIDIOC_S_FBUF32 _IOW ('V', 11, struct v4l2_framebuffer32) #define VIDIOC_QBUF32 _IOWR('V', 15, struct v4l2_buffer32) +#define VIDIOC_QBUF32_TIME32 _IOWR('V', 15, struct v4l2_buffer32_time32) #define VIDIOC_DQBUF32 _IOWR('V', 17, struct v4l2_buffer32) +#define VIDIOC_DQBUF32_TIME32 _IOWR('V', 17, struct v4l2_buffer32_time32) #define VIDIOC_ENUMSTD32 _IOWR('V', 25, struct v4l2_standard32) #define VIDIOC_ENUMINPUT32 _IOWR('V', 26, struct v4l2_input32) #define VIDIOC_G_EDID32 _IOWR('V', 40, struct v4l2_edid32) @@ -1166,6 +1405,7 @@ static int put_v4l2_edid32(struct v4l2_edid __user *p64, #define VIDIOC_DQEVENT32_TIME32 _IOR ('V', 89, struct v4l2_event32_time32) #define VIDIOC_CREATE_BUFS32 _IOWR('V', 92, struct v4l2_create_buffers32) #define VIDIOC_PREPARE_BUF32 _IOWR('V', 93, struct v4l2_buffer32) +#define VIDIOC_PREPARE_BUF32_TIME32 _IOWR('V', 93, struct v4l2_buffer32_time32) #define VIDIOC_OVERLAY32 _IOW ('V', 14, s32) #define VIDIOC_STREAMON32 _IOW ('V', 18, s32) @@ -1235,10 +1475,13 @@ static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long ar case VIDIOC_G_FMT32: ncmd = VIDIOC_G_FMT; break; case VIDIOC_S_FMT32: ncmd = VIDIOC_S_FMT; break; case VIDIOC_QUERYBUF32: ncmd = VIDIOC_QUERYBUF; break; + case VIDIOC_QUERYBUF32_TIME32: ncmd = VIDIOC_QUERYBUF_TIME32; break; case VIDIOC_G_FBUF32: ncmd = VIDIOC_G_FBUF; break; case VIDIOC_S_FBUF32: ncmd = VIDIOC_S_FBUF; break; case VIDIOC_QBUF32: ncmd = VIDIOC_QBUF; break; + case VIDIOC_QBUF32_TIME32: ncmd = VIDIOC_QBUF_TIME32; break; case VIDIOC_DQBUF32: ncmd = VIDIOC_DQBUF; break; + case VIDIOC_DQBUF32_TIME32: ncmd = VIDIOC_DQBUF_TIME32; break; case VIDIOC_ENUMSTD32: ncmd = VIDIOC_ENUMSTD; break; case VIDIOC_ENUMINPUT32: ncmd = VIDIOC_ENUMINPUT; break; case VIDIOC_TRY_FMT32: ncmd = VIDIOC_TRY_FMT; break; @@ -1258,6 +1501,7 @@ static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long ar case VIDIOC_S_OUTPUT32: ncmd = VIDIOC_S_OUTPUT; break; case VIDIOC_CREATE_BUFS32: ncmd = VIDIOC_CREATE_BUFS; break; case VIDIOC_PREPARE_BUF32: ncmd = VIDIOC_PREPARE_BUF; break; + case VIDIOC_PREPARE_BUF32_TIME32: ncmd = VIDIOC_PREPARE_BUF_TIME32; break; case VIDIOC_G_EDID32: ncmd = VIDIOC_G_EDID; break; case VIDIOC_S_EDID32: ncmd = VIDIOC_S_EDID; break; default: ncmd = cmd; break; @@ -1339,6 +1583,22 @@ static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long ar compatible_arg = 0; break; + case VIDIOC_PREPARE_BUF32_TIME32: + case VIDIOC_QUERYBUF32_TIME32: + case VIDIOC_QBUF32_TIME32: + case VIDIOC_DQBUF32_TIME32: + err = bufsize_v4l2_buffer_time32(p32, &aux_space); + if (!err) + err = alloc_userspace(sizeof(struct v4l2_buffer), + aux_space, &new_p64); + if (!err) { + aux_buf = new_p64 + sizeof(struct v4l2_buffer); + err = get_v4l2_buffer32_time32(new_p64, p32, + aux_buf, aux_space); + } + compatible_arg = 0; + break; + case VIDIOC_S_FBUF32: err = alloc_userspace(sizeof(struct v4l2_framebuffer), 0, &new_p64); @@ -1487,6 +1747,13 @@ static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long ar err = put_v4l2_buffer32(new_p64, p32); break; + case VIDIOC_PREPARE_BUF32_TIME32: + case VIDIOC_QUERYBUF32_TIME32: + case VIDIOC_QBUF32_TIME32: + case VIDIOC_DQBUF32_TIME32: + err = put_v4l2_buffer32_time32(new_p64, p32); + break; + case VIDIOC_ENUMSTD32: err = put_v4l2_standard32(new_p64, p32); break;