From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Cyrus-Session-Id: sloti22d1t05-1025519-1521802604-2-12346194490523544319 X-Sieve: CMU Sieve 3.0 X-Spam-known-sender: no X-Spam-score: 0.0 X-Spam-hits: BAYES_00 -1.9, HEADER_FROM_DIFFERENT_DOMAINS 0.25, ME_NOAUTH 0.01, RCVD_IN_DNSWL_HI -5, T_RP_MATCHES_RCVD -0.01, LANGUAGES unknown, BAYES_USED global, SA_VERSION 3.4.0 X-Spam-source: IP='209.132.180.67', Host='vger.kernel.org', Country='CN', FromHeader='org', MailFrom='org' X-Spam-charsets: plain='UTF-8' X-Resolved-to: greg@kroah.com X-Delivered-to: greg@kroah.com X-Mail-from: stable-owner@vger.kernel.org ARC-Seal: i=1; a=rsa-sha256; cv=none; d=messagingengine.com; s=arctest; t=1521802603; b=MLHomj3cey6kjw54tbZ9H0pbzvKituPj2U2xoNmglZlCZjc Pv0Yjg+mokeYkYXVdhQuqKj6DHXv9Us6cSub/fBCsxNIL99U+Vi9TSjxqcNWIAHC RouCneZEqJMk3jRi7zIF/yduHOcxGYNyPh4YDNzwcnAbnq7KVhSxG+t8zwzT9TVo XL97aORXyWXcaTr/OjLMSLOQPp719tkolpfNqHY4qRq1By7yf2l3mw0zrYwvc2+t J2Fn54k4EeCNaK5P07HZoWjCEhHi+7k2123pt1353SEVThv7PBMzwffB+z86fG9x bylR5rfeAGyKJl/U2SvE1ZkkCZqQo4WI3s0WYzg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-type:sender :list-id; s=arctest; t=1521802603; bh=/S3TLUfp4w+tla1u4KF1IMF+PH L0kptiPifbu/N/FHM=; b=NSD2NYKW3uugnWxsk+sWTMM8oyYV3/UntWH5s0TCe/ IoLrAizjXi5X/2/f3UtzACwklN1TzP1guR30Jm9g///+NAzbys8jXf8eBY772kzK GXdjpw8zb4SzVDxrnisP3Io/9S1SPGrmUJ4X2JZG7ADhEqpvaZDA5SqWpyXRldgY 45jwxLQFipWZ+cdXdztuZmLnQ9v6gwrI32ZXN/U773bmR+9roSpRsPMApAyzQhIg L8sqL58PlS0aq2JItobyuaWcPMfDwDIXTym5WqNnKMw7nahcjEJm4/w1F67LMRMi kmUkpK6+YK+5nuvwZJaMtVnkx3CjjQ5ky/hRIWKzySZQ== ARC-Authentication-Results: i=1; mx2.messagingengine.com; arc=none (no signatures found); dkim=none (no signatures found); dmarc=none (p=none,has-list-id=yes,d=none) header.from=linuxfoundation.org; iprev=pass policy.iprev=209.132.180.67 (vger.kernel.org); spf=none smtp.mailfrom=stable-owner@vger.kernel.org smtp.helo=vger.kernel.org; x-aligned-from=fail; x-ptr=pass x-ptr-helo=vger.kernel.org x-ptr-lookup=vger.kernel.org; x-return-mx=pass smtp.domain=vger.kernel.org smtp.result=pass smtp_org.domain=kernel.org smtp_org.result=pass smtp_is_org_domain=no header.domain=linuxfoundation.org header.result=pass header_is_org_domain=yes; x-vs=clean score=-100 state=0 Authentication-Results: mx2.messagingengine.com; arc=none (no signatures found); dkim=none (no signatures found); dmarc=none (p=none,has-list-id=yes,d=none) header.from=linuxfoundation.org; iprev=pass policy.iprev=209.132.180.67 (vger.kernel.org); spf=none smtp.mailfrom=stable-owner@vger.kernel.org smtp.helo=vger.kernel.org; x-aligned-from=fail; x-ptr=pass x-ptr-helo=vger.kernel.org x-ptr-lookup=vger.kernel.org; x-return-mx=pass smtp.domain=vger.kernel.org smtp.result=pass smtp_org.domain=kernel.org smtp_org.result=pass smtp_is_org_domain=no header.domain=linuxfoundation.org header.result=pass header_is_org_domain=yes; x-vs=clean score=-100 state=0 X-ME-VSCategory: clean Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755895AbeCWK4a (ORCPT ); Fri, 23 Mar 2018 06:56:30 -0400 Received: from mail.linuxfoundation.org ([140.211.169.12]:44582 "EHLO mail.linuxfoundation.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755591AbeCWKNE (ORCPT ); Fri, 23 Mar 2018 06:13:04 -0400 From: Greg Kroah-Hartman To: linux-kernel@vger.kernel.org Cc: Greg Kroah-Hartman , stable@vger.kernel.org, Deepa Dinamani , arnd@arndb.de, y2038@lists.linaro.org, netdev@vger.kernel.org, Richard Cochran , john.stultz@linaro.org, Thomas Gleixner , Sasha Levin Subject: [PATCH 4.4 11/97] time: Change posix clocks ops interfaces to use timespec64 Date: Fri, 23 Mar 2018 10:53:58 +0100 Message-Id: <20180323094158.122202599@linuxfoundation.org> X-Mailer: git-send-email 2.16.2 In-Reply-To: <20180323094157.535925724@linuxfoundation.org> References: <20180323094157.535925724@linuxfoundation.org> User-Agent: quilt/0.65 X-stable: review MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Sender: stable-owner@vger.kernel.org X-Mailing-List: stable@vger.kernel.org X-getmail-retrieved-from-mailbox: INBOX X-Mailing-List: linux-kernel@vger.kernel.org List-ID: 4.4-stable review patch. If anyone has any objections, please let me know. ------------------ From: Deepa Dinamani [ Upstream commit d340266e19ddb70dbd608f9deedcfb35fdb9d419 ] 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: arnd@arndb.de Cc: y2038@lists.linaro.org Cc: netdev@vger.kernel.org Cc: Richard Cochran Cc: john.stultz@linaro.org Link: http://lkml.kernel.org/r/1490555058-4603-3-git-send-email-deepa.kernel@gmail.com Signed-off-by: Thomas Gleixner Signed-off-by: Sasha Levin Signed-off-by: Greg Kroah-Hartman --- 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(-) --- 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 posi 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 posi 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) { --- 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: */ --- a/kernel/time/posix-clock.c +++ b/kernel/time/posix-clock.c @@ -300,14 +300,17 @@ out: 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 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, 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 } 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_it { 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; From mboxrd@z Thu Jan 1 00:00:00 1970 From: Greg Kroah-Hartman Subject: [PATCH 4.4 11/97] time: Change posix clocks ops interfaces to use timespec64 Date: Fri, 23 Mar 2018 10:53:58 +0100 Message-ID: <20180323094158.122202599@linuxfoundation.org> References: <20180323094157.535925724@linuxfoundation.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Cc: arnd@arndb.de, y2038@lists.linaro.org, Greg Kroah-Hartman , Richard Cochran , stable@vger.kernel.org, Sasha Levin , john.stultz@linaro.org, Deepa Dinamani , netdev@vger.kernel.org, Thomas Gleixner To: linux-kernel@vger.kernel.org Return-path: In-Reply-To: <20180323094157.535925724@linuxfoundation.org> 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 NC40LXN0YWJsZSByZXZpZXcgcGF0Y2guICBJZiBhbnlvbmUgaGFzIGFueSBvYmplY3Rpb25zLCBw bGVhc2UgbGV0IG1lIGtub3cuCgotLS0tLS0tLS0tLS0tLS0tLS0KCkZyb206IERlZXBhIERpbmFt YW5pIDxkZWVwYS5rZXJuZWxAZ21haWwuY29tPgoKClsgVXBzdHJlYW0gY29tbWl0IGQzNDAyNjZl MTlkZGI3MGRiZDYwOGY5ZGVlZGNmYjM1ZmRiOWQ0MTkgXQoKc3RydWN0IHRpbWVzcGVjIGlzIG5v dCB5MjAzOCBzYWZlIG9uIDMyIGJpdCBtYWNoaW5lcy4KClRoZSBwb3NpeCBjbG9ja3MgYXBpcyB1 c2Ugc3RydWN0IHRpbWVzcGVjIGRpcmVjdGx5IGFuZCB0aHJvdWdoIHN0cnVjdAppdGltZXJzcGVj LgoKUmVwbGFjZSB0aGUgcG9zaXggY2xvY2sgaW50ZXJmYWNlcyB0byB1c2Ugc3RydWN0IHRpbWVz cGVjNjQgYW5kIHN0cnVjdAppdGltZXJzcGVjNjQgaW5zdGVhZC4gIEFsc28gZml4IHVwIHRoZWly IGltcGxlbWVudGF0aW9ucyBhY2NvcmRpbmdseS4KCk5vdGUgdGhhdCB0aGUgY2xvY2tfZ2V0cmVz KCkgaW50ZXJmYWNlIGhhcyBhbHNvIGJlZW4gY2hhbmdlZCB0byB1c2UKdGltZXNwZWM2NCBldmVu IHRob3VnaCB0aGlzIHBhcnRpY3VsYXIgaW50ZXJmYWNlIGlzIG5vdCBhZmZlY3RlZCBieSB0aGUK eTIwMzggcHJvYmxlbS4gVGhpcyBoZWxwcyB2ZXJpZmljYXRpb24gZm9yIGludGVybmFsIGtlcm5l bCBjb2RlIGZvciB5MjAzOApyZWFkaW5lc3MgYnkgZ2V0dGluZyByaWQgb2YgdGltZV90LyB0aW1l dmFsLyB0aW1lc3BlYy4KClNpZ25lZC1vZmYtYnk6IERlZXBhIERpbmFtYW5pIDxkZWVwYS5rZXJu ZWxAZ21haWwuY29tPgpDYzogYXJuZEBhcm5kYi5kZQpDYzogeTIwMzhAbGlzdHMubGluYXJvLm9y ZwpDYzogbmV0ZGV2QHZnZXIua2VybmVsLm9yZwpDYzogUmljaGFyZCBDb2NocmFuIDxyaWNoYXJk Y29jaHJhbkBnbWFpbC5jb20+CkNjOiBqb2huLnN0dWx0ekBsaW5hcm8ub3JnCkxpbms6IGh0dHA6 Ly9sa21sLmtlcm5lbC5vcmcvci8xNDkwNTU1MDU4LTQ2MDMtMy1naXQtc2VuZC1lbWFpbC1kZWVw YS5rZXJuZWxAZ21haWwuY29tClNpZ25lZC1vZmYtYnk6IFRob21hcyBHbGVpeG5lciA8dGdseEBs aW51dHJvbml4LmRlPgpTaWduZWQtb2ZmLWJ5OiBTYXNoYSBMZXZpbiA8YWxleGFuZGVyLmxldmlu QG1pY3Jvc29mdC5jb20+ClNpZ25lZC1vZmYtYnk6IEdyZWcgS3JvYWgtSGFydG1hbiA8Z3JlZ2to QGxpbnV4Zm91bmRhdGlvbi5vcmc+Ci0tLQogZHJpdmVycy9wdHAvcHRwX2Nsb2NrLmMgICAgIHwg ICAxOCArKysrKysrLS0tLS0tLS0tLS0KIGluY2x1ZGUvbGludXgvcG9zaXgtY2xvY2suaCB8ICAg MTAgKysrKystLS0tLQoga2VybmVsL3RpbWUvcG9zaXgtY2xvY2suYyAgIHwgICAzNCArKysrKysr KysrKysrKysrKysrKysrKystLS0tLS0tLS0tCiAzIGZpbGVzIGNoYW5nZWQsIDM2IGluc2VydGlv bnMoKyksIDI2IGRlbGV0aW9ucygtKQoKLS0tIGEvZHJpdmVycy9wdHAvcHRwX2Nsb2NrLmMKKysr IGIvZHJpdmVycy9wdHAvcHRwX2Nsb2NrLmMKQEAgLTk3LDMwICs5NywyNiBAQCBzdGF0aWMgczMy IHNjYWxlZF9wcG1fdG9fcHBiKGxvbmcgcHBtKQogCiAvKiBwb3NpeCBjbG9jayBpbXBsZW1lbnRh dGlvbiAqLwogCi1zdGF0aWMgaW50IHB0cF9jbG9ja19nZXRyZXMoc3RydWN0IHBvc2l4X2Nsb2Nr ICpwYywgc3RydWN0IHRpbWVzcGVjICp0cCkKK3N0YXRpYyBpbnQgcHRwX2Nsb2NrX2dldHJlcyhz dHJ1Y3QgcG9zaXhfY2xvY2sgKnBjLCBzdHJ1Y3QgdGltZXNwZWM2NCAqdHApCiB7CiAJdHAtPnR2 X3NlYyA9IDA7CiAJdHAtPnR2X25zZWMgPSAxOwogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50 IHB0cF9jbG9ja19zZXR0aW1lKHN0cnVjdCBwb3NpeF9jbG9jayAqcGMsIGNvbnN0IHN0cnVjdCB0 aW1lc3BlYyAqdHApCitzdGF0aWMgaW50IHB0cF9jbG9ja19zZXR0aW1lKHN0cnVjdCBwb3NpeF9j bG9jayAqcGMsIGNvbnN0IHN0cnVjdCB0aW1lc3BlYzY0ICp0cCkKIHsKIAlzdHJ1Y3QgcHRwX2Ns b2NrICpwdHAgPSBjb250YWluZXJfb2YocGMsIHN0cnVjdCBwdHBfY2xvY2ssIGNsb2NrKTsKLQlz dHJ1Y3QgdGltZXNwZWM2NCB0cyA9IHRpbWVzcGVjX3RvX3RpbWVzcGVjNjQoKnRwKTsKIAotCXJl dHVybiAgcHRwLT5pbmZvLT5zZXR0aW1lNjQocHRwLT5pbmZvLCAmdHMpOworCXJldHVybiAgcHRw LT5pbmZvLT5zZXR0aW1lNjQocHRwLT5pbmZvLCB0cCk7CiB9CiAKLXN0YXRpYyBpbnQgcHRwX2Ns b2NrX2dldHRpbWUoc3RydWN0IHBvc2l4X2Nsb2NrICpwYywgc3RydWN0IHRpbWVzcGVjICp0cCkK K3N0YXRpYyBpbnQgcHRwX2Nsb2NrX2dldHRpbWUoc3RydWN0IHBvc2l4X2Nsb2NrICpwYywgc3Ry dWN0IHRpbWVzcGVjNjQgKnRwKQogewogCXN0cnVjdCBwdHBfY2xvY2sgKnB0cCA9IGNvbnRhaW5l cl9vZihwYywgc3RydWN0IHB0cF9jbG9jaywgY2xvY2spOwotCXN0cnVjdCB0aW1lc3BlYzY0IHRz OwogCWludCBlcnI7CiAKLQllcnIgPSBwdHAtPmluZm8tPmdldHRpbWU2NChwdHAtPmluZm8sICZ0 cyk7Ci0JaWYgKCFlcnIpCi0JCSp0cCA9IHRpbWVzcGVjNjRfdG9fdGltZXNwZWModHMpOworCWVy ciA9IHB0cC0+aW5mby0+Z2V0dGltZTY0KHB0cC0+aW5mbywgdHApOwogCXJldHVybiBlcnI7CiB9 CiAKQEAgLTEzMyw3ICsxMjksNyBAQCBzdGF0aWMgaW50IHB0cF9jbG9ja19hZGp0aW1lKHN0cnVj dCBwb3NpCiAJb3BzID0gcHRwLT5pbmZvOwogCiAJaWYgKHR4LT5tb2RlcyAmIEFESl9TRVRPRkZT RVQpIHsKLQkJc3RydWN0IHRpbWVzcGVjIHRzOworCQlzdHJ1Y3QgdGltZXNwZWM2NCB0czsKIAkJ a3RpbWVfdCBrdDsKIAkJczY0IGRlbHRhOwogCkBAIC0xNDYsNyArMTQyLDcgQEAgc3RhdGljIGlu dCBwdHBfY2xvY2tfYWRqdGltZShzdHJ1Y3QgcG9zaQogCQlpZiAoKHVuc2lnbmVkIGxvbmcpIHRz LnR2X25zZWMgPj0gTlNFQ19QRVJfU0VDKQogCQkJcmV0dXJuIC1FSU5WQUw7CiAKLQkJa3QgPSB0 aW1lc3BlY190b19rdGltZSh0cyk7CisJCWt0ID0gdGltZXNwZWM2NF90b19rdGltZSh0cyk7CiAJ CWRlbHRhID0ga3RpbWVfdG9fbnMoa3QpOwogCQllcnIgPSBvcHMtPmFkanRpbWUob3BzLCBkZWx0 YSk7CiAJfSBlbHNlIGlmICh0eC0+bW9kZXMgJiBBREpfRlJFUVVFTkNZKSB7Ci0tLSBhL2luY2x1 ZGUvbGludXgvcG9zaXgtY2xvY2suaAorKysgYi9pbmNsdWRlL2xpbnV4L3Bvc2l4LWNsb2NrLmgK QEAgLTU5LDIzICs1OSwyMyBAQCBzdHJ1Y3QgcG9zaXhfY2xvY2tfb3BlcmF0aW9ucyB7CiAKIAlp bnQgICgqY2xvY2tfYWRqdGltZSkoc3RydWN0IHBvc2l4X2Nsb2NrICpwYywgc3RydWN0IHRpbWV4 ICp0eCk7CiAKLQlpbnQgICgqY2xvY2tfZ2V0dGltZSkoc3RydWN0IHBvc2l4X2Nsb2NrICpwYywg c3RydWN0IHRpbWVzcGVjICp0cyk7CisJaW50ICAoKmNsb2NrX2dldHRpbWUpKHN0cnVjdCBwb3Np eF9jbG9jayAqcGMsIHN0cnVjdCB0aW1lc3BlYzY0ICp0cyk7CiAKLQlpbnQgICgqY2xvY2tfZ2V0 cmVzKSAoc3RydWN0IHBvc2l4X2Nsb2NrICpwYywgc3RydWN0IHRpbWVzcGVjICp0cyk7CisJaW50 ICAoKmNsb2NrX2dldHJlcykgKHN0cnVjdCBwb3NpeF9jbG9jayAqcGMsIHN0cnVjdCB0aW1lc3Bl YzY0ICp0cyk7CiAKIAlpbnQgICgqY2xvY2tfc2V0dGltZSkoc3RydWN0IHBvc2l4X2Nsb2NrICpw YywKLQkJCSAgICAgIGNvbnN0IHN0cnVjdCB0aW1lc3BlYyAqdHMpOworCQkJICAgICAgY29uc3Qg c3RydWN0IHRpbWVzcGVjNjQgKnRzKTsKIAogCWludCAgKCp0aW1lcl9jcmVhdGUpIChzdHJ1Y3Qg cG9zaXhfY2xvY2sgKnBjLCBzdHJ1Y3Qga19pdGltZXIgKmtpdCk7CiAKIAlpbnQgICgqdGltZXJf ZGVsZXRlKSAoc3RydWN0IHBvc2l4X2Nsb2NrICpwYywgc3RydWN0IGtfaXRpbWVyICpraXQpOwog CiAJdm9pZCAoKnRpbWVyX2dldHRpbWUpKHN0cnVjdCBwb3NpeF9jbG9jayAqcGMsCi0JCQkgICAg ICBzdHJ1Y3Qga19pdGltZXIgKmtpdCwgc3RydWN0IGl0aW1lcnNwZWMgKnRzcCk7CisJCQkgICAg ICBzdHJ1Y3Qga19pdGltZXIgKmtpdCwgc3RydWN0IGl0aW1lcnNwZWM2NCAqdHNwKTsKIAogCWlu dCAgKCp0aW1lcl9zZXR0aW1lKShzdHJ1Y3QgcG9zaXhfY2xvY2sgKnBjLAogCQkJICAgICAgc3Ry dWN0IGtfaXRpbWVyICpraXQsIGludCBmbGFncywKLQkJCSAgICAgIHN0cnVjdCBpdGltZXJzcGVj ICp0c3AsIHN0cnVjdCBpdGltZXJzcGVjICpvbGQpOworCQkJICAgICAgc3RydWN0IGl0aW1lcnNw ZWM2NCAqdHNwLCBzdHJ1Y3QgaXRpbWVyc3BlYzY0ICpvbGQpOwogCS8qCiAJICogT3B0aW9uYWwg Y2hhcmFjdGVyIGRldmljZSBtZXRob2RzOgogCSAqLwotLS0gYS9rZXJuZWwvdGltZS9wb3NpeC1j bG9jay5jCisrKyBiL2tlcm5lbC90aW1lL3Bvc2l4LWNsb2NrLmMKQEAgLTMwMCwxNCArMzAwLDE3 IEBAIG91dDoKIHN0YXRpYyBpbnQgcGNfY2xvY2tfZ2V0dGltZShjbG9ja2lkX3QgaWQsIHN0cnVj dCB0aW1lc3BlYyAqdHMpCiB7CiAJc3RydWN0IHBvc2l4X2Nsb2NrX2Rlc2MgY2Q7CisJc3RydWN0 IHRpbWVzcGVjNjQgdHM2NDsKIAlpbnQgZXJyOwogCiAJZXJyID0gZ2V0X2Nsb2NrX2Rlc2MoaWQs ICZjZCk7CiAJaWYgKGVycikKIAkJcmV0dXJuIGVycjsKIAotCWlmIChjZC5jbGstPm9wcy5jbG9j a19nZXR0aW1lKQotCQllcnIgPSBjZC5jbGstPm9wcy5jbG9ja19nZXR0aW1lKGNkLmNsaywgdHMp OworCWlmIChjZC5jbGstPm9wcy5jbG9ja19nZXR0aW1lKSB7CisJCWVyciA9IGNkLmNsay0+b3Bz LmNsb2NrX2dldHRpbWUoY2QuY2xrLCAmdHM2NCk7CisJCSp0cyA9IHRpbWVzcGVjNjRfdG9fdGlt ZXNwZWModHM2NCk7CisJfQogCWVsc2UKIAkJZXJyID0gLUVPUE5PVFNVUFA7CiAKQEAgLTMxOSwx NCArMzIyLDE3IEBAIHN0YXRpYyBpbnQgcGNfY2xvY2tfZ2V0dGltZShjbG9ja2lkX3QgaWQKIHN0 YXRpYyBpbnQgcGNfY2xvY2tfZ2V0cmVzKGNsb2NraWRfdCBpZCwgc3RydWN0IHRpbWVzcGVjICp0 cykKIHsKIAlzdHJ1Y3QgcG9zaXhfY2xvY2tfZGVzYyBjZDsKKwlzdHJ1Y3QgdGltZXNwZWM2NCB0 czY0OwogCWludCBlcnI7CiAKIAllcnIgPSBnZXRfY2xvY2tfZGVzYyhpZCwgJmNkKTsKIAlpZiAo ZXJyKQogCQlyZXR1cm4gZXJyOwogCi0JaWYgKGNkLmNsay0+b3BzLmNsb2NrX2dldHJlcykKLQkJ ZXJyID0gY2QuY2xrLT5vcHMuY2xvY2tfZ2V0cmVzKGNkLmNsaywgdHMpOworCWlmIChjZC5jbGst Pm9wcy5jbG9ja19nZXRyZXMpIHsKKwkJZXJyID0gY2QuY2xrLT5vcHMuY2xvY2tfZ2V0cmVzKGNk LmNsaywgJnRzNjQpOworCQkqdHMgPSB0aW1lc3BlYzY0X3RvX3RpbWVzcGVjKHRzNjQpOworCX0K IAllbHNlCiAJCWVyciA9IC1FT1BOT1RTVVBQOwogCkBAIC0zMzcsNiArMzQzLDcgQEAgc3RhdGlj IGludCBwY19jbG9ja19nZXRyZXMoY2xvY2tpZF90IGlkLAogCiBzdGF0aWMgaW50IHBjX2Nsb2Nr X3NldHRpbWUoY2xvY2tpZF90IGlkLCBjb25zdCBzdHJ1Y3QgdGltZXNwZWMgKnRzKQogeworCXN0 cnVjdCB0aW1lc3BlYzY0IHRzNjQgPSB0aW1lc3BlY190b190aW1lc3BlYzY0KCp0cyk7CiAJc3Ry dWN0IHBvc2l4X2Nsb2NrX2Rlc2MgY2Q7CiAJaW50IGVycjsKIApAQCAtMzUwLDcgKzM1Nyw3IEBA IHN0YXRpYyBpbnQgcGNfY2xvY2tfc2V0dGltZShjbG9ja2lkX3QgaWQKIAl9CiAKIAlpZiAoY2Qu Y2xrLT5vcHMuY2xvY2tfc2V0dGltZSkKLQkJZXJyID0gY2QuY2xrLT5vcHMuY2xvY2tfc2V0dGlt ZShjZC5jbGssIHRzKTsKKwkJZXJyID0gY2QuY2xrLT5vcHMuY2xvY2tfc2V0dGltZShjZC5jbGss ICZ0czY0KTsKIAllbHNlCiAJCWVyciA9IC1FT1BOT1RTVVBQOwogb3V0OgpAQCAtNDAzLDI5ICs0 MTAsMzYgQEAgc3RhdGljIHZvaWQgcGNfdGltZXJfZ2V0dGltZShzdHJ1Y3Qga19pdAogewogCWNs b2NraWRfdCBpZCA9IGtpdC0+aXRfY2xvY2s7CiAJc3RydWN0IHBvc2l4X2Nsb2NrX2Rlc2MgY2Q7 CisJc3RydWN0IGl0aW1lcnNwZWM2NCB0czY0OwogCiAJaWYgKGdldF9jbG9ja19kZXNjKGlkLCAm Y2QpKQogCQlyZXR1cm47CiAKLQlpZiAoY2QuY2xrLT5vcHMudGltZXJfZ2V0dGltZSkKLQkJY2Qu Y2xrLT5vcHMudGltZXJfZ2V0dGltZShjZC5jbGssIGtpdCwgdHMpOwotCisJaWYgKGNkLmNsay0+ b3BzLnRpbWVyX2dldHRpbWUpIHsKKwkJY2QuY2xrLT5vcHMudGltZXJfZ2V0dGltZShjZC5jbGss IGtpdCwgJnRzNjQpOworCQkqdHMgPSBpdGltZXJzcGVjNjRfdG9faXRpbWVyc3BlYygmdHM2NCk7 CisJfQogCXB1dF9jbG9ja19kZXNjKCZjZCk7CiB9CiAKIHN0YXRpYyBpbnQgcGNfdGltZXJfc2V0 dGltZShzdHJ1Y3Qga19pdGltZXIgKmtpdCwgaW50IGZsYWdzLAogCQkJICAgIHN0cnVjdCBpdGlt ZXJzcGVjICp0cywgc3RydWN0IGl0aW1lcnNwZWMgKm9sZCkKIHsKKwlzdHJ1Y3QgaXRpbWVyc3Bl YzY0IHRzNjQgPSBpdGltZXJzcGVjX3RvX2l0aW1lcnNwZWM2NCh0cyk7CiAJY2xvY2tpZF90IGlk ID0ga2l0LT5pdF9jbG9jazsKIAlzdHJ1Y3QgcG9zaXhfY2xvY2tfZGVzYyBjZDsKKwlzdHJ1Y3Qg aXRpbWVyc3BlYzY0IG9sZDY0OwogCWludCBlcnI7CiAKIAllcnIgPSBnZXRfY2xvY2tfZGVzYyhp ZCwgJmNkKTsKIAlpZiAoZXJyKQogCQlyZXR1cm4gZXJyOwogCi0JaWYgKGNkLmNsay0+b3BzLnRp bWVyX3NldHRpbWUpCi0JCWVyciA9IGNkLmNsay0+b3BzLnRpbWVyX3NldHRpbWUoY2QuY2xrLCBr aXQsIGZsYWdzLCB0cywgb2xkKTsKKwlpZiAoY2QuY2xrLT5vcHMudGltZXJfc2V0dGltZSkgewor CQllcnIgPSBjZC5jbGstPm9wcy50aW1lcl9zZXR0aW1lKGNkLmNsaywga2l0LCBmbGFncywgJnRz NjQsICZvbGQ2NCk7CisJCWlmIChvbGQpCisJCQkqb2xkID0gaXRpbWVyc3BlYzY0X3RvX2l0aW1l cnNwZWMoJm9sZDY0KTsKKwl9CiAJZWxzZQogCQllcnIgPSAtRU9QTk9UU1VQUDsKIAoKCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClkyMDM4IG1haWxpbmcg bGlzdApZMjAzOEBsaXN0cy5saW5hcm8ub3JnCmh0dHBzOi8vbGlzdHMubGluYXJvLm9yZy9tYWls bWFuL2xpc3RpbmZvL3kyMDM4Cg==