From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751919AbdCZTM4 (ORCPT ); Sun, 26 Mar 2017 15:12:56 -0400 Received: from mail-pg0-f66.google.com ([74.125.83.66]:33947 "EHLO mail-pg0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751490AbdCZTMw (ORCPT ); Sun, 26 Mar 2017 15:12:52 -0400 From: Deepa Dinamani To: tglx@linutronix.de, linux-kernel@vger.kernel.org Cc: john.stultz@linaro.org, arnd@arndb.de, y2038@lists.linaro.org, Richard Cochran , netdev@vger.kernel.org Subject: [PATCH v2 2/7] time: Change posix clocks ops interfaces to use timespec64 Date: Sun, 26 Mar 2017 12:04:13 -0700 Message-Id: <1490555058-4603-3-git-send-email-deepa.kernel@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1490555058-4603-1-git-send-email-deepa.kernel@gmail.com> References: <1490555058-4603-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 timespec is not y2038 safe on 32 bit machines. The posix clocks apis use struct timespec directly and through struct itimerspec. Replace the posix clock interfaces to use struct timespec64 and struct itimerspec64 instead. Also fix up their implementations accordingly. Note that the clock_getres() interface has also been changed to use timespec64 even though this particular interface is not affected by the y2038 problem. This helps verification for internal kernel code for y2038 readiness by getting rid of time_t/ timeval/ timespec. Signed-off-by: Deepa Dinamani Cc: Richard Cochran Cc: netdev@vger.kernel.org --- drivers/ptp/ptp_clock.c | 18 +++++++----------- include/linux/posix-clock.h | 10 +++++----- kernel/time/posix-clock.c | 34 ++++++++++++++++++++++++---------- 3 files changed, 36 insertions(+), 26 deletions(-) diff --git a/drivers/ptp/ptp_clock.c b/drivers/ptp/ptp_clock.c index e814280..b774357 100644 --- a/drivers/ptp/ptp_clock.c +++ b/drivers/ptp/ptp_clock.c @@ -97,30 +97,26 @@ static s32 scaled_ppm_to_ppb(long ppm) /* posix clock implementation */ -static int ptp_clock_getres(struct posix_clock *pc, struct timespec *tp) +static int ptp_clock_getres(struct posix_clock *pc, struct timespec64 *tp) { tp->tv_sec = 0; tp->tv_nsec = 1; return 0; } -static int ptp_clock_settime(struct posix_clock *pc, const struct timespec *tp) +static int ptp_clock_settime(struct posix_clock *pc, const struct timespec64 *tp) { struct ptp_clock *ptp = container_of(pc, struct ptp_clock, clock); - struct timespec64 ts = timespec_to_timespec64(*tp); - return ptp->info->settime64(ptp->info, &ts); + return ptp->info->settime64(ptp->info, tp); } -static int ptp_clock_gettime(struct posix_clock *pc, struct timespec *tp) +static int ptp_clock_gettime(struct posix_clock *pc, struct timespec64 *tp) { struct ptp_clock *ptp = container_of(pc, struct ptp_clock, clock); - struct timespec64 ts; int err; - err = ptp->info->gettime64(ptp->info, &ts); - if (!err) - *tp = timespec64_to_timespec(ts); + err = ptp->info->gettime64(ptp->info, tp); return err; } @@ -133,7 +129,7 @@ static int ptp_clock_adjtime(struct posix_clock *pc, struct timex *tx) ops = ptp->info; if (tx->modes & ADJ_SETOFFSET) { - struct timespec ts; + struct timespec64 ts; ktime_t kt; s64 delta; @@ -146,7 +142,7 @@ static int ptp_clock_adjtime(struct posix_clock *pc, struct timex *tx) if ((unsigned long) ts.tv_nsec >= NSEC_PER_SEC) return -EINVAL; - kt = timespec_to_ktime(ts); + kt = timespec64_to_ktime(ts); delta = ktime_to_ns(kt); err = ops->adjtime(ops, delta); } else if (tx->modes & ADJ_FREQUENCY) { diff --git a/include/linux/posix-clock.h b/include/linux/posix-clock.h index 34c4498..83b22ae 100644 --- a/include/linux/posix-clock.h +++ b/include/linux/posix-clock.h @@ -59,23 +59,23 @@ struct posix_clock_operations { int (*clock_adjtime)(struct posix_clock *pc, struct timex *tx); - int (*clock_gettime)(struct posix_clock *pc, struct timespec *ts); + int (*clock_gettime)(struct posix_clock *pc, struct timespec64 *ts); - int (*clock_getres) (struct posix_clock *pc, struct timespec *ts); + int (*clock_getres) (struct posix_clock *pc, struct timespec64 *ts); int (*clock_settime)(struct posix_clock *pc, - const struct timespec *ts); + const struct timespec64 *ts); int (*timer_create) (struct posix_clock *pc, struct k_itimer *kit); int (*timer_delete) (struct posix_clock *pc, struct k_itimer *kit); void (*timer_gettime)(struct posix_clock *pc, - struct k_itimer *kit, struct itimerspec *tsp); + struct k_itimer *kit, struct itimerspec64 *tsp); int (*timer_settime)(struct posix_clock *pc, struct k_itimer *kit, int flags, - struct itimerspec *tsp, struct itimerspec *old); + struct itimerspec64 *tsp, struct itimerspec64 *old); /* * Optional character device methods: */ diff --git a/kernel/time/posix-clock.c b/kernel/time/posix-clock.c index 9cff0ab..e24008c 100644 --- a/kernel/time/posix-clock.c +++ b/kernel/time/posix-clock.c @@ -300,14 +300,17 @@ static int pc_clock_adjtime(clockid_t id, struct timex *tx) static int pc_clock_gettime(clockid_t id, struct timespec *ts) { struct posix_clock_desc cd; + struct timespec64 ts64; int err; err = get_clock_desc(id, &cd); if (err) return err; - if (cd.clk->ops.clock_gettime) - err = cd.clk->ops.clock_gettime(cd.clk, ts); + if (cd.clk->ops.clock_gettime) { + err = cd.clk->ops.clock_gettime(cd.clk, &ts64); + *ts = timespec64_to_timespec(ts64); + } else err = -EOPNOTSUPP; @@ -319,14 +322,17 @@ static int pc_clock_gettime(clockid_t id, struct timespec *ts) static int pc_clock_getres(clockid_t id, struct timespec *ts) { struct posix_clock_desc cd; + struct timespec64 ts64; int err; err = get_clock_desc(id, &cd); if (err) return err; - if (cd.clk->ops.clock_getres) - err = cd.clk->ops.clock_getres(cd.clk, ts); + if (cd.clk->ops.clock_getres) { + err = cd.clk->ops.clock_getres(cd.clk, &ts64); + *ts = timespec64_to_timespec(ts64); + } else err = -EOPNOTSUPP; @@ -337,6 +343,7 @@ static int pc_clock_getres(clockid_t id, struct timespec *ts) static int pc_clock_settime(clockid_t id, const struct timespec *ts) { + struct timespec64 ts64 = timespec_to_timespec64(*ts); struct posix_clock_desc cd; int err; @@ -350,7 +357,7 @@ static int pc_clock_settime(clockid_t id, const struct timespec *ts) } if (cd.clk->ops.clock_settime) - err = cd.clk->ops.clock_settime(cd.clk, ts); + err = cd.clk->ops.clock_settime(cd.clk, &ts64); else err = -EOPNOTSUPP; out: @@ -403,29 +410,36 @@ static void pc_timer_gettime(struct k_itimer *kit, struct itimerspec *ts) { clockid_t id = kit->it_clock; struct posix_clock_desc cd; + struct itimerspec64 ts64; if (get_clock_desc(id, &cd)) return; - if (cd.clk->ops.timer_gettime) - cd.clk->ops.timer_gettime(cd.clk, kit, ts); - + if (cd.clk->ops.timer_gettime) { + cd.clk->ops.timer_gettime(cd.clk, kit, &ts64); + *ts = itimerspec64_to_itimerspec(&ts64); + } put_clock_desc(&cd); } static int pc_timer_settime(struct k_itimer *kit, int flags, struct itimerspec *ts, struct itimerspec *old) { + struct itimerspec64 ts64 = itimerspec_to_itimerspec64(ts); clockid_t id = kit->it_clock; struct posix_clock_desc cd; + struct itimerspec64 old64; int err; err = get_clock_desc(id, &cd); if (err) return err; - if (cd.clk->ops.timer_settime) - err = cd.clk->ops.timer_settime(cd.clk, kit, flags, ts, old); + if (cd.clk->ops.timer_settime) { + err = cd.clk->ops.timer_settime(cd.clk, kit, flags, &ts64, &old64); + if (old) + *old = itimerspec64_to_itimerspec(&old64); + } else err = -EOPNOTSUPP; -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Deepa Dinamani Subject: [PATCH v2 2/7] time: Change posix clocks ops interfaces to use timespec64 Date: Sun, 26 Mar 2017 12:04:13 -0700 Message-ID: <1490555058-4603-3-git-send-email-deepa.kernel@gmail.com> References: <1490555058-4603-1-git-send-email-deepa.kernel@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Cc: y2038@lists.linaro.org, netdev@vger.kernel.org, Richard Cochran , john.stultz@linaro.org, arnd@arndb.de To: tglx@linutronix.de, linux-kernel@vger.kernel.org Return-path: In-Reply-To: <1490555058-4603-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" List-Id: netdev.vger.kernel.org c3RydWN0IHRpbWVzcGVjIGlzIG5vdCB5MjAzOCBzYWZlIG9uIDMyIGJpdCBtYWNoaW5lcy4KClRo ZSBwb3NpeCBjbG9ja3MgYXBpcyB1c2Ugc3RydWN0IHRpbWVzcGVjIGRpcmVjdGx5IGFuZAp0aHJv dWdoIHN0cnVjdCBpdGltZXJzcGVjLgoKUmVwbGFjZSB0aGUgcG9zaXggY2xvY2sgaW50ZXJmYWNl cyB0byB1c2UKc3RydWN0IHRpbWVzcGVjNjQgYW5kIHN0cnVjdCBpdGltZXJzcGVjNjQgaW5zdGVh ZC4KQWxzbyBmaXggdXAgdGhlaXIgaW1wbGVtZW50YXRpb25zIGFjY29yZGluZ2x5LgoKTm90ZSB0 aGF0IHRoZSBjbG9ja19nZXRyZXMoKSBpbnRlcmZhY2UgaGFzIGFsc28gYmVlbiBjaGFuZ2VkCnRv IHVzZSB0aW1lc3BlYzY0IGV2ZW4gdGhvdWdoIHRoaXMgcGFydGljdWxhciBpbnRlcmZhY2UgaXMK bm90IGFmZmVjdGVkIGJ5IHRoZSB5MjAzOCBwcm9ibGVtLiBUaGlzIGhlbHBzIHZlcmlmaWNhdGlv biBmb3IKaW50ZXJuYWwga2VybmVsIGNvZGUgZm9yIHkyMDM4IHJlYWRpbmVzcyBieSBnZXR0aW5n IHJpZCBvZgp0aW1lX3QvIHRpbWV2YWwvIHRpbWVzcGVjLgoKU2lnbmVkLW9mZi1ieTogRGVlcGEg RGluYW1hbmkgPGRlZXBhLmtlcm5lbEBnbWFpbC5jb20+CkNjOiBSaWNoYXJkIENvY2hyYW4gPHJp Y2hhcmRjb2NocmFuQGdtYWlsLmNvbT4KQ2M6IG5ldGRldkB2Z2VyLmtlcm5lbC5vcmcKLS0tCiBk cml2ZXJzL3B0cC9wdHBfY2xvY2suYyAgICAgfCAxOCArKysrKysrLS0tLS0tLS0tLS0KIGluY2x1 ZGUvbGludXgvcG9zaXgtY2xvY2suaCB8IDEwICsrKysrLS0tLS0KIGtlcm5lbC90aW1lL3Bvc2l4 LWNsb2NrLmMgICB8IDM0ICsrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0KIDMgZmls ZXMgY2hhbmdlZCwgMzYgaW5zZXJ0aW9ucygrKSwgMjYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9wdHAvcHRwX2Nsb2NrLmMgYi9kcml2ZXJzL3B0cC9wdHBfY2xvY2suYwppbmRl eCBlODE0MjgwLi5iNzc0MzU3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3B0cC9wdHBfY2xvY2suYwor KysgYi9kcml2ZXJzL3B0cC9wdHBfY2xvY2suYwpAQCAtOTcsMzAgKzk3LDI2IEBAIHN0YXRpYyBz MzIgc2NhbGVkX3BwbV90b19wcGIobG9uZyBwcG0pCiAKIC8qIHBvc2l4IGNsb2NrIGltcGxlbWVu dGF0aW9uICovCiAKLXN0YXRpYyBpbnQgcHRwX2Nsb2NrX2dldHJlcyhzdHJ1Y3QgcG9zaXhfY2xv Y2sgKnBjLCBzdHJ1Y3QgdGltZXNwZWMgKnRwKQorc3RhdGljIGludCBwdHBfY2xvY2tfZ2V0cmVz KHN0cnVjdCBwb3NpeF9jbG9jayAqcGMsIHN0cnVjdCB0aW1lc3BlYzY0ICp0cCkKIHsKIAl0cC0+ dHZfc2VjID0gMDsKIAl0cC0+dHZfbnNlYyA9IDE7CiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBp bnQgcHRwX2Nsb2NrX3NldHRpbWUoc3RydWN0IHBvc2l4X2Nsb2NrICpwYywgY29uc3Qgc3RydWN0 IHRpbWVzcGVjICp0cCkKK3N0YXRpYyBpbnQgcHRwX2Nsb2NrX3NldHRpbWUoc3RydWN0IHBvc2l4 X2Nsb2NrICpwYywgY29uc3Qgc3RydWN0IHRpbWVzcGVjNjQgKnRwKQogewogCXN0cnVjdCBwdHBf Y2xvY2sgKnB0cCA9IGNvbnRhaW5lcl9vZihwYywgc3RydWN0IHB0cF9jbG9jaywgY2xvY2spOwot CXN0cnVjdCB0aW1lc3BlYzY0IHRzID0gdGltZXNwZWNfdG9fdGltZXNwZWM2NCgqdHApOwogCi0J cmV0dXJuICBwdHAtPmluZm8tPnNldHRpbWU2NChwdHAtPmluZm8sICZ0cyk7CisJcmV0dXJuICBw dHAtPmluZm8tPnNldHRpbWU2NChwdHAtPmluZm8sIHRwKTsKIH0KIAotc3RhdGljIGludCBwdHBf Y2xvY2tfZ2V0dGltZShzdHJ1Y3QgcG9zaXhfY2xvY2sgKnBjLCBzdHJ1Y3QgdGltZXNwZWMgKnRw KQorc3RhdGljIGludCBwdHBfY2xvY2tfZ2V0dGltZShzdHJ1Y3QgcG9zaXhfY2xvY2sgKnBjLCBz dHJ1Y3QgdGltZXNwZWM2NCAqdHApCiB7CiAJc3RydWN0IHB0cF9jbG9jayAqcHRwID0gY29udGFp bmVyX29mKHBjLCBzdHJ1Y3QgcHRwX2Nsb2NrLCBjbG9jayk7Ci0Jc3RydWN0IHRpbWVzcGVjNjQg dHM7CiAJaW50IGVycjsKIAotCWVyciA9IHB0cC0+aW5mby0+Z2V0dGltZTY0KHB0cC0+aW5mbywg JnRzKTsKLQlpZiAoIWVycikKLQkJKnRwID0gdGltZXNwZWM2NF90b190aW1lc3BlYyh0cyk7CisJ ZXJyID0gcHRwLT5pbmZvLT5nZXR0aW1lNjQocHRwLT5pbmZvLCB0cCk7CiAJcmV0dXJuIGVycjsK IH0KIApAQCAtMTMzLDcgKzEyOSw3IEBAIHN0YXRpYyBpbnQgcHRwX2Nsb2NrX2FkanRpbWUoc3Ry dWN0IHBvc2l4X2Nsb2NrICpwYywgc3RydWN0IHRpbWV4ICp0eCkKIAlvcHMgPSBwdHAtPmluZm87 CiAKIAlpZiAodHgtPm1vZGVzICYgQURKX1NFVE9GRlNFVCkgewotCQlzdHJ1Y3QgdGltZXNwZWMg dHM7CisJCXN0cnVjdCB0aW1lc3BlYzY0IHRzOwogCQlrdGltZV90IGt0OwogCQlzNjQgZGVsdGE7 CiAKQEAgLTE0Niw3ICsxNDIsNyBAQCBzdGF0aWMgaW50IHB0cF9jbG9ja19hZGp0aW1lKHN0cnVj dCBwb3NpeF9jbG9jayAqcGMsIHN0cnVjdCB0aW1leCAqdHgpCiAJCWlmICgodW5zaWduZWQgbG9u ZykgdHMudHZfbnNlYyA+PSBOU0VDX1BFUl9TRUMpCiAJCQlyZXR1cm4gLUVJTlZBTDsKIAotCQlr dCA9IHRpbWVzcGVjX3RvX2t0aW1lKHRzKTsKKwkJa3QgPSB0aW1lc3BlYzY0X3RvX2t0aW1lKHRz KTsKIAkJZGVsdGEgPSBrdGltZV90b19ucyhrdCk7CiAJCWVyciA9IG9wcy0+YWRqdGltZShvcHMs IGRlbHRhKTsKIAl9IGVsc2UgaWYgKHR4LT5tb2RlcyAmIEFESl9GUkVRVUVOQ1kpIHsKZGlmZiAt LWdpdCBhL2luY2x1ZGUvbGludXgvcG9zaXgtY2xvY2suaCBiL2luY2x1ZGUvbGludXgvcG9zaXgt Y2xvY2suaAppbmRleCAzNGM0NDk4Li44M2IyMmFlIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4 L3Bvc2l4LWNsb2NrLmgKKysrIGIvaW5jbHVkZS9saW51eC9wb3NpeC1jbG9jay5oCkBAIC01OSwy MyArNTksMjMgQEAgc3RydWN0IHBvc2l4X2Nsb2NrX29wZXJhdGlvbnMgewogCiAJaW50ICAoKmNs b2NrX2FkanRpbWUpKHN0cnVjdCBwb3NpeF9jbG9jayAqcGMsIHN0cnVjdCB0aW1leCAqdHgpOwog Ci0JaW50ICAoKmNsb2NrX2dldHRpbWUpKHN0cnVjdCBwb3NpeF9jbG9jayAqcGMsIHN0cnVjdCB0 aW1lc3BlYyAqdHMpOworCWludCAgKCpjbG9ja19nZXR0aW1lKShzdHJ1Y3QgcG9zaXhfY2xvY2sg KnBjLCBzdHJ1Y3QgdGltZXNwZWM2NCAqdHMpOwogCi0JaW50ICAoKmNsb2NrX2dldHJlcykgKHN0 cnVjdCBwb3NpeF9jbG9jayAqcGMsIHN0cnVjdCB0aW1lc3BlYyAqdHMpOworCWludCAgKCpjbG9j a19nZXRyZXMpIChzdHJ1Y3QgcG9zaXhfY2xvY2sgKnBjLCBzdHJ1Y3QgdGltZXNwZWM2NCAqdHMp OwogCiAJaW50ICAoKmNsb2NrX3NldHRpbWUpKHN0cnVjdCBwb3NpeF9jbG9jayAqcGMsCi0JCQkg ICAgICBjb25zdCBzdHJ1Y3QgdGltZXNwZWMgKnRzKTsKKwkJCSAgICAgIGNvbnN0IHN0cnVjdCB0 aW1lc3BlYzY0ICp0cyk7CiAKIAlpbnQgICgqdGltZXJfY3JlYXRlKSAoc3RydWN0IHBvc2l4X2Ns b2NrICpwYywgc3RydWN0IGtfaXRpbWVyICpraXQpOwogCiAJaW50ICAoKnRpbWVyX2RlbGV0ZSkg KHN0cnVjdCBwb3NpeF9jbG9jayAqcGMsIHN0cnVjdCBrX2l0aW1lciAqa2l0KTsKIAogCXZvaWQg KCp0aW1lcl9nZXR0aW1lKShzdHJ1Y3QgcG9zaXhfY2xvY2sgKnBjLAotCQkJICAgICAgc3RydWN0 IGtfaXRpbWVyICpraXQsIHN0cnVjdCBpdGltZXJzcGVjICp0c3ApOworCQkJICAgICAgc3RydWN0 IGtfaXRpbWVyICpraXQsIHN0cnVjdCBpdGltZXJzcGVjNjQgKnRzcCk7CiAKIAlpbnQgICgqdGlt ZXJfc2V0dGltZSkoc3RydWN0IHBvc2l4X2Nsb2NrICpwYywKIAkJCSAgICAgIHN0cnVjdCBrX2l0 aW1lciAqa2l0LCBpbnQgZmxhZ3MsCi0JCQkgICAgICBzdHJ1Y3QgaXRpbWVyc3BlYyAqdHNwLCBz dHJ1Y3QgaXRpbWVyc3BlYyAqb2xkKTsKKwkJCSAgICAgIHN0cnVjdCBpdGltZXJzcGVjNjQgKnRz cCwgc3RydWN0IGl0aW1lcnNwZWM2NCAqb2xkKTsKIAkvKgogCSAqIE9wdGlvbmFsIGNoYXJhY3Rl ciBkZXZpY2UgbWV0aG9kczoKIAkgKi8KZGlmZiAtLWdpdCBhL2tlcm5lbC90aW1lL3Bvc2l4LWNs b2NrLmMgYi9rZXJuZWwvdGltZS9wb3NpeC1jbG9jay5jCmluZGV4IDljZmYwYWIuLmUyNDAwOGMg MTAwNjQ0Ci0tLSBhL2tlcm5lbC90aW1lL3Bvc2l4LWNsb2NrLmMKKysrIGIva2VybmVsL3RpbWUv cG9zaXgtY2xvY2suYwpAQCAtMzAwLDE0ICszMDAsMTcgQEAgc3RhdGljIGludCBwY19jbG9ja19h ZGp0aW1lKGNsb2NraWRfdCBpZCwgc3RydWN0IHRpbWV4ICp0eCkKIHN0YXRpYyBpbnQgcGNfY2xv Y2tfZ2V0dGltZShjbG9ja2lkX3QgaWQsIHN0cnVjdCB0aW1lc3BlYyAqdHMpCiB7CiAJc3RydWN0 IHBvc2l4X2Nsb2NrX2Rlc2MgY2Q7CisJc3RydWN0IHRpbWVzcGVjNjQgdHM2NDsKIAlpbnQgZXJy OwogCiAJZXJyID0gZ2V0X2Nsb2NrX2Rlc2MoaWQsICZjZCk7CiAJaWYgKGVycikKIAkJcmV0dXJu IGVycjsKIAotCWlmIChjZC5jbGstPm9wcy5jbG9ja19nZXR0aW1lKQotCQllcnIgPSBjZC5jbGst Pm9wcy5jbG9ja19nZXR0aW1lKGNkLmNsaywgdHMpOworCWlmIChjZC5jbGstPm9wcy5jbG9ja19n ZXR0aW1lKSB7CisJCWVyciA9IGNkLmNsay0+b3BzLmNsb2NrX2dldHRpbWUoY2QuY2xrLCAmdHM2 NCk7CisJCSp0cyA9IHRpbWVzcGVjNjRfdG9fdGltZXNwZWModHM2NCk7CisJfQogCWVsc2UKIAkJ ZXJyID0gLUVPUE5PVFNVUFA7CiAKQEAgLTMxOSwxNCArMzIyLDE3IEBAIHN0YXRpYyBpbnQgcGNf Y2xvY2tfZ2V0dGltZShjbG9ja2lkX3QgaWQsIHN0cnVjdCB0aW1lc3BlYyAqdHMpCiBzdGF0aWMg aW50IHBjX2Nsb2NrX2dldHJlcyhjbG9ja2lkX3QgaWQsIHN0cnVjdCB0aW1lc3BlYyAqdHMpCiB7 CiAJc3RydWN0IHBvc2l4X2Nsb2NrX2Rlc2MgY2Q7CisJc3RydWN0IHRpbWVzcGVjNjQgdHM2NDsK IAlpbnQgZXJyOwogCiAJZXJyID0gZ2V0X2Nsb2NrX2Rlc2MoaWQsICZjZCk7CiAJaWYgKGVycikK IAkJcmV0dXJuIGVycjsKIAotCWlmIChjZC5jbGstPm9wcy5jbG9ja19nZXRyZXMpCi0JCWVyciA9 IGNkLmNsay0+b3BzLmNsb2NrX2dldHJlcyhjZC5jbGssIHRzKTsKKwlpZiAoY2QuY2xrLT5vcHMu Y2xvY2tfZ2V0cmVzKSB7CisJCWVyciA9IGNkLmNsay0+b3BzLmNsb2NrX2dldHJlcyhjZC5jbGss ICZ0czY0KTsKKwkJKnRzID0gdGltZXNwZWM2NF90b190aW1lc3BlYyh0czY0KTsKKwl9CiAJZWxz ZQogCQllcnIgPSAtRU9QTk9UU1VQUDsKIApAQCAtMzM3LDYgKzM0Myw3IEBAIHN0YXRpYyBpbnQg cGNfY2xvY2tfZ2V0cmVzKGNsb2NraWRfdCBpZCwgc3RydWN0IHRpbWVzcGVjICp0cykKIAogc3Rh dGljIGludCBwY19jbG9ja19zZXR0aW1lKGNsb2NraWRfdCBpZCwgY29uc3Qgc3RydWN0IHRpbWVz cGVjICp0cykKIHsKKwlzdHJ1Y3QgdGltZXNwZWM2NCB0czY0ID0gdGltZXNwZWNfdG9fdGltZXNw ZWM2NCgqdHMpOwogCXN0cnVjdCBwb3NpeF9jbG9ja19kZXNjIGNkOwogCWludCBlcnI7CiAKQEAg LTM1MCw3ICszNTcsNyBAQCBzdGF0aWMgaW50IHBjX2Nsb2NrX3NldHRpbWUoY2xvY2tpZF90IGlk LCBjb25zdCBzdHJ1Y3QgdGltZXNwZWMgKnRzKQogCX0KIAogCWlmIChjZC5jbGstPm9wcy5jbG9j a19zZXR0aW1lKQotCQllcnIgPSBjZC5jbGstPm9wcy5jbG9ja19zZXR0aW1lKGNkLmNsaywgdHMp OworCQllcnIgPSBjZC5jbGstPm9wcy5jbG9ja19zZXR0aW1lKGNkLmNsaywgJnRzNjQpOwogCWVs c2UKIAkJZXJyID0gLUVPUE5PVFNVUFA7CiBvdXQ6CkBAIC00MDMsMjkgKzQxMCwzNiBAQCBzdGF0 aWMgdm9pZCBwY190aW1lcl9nZXR0aW1lKHN0cnVjdCBrX2l0aW1lciAqa2l0LCBzdHJ1Y3QgaXRp bWVyc3BlYyAqdHMpCiB7CiAJY2xvY2tpZF90IGlkID0ga2l0LT5pdF9jbG9jazsKIAlzdHJ1Y3Qg cG9zaXhfY2xvY2tfZGVzYyBjZDsKKwlzdHJ1Y3QgaXRpbWVyc3BlYzY0IHRzNjQ7CiAKIAlpZiAo Z2V0X2Nsb2NrX2Rlc2MoaWQsICZjZCkpCiAJCXJldHVybjsKIAotCWlmIChjZC5jbGstPm9wcy50 aW1lcl9nZXR0aW1lKQotCQljZC5jbGstPm9wcy50aW1lcl9nZXR0aW1lKGNkLmNsaywga2l0LCB0 cyk7Ci0KKwlpZiAoY2QuY2xrLT5vcHMudGltZXJfZ2V0dGltZSkgeworCQljZC5jbGstPm9wcy50 aW1lcl9nZXR0aW1lKGNkLmNsaywga2l0LCAmdHM2NCk7CisJCSp0cyA9IGl0aW1lcnNwZWM2NF90 b19pdGltZXJzcGVjKCZ0czY0KTsKKwl9CiAJcHV0X2Nsb2NrX2Rlc2MoJmNkKTsKIH0KIAogc3Rh dGljIGludCBwY190aW1lcl9zZXR0aW1lKHN0cnVjdCBrX2l0aW1lciAqa2l0LCBpbnQgZmxhZ3Ms CiAJCQkgICAgc3RydWN0IGl0aW1lcnNwZWMgKnRzLCBzdHJ1Y3QgaXRpbWVyc3BlYyAqb2xkKQog eworCXN0cnVjdCBpdGltZXJzcGVjNjQgdHM2NCA9IGl0aW1lcnNwZWNfdG9faXRpbWVyc3BlYzY0 KHRzKTsKIAljbG9ja2lkX3QgaWQgPSBraXQtPml0X2Nsb2NrOwogCXN0cnVjdCBwb3NpeF9jbG9j a19kZXNjIGNkOworCXN0cnVjdCBpdGltZXJzcGVjNjQgb2xkNjQ7CiAJaW50IGVycjsKIAogCWVy ciA9IGdldF9jbG9ja19kZXNjKGlkLCAmY2QpOwogCWlmIChlcnIpCiAJCXJldHVybiBlcnI7CiAK LQlpZiAoY2QuY2xrLT5vcHMudGltZXJfc2V0dGltZSkKLQkJZXJyID0gY2QuY2xrLT5vcHMudGlt ZXJfc2V0dGltZShjZC5jbGssIGtpdCwgZmxhZ3MsIHRzLCBvbGQpOworCWlmIChjZC5jbGstPm9w cy50aW1lcl9zZXR0aW1lKSB7CisJCWVyciA9IGNkLmNsay0+b3BzLnRpbWVyX3NldHRpbWUoY2Qu Y2xrLCBraXQsIGZsYWdzLCAmdHM2NCwgJm9sZDY0KTsKKwkJaWYgKG9sZCkKKwkJCSpvbGQgPSBp dGltZXJzcGVjNjRfdG9faXRpbWVyc3BlYygmb2xkNjQpOworCX0KIAllbHNlCiAJCWVyciA9IC1F T1BOT1RTVVBQOwogCi0tIAoyLjcuNAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KWTIwMzggbWFpbGluZyBsaXN0ClkyMDM4QGxpc3RzLmxpbmFyby5vcmcK aHR0cHM6Ly9saXN0cy5saW5hcm8ub3JnL21haWxtYW4vbGlzdGluZm8veTIwMzgK