From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-pa0-f66.google.com ([209.85.220.66]:35531 "EHLO mail-pa0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752524AbcEDT0I (ORCPT ); Wed, 4 May 2016 15:26:08 -0400 From: Deepa Dinamani To: linux-kernel@vger.kernel.org Cc: arnd@arndb.de, john.stultz@linaro.org, tglx@linutronix.de, y2038@lists.linaro.org, linux-fsdevel@vger.kernel.org, Alexander Viro , "David S. Miller" , netdev@vger.kernel.org Subject: [RESEND PATCH 2/3] fs: poll/select/recvmmsg: use timespec64 for timeout events Date: Wed, 4 May 2016 12:24:59 -0700 Message-Id: <1462389899-2480-1-git-send-email-deepa.kernel@gmail.com> In-Reply-To: <1461947989-21926-3-git-send-email-deepa.kernel@gmail.com> References: <1461947989-21926-3-git-send-email-deepa.kernel@gmail.com> Sender: linux-fsdevel-owner@vger.kernel.org List-ID: struct timespec is not y2038 safe. Even though timespec might be sufficient to represent timeouts, use struct timespec64 here as the plan is to get rid of all timespec reference in the kernel. The patch transitions the common functions: poll_select_set_timeout() and select_estimate_accuracy() to use timespec64. And, all the syscalls that use these functions are transitioned in the same patch. The restart block parameters for poll uses monotonic time. Use timespec64 here as well to assign timeout value. This parameter in the restart block need not change because this only holds the monotonic timestamp at which timeout should occur. And, unsigned long data type should be big enough for this timestamp. The system call interfaces will be handled in a separate series. Compat interfaces need not change as timespec64 is an alias to struct timespec on a 64 bit system. Signed-off-by: Deepa Dinamani Cc: Alexander Viro Cc: "David S. Miller" Cc: netdev@vger.kernel.org --- Resending to include John and Thomas on this patch as well. This is to include this patch also in John's tree. This will let all 3 patches in the series to merged through the same tree. fs/eventpoll.c | 12 +++++----- fs/select.c | 67 +++++++++++++++++++++++++++++----------------------- include/linux/poll.h | 11 +++++---- net/socket.c | 8 ++++--- 4 files changed, 54 insertions(+), 44 deletions(-) diff --git a/fs/eventpoll.c b/fs/eventpoll.c index 8a74a2a..10db912 100644 --- a/fs/eventpoll.c +++ b/fs/eventpoll.c @@ -1583,15 +1583,15 @@ static int ep_send_events(struct eventpoll *ep, return ep_scan_ready_list(ep, ep_send_events_proc, &esed, 0, false); } -static inline struct timespec ep_set_mstimeout(long ms) +static inline struct timespec64 ep_set_mstimeout(long ms) { - struct timespec now, ts = { + struct timespec64 now, ts = { .tv_sec = ms / MSEC_PER_SEC, .tv_nsec = NSEC_PER_MSEC * (ms % MSEC_PER_SEC), }; - ktime_get_ts(&now); - return timespec_add_safe(now, ts); + ktime_get_ts64(&now); + return timespec64_add_safe(now, ts); } /** @@ -1621,11 +1621,11 @@ static int ep_poll(struct eventpoll *ep, struct epoll_event __user *events, ktime_t expires, *to = NULL; if (timeout > 0) { - struct timespec end_time = ep_set_mstimeout(timeout); + struct timespec64 end_time = ep_set_mstimeout(timeout); slack = select_estimate_accuracy(&end_time); to = &expires; - *to = timespec_to_ktime(end_time); + *to = timespec64_to_ktime(end_time); } else if (timeout == 0) { /* * Avoid the unnecessary trip to the wait queue loop, if the diff --git a/fs/select.c b/fs/select.c index 8692939..8ed9da5 100644 --- a/fs/select.c +++ b/fs/select.c @@ -47,7 +47,7 @@ #define MAX_SLACK (100 * NSEC_PER_MSEC) -static long __estimate_accuracy(struct timespec *tv) +static long __estimate_accuracy(struct timespec64 *tv) { long slack; int divfactor = 1000; @@ -70,10 +70,10 @@ static long __estimate_accuracy(struct timespec *tv) return slack; } -u64 select_estimate_accuracy(struct timespec *tv) +u64 select_estimate_accuracy(struct timespec64 *tv) { u64 ret; - struct timespec now; + struct timespec64 now; /* * Realtime tasks get a slack of 0 for obvious reasons. @@ -82,8 +82,8 @@ u64 select_estimate_accuracy(struct timespec *tv) if (rt_task(current)) return 0; - ktime_get_ts(&now); - now = timespec_sub(*tv, now); + ktime_get_ts64(&now); + now = timespec64_sub(*tv, now); ret = __estimate_accuracy(&now); if (ret < current->timer_slack_ns) return current->timer_slack_ns; @@ -260,7 +260,7 @@ EXPORT_SYMBOL(poll_schedule_timeout); /** * poll_select_set_timeout - helper function to setup the timeout value - * @to: pointer to timespec variable for the final timeout + * @to: pointer to timespec64 variable for the final timeout * @sec: seconds (from user space) * @nsec: nanoseconds (from user space) * @@ -269,26 +269,28 @@ EXPORT_SYMBOL(poll_schedule_timeout); * * Returns -EINVAL if sec/nsec are not normalized. Otherwise 0. */ -int poll_select_set_timeout(struct timespec *to, long sec, long nsec) +int poll_select_set_timeout(struct timespec64 *to, time64_t sec, long nsec) { - struct timespec ts = {.tv_sec = sec, .tv_nsec = nsec}; + struct timespec64 ts = {.tv_sec = sec, .tv_nsec = nsec}; - if (!timespec_valid(&ts)) + if (!timespec64_valid(&ts)) return -EINVAL; /* Optimize for the zero timeout value here */ if (!sec && !nsec) { to->tv_sec = to->tv_nsec = 0; } else { - ktime_get_ts(to); - *to = timespec_add_safe(*to, ts); + ktime_get_ts64(to); + *to = timespec64_add_safe(*to, ts); } return 0; } -static int poll_select_copy_remaining(struct timespec *end_time, void __user *p, +static int poll_select_copy_remaining(struct timespec64 *end_time, + void __user *p, int timeval, int ret) { + struct timespec64 rts64; struct timespec rts; struct timeval rtv; @@ -302,16 +304,18 @@ static int poll_select_copy_remaining(struct timespec *end_time, void __user *p, if (!end_time->tv_sec && !end_time->tv_nsec) return ret; - ktime_get_ts(&rts); - rts = timespec_sub(*end_time, rts); - if (rts.tv_sec < 0) - rts.tv_sec = rts.tv_nsec = 0; + ktime_get_ts64(&rts64); + rts64 = timespec64_sub(*end_time, rts64); + if (rts64.tv_sec < 0) + rts64.tv_sec = rts64.tv_nsec = 0; + + rts = timespec64_to_timespec(rts64); if (timeval) { if (sizeof(rtv) > sizeof(rtv.tv_sec) + sizeof(rtv.tv_usec)) memset(&rtv, 0, sizeof(rtv)); - rtv.tv_sec = rts.tv_sec; - rtv.tv_usec = rts.tv_nsec / NSEC_PER_USEC; + rtv.tv_sec = rts64.tv_sec; + rtv.tv_usec = rts64.tv_nsec / NSEC_PER_USEC; if (!copy_to_user(p, &rtv, sizeof(rtv))) return ret; @@ -396,7 +400,7 @@ static inline void wait_key_set(poll_table *wait, unsigned long in, wait->_key |= POLLOUT_SET; } -int do_select(int n, fd_set_bits *fds, struct timespec *end_time) +int do_select(int n, fd_set_bits *fds, struct timespec64 *end_time) { ktime_t expire, *to = NULL; struct poll_wqueues table; @@ -522,7 +526,7 @@ int do_select(int n, fd_set_bits *fds, struct timespec *end_time) * pointer to the expiry value. */ if (end_time && !to) { - expire = timespec_to_ktime(*end_time); + expire = timespec64_to_ktime(*end_time); to = &expire; } @@ -545,7 +549,7 @@ int do_select(int n, fd_set_bits *fds, struct timespec *end_time) * I'm trying ERESTARTNOHAND which restart only when you want to. */ int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp, - fd_set __user *exp, struct timespec *end_time) + fd_set __user *exp, struct timespec64 *end_time) { fd_set_bits fds; void *bits; @@ -622,7 +626,7 @@ out_nofds: SYSCALL_DEFINE5(select, int, n, fd_set __user *, inp, fd_set __user *, outp, fd_set __user *, exp, struct timeval __user *, tvp) { - struct timespec end_time, *to = NULL; + struct timespec64 end_time, *to = NULL; struct timeval tv; int ret; @@ -648,15 +652,17 @@ static long do_pselect(int n, fd_set __user *inp, fd_set __user *outp, const sigset_t __user *sigmask, size_t sigsetsize) { sigset_t ksigmask, sigsaved; - struct timespec ts, end_time, *to = NULL; + struct timespec ts; + struct timespec64 ts64, end_time, *to = NULL; int ret; if (tsp) { if (copy_from_user(&ts, tsp, sizeof(ts))) return -EFAULT; + ts64 = timespec_to_timespec64(ts); to = &end_time; - if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec)) + if (poll_select_set_timeout(to, ts64.tv_sec, ts64.tv_nsec)) return -EINVAL; } @@ -779,7 +785,7 @@ static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait, } static int do_poll(struct poll_list *list, struct poll_wqueues *wait, - struct timespec *end_time) + struct timespec64 *end_time) { poll_table* pt = &wait->pt; ktime_t expire, *to = NULL; @@ -854,7 +860,7 @@ static int do_poll(struct poll_list *list, struct poll_wqueues *wait, * pointer to the expiry value. */ if (end_time && !to) { - expire = timespec_to_ktime(*end_time); + expire = timespec64_to_ktime(*end_time); to = &expire; } @@ -868,7 +874,7 @@ static int do_poll(struct poll_list *list, struct poll_wqueues *wait, sizeof(struct pollfd)) int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds, - struct timespec *end_time) + struct timespec64 *end_time) { struct poll_wqueues table; int err = -EFAULT, fdcount, len, size; @@ -936,7 +942,7 @@ static long do_restart_poll(struct restart_block *restart_block) { struct pollfd __user *ufds = restart_block->poll.ufds; int nfds = restart_block->poll.nfds; - struct timespec *to = NULL, end_time; + struct timespec64 *to = NULL, end_time; int ret; if (restart_block->poll.has_timeout) { @@ -957,7 +963,7 @@ static long do_restart_poll(struct restart_block *restart_block) SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds, int, timeout_msecs) { - struct timespec end_time, *to = NULL; + struct timespec64 end_time, *to = NULL; int ret; if (timeout_msecs >= 0) { @@ -993,7 +999,8 @@ SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds, unsigned int, nfds, size_t, sigsetsize) { sigset_t ksigmask, sigsaved; - struct timespec ts, end_time, *to = NULL; + struct timespec ts; + struct timespec64 end_time, *to = NULL; int ret; if (tsp) { diff --git a/include/linux/poll.h b/include/linux/poll.h index 9fb4f40..37b057b 100644 --- a/include/linux/poll.h +++ b/include/linux/poll.h @@ -96,7 +96,7 @@ extern void poll_initwait(struct poll_wqueues *pwq); extern void poll_freewait(struct poll_wqueues *pwq); extern int poll_schedule_timeout(struct poll_wqueues *pwq, int state, ktime_t *expires, unsigned long slack); -extern u64 select_estimate_accuracy(struct timespec *tv); +extern u64 select_estimate_accuracy(struct timespec64 *tv); static inline int poll_schedule(struct poll_wqueues *pwq, int state) @@ -153,12 +153,13 @@ void zero_fd_set(unsigned long nr, unsigned long *fdset) #define MAX_INT64_SECONDS (((s64)(~((u64)0)>>1)/HZ)-1) -extern int do_select(int n, fd_set_bits *fds, struct timespec *end_time); +extern int do_select(int n, fd_set_bits *fds, struct timespec64 *end_time); extern int do_sys_poll(struct pollfd __user * ufds, unsigned int nfds, - struct timespec *end_time); + struct timespec64 *end_time); extern int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp, - fd_set __user *exp, struct timespec *end_time); + fd_set __user *exp, struct timespec64 *end_time); -extern int poll_select_set_timeout(struct timespec *to, long sec, long nsec); +extern int poll_select_set_timeout(struct timespec64 *to, time64_t sec, + long nsec); #endif /* _LINUX_POLL_H */ diff --git a/net/socket.c b/net/socket.c index 5dbb0bb..bdfe115 100644 --- a/net/socket.c +++ b/net/socket.c @@ -2171,7 +2171,8 @@ int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen, struct mmsghdr __user *entry; struct compat_mmsghdr __user *compat_entry; struct msghdr msg_sys; - struct timespec end_time; + struct timespec64 end_time; + struct timespec64 timeout64; if (timeout && poll_select_set_timeout(&end_time, timeout->tv_sec, @@ -2223,8 +2224,9 @@ int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen, flags |= MSG_DONTWAIT; if (timeout) { - ktime_get_ts(timeout); - *timeout = timespec_sub(end_time, *timeout); + ktime_get_ts64(&timeout64); + *timeout = timespec64_to_timespec( + timespec64_sub(end_time, timeout64)); if (timeout->tv_sec < 0) { timeout->tv_sec = timeout->tv_nsec = 0; break; -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Deepa Dinamani Subject: [RESEND PATCH 2/3] fs: poll/select/recvmmsg: use timespec64 for timeout events Date: Wed, 4 May 2016 12:24:59 -0700 Message-ID: <1462389899-2480-1-git-send-email-deepa.kernel@gmail.com> References: <1461947989-21926-3-git-send-email-deepa.kernel@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Cc: arnd@arndb.de, y2038@lists.linaro.org, netdev@vger.kernel.org, john.stultz@linaro.org, Alexander Viro , linux-fsdevel@vger.kernel.org, tglx@linutronix.de, "David S. Miller" To: linux-kernel@vger.kernel.org Return-path: In-Reply-To: <1461947989-21926-3-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" List-Id: netdev.vger.kernel.org c3RydWN0IHRpbWVzcGVjIGlzIG5vdCB5MjAzOCBzYWZlLgpFdmVuIHRob3VnaCB0aW1lc3BlYyBt aWdodCBiZSBzdWZmaWNpZW50IHRvIHJlcHJlc2VudAp0aW1lb3V0cywgdXNlIHN0cnVjdCB0aW1l c3BlYzY0IGhlcmUgYXMgdGhlIHBsYW4gaXMgdG8KZ2V0IHJpZCBvZiBhbGwgdGltZXNwZWMgcmVm ZXJlbmNlIGluIHRoZSBrZXJuZWwuCgpUaGUgcGF0Y2ggdHJhbnNpdGlvbnMgdGhlIGNvbW1vbiBm dW5jdGlvbnM6CnBvbGxfc2VsZWN0X3NldF90aW1lb3V0KCkgYW5kIHNlbGVjdF9lc3RpbWF0ZV9h Y2N1cmFjeSgpCnRvIHVzZSB0aW1lc3BlYzY0LiBBbmQsIGFsbCB0aGUgc3lzY2FsbHMgdGhhdCB1 c2UgdGhlc2UKZnVuY3Rpb25zIGFyZSB0cmFuc2l0aW9uZWQgaW4gdGhlIHNhbWUgcGF0Y2guCgpU aGUgcmVzdGFydCBibG9jayBwYXJhbWV0ZXJzIGZvciBwb2xsIHVzZXMgbW9ub3RvbmljIHRpbWUu ClVzZSB0aW1lc3BlYzY0IGhlcmUgYXMgd2VsbCB0byBhc3NpZ24gdGltZW91dCB2YWx1ZS4gVGhp cwpwYXJhbWV0ZXIgaW4gdGhlIHJlc3RhcnQgYmxvY2sgbmVlZCBub3QgY2hhbmdlIGJlY2F1c2UK dGhpcyBvbmx5IGhvbGRzIHRoZSBtb25vdG9uaWMgdGltZXN0YW1wIGF0IHdoaWNoIHRpbWVvdXQK c2hvdWxkIG9jY3VyLiBBbmQsIHVuc2lnbmVkIGxvbmcgZGF0YSB0eXBlIHNob3VsZCBiZSBiaWcK ZW5vdWdoIGZvciB0aGlzIHRpbWVzdGFtcC4KClRoZSBzeXN0ZW0gY2FsbCBpbnRlcmZhY2VzIHdp bGwgYmUgaGFuZGxlZCBpbiBhIHNlcGFyYXRlCnNlcmllcy4KCkNvbXBhdCBpbnRlcmZhY2VzIG5l ZWQgbm90IGNoYW5nZSBhcyB0aW1lc3BlYzY0IGlzIGFuCmFsaWFzIHRvIHN0cnVjdCB0aW1lc3Bl YyBvbiBhIDY0IGJpdCBzeXN0ZW0uCgpTaWduZWQtb2ZmLWJ5OiBEZWVwYSBEaW5hbWFuaSA8ZGVl cGEua2VybmVsQGdtYWlsLmNvbT4KQ2M6IEFsZXhhbmRlciBWaXJvIDx2aXJvQHplbml2LmxpbnV4 Lm9yZy51az4KQ2M6ICJEYXZpZCBTLiBNaWxsZXIiIDxkYXZlbUBkYXZlbWxvZnQubmV0PgpDYzog bmV0ZGV2QHZnZXIua2VybmVsLm9yZwotLS0KUmVzZW5kaW5nIHRvIGluY2x1ZGUgSm9obiBhbmQg VGhvbWFzIG9uIHRoaXMgcGF0Y2ggYXMgd2VsbC4KVGhpcyBpcyB0byBpbmNsdWRlIHRoaXMgcGF0 Y2ggYWxzbyBpbiBKb2huJ3MgdHJlZS4KVGhpcyB3aWxsIGxldCBhbGwgMyBwYXRjaGVzIGluIHRo ZSBzZXJpZXMgdG8gbWVyZ2VkIHRocm91Z2ggdGhlIHNhbWUgdHJlZS4KIAogZnMvZXZlbnRwb2xs LmMgICAgICAgfCAxMiArKysrKy0tLS0tCiBmcy9zZWxlY3QuYyAgICAgICAgICB8IDY3ICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGluY2x1ZGUv bGludXgvcG9sbC5oIHwgMTEgKysrKystLS0tCiBuZXQvc29ja2V0LmMgICAgICAgICB8ICA4ICsr KystLS0KIDQgZmlsZXMgY2hhbmdlZCwgNTQgaW5zZXJ0aW9ucygrKSwgNDQgZGVsZXRpb25zKC0p CgpkaWZmIC0tZ2l0IGEvZnMvZXZlbnRwb2xsLmMgYi9mcy9ldmVudHBvbGwuYwppbmRleCA4YTc0 YTJhLi4xMGRiOTEyIDEwMDY0NAotLS0gYS9mcy9ldmVudHBvbGwuYworKysgYi9mcy9ldmVudHBv bGwuYwpAQCAtMTU4MywxNSArMTU4MywxNSBAQCBzdGF0aWMgaW50IGVwX3NlbmRfZXZlbnRzKHN0 cnVjdCBldmVudHBvbGwgKmVwLAogCXJldHVybiBlcF9zY2FuX3JlYWR5X2xpc3QoZXAsIGVwX3Nl bmRfZXZlbnRzX3Byb2MsICZlc2VkLCAwLCBmYWxzZSk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgc3Ry dWN0IHRpbWVzcGVjIGVwX3NldF9tc3RpbWVvdXQobG9uZyBtcykKK3N0YXRpYyBpbmxpbmUgc3Ry dWN0IHRpbWVzcGVjNjQgZXBfc2V0X21zdGltZW91dChsb25nIG1zKQogewotCXN0cnVjdCB0aW1l c3BlYyBub3csIHRzID0geworCXN0cnVjdCB0aW1lc3BlYzY0IG5vdywgdHMgPSB7CiAJCS50dl9z ZWMgPSBtcyAvIE1TRUNfUEVSX1NFQywKIAkJLnR2X25zZWMgPSBOU0VDX1BFUl9NU0VDICogKG1z ICUgTVNFQ19QRVJfU0VDKSwKIAl9OwogCi0Ja3RpbWVfZ2V0X3RzKCZub3cpOwotCXJldHVybiB0 aW1lc3BlY19hZGRfc2FmZShub3csIHRzKTsKKwlrdGltZV9nZXRfdHM2NCgmbm93KTsKKwlyZXR1 cm4gdGltZXNwZWM2NF9hZGRfc2FmZShub3csIHRzKTsKIH0KIAogLyoqCkBAIC0xNjIxLDExICsx NjIxLDExIEBAIHN0YXRpYyBpbnQgZXBfcG9sbChzdHJ1Y3QgZXZlbnRwb2xsICplcCwgc3RydWN0 IGVwb2xsX2V2ZW50IF9fdXNlciAqZXZlbnRzLAogCWt0aW1lX3QgZXhwaXJlcywgKnRvID0gTlVM TDsKIAogCWlmICh0aW1lb3V0ID4gMCkgewotCQlzdHJ1Y3QgdGltZXNwZWMgZW5kX3RpbWUgPSBl cF9zZXRfbXN0aW1lb3V0KHRpbWVvdXQpOworCQlzdHJ1Y3QgdGltZXNwZWM2NCBlbmRfdGltZSA9 IGVwX3NldF9tc3RpbWVvdXQodGltZW91dCk7CiAKIAkJc2xhY2sgPSBzZWxlY3RfZXN0aW1hdGVf YWNjdXJhY3koJmVuZF90aW1lKTsKIAkJdG8gPSAmZXhwaXJlczsKLQkJKnRvID0gdGltZXNwZWNf dG9fa3RpbWUoZW5kX3RpbWUpOworCQkqdG8gPSB0aW1lc3BlYzY0X3RvX2t0aW1lKGVuZF90aW1l KTsKIAl9IGVsc2UgaWYgKHRpbWVvdXQgPT0gMCkgewogCQkvKgogCQkgKiBBdm9pZCB0aGUgdW5u ZWNlc3NhcnkgdHJpcCB0byB0aGUgd2FpdCBxdWV1ZSBsb29wLCBpZiB0aGUKZGlmZiAtLWdpdCBh L2ZzL3NlbGVjdC5jIGIvZnMvc2VsZWN0LmMKaW5kZXggODY5MjkzOS4uOGVkOWRhNSAxMDA2NDQK LS0tIGEvZnMvc2VsZWN0LmMKKysrIGIvZnMvc2VsZWN0LmMKQEAgLTQ3LDcgKzQ3LDcgQEAKIAog I2RlZmluZSBNQVhfU0xBQ0sJKDEwMCAqIE5TRUNfUEVSX01TRUMpCiAKLXN0YXRpYyBsb25nIF9f ZXN0aW1hdGVfYWNjdXJhY3koc3RydWN0IHRpbWVzcGVjICp0dikKK3N0YXRpYyBsb25nIF9fZXN0 aW1hdGVfYWNjdXJhY3koc3RydWN0IHRpbWVzcGVjNjQgKnR2KQogewogCWxvbmcgc2xhY2s7CiAJ aW50IGRpdmZhY3RvciA9IDEwMDA7CkBAIC03MCwxMCArNzAsMTAgQEAgc3RhdGljIGxvbmcgX19l c3RpbWF0ZV9hY2N1cmFjeShzdHJ1Y3QgdGltZXNwZWMgKnR2KQogCXJldHVybiBzbGFjazsKIH0K IAotdTY0IHNlbGVjdF9lc3RpbWF0ZV9hY2N1cmFjeShzdHJ1Y3QgdGltZXNwZWMgKnR2KQordTY0 IHNlbGVjdF9lc3RpbWF0ZV9hY2N1cmFjeShzdHJ1Y3QgdGltZXNwZWM2NCAqdHYpCiB7CiAJdTY0 IHJldDsKLQlzdHJ1Y3QgdGltZXNwZWMgbm93OworCXN0cnVjdCB0aW1lc3BlYzY0IG5vdzsKIAog CS8qCiAJICogUmVhbHRpbWUgdGFza3MgZ2V0IGEgc2xhY2sgb2YgMCBmb3Igb2J2aW91cyByZWFz b25zLgpAQCAtODIsOCArODIsOCBAQCB1NjQgc2VsZWN0X2VzdGltYXRlX2FjY3VyYWN5KHN0cnVj dCB0aW1lc3BlYyAqdHYpCiAJaWYgKHJ0X3Rhc2soY3VycmVudCkpCiAJCXJldHVybiAwOwogCi0J a3RpbWVfZ2V0X3RzKCZub3cpOwotCW5vdyA9IHRpbWVzcGVjX3N1YigqdHYsIG5vdyk7CisJa3Rp bWVfZ2V0X3RzNjQoJm5vdyk7CisJbm93ID0gdGltZXNwZWM2NF9zdWIoKnR2LCBub3cpOwogCXJl dCA9IF9fZXN0aW1hdGVfYWNjdXJhY3koJm5vdyk7CiAJaWYgKHJldCA8IGN1cnJlbnQtPnRpbWVy X3NsYWNrX25zKQogCQlyZXR1cm4gY3VycmVudC0+dGltZXJfc2xhY2tfbnM7CkBAIC0yNjAsNyAr MjYwLDcgQEAgRVhQT1JUX1NZTUJPTChwb2xsX3NjaGVkdWxlX3RpbWVvdXQpOwogCiAvKioKICAq IHBvbGxfc2VsZWN0X3NldF90aW1lb3V0IC0gaGVscGVyIGZ1bmN0aW9uIHRvIHNldHVwIHRoZSB0 aW1lb3V0IHZhbHVlCi0gKiBAdG86CQlwb2ludGVyIHRvIHRpbWVzcGVjIHZhcmlhYmxlIGZvciB0 aGUgZmluYWwgdGltZW91dAorICogQHRvOgkJcG9pbnRlciB0byB0aW1lc3BlYzY0IHZhcmlhYmxl IGZvciB0aGUgZmluYWwgdGltZW91dAogICogQHNlYzoJc2Vjb25kcyAoZnJvbSB1c2VyIHNwYWNl KQogICogQG5zZWM6CW5hbm9zZWNvbmRzIChmcm9tIHVzZXIgc3BhY2UpCiAgKgpAQCAtMjY5LDI2 ICsyNjksMjggQEAgRVhQT1JUX1NZTUJPTChwb2xsX3NjaGVkdWxlX3RpbWVvdXQpOwogICoKICAq IFJldHVybnMgLUVJTlZBTCBpZiBzZWMvbnNlYyBhcmUgbm90IG5vcm1hbGl6ZWQuIE90aGVyd2lz ZSAwLgogICovCi1pbnQgcG9sbF9zZWxlY3Rfc2V0X3RpbWVvdXQoc3RydWN0IHRpbWVzcGVjICp0 bywgbG9uZyBzZWMsIGxvbmcgbnNlYykKK2ludCBwb2xsX3NlbGVjdF9zZXRfdGltZW91dChzdHJ1 Y3QgdGltZXNwZWM2NCAqdG8sIHRpbWU2NF90IHNlYywgbG9uZyBuc2VjKQogewotCXN0cnVjdCB0 aW1lc3BlYyB0cyA9IHsudHZfc2VjID0gc2VjLCAudHZfbnNlYyA9IG5zZWN9OworCXN0cnVjdCB0 aW1lc3BlYzY0IHRzID0gey50dl9zZWMgPSBzZWMsIC50dl9uc2VjID0gbnNlY307CiAKLQlpZiAo IXRpbWVzcGVjX3ZhbGlkKCZ0cykpCisJaWYgKCF0aW1lc3BlYzY0X3ZhbGlkKCZ0cykpCiAJCXJl dHVybiAtRUlOVkFMOwogCiAJLyogT3B0aW1pemUgZm9yIHRoZSB6ZXJvIHRpbWVvdXQgdmFsdWUg aGVyZSAqLwogCWlmICghc2VjICYmICFuc2VjKSB7CiAJCXRvLT50dl9zZWMgPSB0by0+dHZfbnNl YyA9IDA7CiAJfSBlbHNlIHsKLQkJa3RpbWVfZ2V0X3RzKHRvKTsKLQkJKnRvID0gdGltZXNwZWNf YWRkX3NhZmUoKnRvLCB0cyk7CisJCWt0aW1lX2dldF90czY0KHRvKTsKKwkJKnRvID0gdGltZXNw ZWM2NF9hZGRfc2FmZSgqdG8sIHRzKTsKIAl9CiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQg cG9sbF9zZWxlY3RfY29weV9yZW1haW5pbmcoc3RydWN0IHRpbWVzcGVjICplbmRfdGltZSwgdm9p ZCBfX3VzZXIgKnAsCitzdGF0aWMgaW50IHBvbGxfc2VsZWN0X2NvcHlfcmVtYWluaW5nKHN0cnVj dCB0aW1lc3BlYzY0ICplbmRfdGltZSwKKwkJCQkgICAgICB2b2lkIF9fdXNlciAqcCwKIAkJCQkg ICAgICBpbnQgdGltZXZhbCwgaW50IHJldCkKIHsKKwlzdHJ1Y3QgdGltZXNwZWM2NCBydHM2NDsK IAlzdHJ1Y3QgdGltZXNwZWMgcnRzOwogCXN0cnVjdCB0aW1ldmFsIHJ0djsKIApAQCAtMzAyLDE2 ICszMDQsMTggQEAgc3RhdGljIGludCBwb2xsX3NlbGVjdF9jb3B5X3JlbWFpbmluZyhzdHJ1Y3Qg dGltZXNwZWMgKmVuZF90aW1lLCB2b2lkIF9fdXNlciAqcCwKIAlpZiAoIWVuZF90aW1lLT50dl9z ZWMgJiYgIWVuZF90aW1lLT50dl9uc2VjKQogCQlyZXR1cm4gcmV0OwogCi0Ja3RpbWVfZ2V0X3Rz KCZydHMpOwotCXJ0cyA9IHRpbWVzcGVjX3N1YigqZW5kX3RpbWUsIHJ0cyk7Ci0JaWYgKHJ0cy50 dl9zZWMgPCAwKQotCQlydHMudHZfc2VjID0gcnRzLnR2X25zZWMgPSAwOworCWt0aW1lX2dldF90 czY0KCZydHM2NCk7CisJcnRzNjQgPSB0aW1lc3BlYzY0X3N1YigqZW5kX3RpbWUsIHJ0czY0KTsK KwlpZiAocnRzNjQudHZfc2VjIDwgMCkKKwkJcnRzNjQudHZfc2VjID0gcnRzNjQudHZfbnNlYyA9 IDA7CisKKwlydHMgPSB0aW1lc3BlYzY0X3RvX3RpbWVzcGVjKHJ0czY0KTsKIAogCWlmICh0aW1l dmFsKSB7CiAJCWlmIChzaXplb2YocnR2KSA+IHNpemVvZihydHYudHZfc2VjKSArIHNpemVvZihy dHYudHZfdXNlYykpCiAJCQltZW1zZXQoJnJ0diwgMCwgc2l6ZW9mKHJ0dikpOwotCQlydHYudHZf c2VjID0gcnRzLnR2X3NlYzsKLQkJcnR2LnR2X3VzZWMgPSBydHMudHZfbnNlYyAvIE5TRUNfUEVS X1VTRUM7CisJCXJ0di50dl9zZWMgPSBydHM2NC50dl9zZWM7CisJCXJ0di50dl91c2VjID0gcnRz NjQudHZfbnNlYyAvIE5TRUNfUEVSX1VTRUM7CiAKIAkJaWYgKCFjb3B5X3RvX3VzZXIocCwgJnJ0 diwgc2l6ZW9mKHJ0dikpKQogCQkJcmV0dXJuIHJldDsKQEAgLTM5Niw3ICs0MDAsNyBAQCBzdGF0 aWMgaW5saW5lIHZvaWQgd2FpdF9rZXlfc2V0KHBvbGxfdGFibGUgKndhaXQsIHVuc2lnbmVkIGxv bmcgaW4sCiAJCXdhaXQtPl9rZXkgfD0gUE9MTE9VVF9TRVQ7CiB9CiAKLWludCBkb19zZWxlY3Qo aW50IG4sIGZkX3NldF9iaXRzICpmZHMsIHN0cnVjdCB0aW1lc3BlYyAqZW5kX3RpbWUpCitpbnQg ZG9fc2VsZWN0KGludCBuLCBmZF9zZXRfYml0cyAqZmRzLCBzdHJ1Y3QgdGltZXNwZWM2NCAqZW5k X3RpbWUpCiB7CiAJa3RpbWVfdCBleHBpcmUsICp0byA9IE5VTEw7CiAJc3RydWN0IHBvbGxfd3F1 ZXVlcyB0YWJsZTsKQEAgLTUyMiw3ICs1MjYsNyBAQCBpbnQgZG9fc2VsZWN0KGludCBuLCBmZF9z ZXRfYml0cyAqZmRzLCBzdHJ1Y3QgdGltZXNwZWMgKmVuZF90aW1lKQogCQkgKiBwb2ludGVyIHRv IHRoZSBleHBpcnkgdmFsdWUuCiAJCSAqLwogCQlpZiAoZW5kX3RpbWUgJiYgIXRvKSB7Ci0JCQll eHBpcmUgPSB0aW1lc3BlY190b19rdGltZSgqZW5kX3RpbWUpOworCQkJZXhwaXJlID0gdGltZXNw ZWM2NF90b19rdGltZSgqZW5kX3RpbWUpOwogCQkJdG8gPSAmZXhwaXJlOwogCQl9CiAKQEAgLTU0 NSw3ICs1NDksNyBAQCBpbnQgZG9fc2VsZWN0KGludCBuLCBmZF9zZXRfYml0cyAqZmRzLCBzdHJ1 Y3QgdGltZXNwZWMgKmVuZF90aW1lKQogICogSSdtIHRyeWluZyBFUkVTVEFSVE5PSEFORCB3aGlj aCByZXN0YXJ0IG9ubHkgd2hlbiB5b3Ugd2FudCB0by4KICAqLwogaW50IGNvcmVfc3lzX3NlbGVj dChpbnQgbiwgZmRfc2V0IF9fdXNlciAqaW5wLCBmZF9zZXQgX191c2VyICpvdXRwLAotCQkJICAg ZmRfc2V0IF9fdXNlciAqZXhwLCBzdHJ1Y3QgdGltZXNwZWMgKmVuZF90aW1lKQorCQkJICAgZmRf c2V0IF9fdXNlciAqZXhwLCBzdHJ1Y3QgdGltZXNwZWM2NCAqZW5kX3RpbWUpCiB7CiAJZmRfc2V0 X2JpdHMgZmRzOwogCXZvaWQgKmJpdHM7CkBAIC02MjIsNyArNjI2LDcgQEAgb3V0X25vZmRzOgog U1lTQ0FMTF9ERUZJTkU1KHNlbGVjdCwgaW50LCBuLCBmZF9zZXQgX191c2VyICosIGlucCwgZmRf c2V0IF9fdXNlciAqLCBvdXRwLAogCQlmZF9zZXQgX191c2VyICosIGV4cCwgc3RydWN0IHRpbWV2 YWwgX191c2VyICosIHR2cCkKIHsKLQlzdHJ1Y3QgdGltZXNwZWMgZW5kX3RpbWUsICp0byA9IE5V TEw7CisJc3RydWN0IHRpbWVzcGVjNjQgZW5kX3RpbWUsICp0byA9IE5VTEw7CiAJc3RydWN0IHRp bWV2YWwgdHY7CiAJaW50IHJldDsKIApAQCAtNjQ4LDE1ICs2NTIsMTcgQEAgc3RhdGljIGxvbmcg ZG9fcHNlbGVjdChpbnQgbiwgZmRfc2V0IF9fdXNlciAqaW5wLCBmZF9zZXQgX191c2VyICpvdXRw LAogCQkgICAgICAgY29uc3Qgc2lnc2V0X3QgX191c2VyICpzaWdtYXNrLCBzaXplX3Qgc2lnc2V0 c2l6ZSkKIHsKIAlzaWdzZXRfdCBrc2lnbWFzaywgc2lnc2F2ZWQ7Ci0Jc3RydWN0IHRpbWVzcGVj IHRzLCBlbmRfdGltZSwgKnRvID0gTlVMTDsKKwlzdHJ1Y3QgdGltZXNwZWMgdHM7CisJc3RydWN0 IHRpbWVzcGVjNjQgdHM2NCwgZW5kX3RpbWUsICp0byA9IE5VTEw7CiAJaW50IHJldDsKIAogCWlm ICh0c3ApIHsKIAkJaWYgKGNvcHlfZnJvbV91c2VyKCZ0cywgdHNwLCBzaXplb2YodHMpKSkKIAkJ CXJldHVybiAtRUZBVUxUOworCQl0czY0ID0gdGltZXNwZWNfdG9fdGltZXNwZWM2NCh0cyk7CiAK IAkJdG8gPSAmZW5kX3RpbWU7Ci0JCWlmIChwb2xsX3NlbGVjdF9zZXRfdGltZW91dCh0bywgdHMu dHZfc2VjLCB0cy50dl9uc2VjKSkKKwkJaWYgKHBvbGxfc2VsZWN0X3NldF90aW1lb3V0KHRvLCB0 czY0LnR2X3NlYywgdHM2NC50dl9uc2VjKSkKIAkJCXJldHVybiAtRUlOVkFMOwogCX0KIApAQCAt Nzc5LDcgKzc4NSw3IEBAIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50IGRvX3BvbGxmZChzdHJ1 Y3QgcG9sbGZkICpwb2xsZmQsIHBvbGxfdGFibGUgKnB3YWl0LAogfQogCiBzdGF0aWMgaW50IGRv X3BvbGwoc3RydWN0IHBvbGxfbGlzdCAqbGlzdCwgc3RydWN0IHBvbGxfd3F1ZXVlcyAqd2FpdCwK LQkJICAgc3RydWN0IHRpbWVzcGVjICplbmRfdGltZSkKKwkJICAgc3RydWN0IHRpbWVzcGVjNjQg KmVuZF90aW1lKQogewogCXBvbGxfdGFibGUqIHB0ID0gJndhaXQtPnB0OwogCWt0aW1lX3QgZXhw aXJlLCAqdG8gPSBOVUxMOwpAQCAtODU0LDcgKzg2MCw3IEBAIHN0YXRpYyBpbnQgZG9fcG9sbChz dHJ1Y3QgcG9sbF9saXN0ICpsaXN0LCBzdHJ1Y3QgcG9sbF93cXVldWVzICp3YWl0LAogCQkgKiBw b2ludGVyIHRvIHRoZSBleHBpcnkgdmFsdWUuCiAJCSAqLwogCQlpZiAoZW5kX3RpbWUgJiYgIXRv KSB7Ci0JCQlleHBpcmUgPSB0aW1lc3BlY190b19rdGltZSgqZW5kX3RpbWUpOworCQkJZXhwaXJl ID0gdGltZXNwZWM2NF90b19rdGltZSgqZW5kX3RpbWUpOwogCQkJdG8gPSAmZXhwaXJlOwogCQl9 CiAKQEAgLTg2OCw3ICs4NzQsNyBAQCBzdGF0aWMgaW50IGRvX3BvbGwoc3RydWN0IHBvbGxfbGlz dCAqbGlzdCwgc3RydWN0IHBvbGxfd3F1ZXVlcyAqd2FpdCwKIAkJCXNpemVvZihzdHJ1Y3QgcG9s bGZkKSkKIAogaW50IGRvX3N5c19wb2xsKHN0cnVjdCBwb2xsZmQgX191c2VyICp1ZmRzLCB1bnNp Z25lZCBpbnQgbmZkcywKLQkJc3RydWN0IHRpbWVzcGVjICplbmRfdGltZSkKKwkJc3RydWN0IHRp bWVzcGVjNjQgKmVuZF90aW1lKQogewogCXN0cnVjdCBwb2xsX3dxdWV1ZXMgdGFibGU7CiAgCWlu dCBlcnIgPSAtRUZBVUxULCBmZGNvdW50LCBsZW4sIHNpemU7CkBAIC05MzYsNyArOTQyLDcgQEAg c3RhdGljIGxvbmcgZG9fcmVzdGFydF9wb2xsKHN0cnVjdCByZXN0YXJ0X2Jsb2NrICpyZXN0YXJ0 X2Jsb2NrKQogewogCXN0cnVjdCBwb2xsZmQgX191c2VyICp1ZmRzID0gcmVzdGFydF9ibG9jay0+ cG9sbC51ZmRzOwogCWludCBuZmRzID0gcmVzdGFydF9ibG9jay0+cG9sbC5uZmRzOwotCXN0cnVj dCB0aW1lc3BlYyAqdG8gPSBOVUxMLCBlbmRfdGltZTsKKwlzdHJ1Y3QgdGltZXNwZWM2NCAqdG8g PSBOVUxMLCBlbmRfdGltZTsKIAlpbnQgcmV0OwogCiAJaWYgKHJlc3RhcnRfYmxvY2stPnBvbGwu aGFzX3RpbWVvdXQpIHsKQEAgLTk1Nyw3ICs5NjMsNyBAQCBzdGF0aWMgbG9uZyBkb19yZXN0YXJ0 X3BvbGwoc3RydWN0IHJlc3RhcnRfYmxvY2sgKnJlc3RhcnRfYmxvY2spCiBTWVNDQUxMX0RFRklO RTMocG9sbCwgc3RydWN0IHBvbGxmZCBfX3VzZXIgKiwgdWZkcywgdW5zaWduZWQgaW50LCBuZmRz LAogCQlpbnQsIHRpbWVvdXRfbXNlY3MpCiB7Ci0Jc3RydWN0IHRpbWVzcGVjIGVuZF90aW1lLCAq dG8gPSBOVUxMOworCXN0cnVjdCB0aW1lc3BlYzY0IGVuZF90aW1lLCAqdG8gPSBOVUxMOwogCWlu dCByZXQ7CiAKIAlpZiAodGltZW91dF9tc2VjcyA+PSAwKSB7CkBAIC05OTMsNyArOTk5LDggQEAg U1lTQ0FMTF9ERUZJTkU1KHBwb2xsLCBzdHJ1Y3QgcG9sbGZkIF9fdXNlciAqLCB1ZmRzLCB1bnNp Z25lZCBpbnQsIG5mZHMsCiAJCXNpemVfdCwgc2lnc2V0c2l6ZSkKIHsKIAlzaWdzZXRfdCBrc2ln bWFzaywgc2lnc2F2ZWQ7Ci0Jc3RydWN0IHRpbWVzcGVjIHRzLCBlbmRfdGltZSwgKnRvID0gTlVM TDsKKwlzdHJ1Y3QgdGltZXNwZWMgdHM7CisJc3RydWN0IHRpbWVzcGVjNjQgZW5kX3RpbWUsICp0 byA9IE5VTEw7CiAJaW50IHJldDsKIAogCWlmICh0c3ApIHsKZGlmZiAtLWdpdCBhL2luY2x1ZGUv bGludXgvcG9sbC5oIGIvaW5jbHVkZS9saW51eC9wb2xsLmgKaW5kZXggOWZiNGY0MC4uMzdiMDU3 YiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9wb2xsLmgKKysrIGIvaW5jbHVkZS9saW51eC9w b2xsLmgKQEAgLTk2LDcgKzk2LDcgQEAgZXh0ZXJuIHZvaWQgcG9sbF9pbml0d2FpdChzdHJ1Y3Qg cG9sbF93cXVldWVzICpwd3EpOwogZXh0ZXJuIHZvaWQgcG9sbF9mcmVld2FpdChzdHJ1Y3QgcG9s bF93cXVldWVzICpwd3EpOwogZXh0ZXJuIGludCBwb2xsX3NjaGVkdWxlX3RpbWVvdXQoc3RydWN0 IHBvbGxfd3F1ZXVlcyAqcHdxLCBpbnQgc3RhdGUsCiAJCQkJIGt0aW1lX3QgKmV4cGlyZXMsIHVu c2lnbmVkIGxvbmcgc2xhY2spOwotZXh0ZXJuIHU2NCBzZWxlY3RfZXN0aW1hdGVfYWNjdXJhY3ko c3RydWN0IHRpbWVzcGVjICp0dik7CitleHRlcm4gdTY0IHNlbGVjdF9lc3RpbWF0ZV9hY2N1cmFj eShzdHJ1Y3QgdGltZXNwZWM2NCAqdHYpOwogCiAKIHN0YXRpYyBpbmxpbmUgaW50IHBvbGxfc2No ZWR1bGUoc3RydWN0IHBvbGxfd3F1ZXVlcyAqcHdxLCBpbnQgc3RhdGUpCkBAIC0xNTMsMTIgKzE1 MywxMyBAQCB2b2lkIHplcm9fZmRfc2V0KHVuc2lnbmVkIGxvbmcgbnIsIHVuc2lnbmVkIGxvbmcg KmZkc2V0KQogCiAjZGVmaW5lIE1BWF9JTlQ2NF9TRUNPTkRTICgoKHM2NCkofigodTY0KTApPj4x KS9IWiktMSkKIAotZXh0ZXJuIGludCBkb19zZWxlY3QoaW50IG4sIGZkX3NldF9iaXRzICpmZHMs IHN0cnVjdCB0aW1lc3BlYyAqZW5kX3RpbWUpOworZXh0ZXJuIGludCBkb19zZWxlY3QoaW50IG4s IGZkX3NldF9iaXRzICpmZHMsIHN0cnVjdCB0aW1lc3BlYzY0ICplbmRfdGltZSk7CiBleHRlcm4g aW50IGRvX3N5c19wb2xsKHN0cnVjdCBwb2xsZmQgX191c2VyICogdWZkcywgdW5zaWduZWQgaW50 IG5mZHMsCi0JCSAgICAgICBzdHJ1Y3QgdGltZXNwZWMgKmVuZF90aW1lKTsKKwkJICAgICAgIHN0 cnVjdCB0aW1lc3BlYzY0ICplbmRfdGltZSk7CiBleHRlcm4gaW50IGNvcmVfc3lzX3NlbGVjdChp bnQgbiwgZmRfc2V0IF9fdXNlciAqaW5wLCBmZF9zZXQgX191c2VyICpvdXRwLAotCQkJICAgZmRf c2V0IF9fdXNlciAqZXhwLCBzdHJ1Y3QgdGltZXNwZWMgKmVuZF90aW1lKTsKKwkJCSAgIGZkX3Nl dCBfX3VzZXIgKmV4cCwgc3RydWN0IHRpbWVzcGVjNjQgKmVuZF90aW1lKTsKIAotZXh0ZXJuIGlu dCBwb2xsX3NlbGVjdF9zZXRfdGltZW91dChzdHJ1Y3QgdGltZXNwZWMgKnRvLCBsb25nIHNlYywg bG9uZyBuc2VjKTsKK2V4dGVybiBpbnQgcG9sbF9zZWxlY3Rfc2V0X3RpbWVvdXQoc3RydWN0IHRp bWVzcGVjNjQgKnRvLCB0aW1lNjRfdCBzZWMsCisJCQkJICAgbG9uZyBuc2VjKTsKIAogI2VuZGlm IC8qIF9MSU5VWF9QT0xMX0ggKi8KZGlmZiAtLWdpdCBhL25ldC9zb2NrZXQuYyBiL25ldC9zb2Nr ZXQuYwppbmRleCA1ZGJiMGJiLi5iZGZlMTE1IDEwMDY0NAotLS0gYS9uZXQvc29ja2V0LmMKKysr IGIvbmV0L3NvY2tldC5jCkBAIC0yMTcxLDcgKzIxNzEsOCBAQCBpbnQgX19zeXNfcmVjdm1tc2co aW50IGZkLCBzdHJ1Y3QgbW1zZ2hkciBfX3VzZXIgKm1tc2csIHVuc2lnbmVkIGludCB2bGVuLAog CXN0cnVjdCBtbXNnaGRyIF9fdXNlciAqZW50cnk7CiAJc3RydWN0IGNvbXBhdF9tbXNnaGRyIF9f dXNlciAqY29tcGF0X2VudHJ5OwogCXN0cnVjdCBtc2doZHIgbXNnX3N5czsKLQlzdHJ1Y3QgdGlt ZXNwZWMgZW5kX3RpbWU7CisJc3RydWN0IHRpbWVzcGVjNjQgZW5kX3RpbWU7CisJc3RydWN0IHRp bWVzcGVjNjQgdGltZW91dDY0OwogCiAJaWYgKHRpbWVvdXQgJiYKIAkgICAgcG9sbF9zZWxlY3Rf c2V0X3RpbWVvdXQoJmVuZF90aW1lLCB0aW1lb3V0LT50dl9zZWMsCkBAIC0yMjIzLDggKzIyMjQs OSBAQCBpbnQgX19zeXNfcmVjdm1tc2coaW50IGZkLCBzdHJ1Y3QgbW1zZ2hkciBfX3VzZXIgKm1t c2csIHVuc2lnbmVkIGludCB2bGVuLAogCQkJZmxhZ3MgfD0gTVNHX0RPTlRXQUlUOwogCiAJCWlm ICh0aW1lb3V0KSB7Ci0JCQlrdGltZV9nZXRfdHModGltZW91dCk7Ci0JCQkqdGltZW91dCA9IHRp bWVzcGVjX3N1YihlbmRfdGltZSwgKnRpbWVvdXQpOworCQkJa3RpbWVfZ2V0X3RzNjQoJnRpbWVv dXQ2NCk7CisJCQkqdGltZW91dCA9IHRpbWVzcGVjNjRfdG9fdGltZXNwZWMoCisJCQkJCXRpbWVz cGVjNjRfc3ViKGVuZF90aW1lLCB0aW1lb3V0NjQpKTsKIAkJCWlmICh0aW1lb3V0LT50dl9zZWMg PCAwKSB7CiAJCQkJdGltZW91dC0+dHZfc2VjID0gdGltZW91dC0+dHZfbnNlYyA9IDA7CiAJCQkJ YnJlYWs7Ci0tIAoxLjkuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18KWTIwMzggbWFpbGluZyBsaXN0ClkyMDM4QGxpc3RzLmxpbmFyby5vcmcKaHR0cHM6 Ly9saXN0cy5saW5hcm8ub3JnL21haWxtYW4vbGlzdGluZm8veTIwMzgK