From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1758628AbcIMOLM (ORCPT ); Tue, 13 Sep 2016 10:11:12 -0400 Received: from mail-pa0-f66.google.com ([209.85.220.66]:35334 "EHLO mail-pa0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1758393AbcIMOKm (ORCPT ); Tue, 13 Sep 2016 10:10:42 -0400 From: Deepa Dinamani To: Dmitry Torokhov , linux-input@vger.kernel.org, linux-kernel@vger.kernel.org Cc: arnd@arndb.de, y2038@lists.linaro.org Subject: [PATCH 1/4] uinput: Add ioctl for using monotonic/ boot times Date: Tue, 13 Sep 2016 07:10:02 -0700 Message-Id: <1473775805-2242-2-git-send-email-deepa.kernel@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1473775805-2242-1-git-send-email-deepa.kernel@gmail.com> References: <1473775805-2242-1-git-send-email-deepa.kernel@gmail.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org struct timeval which is part of struct input_event to maintain the event times is not y2038 safe. Real time timestamps are also not ideal for input_event as this time can go backwards as noted in the patch a80b83b7b8 by John Stultz. Arnd Bergmann suggested deprecating real time and using monotonic or other timers for all input_event times as a solution to both the above problems. Add a new ioctl to let the user dictate the kind of time to be used for input events. This is similar to the evdev implementation of the feature. Realtime is still the default time. This is to maintain backward compatibility. The structure to maintain input events will be changed in a different patch. Signed-off-by: Deepa Dinamani --- drivers/input/misc/uinput.c | 58 ++++++++++++++++++++++++++++++++++++++++++++- include/linux/uinput.h | 1 + include/uapi/linux/uinput.h | 3 +++ 3 files changed, 61 insertions(+), 1 deletion(-) diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c index 92595b9..ae22927 100644 --- a/drivers/input/misc/uinput.c +++ b/drivers/input/misc/uinput.c @@ -46,11 +46,28 @@ static int uinput_dev_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { struct uinput_device *udev = input_get_drvdata(dev); + struct timespec64 ts; + ktime_t kt; udev->buff[udev->head].type = type; udev->buff[udev->head].code = code; udev->buff[udev->head].value = value; - do_gettimeofday(&udev->buff[udev->head].time); + + kt = ktime_get(); + switch (udev->clk_type) { + case CLOCK_REALTIME: + ts = ktime_to_timespec64(ktime_mono_to_real(kt)); + break; + case CLOCK_MONOTONIC: + ts = ktime_to_timespec64(kt); + break; + case CLOCK_BOOTTIME: + ts = ktime_to_timespec64(ktime_mono_to_any(kt, TK_OFFS_BOOT)); + break; + } + + udev->buff[udev->head].time.tv_sec = ts.tv_sec; + udev->buff[udev->head].time.tv_usec = ts.tv_nsec / NSEC_PER_USEC; udev->head = (udev->head + 1) % UINPUT_BUFFER_SIZE; wake_up_interruptible(&udev->waitq); @@ -295,6 +312,7 @@ static int uinput_create_device(struct uinput_device *udev) if (error) goto fail2; + udev->clk_type = CLOCK_REALTIME; udev->state = UIST_CREATED; return 0; @@ -304,6 +322,38 @@ static int uinput_create_device(struct uinput_device *udev) return error; } +static int uinput_set_clk_type(struct uinput_device *udev, unsigned int clkid) +{ + unsigned int clk_type; + + if (udev->state != UIST_CREATED) + return -EINVAL; + + switch (clkid) { + /* Realtime clock is only valid until year 2038.*/ + case CLOCK_REALTIME: + clk_type = CLOCK_REALTIME; + break; + case CLOCK_MONOTONIC: + clk_type = CLOCK_MONOTONIC; + break; + case CLOCK_BOOTTIME: + clk_type = CLOCK_BOOTTIME; + break; + default: + return -EINVAL; + } + + if (udev->clk_type != clk_type) { + udev->clk_type = clk_type; + + /* Flush pending events */ + uinput_flush_requests(udev); + } + + return 0; +} + static int uinput_open(struct inode *inode, struct file *file) { struct uinput_device *newdev; @@ -787,6 +837,7 @@ static long uinput_ioctl_handler(struct file *file, unsigned int cmd, char *phys; const char *name; unsigned int size; + int clock_id; retval = mutex_lock_interruptible(&udev->mutex); if (retval) @@ -817,6 +868,11 @@ static long uinput_ioctl_handler(struct file *file, unsigned int cmd, retval = uinput_dev_setup(udev, p); goto out; + case UI_SET_CLOCKID: + if (copy_from_user(&clock_id, p, sizeof(unsigned int))) + return -EFAULT; + return uinput_set_clk_type(udev, clock_id); + /* UI_ABS_SETUP is handled in the variable size ioctls */ case UI_SET_EVBIT: diff --git a/include/linux/uinput.h b/include/linux/uinput.h index 75de43d..6527fb7 100644 --- a/include/linux/uinput.h +++ b/include/linux/uinput.h @@ -72,6 +72,7 @@ struct uinput_device { unsigned char head; unsigned char tail; struct input_event buff[UINPUT_BUFFER_SIZE]; + int clk_type; unsigned int ff_effects_max; struct uinput_request *requests[UINPUT_NUM_REQUESTS]; diff --git a/include/uapi/linux/uinput.h b/include/uapi/linux/uinput.h index dc652e2..d9494ae 100644 --- a/include/uapi/linux/uinput.h +++ b/include/uapi/linux/uinput.h @@ -133,6 +133,9 @@ struct uinput_abs_setup { */ #define UI_ABS_SETUP _IOW(UINPUT_IOCTL_BASE, 4, struct uinput_abs_setup) +/* Set clockid to be used for timestamps */ +#define UI_SET_CLOCKID _IOW(UINPUT_IOCTL_BASE, 5, int) + #define UI_SET_EVBIT _IOW(UINPUT_IOCTL_BASE, 100, int) #define UI_SET_KEYBIT _IOW(UINPUT_IOCTL_BASE, 101, int) #define UI_SET_RELBIT _IOW(UINPUT_IOCTL_BASE, 102, int) -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Deepa Dinamani Subject: [PATCH 1/4] uinput: Add ioctl for using monotonic/ boot times Date: Tue, 13 Sep 2016 07:10:02 -0700 Message-ID: <1473775805-2242-2-git-send-email-deepa.kernel@gmail.com> References: <1473775805-2242-1-git-send-email-deepa.kernel@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1473775805-2242-1-git-send-email-deepa.kernel@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: y2038-bounces@lists.linaro.org Sender: "Y2038" To: Dmitry Torokhov , linux-input@vger.kernel.org, linux-kernel@vger.kernel.org Cc: y2038@lists.linaro.org, arnd@arndb.de List-Id: linux-input@vger.kernel.org c3RydWN0IHRpbWV2YWwgd2hpY2ggaXMgcGFydCBvZiBzdHJ1Y3QgaW5wdXRfZXZlbnQgdG8KbWFp bnRhaW4gdGhlIGV2ZW50IHRpbWVzIGlzIG5vdCB5MjAzOCBzYWZlLgoKUmVhbCB0aW1lIHRpbWVz dGFtcHMgYXJlIGFsc28gbm90IGlkZWFsIGZvciBpbnB1dF9ldmVudAphcyB0aGlzIHRpbWUgY2Fu IGdvIGJhY2t3YXJkcyBhcyBub3RlZCBpbiB0aGUgcGF0Y2gKYTgwYjgzYjdiOCBieSBKb2huIFN0 dWx0ei4KCkFybmQgQmVyZ21hbm4gc3VnZ2VzdGVkIGRlcHJlY2F0aW5nIHJlYWwgdGltZSBhbmQg dXNpbmcKbW9ub3RvbmljIG9yIG90aGVyIHRpbWVycyBmb3IgYWxsIGlucHV0X2V2ZW50IHRpbWVz IGFzIGEKc29sdXRpb24gdG8gYm90aCB0aGUgYWJvdmUgcHJvYmxlbXMuCgpBZGQgYSBuZXcgaW9j dGwgdG8gbGV0IHRoZSB1c2VyIGRpY3RhdGUgdGhlIGtpbmQgb2YgdGltZQp0byBiZSB1c2VkIGZv ciBpbnB1dCBldmVudHMuIFRoaXMgaXMgc2ltaWxhciB0byB0aGUgZXZkZXYKaW1wbGVtZW50YXRp b24gb2YgdGhlIGZlYXR1cmUuIFJlYWx0aW1lIGlzIHN0aWxsIHRoZQpkZWZhdWx0IHRpbWUuIFRo aXMgaXMgdG8gbWFpbnRhaW4gYmFja3dhcmQgY29tcGF0aWJpbGl0eS4KClRoZSBzdHJ1Y3R1cmUg dG8gbWFpbnRhaW4gaW5wdXQgZXZlbnRzIHdpbGwgYmUgY2hhbmdlZAppbiBhIGRpZmZlcmVudCBw YXRjaC4KClNpZ25lZC1vZmYtYnk6IERlZXBhIERpbmFtYW5pIDxkZWVwYS5rZXJuZWxAZ21haWwu Y29tPgotLS0KIGRyaXZlcnMvaW5wdXQvbWlzYy91aW5wdXQuYyB8IDU4ICsrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLQogaW5jbHVkZS9saW51eC91aW5wdXQuaCAg ICAgIHwgIDEgKwogaW5jbHVkZS91YXBpL2xpbnV4L3VpbnB1dC5oIHwgIDMgKysrCiAzIGZpbGVz IGNoYW5nZWQsIDYxIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9k cml2ZXJzL2lucHV0L21pc2MvdWlucHV0LmMgYi9kcml2ZXJzL2lucHV0L21pc2MvdWlucHV0LmMK aW5kZXggOTI1OTViOS4uYWUyMjkyNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC9taXNjL3Vp bnB1dC5jCisrKyBiL2RyaXZlcnMvaW5wdXQvbWlzYy91aW5wdXQuYwpAQCAtNDYsMTEgKzQ2LDI4 IEBAIHN0YXRpYyBpbnQgdWlucHV0X2Rldl9ldmVudChzdHJ1Y3QgaW5wdXRfZGV2ICpkZXYsCiAJ CQkgICAgdW5zaWduZWQgaW50IHR5cGUsIHVuc2lnbmVkIGludCBjb2RlLCBpbnQgdmFsdWUpCiB7 CiAJc3RydWN0IHVpbnB1dF9kZXZpY2UJKnVkZXYgPSBpbnB1dF9nZXRfZHJ2ZGF0YShkZXYpOwor CXN0cnVjdCB0aW1lc3BlYzY0CXRzOworCWt0aW1lX3Qga3Q7CiAKIAl1ZGV2LT5idWZmW3VkZXYt PmhlYWRdLnR5cGUgPSB0eXBlOwogCXVkZXYtPmJ1ZmZbdWRldi0+aGVhZF0uY29kZSA9IGNvZGU7 CiAJdWRldi0+YnVmZlt1ZGV2LT5oZWFkXS52YWx1ZSA9IHZhbHVlOwotCWRvX2dldHRpbWVvZmRh eSgmdWRldi0+YnVmZlt1ZGV2LT5oZWFkXS50aW1lKTsKKworCWt0ID0ga3RpbWVfZ2V0KCk7CisJ c3dpdGNoICh1ZGV2LT5jbGtfdHlwZSkgeworCWNhc2UgQ0xPQ0tfUkVBTFRJTUU6CisJCXRzID0g a3RpbWVfdG9fdGltZXNwZWM2NChrdGltZV9tb25vX3RvX3JlYWwoa3QpKTsKKwkJYnJlYWs7CisJ Y2FzZSBDTE9DS19NT05PVE9OSUM6CisJCXRzID0ga3RpbWVfdG9fdGltZXNwZWM2NChrdCk7CisJ CWJyZWFrOworCWNhc2UgQ0xPQ0tfQk9PVFRJTUU6CisJCXRzID0ga3RpbWVfdG9fdGltZXNwZWM2 NChrdGltZV9tb25vX3RvX2FueShrdCwgVEtfT0ZGU19CT09UKSk7CisJCWJyZWFrOworCX0KKwor CXVkZXYtPmJ1ZmZbdWRldi0+aGVhZF0udGltZS50dl9zZWMgPSB0cy50dl9zZWM7CisJdWRldi0+ YnVmZlt1ZGV2LT5oZWFkXS50aW1lLnR2X3VzZWMgPSB0cy50dl9uc2VjIC8gTlNFQ19QRVJfVVNF QzsKIAl1ZGV2LT5oZWFkID0gKHVkZXYtPmhlYWQgKyAxKSAlIFVJTlBVVF9CVUZGRVJfU0laRTsK IAogCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmdWRldi0+d2FpdHEpOwpAQCAtMjk1LDYgKzMxMiw3 IEBAIHN0YXRpYyBpbnQgdWlucHV0X2NyZWF0ZV9kZXZpY2Uoc3RydWN0IHVpbnB1dF9kZXZpY2Ug KnVkZXYpCiAJaWYgKGVycm9yKQogCQlnb3RvIGZhaWwyOwogCisJdWRldi0+Y2xrX3R5cGUgPSBD TE9DS19SRUFMVElNRTsKIAl1ZGV2LT5zdGF0ZSA9IFVJU1RfQ1JFQVRFRDsKIAogCXJldHVybiAw OwpAQCAtMzA0LDYgKzMyMiwzOCBAQCBzdGF0aWMgaW50IHVpbnB1dF9jcmVhdGVfZGV2aWNlKHN0 cnVjdCB1aW5wdXRfZGV2aWNlICp1ZGV2KQogCXJldHVybiBlcnJvcjsKIH0KIAorc3RhdGljIGlu dCB1aW5wdXRfc2V0X2Nsa190eXBlKHN0cnVjdCB1aW5wdXRfZGV2aWNlICp1ZGV2LCB1bnNpZ25l ZCBpbnQgY2xraWQpCit7CisJdW5zaWduZWQgaW50IGNsa190eXBlOworCisJaWYgKHVkZXYtPnN0 YXRlICE9IFVJU1RfQ1JFQVRFRCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlzd2l0Y2ggKGNsa2lk KSB7CisJLyogUmVhbHRpbWUgY2xvY2sgaXMgb25seSB2YWxpZCB1bnRpbCB5ZWFyIDIwMzguKi8K KwljYXNlIENMT0NLX1JFQUxUSU1FOgorCQljbGtfdHlwZSA9IENMT0NLX1JFQUxUSU1FOworCQli cmVhazsKKwljYXNlIENMT0NLX01PTk9UT05JQzoKKwkJY2xrX3R5cGUgPSBDTE9DS19NT05PVE9O SUM7CisJCWJyZWFrOworCWNhc2UgQ0xPQ0tfQk9PVFRJTUU6CisJCWNsa190eXBlID0gQ0xPQ0tf Qk9PVFRJTUU7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXJldHVybiAtRUlOVkFMOworCX0KKwor CWlmICh1ZGV2LT5jbGtfdHlwZSAhPSBjbGtfdHlwZSkgeworCQl1ZGV2LT5jbGtfdHlwZSA9IGNs a190eXBlOworCisJCS8qIEZsdXNoIHBlbmRpbmcgZXZlbnRzICovCisJCXVpbnB1dF9mbHVzaF9y ZXF1ZXN0cyh1ZGV2KTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIGludCB1aW5wdXRf b3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKIHsKIAlzdHJ1Y3Qg dWlucHV0X2RldmljZSAqbmV3ZGV2OwpAQCAtNzg3LDYgKzgzNyw3IEBAIHN0YXRpYyBsb25nIHVp bnB1dF9pb2N0bF9oYW5kbGVyKHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLAog CWNoYXIJCQkqcGh5czsKIAljb25zdCBjaGFyCQkqbmFtZTsKIAl1bnNpZ25lZCBpbnQJCXNpemU7 CisJaW50CQkJY2xvY2tfaWQ7CiAKIAlyZXR2YWwgPSBtdXRleF9sb2NrX2ludGVycnVwdGlibGUo JnVkZXYtPm11dGV4KTsKIAlpZiAocmV0dmFsKQpAQCAtODE3LDYgKzg2OCwxMSBAQCBzdGF0aWMg bG9uZyB1aW5wdXRfaW9jdGxfaGFuZGxlcihzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5zaWduZWQgaW50 IGNtZCwKIAkJCXJldHZhbCA9IHVpbnB1dF9kZXZfc2V0dXAodWRldiwgcCk7CiAJCQlnb3RvIG91 dDsKIAorCQljYXNlIFVJX1NFVF9DTE9DS0lEOgorCQkJaWYgKGNvcHlfZnJvbV91c2VyKCZjbG9j a19pZCwgcCwgc2l6ZW9mKHVuc2lnbmVkIGludCkpKQorCQkJCXJldHVybiAtRUZBVUxUOworCQkJ cmV0dXJuIHVpbnB1dF9zZXRfY2xrX3R5cGUodWRldiwgY2xvY2tfaWQpOworCiAJCS8qIFVJX0FC U19TRVRVUCBpcyBoYW5kbGVkIGluIHRoZSB2YXJpYWJsZSBzaXplIGlvY3RscyAqLwogCiAJCWNh c2UgVUlfU0VUX0VWQklUOgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC91aW5wdXQuaCBiL2lu Y2x1ZGUvbGludXgvdWlucHV0LmgKaW5kZXggNzVkZTQzZC4uNjUyN2ZiNyAxMDA2NDQKLS0tIGEv aW5jbHVkZS9saW51eC91aW5wdXQuaAorKysgYi9pbmNsdWRlL2xpbnV4L3VpbnB1dC5oCkBAIC03 Miw2ICs3Miw3IEBAIHN0cnVjdCB1aW5wdXRfZGV2aWNlIHsKIAl1bnNpZ25lZCBjaGFyCQloZWFk OwogCXVuc2lnbmVkIGNoYXIJCXRhaWw7CiAJc3RydWN0IGlucHV0X2V2ZW50CWJ1ZmZbVUlOUFVU X0JVRkZFUl9TSVpFXTsKKwlpbnQJCQljbGtfdHlwZTsKIAl1bnNpZ25lZCBpbnQJCWZmX2VmZmVj dHNfbWF4OwogCiAJc3RydWN0IHVpbnB1dF9yZXF1ZXN0CSpyZXF1ZXN0c1tVSU5QVVRfTlVNX1JF UVVFU1RTXTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9saW51eC91aW5wdXQuaCBiL2luY2x1 ZGUvdWFwaS9saW51eC91aW5wdXQuaAppbmRleCBkYzY1MmUyLi5kOTQ5NGFlIDEwMDY0NAotLS0g YS9pbmNsdWRlL3VhcGkvbGludXgvdWlucHV0LmgKKysrIGIvaW5jbHVkZS91YXBpL2xpbnV4L3Vp bnB1dC5oCkBAIC0xMzMsNiArMTMzLDkgQEAgc3RydWN0IHVpbnB1dF9hYnNfc2V0dXAgewogICov CiAjZGVmaW5lIFVJX0FCU19TRVRVUCBfSU9XKFVJTlBVVF9JT0NUTF9CQVNFLCA0LCBzdHJ1Y3Qg dWlucHV0X2Fic19zZXR1cCkKIAorLyogU2V0IGNsb2NraWQgdG8gYmUgdXNlZCBmb3IgdGltZXN0 YW1wcyAqLworI2RlZmluZSBVSV9TRVRfQ0xPQ0tJRCBfSU9XKFVJTlBVVF9JT0NUTF9CQVNFLCA1 LCBpbnQpCisKICNkZWZpbmUgVUlfU0VUX0VWQklUCQlfSU9XKFVJTlBVVF9JT0NUTF9CQVNFLCAx MDAsIGludCkKICNkZWZpbmUgVUlfU0VUX0tFWUJJVAkJX0lPVyhVSU5QVVRfSU9DVExfQkFTRSwg MTAxLCBpbnQpCiAjZGVmaW5lIFVJX1NFVF9SRUxCSVQJCV9JT1coVUlOUFVUX0lPQ1RMX0JBU0Us IDEwMiwgaW50KQotLSAKMi43LjQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fClkyMDM4IG1haWxpbmcgbGlzdApZMjAzOEBsaXN0cy5saW5hcm8ub3JnCmh0 dHBzOi8vbGlzdHMubGluYXJvLm9yZy9tYWlsbWFuL2xpc3RpbmZvL3kyMDM4Cg==