From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752020AbdJKPV2 (ORCPT ); Wed, 11 Oct 2017 11:21:28 -0400 Received: from mout.kundenserver.de ([212.227.126.135]:59280 "EHLO mout.kundenserver.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751459AbdJKPV0 (ORCPT ); Wed, 11 Oct 2017 11:21:26 -0400 From: Arnd Bergmann To: Daniel Vetter , Daniel Vetter , Jani Nikula , Sean Paul , David Airlie Cc: Arnd Bergmann , =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Chris Wilson , Alex Deucher , Thierry Reding , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [PATCH 1/2] drm: vblank: use ktime_t instead of timeval Date: Wed, 11 Oct 2017 17:20:12 +0200 Message-Id: <20171011152059.2394516-1-arnd@arndb.de> X-Mailer: git-send-email 2.9.0 X-Provags-ID: V03:K0:SwuMn8aOZd3i87BZeHwlObDWhw7Z61RUiQ4LpVappN42PpYYx55 JqXH+Hmdz1Ox9gJqNtoQqtoMpwawkDlkF3u8CkeG96xUhnbnnvZn+zznCnuf3q0Mo4ca/Ht AofSM9FALn+z9+LTytC5ZnjkWtJlWh3vuAjRigBaxAhRuDFJ0PszBp/7qSZOD1A77tBrHPf K76U9vx0MlFJOg5o6AKNA== X-UI-Out-Filterresults: notjunk:1;V01:K0:H0foQYNL+a4=:GnApkOPivajR5UR8bpIJcs kW/w7VF4C6kIY/hY8sIUiDFIFkmSbgoM4M3oPUJTaBMmyjKe8gk3GvIQ//EWSojuBQ7NlcC3Z 9bTzxGC8C8IKsvtiGHCjeQxdxegnb7eFSLG2zdkOxfrOnWJSJXTIn7bbD37eEQENll257vcbt EsitNeaRITsAbOr0fM5ZhpCVl2JYNNarBDBWrS9ASuT8DLlQ9oXlyWgwes6R2IOD1dGsA2dHz 820DuU/caLsXmJ60L5t787l4+BA2RqaBkDcx0gYVp7Fj6pDJMK4OLNWsYWZ09gFkMkPnUPJqQ O5s9czPRiMUs9/6eNn60xIEX38CuPVAFRPS3VGNtEwPWIO/v9h2rzHnBGif30XSRDw3AIs91n 2tyVaNjYBcM1xh62EEVi4emPtVDpQ3NvLYUnpN07E96CUuTO+vRCJ6haMI/5rMJ6LRQqSimjo PPMQTyog2EMntYaRewXzEXjIfwibc4bXssJAQj7rA2INXLvEKpr8SuaVvvsGJFA4ehcg4AAgl 7877DCdYTSmdKSsb6OvE7xUtWV1bYkvhxmmekMKYkkT623eOJTTHx2NIIiSh7lR28dxPh6uvR o8oOkYHkw4QdiuH9n/y+2/p9MGWNC/Jei2CtlxdgvHYvNpqfU5BD717FF2EkJTjSHIFWpo68x q0e55kMQuYAOmVY79eBgPaoCY1TM7wCQzQXg2yZCIXTBqsubfLROe/TyzcTegueIkWPquOQLv CEaQ6T/irOiQyI0Y6OEPByCI0bxbGwmhPGUOZg== Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The drm vblank handling uses 'timeval' to store timestamps in either monotonic or wall-clock time base. In either case, it reads the current time as a ktime_t in get_drm_timestamp() and converts it from there. This is a bit suspicious, as users of 'timeval' often suffer from the time_t overflow in y2038. I have gone through this code and found that it is unlikely to cause problems here: - The user space ABI does not use time_t or timeval, but uses 'u32' and 'long' as the types. This means at least that rebuilding user programs against a new libc with 64-bit time_t does not change the ABI. - As of commit c61eef726a78 ("drm: add support for monotonic vblank timestamps") in linux-3.8, the monotonic timestamp is the default and can only get reverted to wall-clock through a module-parameter. - With the default monotonic timestamps, there is no problem at all. - The drm_wait_vblank_ioctl() interface is alway safe on 64-bit architectures, on 32-bit it might overflow the 'long' timestamps in 2038 with wall-clock timestamps. - The event handling uses 'u32' seconds, which overflow in 2106 on both 32-bit and 64-bit machines, when wall-clock timestamps are used. - The effect of overflowing either of the two is only temporary (during the overflow, and is likely to keep working again afterwards. It is likely the same problem as observing a 'settimeofday()' call, which was the reason for moving to the monotonic timestamps in the first place. Overall, this seems good enough, so my patch removes the use of 'timeval' from the vblank handling altogether and uses ktime_t consistently, except for the part where we copy the data to user space structures in the existing format. Signed-off-by: Arnd Bergmann --- drivers/gpu/drm/drm_vblank.c | 123 +++++++++++++++++++++++-------------------- include/drm/drm_drv.h | 2 +- include/drm/drm_vblank.h | 6 +-- 3 files changed, 71 insertions(+), 60 deletions(-) diff --git a/drivers/gpu/drm/drm_vblank.c b/drivers/gpu/drm/drm_vblank.c index 70f2b9593edc..c605c3ad6b6e 100644 --- a/drivers/gpu/drm/drm_vblank.c +++ b/drivers/gpu/drm/drm_vblank.c @@ -78,7 +78,7 @@ static bool drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe, - struct timeval *tvblank, bool in_vblank_irq); + ktime_t *tvblank, bool in_vblank_irq); static unsigned int drm_timestamp_precision = 20; /* Default to 20 usecs. */ @@ -99,7 +99,7 @@ MODULE_PARM_DESC(timestamp_monotonic, "Use monotonic timestamps"); static void store_vblank(struct drm_device *dev, unsigned int pipe, u32 vblank_count_inc, - struct timeval *t_vblank, u32 last) + ktime_t t_vblank, u32 last) { struct drm_vblank_crtc *vblank = &dev->vblank[pipe]; @@ -108,7 +108,7 @@ static void store_vblank(struct drm_device *dev, unsigned int pipe, vblank->last = last; write_seqlock(&vblank->seqlock); - vblank->time = *t_vblank; + vblank->time = t_vblank; vblank->count += vblank_count_inc; write_sequnlock(&vblank->seqlock); } @@ -151,7 +151,7 @@ static void drm_reset_vblank_timestamp(struct drm_device *dev, unsigned int pipe { u32 cur_vblank; bool rc; - struct timeval t_vblank; + ktime_t t_vblank; int count = DRM_TIMESTAMP_MAXRETRIES; spin_lock(&dev->vblank_time_lock); @@ -171,13 +171,13 @@ static void drm_reset_vblank_timestamp(struct drm_device *dev, unsigned int pipe * interrupt and assign 0 for now, to mark the vblanktimestamp as invalid. */ if (!rc) - t_vblank = (struct timeval) {0, 0}; + t_vblank = 0; /* * +1 to make sure user will never see the same * vblank counter value before and after a modeset */ - store_vblank(dev, pipe, 1, &t_vblank, cur_vblank); + store_vblank(dev, pipe, 1, t_vblank, cur_vblank); spin_unlock(&dev->vblank_time_lock); } @@ -200,7 +200,7 @@ static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe, struct drm_vblank_crtc *vblank = &dev->vblank[pipe]; u32 cur_vblank, diff; bool rc; - struct timeval t_vblank; + ktime_t t_vblank; int count = DRM_TIMESTAMP_MAXRETRIES; int framedur_ns = vblank->framedur_ns; @@ -225,11 +225,7 @@ static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe, /* trust the hw counter when it's around */ diff = (cur_vblank - vblank->last) & dev->max_vblank_count; } else if (rc && framedur_ns) { - const struct timeval *t_old; - u64 diff_ns; - - t_old = &vblank->time; - diff_ns = timeval_to_ns(&t_vblank) - timeval_to_ns(t_old); + u64 diff_ns = ktime_to_ns(ktime_sub(t_vblank, vblank->time)); /* * Figure out how many vblanks we've missed based @@ -278,9 +274,9 @@ static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe, * for now, to mark the vblanktimestamp as invalid. */ if (!rc && !in_vblank_irq) - t_vblank = (struct timeval) {0, 0}; + t_vblank = 0; - store_vblank(dev, pipe, diff, &t_vblank, cur_vblank); + store_vblank(dev, pipe, diff, t_vblank, cur_vblank); } static u32 drm_vblank_count(struct drm_device *dev, unsigned int pipe) @@ -556,7 +552,7 @@ EXPORT_SYMBOL(drm_calc_timestamping_constants); * @pipe: index of CRTC whose vblank timestamp to retrieve * @max_error: Desired maximum allowable error in timestamps (nanosecs) * On return contains true maximum error of timestamp - * @vblank_time: Pointer to struct timeval which should receive the timestamp + * @vblank_time: Pointer to time which should receive the timestamp * @in_vblank_irq: * True when called from drm_crtc_handle_vblank(). Some drivers * need to apply some workarounds for gpu-specific vblank irq quirks @@ -584,10 +580,10 @@ EXPORT_SYMBOL(drm_calc_timestamping_constants); bool drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev, unsigned int pipe, int *max_error, - struct timeval *vblank_time, + ktime_t *vblank_time, bool in_vblank_irq) { - struct timeval tv_etime; + struct timespec64 ts_etime, ts_vblank_time; ktime_t stime, etime; bool vbl_status; struct drm_crtc *crtc; @@ -680,29 +676,27 @@ bool drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev, etime = ktime_mono_to_real(etime); /* save this only for debugging purposes */ - tv_etime = ktime_to_timeval(etime); + ts_etime = ktime_to_timespec64(etime); + ts_vblank_time = ktime_to_timespec64(*vblank_time); /* Subtract time delta from raw timestamp to get final * vblank_time timestamp for end of vblank. */ etime = ktime_sub_ns(etime, delta_ns); - *vblank_time = ktime_to_timeval(etime); + *vblank_time = etime; - DRM_DEBUG_VBL("crtc %u : v p(%d,%d)@ %ld.%ld -> %ld.%ld [e %d us, %d rep]\n", + DRM_DEBUG_VBL("crtc %u : v p(%d,%d)@ %lld.%06ld -> %lld.%06ld [e %d us, %d rep]\n", pipe, hpos, vpos, - (long)tv_etime.tv_sec, (long)tv_etime.tv_usec, - (long)vblank_time->tv_sec, (long)vblank_time->tv_usec, - duration_ns/1000, i); + (u64)ts_etime.tv_sec, ts_etime.tv_nsec / 1000, + (u64)ts_vblank_time.tv_sec, ts_vblank_time.tv_nsec / 1000, + duration_ns / 1000, i); return true; } EXPORT_SYMBOL(drm_calc_vbltimestamp_from_scanoutpos); -static struct timeval get_drm_timestamp(void) +static ktime_t get_drm_timestamp(void) { - ktime_t now; - - now = drm_timestamp_monotonic ? ktime_get() : ktime_get_real(); - return ktime_to_timeval(now); + return drm_timestamp_monotonic ? ktime_get() : ktime_get_real(); } /** @@ -710,7 +704,7 @@ static struct timeval get_drm_timestamp(void) * vblank interval * @dev: DRM device * @pipe: index of CRTC whose vblank timestamp to retrieve - * @tvblank: Pointer to target struct timeval which should receive the timestamp + * @tvblank: Pointer to target time which should receive the timestamp * @in_vblank_irq: * True when called from drm_crtc_handle_vblank(). Some drivers * need to apply some workarounds for gpu-specific vblank irq quirks @@ -728,7 +722,7 @@ static struct timeval get_drm_timestamp(void) */ static bool drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe, - struct timeval *tvblank, bool in_vblank_irq) + ktime_t *tvblank, bool in_vblank_irq) { bool ret = false; @@ -769,14 +763,14 @@ u32 drm_crtc_vblank_count(struct drm_crtc *crtc) EXPORT_SYMBOL(drm_crtc_vblank_count); static u32 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe, - struct timeval *vblanktime) + ktime_t *vblanktime) { struct drm_vblank_crtc *vblank = &dev->vblank[pipe]; u32 vblank_count; unsigned int seq; if (WARN_ON(pipe >= dev->num_crtcs)) { - *vblanktime = (struct timeval) { 0 }; + *vblanktime = 0; return 0; } @@ -793,7 +787,7 @@ static u32 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe, * drm_crtc_vblank_count_and_time - retrieve "cooked" vblank counter value * and the system timestamp corresponding to that vblank counter value * @crtc: which counter to retrieve - * @vblanktime: Pointer to struct timeval to receive the vblank timestamp. + * @vblanktime: Pointer to time to receive the vblank timestamp. * * Fetches the "cooked" vblank count value that represents the number of * vblank events since the system was booted, including lost events due to @@ -801,7 +795,7 @@ static u32 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe, * of the vblank interval that corresponds to the current vblank counter value. */ u32 drm_crtc_vblank_count_and_time(struct drm_crtc *crtc, - struct timeval *vblanktime) + ktime_t *vblanktime) { return drm_vblank_count_and_time(crtc->dev, drm_crtc_index(crtc), vblanktime); @@ -810,11 +804,18 @@ EXPORT_SYMBOL(drm_crtc_vblank_count_and_time); static void send_vblank_event(struct drm_device *dev, struct drm_pending_vblank_event *e, - unsigned long seq, struct timeval *now) + unsigned long seq, ktime_t now) { + struct timespec64 tv = ktime_to_timespec64(now); + e->event.sequence = seq; - e->event.tv_sec = now->tv_sec; - e->event.tv_usec = now->tv_usec; + /* + * e->event is a user space structure, with hardcoded unsigned + * 32-bit seconds/microseconds. This will overflow in 2106 for + * drm_timestamp_monotonic==0, but not with drm_timestamp_monotonic==1 + */ + e->event.tv_sec = tv.tv_sec; + e->event.tv_usec = tv.tv_nsec / 1000; trace_drm_vblank_event_delivered(e->base.file_priv, e->pipe, e->event.sequence); @@ -891,7 +892,7 @@ void drm_crtc_send_vblank_event(struct drm_crtc *crtc, { struct drm_device *dev = crtc->dev; unsigned int seq, pipe = drm_crtc_index(crtc); - struct timeval now; + ktime_t now; if (dev->num_crtcs > 0) { seq = drm_vblank_count_and_time(dev, pipe, &now); @@ -902,7 +903,7 @@ void drm_crtc_send_vblank_event(struct drm_crtc *crtc, } e->pipe = pipe; e->event.crtc_id = crtc->base.id; - send_vblank_event(dev, e, seq, &now); + send_vblank_event(dev, e, seq, now); } EXPORT_SYMBOL(drm_crtc_send_vblank_event); @@ -1100,7 +1101,8 @@ void drm_crtc_vblank_off(struct drm_crtc *crtc) unsigned int pipe = drm_crtc_index(crtc); struct drm_vblank_crtc *vblank = &dev->vblank[pipe]; struct drm_pending_vblank_event *e, *t; - struct timeval now; + + ktime_t now; unsigned long irqflags; unsigned int seq; @@ -1141,7 +1143,7 @@ void drm_crtc_vblank_off(struct drm_crtc *crtc) e->event.sequence, seq); list_del(&e->base.link); drm_vblank_put(dev, pipe); - send_vblank_event(dev, e, seq, &now); + send_vblank_event(dev, e, seq, now); } spin_unlock_irqrestore(&dev->event_lock, irqflags); @@ -1321,7 +1323,7 @@ static int drm_queue_vblank_event(struct drm_device *dev, unsigned int pipe, { struct drm_vblank_crtc *vblank = &dev->vblank[pipe]; struct drm_pending_vblank_event *e; - struct timeval now; + ktime_t now; unsigned long flags; unsigned int seq; int ret; @@ -1367,7 +1369,7 @@ static int drm_queue_vblank_event(struct drm_device *dev, unsigned int pipe, e->event.sequence = vblwait->request.sequence; if (vblank_passed(seq, vblwait->request.sequence)) { drm_vblank_put(dev, pipe); - send_vblank_event(dev, e, seq, &now); + send_vblank_event(dev, e, seq, now); vblwait->reply.sequence = seq; } else { /* drm_handle_vblank_events will call drm_vblank_put */ @@ -1398,6 +1400,24 @@ static bool drm_wait_vblank_is_query(union drm_wait_vblank *vblwait) _DRM_VBLANK_NEXTONMISS)); } +static void drm_wait_vblank_reply(struct drm_device *dev, unsigned int pipe, + struct drm_wait_vblank_reply *reply) +{ + ktime_t now; + struct timespec64 ts; + + /* + * drm_wait_vblank_reply is a UAPI structure that uses 'long' + * to store the seconds. This will overflow in y2038 on 32-bit + * architectures with drm_timestamp_monotonic==0, but not with + * drm_timestamp_monotonic==1 (the default). + */ + reply->sequence = drm_vblank_count_and_time(dev, pipe, &now); + ts = ktime_to_timespec64(now); + reply->tval_sec = (u32)ts.tv_sec; + reply->tval_usec = ts.tv_nsec / 1000; +} + int drm_wait_vblank_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) { @@ -1439,12 +1459,7 @@ int drm_wait_vblank_ioctl(struct drm_device *dev, void *data, if (dev->vblank_disable_immediate && drm_wait_vblank_is_query(vblwait) && READ_ONCE(vblank->enabled)) { - struct timeval now; - - vblwait->reply.sequence = - drm_vblank_count_and_time(dev, pipe, &now); - vblwait->reply.tval_sec = now.tv_sec; - vblwait->reply.tval_usec = now.tv_usec; + drm_wait_vblank_reply(dev, pipe, &vblwait->reply); return 0; } @@ -1487,11 +1502,7 @@ int drm_wait_vblank_ioctl(struct drm_device *dev, void *data, } if (ret != -EINTR) { - struct timeval now; - - vblwait->reply.sequence = drm_vblank_count_and_time(dev, pipe, &now); - vblwait->reply.tval_sec = now.tv_sec; - vblwait->reply.tval_usec = now.tv_usec; + drm_wait_vblank_reply(dev, pipe, &vblwait->reply); DRM_DEBUG("crtc %d returning %u to client\n", pipe, vblwait->reply.sequence); @@ -1507,7 +1518,7 @@ int drm_wait_vblank_ioctl(struct drm_device *dev, void *data, static void drm_handle_vblank_events(struct drm_device *dev, unsigned int pipe) { struct drm_pending_vblank_event *e, *t; - struct timeval now; + ktime_t now; unsigned int seq; assert_spin_locked(&dev->event_lock); @@ -1525,7 +1536,7 @@ static void drm_handle_vblank_events(struct drm_device *dev, unsigned int pipe) list_del(&e->base.link); drm_vblank_put(dev, pipe); - send_vblank_event(dev, e, seq, &now); + send_vblank_event(dev, e, seq, now); } trace_drm_vblank_event(pipe, seq); diff --git a/include/drm/drm_drv.h b/include/drm/drm_drv.h index ee06ecd6c01f..412e83a4d3db 100644 --- a/include/drm/drm_drv.h +++ b/include/drm/drm_drv.h @@ -324,7 +324,7 @@ struct drm_driver { */ bool (*get_vblank_timestamp) (struct drm_device *dev, unsigned int pipe, int *max_error, - struct timeval *vblank_time, + ktime_t *vblank_time, bool in_vblank_irq); /** diff --git a/include/drm/drm_vblank.h b/include/drm/drm_vblank.h index 7fba9efe4951..6a58e2e91a0f 100644 --- a/include/drm/drm_vblank.h +++ b/include/drm/drm_vblank.h @@ -92,7 +92,7 @@ struct drm_vblank_crtc { /** * @time: Vblank timestamp corresponding to @count. */ - struct timeval time; + ktime_t time; /** * @refcount: Number of users/waiters of the vblank interrupt. Only when @@ -154,7 +154,7 @@ struct drm_vblank_crtc { int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs); u32 drm_crtc_vblank_count(struct drm_crtc *crtc); u32 drm_crtc_vblank_count_and_time(struct drm_crtc *crtc, - struct timeval *vblanktime); + ktime_t *vblanktime); void drm_crtc_send_vblank_event(struct drm_crtc *crtc, struct drm_pending_vblank_event *e); void drm_crtc_arm_vblank_event(struct drm_crtc *crtc, @@ -172,7 +172,7 @@ u32 drm_crtc_accurate_vblank_count(struct drm_crtc *crtc); bool drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev, unsigned int pipe, int *max_error, - struct timeval *vblank_time, + ktime_t *vblank_time, bool in_vblank_irq); void drm_calc_timestamping_constants(struct drm_crtc *crtc, const struct drm_display_mode *mode); -- 2.9.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Arnd Bergmann Subject: [PATCH 1/2] drm: vblank: use ktime_t instead of timeval Date: Wed, 11 Oct 2017 17:20:12 +0200 Message-ID: <20171011152059.2394516-1-arnd@arndb.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mout.kundenserver.de (mout.kundenserver.de [212.227.126.135]) by gabe.freedesktop.org (Postfix) with ESMTPS id 062D26E0BF for ; Wed, 11 Oct 2017 15:21:23 +0000 (UTC) List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Daniel Vetter , Daniel Vetter , Jani Nikula , Sean Paul , David Airlie Cc: Arnd Bergmann , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Alex Deucher , Thierry Reding List-Id: dri-devel@lists.freedesktop.org VGhlIGRybSB2YmxhbmsgaGFuZGxpbmcgdXNlcyAndGltZXZhbCcgdG8gc3RvcmUgdGltZXN0YW1w cyBpbiBlaXRoZXIKbW9ub3RvbmljIG9yIHdhbGwtY2xvY2sgdGltZSBiYXNlLiBJbiBlaXRoZXIg Y2FzZSwgaXQgcmVhZHMgdGhlIGN1cnJlbnQKdGltZSBhcyBhIGt0aW1lX3QgaW4gZ2V0X2RybV90 aW1lc3RhbXAoKSBhbmQgY29udmVydHMgaXQgZnJvbSB0aGVyZS4KClRoaXMgaXMgYSBiaXQgc3Vz cGljaW91cywgYXMgdXNlcnMgb2YgJ3RpbWV2YWwnIG9mdGVuIHN1ZmZlciBmcm9tCnRoZSB0aW1l X3Qgb3ZlcmZsb3cgaW4geTIwMzguIEkgaGF2ZSBnb25lIHRocm91Z2ggdGhpcyBjb2RlIGFuZApm b3VuZCB0aGF0IGl0IGlzIHVubGlrZWx5IHRvIGNhdXNlIHByb2JsZW1zIGhlcmU6CgotIFRoZSB1 c2VyIHNwYWNlIEFCSSBkb2VzIG5vdCB1c2UgdGltZV90IG9yIHRpbWV2YWwsIGJ1dCB1c2VzCiAg J3UzMicgYW5kICdsb25nJyBhcyB0aGUgdHlwZXMuIFRoaXMgbWVhbnMgYXQgbGVhc3QgdGhhdCBy ZWJ1aWxkaW5nCiAgdXNlciBwcm9ncmFtcyBhZ2FpbnN0IGEgbmV3IGxpYmMgd2l0aCA2NC1iaXQg dGltZV90IGRvZXMgbm90CiAgY2hhbmdlIHRoZSBBQkkuCgotIEFzIG9mIGNvbW1pdCBjNjFlZWY3 MjZhNzggKCJkcm06IGFkZCBzdXBwb3J0IGZvciBtb25vdG9uaWMgdmJsYW5rCiAgdGltZXN0YW1w cyIpIGluIGxpbnV4LTMuOCwgdGhlIG1vbm90b25pYyB0aW1lc3RhbXAgaXMgdGhlIGRlZmF1bHQK ICBhbmQgY2FuIG9ubHkgZ2V0IHJldmVydGVkIHRvIHdhbGwtY2xvY2sgdGhyb3VnaCBhIG1vZHVs ZS1wYXJhbWV0ZXIuCgotIFdpdGggdGhlIGRlZmF1bHQgbW9ub3RvbmljIHRpbWVzdGFtcHMsIHRo ZXJlIGlzIG5vIHByb2JsZW0gYXQgYWxsLgoKLSBUaGUgZHJtX3dhaXRfdmJsYW5rX2lvY3RsKCkg aW50ZXJmYWNlIGlzIGFsd2F5IHNhZmUgb24gNjQtYml0CiAgYXJjaGl0ZWN0dXJlcywgb24gMzIt Yml0IGl0IG1pZ2h0IG92ZXJmbG93IHRoZSAnbG9uZycgdGltZXN0YW1wcwogIGluIDIwMzggd2l0 aCB3YWxsLWNsb2NrIHRpbWVzdGFtcHMuCgotIFRoZSBldmVudCBoYW5kbGluZyB1c2VzICd1MzIn IHNlY29uZHMsIHdoaWNoIG92ZXJmbG93IGluIDIxMDYKICBvbiBib3RoIDMyLWJpdCBhbmQgNjQt Yml0IG1hY2hpbmVzLCB3aGVuIHdhbGwtY2xvY2sgdGltZXN0YW1wcwogIGFyZSB1c2VkLgoKLSBU aGUgZWZmZWN0IG9mIG92ZXJmbG93aW5nIGVpdGhlciBvZiB0aGUgdHdvIGlzIG9ubHkgdGVtcG9y YXJ5CiAgKGR1cmluZyB0aGUgb3ZlcmZsb3csIGFuZCBpcyBsaWtlbHkgdG8ga2VlcCB3b3JraW5n IGFnYWluCiAgYWZ0ZXJ3YXJkcy4gSXQgaXMgbGlrZWx5IHRoZSBzYW1lIHByb2JsZW0gYXMgb2Jz ZXJ2aW5nIGEKICAnc2V0dGltZW9mZGF5KCknIGNhbGwsIHdoaWNoIHdhcyB0aGUgcmVhc29uIGZv ciBtb3ZpbmcgdG8gdGhlCiAgbW9ub3RvbmljIHRpbWVzdGFtcHMgaW4gdGhlIGZpcnN0IHBsYWNl LgoKT3ZlcmFsbCwgdGhpcyBzZWVtcyBnb29kIGVub3VnaCwgc28gbXkgcGF0Y2ggcmVtb3ZlcyB0 aGUgdXNlIG9mCid0aW1ldmFsJyBmcm9tIHRoZSB2YmxhbmsgaGFuZGxpbmcgYWx0b2dldGhlciBh bmQgdXNlcyBrdGltZV90CmNvbnNpc3RlbnRseSwgZXhjZXB0IGZvciB0aGUgcGFydCB3aGVyZSB3 ZSBjb3B5IHRoZSBkYXRhIHRvIHVzZXIKc3BhY2Ugc3RydWN0dXJlcyBpbiB0aGUgZXhpc3Rpbmcg Zm9ybWF0LgoKU2lnbmVkLW9mZi1ieTogQXJuZCBCZXJnbWFubiA8YXJuZEBhcm5kYi5kZT4KLS0t CiBkcml2ZXJzL2dwdS9kcm0vZHJtX3ZibGFuay5jIHwgMTIzICsrKysrKysrKysrKysrKysrKysr KysrLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGluY2x1ZGUvZHJtL2RybV9kcnYuaCAgICAgICAgfCAg IDIgKy0KIGluY2x1ZGUvZHJtL2RybV92YmxhbmsuaCAgICAgfCAgIDYgKy0tCiAzIGZpbGVzIGNo YW5nZWQsIDcxIGluc2VydGlvbnMoKyksIDYwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9kcm1fdmJsYW5rLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3ZibGFuay5j CmluZGV4IDcwZjJiOTU5M2VkYy4uYzYwNWMzYWQ2YjZlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dw dS9kcm0vZHJtX3ZibGFuay5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fdmJsYW5rLmMKQEAg LTc4LDcgKzc4LDcgQEAKIAogc3RhdGljIGJvb2wKIGRybV9nZXRfbGFzdF92Ymx0aW1lc3RhbXAo c3RydWN0IGRybV9kZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IHBpcGUsCi0JCQkgIHN0cnVjdCB0 aW1ldmFsICp0dmJsYW5rLCBib29sIGluX3ZibGFua19pcnEpOworCQkJICBrdGltZV90ICp0dmJs YW5rLCBib29sIGluX3ZibGFua19pcnEpOwogCiBzdGF0aWMgdW5zaWduZWQgaW50IGRybV90aW1l c3RhbXBfcHJlY2lzaW9uID0gMjA7ICAvKiBEZWZhdWx0IHRvIDIwIHVzZWNzLiAqLwogCkBAIC05 OSw3ICs5OSw3IEBAIE1PRFVMRV9QQVJNX0RFU0ModGltZXN0YW1wX21vbm90b25pYywgIlVzZSBt b25vdG9uaWMgdGltZXN0YW1wcyIpOwogCiBzdGF0aWMgdm9pZCBzdG9yZV92Ymxhbmsoc3RydWN0 IGRybV9kZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IHBpcGUsCiAJCQkgdTMyIHZibGFua19jb3Vu dF9pbmMsCi0JCQkgc3RydWN0IHRpbWV2YWwgKnRfdmJsYW5rLCB1MzIgbGFzdCkKKwkJCSBrdGlt ZV90IHRfdmJsYW5rLCB1MzIgbGFzdCkKIHsKIAlzdHJ1Y3QgZHJtX3ZibGFua19jcnRjICp2Ymxh bmsgPSAmZGV2LT52YmxhbmtbcGlwZV07CiAKQEAgLTEwOCw3ICsxMDgsNyBAQCBzdGF0aWMgdm9p ZCBzdG9yZV92Ymxhbmsoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IHBpcGUs CiAJdmJsYW5rLT5sYXN0ID0gbGFzdDsKIAogCXdyaXRlX3NlcWxvY2soJnZibGFuay0+c2VxbG9j ayk7Ci0JdmJsYW5rLT50aW1lID0gKnRfdmJsYW5rOworCXZibGFuay0+dGltZSA9IHRfdmJsYW5r OwogCXZibGFuay0+Y291bnQgKz0gdmJsYW5rX2NvdW50X2luYzsKIAl3cml0ZV9zZXF1bmxvY2so JnZibGFuay0+c2VxbG9jayk7CiB9CkBAIC0xNTEsNyArMTUxLDcgQEAgc3RhdGljIHZvaWQgZHJt X3Jlc2V0X3ZibGFua190aW1lc3RhbXAoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdW5zaWduZWQg aW50IHBpcGUKIHsKIAl1MzIgY3VyX3ZibGFuazsKIAlib29sIHJjOwotCXN0cnVjdCB0aW1ldmFs IHRfdmJsYW5rOworCWt0aW1lX3QgdF92Ymxhbms7CiAJaW50IGNvdW50ID0gRFJNX1RJTUVTVEFN UF9NQVhSRVRSSUVTOwogCiAJc3Bpbl9sb2NrKCZkZXYtPnZibGFua190aW1lX2xvY2spOwpAQCAt MTcxLDEzICsxNzEsMTMgQEAgc3RhdGljIHZvaWQgZHJtX3Jlc2V0X3ZibGFua190aW1lc3RhbXAo c3RydWN0IGRybV9kZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IHBpcGUKIAkgKiBpbnRlcnJ1cHQg YW5kIGFzc2lnbiAwIGZvciBub3csIHRvIG1hcmsgdGhlIHZibGFua3RpbWVzdGFtcCBhcyBpbnZh bGlkLgogCSAqLwogCWlmICghcmMpCi0JCXRfdmJsYW5rID0gKHN0cnVjdCB0aW1ldmFsKSB7MCwg MH07CisJCXRfdmJsYW5rID0gMDsKIAogCS8qCiAJICogKzEgdG8gbWFrZSBzdXJlIHVzZXIgd2ls bCBuZXZlciBzZWUgdGhlIHNhbWUKIAkgKiB2YmxhbmsgY291bnRlciB2YWx1ZSBiZWZvcmUgYW5k IGFmdGVyIGEgbW9kZXNldAogCSAqLwotCXN0b3JlX3ZibGFuayhkZXYsIHBpcGUsIDEsICZ0X3Zi bGFuaywgY3VyX3ZibGFuayk7CisJc3RvcmVfdmJsYW5rKGRldiwgcGlwZSwgMSwgdF92Ymxhbmss IGN1cl92YmxhbmspOwogCiAJc3Bpbl91bmxvY2soJmRldi0+dmJsYW5rX3RpbWVfbG9jayk7CiB9 CkBAIC0yMDAsNyArMjAwLDcgQEAgc3RhdGljIHZvaWQgZHJtX3VwZGF0ZV92YmxhbmtfY291bnQo c3RydWN0IGRybV9kZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IHBpcGUsCiAJc3RydWN0IGRybV92 YmxhbmtfY3J0YyAqdmJsYW5rID0gJmRldi0+dmJsYW5rW3BpcGVdOwogCXUzMiBjdXJfdmJsYW5r LCBkaWZmOwogCWJvb2wgcmM7Ci0Jc3RydWN0IHRpbWV2YWwgdF92Ymxhbms7CisJa3RpbWVfdCB0 X3ZibGFuazsKIAlpbnQgY291bnQgPSBEUk1fVElNRVNUQU1QX01BWFJFVFJJRVM7CiAJaW50IGZy YW1lZHVyX25zID0gdmJsYW5rLT5mcmFtZWR1cl9uczsKIApAQCAtMjI1LDExICsyMjUsNyBAQCBz dGF0aWMgdm9pZCBkcm1fdXBkYXRlX3ZibGFua19jb3VudChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 LCB1bnNpZ25lZCBpbnQgcGlwZSwKIAkJLyogdHJ1c3QgdGhlIGh3IGNvdW50ZXIgd2hlbiBpdCdz IGFyb3VuZCAqLwogCQlkaWZmID0gKGN1cl92YmxhbmsgLSB2YmxhbmstPmxhc3QpICYgZGV2LT5t YXhfdmJsYW5rX2NvdW50OwogCX0gZWxzZSBpZiAocmMgJiYgZnJhbWVkdXJfbnMpIHsKLQkJY29u c3Qgc3RydWN0IHRpbWV2YWwgKnRfb2xkOwotCQl1NjQgZGlmZl9uczsKLQotCQl0X29sZCA9ICZ2 YmxhbmstPnRpbWU7Ci0JCWRpZmZfbnMgPSB0aW1ldmFsX3RvX25zKCZ0X3ZibGFuaykgLSB0aW1l dmFsX3RvX25zKHRfb2xkKTsKKwkJdTY0IGRpZmZfbnMgPSBrdGltZV90b19ucyhrdGltZV9zdWIo dF92YmxhbmssIHZibGFuay0+dGltZSkpOwogCiAJCS8qCiAJCSAqIEZpZ3VyZSBvdXQgaG93IG1h bnkgdmJsYW5rcyB3ZSd2ZSBtaXNzZWQgYmFzZWQKQEAgLTI3OCw5ICsyNzQsOSBAQCBzdGF0aWMg dm9pZCBkcm1fdXBkYXRlX3ZibGFua19jb3VudChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1bnNp Z25lZCBpbnQgcGlwZSwKIAkgKiBmb3Igbm93LCB0byBtYXJrIHRoZSB2Ymxhbmt0aW1lc3RhbXAg YXMgaW52YWxpZC4KIAkgKi8KIAlpZiAoIXJjICYmICFpbl92YmxhbmtfaXJxKQotCQl0X3ZibGFu ayA9IChzdHJ1Y3QgdGltZXZhbCkgezAsIDB9OworCQl0X3ZibGFuayA9IDA7CiAKLQlzdG9yZV92 YmxhbmsoZGV2LCBwaXBlLCBkaWZmLCAmdF92YmxhbmssIGN1cl92YmxhbmspOworCXN0b3JlX3Zi bGFuayhkZXYsIHBpcGUsIGRpZmYsIHRfdmJsYW5rLCBjdXJfdmJsYW5rKTsKIH0KIAogc3RhdGlj IHUzMiBkcm1fdmJsYW5rX2NvdW50KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHVuc2lnbmVkIGlu dCBwaXBlKQpAQCAtNTU2LDcgKzU1Miw3IEBAIEVYUE9SVF9TWU1CT0woZHJtX2NhbGNfdGltZXN0 YW1waW5nX2NvbnN0YW50cyk7CiAgKiBAcGlwZTogaW5kZXggb2YgQ1JUQyB3aG9zZSB2Ymxhbmsg dGltZXN0YW1wIHRvIHJldHJpZXZlCiAgKiBAbWF4X2Vycm9yOiBEZXNpcmVkIG1heGltdW0gYWxs b3dhYmxlIGVycm9yIGluIHRpbWVzdGFtcHMgKG5hbm9zZWNzKQogICogICAgICAgICAgICAgT24g cmV0dXJuIGNvbnRhaW5zIHRydWUgbWF4aW11bSBlcnJvciBvZiB0aW1lc3RhbXAKLSAqIEB2Ymxh bmtfdGltZTogUG9pbnRlciB0byBzdHJ1Y3QgdGltZXZhbCB3aGljaCBzaG91bGQgcmVjZWl2ZSB0 aGUgdGltZXN0YW1wCisgKiBAdmJsYW5rX3RpbWU6IFBvaW50ZXIgdG8gdGltZSB3aGljaCBzaG91 bGQgcmVjZWl2ZSB0aGUgdGltZXN0YW1wCiAgKiBAaW5fdmJsYW5rX2lycToKICAqICAgICBUcnVl IHdoZW4gY2FsbGVkIGZyb20gZHJtX2NydGNfaGFuZGxlX3ZibGFuaygpLiAgU29tZSBkcml2ZXJz CiAgKiAgICAgbmVlZCB0byBhcHBseSBzb21lIHdvcmthcm91bmRzIGZvciBncHUtc3BlY2lmaWMg dmJsYW5rIGlycSBxdWlya3MKQEAgLTU4NCwxMCArNTgwLDEwIEBAIEVYUE9SVF9TWU1CT0woZHJt X2NhbGNfdGltZXN0YW1waW5nX2NvbnN0YW50cyk7CiBib29sIGRybV9jYWxjX3ZibHRpbWVzdGFt cF9mcm9tX3NjYW5vdXRwb3Moc3RydWN0IGRybV9kZXZpY2UgKmRldiwKIAkJCQkJICAgdW5zaWdu ZWQgaW50IHBpcGUsCiAJCQkJCSAgIGludCAqbWF4X2Vycm9yLAotCQkJCQkgICBzdHJ1Y3QgdGlt ZXZhbCAqdmJsYW5rX3RpbWUsCisJCQkJCSAgIGt0aW1lX3QgKnZibGFua190aW1lLAogCQkJCQkg ICBib29sIGluX3ZibGFua19pcnEpCiB7Ci0Jc3RydWN0IHRpbWV2YWwgdHZfZXRpbWU7CisJc3Ry dWN0IHRpbWVzcGVjNjQgdHNfZXRpbWUsIHRzX3ZibGFua190aW1lOwogCWt0aW1lX3Qgc3RpbWUs IGV0aW1lOwogCWJvb2wgdmJsX3N0YXR1czsKIAlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7CkBAIC02 ODAsMjkgKzY3NiwyNyBAQCBib29sIGRybV9jYWxjX3ZibHRpbWVzdGFtcF9mcm9tX3NjYW5vdXRw b3Moc3RydWN0IGRybV9kZXZpY2UgKmRldiwKIAkJZXRpbWUgPSBrdGltZV9tb25vX3RvX3JlYWwo ZXRpbWUpOwogCiAJLyogc2F2ZSB0aGlzIG9ubHkgZm9yIGRlYnVnZ2luZyBwdXJwb3NlcyAqLwot CXR2X2V0aW1lID0ga3RpbWVfdG9fdGltZXZhbChldGltZSk7CisJdHNfZXRpbWUgPSBrdGltZV90 b190aW1lc3BlYzY0KGV0aW1lKTsKKwl0c192YmxhbmtfdGltZSA9IGt0aW1lX3RvX3RpbWVzcGVj NjQoKnZibGFua190aW1lKTsKIAkvKiBTdWJ0cmFjdCB0aW1lIGRlbHRhIGZyb20gcmF3IHRpbWVz dGFtcCB0byBnZXQgZmluYWwKIAkgKiB2YmxhbmtfdGltZSB0aW1lc3RhbXAgZm9yIGVuZCBvZiB2 YmxhbmsuCiAJICovCiAJZXRpbWUgPSBrdGltZV9zdWJfbnMoZXRpbWUsIGRlbHRhX25zKTsKLQkq dmJsYW5rX3RpbWUgPSBrdGltZV90b190aW1ldmFsKGV0aW1lKTsKKwkqdmJsYW5rX3RpbWUgPSBl dGltZTsKIAotCURSTV9ERUJVR19WQkwoImNydGMgJXUgOiB2IHAoJWQsJWQpQCAlbGQuJWxkIC0+ ICVsZC4lbGQgW2UgJWQgdXMsICVkIHJlcF1cbiIsCisJRFJNX0RFQlVHX1ZCTCgiY3J0YyAldSA6 IHYgcCglZCwlZClAICVsbGQuJTA2bGQgLT4gJWxsZC4lMDZsZCBbZSAlZCB1cywgJWQgcmVwXVxu IiwKIAkJICAgICAgcGlwZSwgaHBvcywgdnBvcywKLQkJICAgICAgKGxvbmcpdHZfZXRpbWUudHZf c2VjLCAobG9uZyl0dl9ldGltZS50dl91c2VjLAotCQkgICAgICAobG9uZyl2YmxhbmtfdGltZS0+ dHZfc2VjLCAobG9uZyl2YmxhbmtfdGltZS0+dHZfdXNlYywKLQkJICAgICAgZHVyYXRpb25fbnMv MTAwMCwgaSk7CisJCSAgICAgICh1NjQpdHNfZXRpbWUudHZfc2VjLCB0c19ldGltZS50dl9uc2Vj IC8gMTAwMCwKKwkJICAgICAgKHU2NCl0c192YmxhbmtfdGltZS50dl9zZWMsIHRzX3ZibGFua190 aW1lLnR2X25zZWMgLyAxMDAwLAorCQkgICAgICBkdXJhdGlvbl9ucyAvIDEwMDAsIGkpOwogCiAJ cmV0dXJuIHRydWU7CiB9CiBFWFBPUlRfU1lNQk9MKGRybV9jYWxjX3ZibHRpbWVzdGFtcF9mcm9t X3NjYW5vdXRwb3MpOwogCi1zdGF0aWMgc3RydWN0IHRpbWV2YWwgZ2V0X2RybV90aW1lc3RhbXAo dm9pZCkKK3N0YXRpYyBrdGltZV90IGdldF9kcm1fdGltZXN0YW1wKHZvaWQpCiB7Ci0Ja3RpbWVf dCBub3c7Ci0KLQlub3cgPSBkcm1fdGltZXN0YW1wX21vbm90b25pYyA/IGt0aW1lX2dldCgpIDog a3RpbWVfZ2V0X3JlYWwoKTsKLQlyZXR1cm4ga3RpbWVfdG9fdGltZXZhbChub3cpOworCXJldHVy biBkcm1fdGltZXN0YW1wX21vbm90b25pYyA/IGt0aW1lX2dldCgpIDoga3RpbWVfZ2V0X3JlYWwo KTsKIH0KIAogLyoqCkBAIC03MTAsNyArNzA0LDcgQEAgc3RhdGljIHN0cnVjdCB0aW1ldmFsIGdl dF9kcm1fdGltZXN0YW1wKHZvaWQpCiAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdmJs YW5rIGludGVydmFsCiAgKiBAZGV2OiBEUk0gZGV2aWNlCiAgKiBAcGlwZTogaW5kZXggb2YgQ1JU QyB3aG9zZSB2YmxhbmsgdGltZXN0YW1wIHRvIHJldHJpZXZlCi0gKiBAdHZibGFuazogUG9pbnRl ciB0byB0YXJnZXQgc3RydWN0IHRpbWV2YWwgd2hpY2ggc2hvdWxkIHJlY2VpdmUgdGhlIHRpbWVz dGFtcAorICogQHR2Ymxhbms6IFBvaW50ZXIgdG8gdGFyZ2V0IHRpbWUgd2hpY2ggc2hvdWxkIHJl Y2VpdmUgdGhlIHRpbWVzdGFtcAogICogQGluX3ZibGFua19pcnE6CiAgKiAgICAgVHJ1ZSB3aGVu IGNhbGxlZCBmcm9tIGRybV9jcnRjX2hhbmRsZV92YmxhbmsoKS4gIFNvbWUgZHJpdmVycwogICog ICAgIG5lZWQgdG8gYXBwbHkgc29tZSB3b3JrYXJvdW5kcyBmb3IgZ3B1LXNwZWNpZmljIHZibGFu ayBpcnEgcXVpcmtzCkBAIC03MjgsNyArNzIyLDcgQEAgc3RhdGljIHN0cnVjdCB0aW1ldmFsIGdl dF9kcm1fdGltZXN0YW1wKHZvaWQpCiAgKi8KIHN0YXRpYyBib29sCiBkcm1fZ2V0X2xhc3RfdmJs dGltZXN0YW1wKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHVuc2lnbmVkIGludCBwaXBlLAotCQkJ ICBzdHJ1Y3QgdGltZXZhbCAqdHZibGFuaywgYm9vbCBpbl92YmxhbmtfaXJxKQorCQkJICBrdGlt ZV90ICp0dmJsYW5rLCBib29sIGluX3ZibGFua19pcnEpCiB7CiAJYm9vbCByZXQgPSBmYWxzZTsK IApAQCAtNzY5LDE0ICs3NjMsMTQgQEAgdTMyIGRybV9jcnRjX3ZibGFua19jb3VudChzdHJ1Y3Qg ZHJtX2NydGMgKmNydGMpCiBFWFBPUlRfU1lNQk9MKGRybV9jcnRjX3ZibGFua19jb3VudCk7CiAK IHN0YXRpYyB1MzIgZHJtX3ZibGFua19jb3VudF9hbmRfdGltZShzdHJ1Y3QgZHJtX2RldmljZSAq ZGV2LCB1bnNpZ25lZCBpbnQgcGlwZSwKLQkJCQkgICAgIHN0cnVjdCB0aW1ldmFsICp2Ymxhbmt0 aW1lKQorCQkJCSAgICAga3RpbWVfdCAqdmJsYW5rdGltZSkKIHsKIAlzdHJ1Y3QgZHJtX3ZibGFu a19jcnRjICp2YmxhbmsgPSAmZGV2LT52YmxhbmtbcGlwZV07CiAJdTMyIHZibGFua19jb3VudDsK IAl1bnNpZ25lZCBpbnQgc2VxOwogCiAJaWYgKFdBUk5fT04ocGlwZSA+PSBkZXYtPm51bV9jcnRj cykpIHsKLQkJKnZibGFua3RpbWUgPSAoc3RydWN0IHRpbWV2YWwpIHsgMCB9OworCQkqdmJsYW5r dGltZSA9IDA7CiAJCXJldHVybiAwOwogCX0KIApAQCAtNzkzLDcgKzc4Nyw3IEBAIHN0YXRpYyB1 MzIgZHJtX3ZibGFua19jb3VudF9hbmRfdGltZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1bnNp Z25lZCBpbnQgcGlwZSwKICAqIGRybV9jcnRjX3ZibGFua19jb3VudF9hbmRfdGltZSAtIHJldHJp ZXZlICJjb29rZWQiIHZibGFuayBjb3VudGVyIHZhbHVlCiAgKiAgICAgYW5kIHRoZSBzeXN0ZW0g dGltZXN0YW1wIGNvcnJlc3BvbmRpbmcgdG8gdGhhdCB2YmxhbmsgY291bnRlciB2YWx1ZQogICog QGNydGM6IHdoaWNoIGNvdW50ZXIgdG8gcmV0cmlldmUKLSAqIEB2Ymxhbmt0aW1lOiBQb2ludGVy IHRvIHN0cnVjdCB0aW1ldmFsIHRvIHJlY2VpdmUgdGhlIHZibGFuayB0aW1lc3RhbXAuCisgKiBA dmJsYW5rdGltZTogUG9pbnRlciB0byB0aW1lIHRvIHJlY2VpdmUgdGhlIHZibGFuayB0aW1lc3Rh bXAuCiAgKgogICogRmV0Y2hlcyB0aGUgImNvb2tlZCIgdmJsYW5rIGNvdW50IHZhbHVlIHRoYXQg cmVwcmVzZW50cyB0aGUgbnVtYmVyIG9mCiAgKiB2YmxhbmsgZXZlbnRzIHNpbmNlIHRoZSBzeXN0 ZW0gd2FzIGJvb3RlZCwgaW5jbHVkaW5nIGxvc3QgZXZlbnRzIGR1ZSB0bwpAQCAtODAxLDcgKzc5 NSw3IEBAIHN0YXRpYyB1MzIgZHJtX3ZibGFua19jb3VudF9hbmRfdGltZShzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2LCB1bnNpZ25lZCBpbnQgcGlwZSwKICAqIG9mIHRoZSB2YmxhbmsgaW50ZXJ2YWwg dGhhdCBjb3JyZXNwb25kcyB0byB0aGUgY3VycmVudCB2YmxhbmsgY291bnRlciB2YWx1ZS4KICAq LwogdTMyIGRybV9jcnRjX3ZibGFua19jb3VudF9hbmRfdGltZShzdHJ1Y3QgZHJtX2NydGMgKmNy dGMsCi0JCQkJICAgc3RydWN0IHRpbWV2YWwgKnZibGFua3RpbWUpCisJCQkJICAga3RpbWVfdCAq dmJsYW5rdGltZSkKIHsKIAlyZXR1cm4gZHJtX3ZibGFua19jb3VudF9hbmRfdGltZShjcnRjLT5k ZXYsIGRybV9jcnRjX2luZGV4KGNydGMpLAogCQkJCQkgdmJsYW5rdGltZSk7CkBAIC04MTAsMTEg KzgwNCwxOCBAQCBFWFBPUlRfU1lNQk9MKGRybV9jcnRjX3ZibGFua19jb3VudF9hbmRfdGltZSk7 CiAKIHN0YXRpYyB2b2lkIHNlbmRfdmJsYW5rX2V2ZW50KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYs CiAJCXN0cnVjdCBkcm1fcGVuZGluZ192YmxhbmtfZXZlbnQgKmUsCi0JCXVuc2lnbmVkIGxvbmcg c2VxLCBzdHJ1Y3QgdGltZXZhbCAqbm93KQorCQl1bnNpZ25lZCBsb25nIHNlcSwga3RpbWVfdCBu b3cpCiB7CisJc3RydWN0IHRpbWVzcGVjNjQgdHYgPSBrdGltZV90b190aW1lc3BlYzY0KG5vdyk7 CisKIAllLT5ldmVudC5zZXF1ZW5jZSA9IHNlcTsKLQllLT5ldmVudC50dl9zZWMgPSBub3ctPnR2 X3NlYzsKLQllLT5ldmVudC50dl91c2VjID0gbm93LT50dl91c2VjOworCS8qCisJICogZS0+ZXZl bnQgaXMgYSB1c2VyIHNwYWNlIHN0cnVjdHVyZSwgd2l0aCBoYXJkY29kZWQgdW5zaWduZWQKKwkg KiAzMi1iaXQgc2Vjb25kcy9taWNyb3NlY29uZHMuIFRoaXMgd2lsbCBvdmVyZmxvdyBpbiAyMTA2 IGZvcgorCSAqIGRybV90aW1lc3RhbXBfbW9ub3RvbmljPT0wLCBidXQgbm90IHdpdGggZHJtX3Rp bWVzdGFtcF9tb25vdG9uaWM9PTEKKwkgKi8KKwllLT5ldmVudC50dl9zZWMgPSB0di50dl9zZWM7 CisJZS0+ZXZlbnQudHZfdXNlYyA9IHR2LnR2X25zZWMgLyAxMDAwOwogCiAJdHJhY2VfZHJtX3Zi bGFua19ldmVudF9kZWxpdmVyZWQoZS0+YmFzZS5maWxlX3ByaXYsIGUtPnBpcGUsCiAJCQkJCSBl LT5ldmVudC5zZXF1ZW5jZSk7CkBAIC04OTEsNyArODkyLDcgQEAgdm9pZCBkcm1fY3J0Y19zZW5k X3ZibGFua19ldmVudChzdHJ1Y3QgZHJtX2NydGMgKmNydGMsCiB7CiAJc3RydWN0IGRybV9kZXZp Y2UgKmRldiA9IGNydGMtPmRldjsKIAl1bnNpZ25lZCBpbnQgc2VxLCBwaXBlID0gZHJtX2NydGNf aW5kZXgoY3J0Yyk7Ci0Jc3RydWN0IHRpbWV2YWwgbm93OworCWt0aW1lX3Qgbm93OwogCiAJaWYg KGRldi0+bnVtX2NydGNzID4gMCkgewogCQlzZXEgPSBkcm1fdmJsYW5rX2NvdW50X2FuZF90aW1l KGRldiwgcGlwZSwgJm5vdyk7CkBAIC05MDIsNyArOTAzLDcgQEAgdm9pZCBkcm1fY3J0Y19zZW5k X3ZibGFua19ldmVudChzdHJ1Y3QgZHJtX2NydGMgKmNydGMsCiAJfQogCWUtPnBpcGUgPSBwaXBl OwogCWUtPmV2ZW50LmNydGNfaWQgPSBjcnRjLT5iYXNlLmlkOwotCXNlbmRfdmJsYW5rX2V2ZW50 KGRldiwgZSwgc2VxLCAmbm93KTsKKwlzZW5kX3ZibGFua19ldmVudChkZXYsIGUsIHNlcSwgbm93 KTsKIH0KIEVYUE9SVF9TWU1CT0woZHJtX2NydGNfc2VuZF92YmxhbmtfZXZlbnQpOwogCkBAIC0x MTAwLDcgKzExMDEsOCBAQCB2b2lkIGRybV9jcnRjX3ZibGFua19vZmYoc3RydWN0IGRybV9jcnRj ICpjcnRjKQogCXVuc2lnbmVkIGludCBwaXBlID0gZHJtX2NydGNfaW5kZXgoY3J0Yyk7CiAJc3Ry dWN0IGRybV92YmxhbmtfY3J0YyAqdmJsYW5rID0gJmRldi0+dmJsYW5rW3BpcGVdOwogCXN0cnVj dCBkcm1fcGVuZGluZ192YmxhbmtfZXZlbnQgKmUsICp0OwotCXN0cnVjdCB0aW1ldmFsIG5vdzsK KworCWt0aW1lX3Qgbm93OwogCXVuc2lnbmVkIGxvbmcgaXJxZmxhZ3M7CiAJdW5zaWduZWQgaW50 IHNlcTsKIApAQCAtMTE0MSw3ICsxMTQzLDcgQEAgdm9pZCBkcm1fY3J0Y192Ymxhbmtfb2ZmKHN0 cnVjdCBkcm1fY3J0YyAqY3J0YykKIAkJCSAgZS0+ZXZlbnQuc2VxdWVuY2UsIHNlcSk7CiAJCWxp c3RfZGVsKCZlLT5iYXNlLmxpbmspOwogCQlkcm1fdmJsYW5rX3B1dChkZXYsIHBpcGUpOwotCQlz ZW5kX3ZibGFua19ldmVudChkZXYsIGUsIHNlcSwgJm5vdyk7CisJCXNlbmRfdmJsYW5rX2V2ZW50 KGRldiwgZSwgc2VxLCBub3cpOwogCX0KIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXYtPmV2 ZW50X2xvY2ssIGlycWZsYWdzKTsKIApAQCAtMTMyMSw3ICsxMzIzLDcgQEAgc3RhdGljIGludCBk cm1fcXVldWVfdmJsYW5rX2V2ZW50KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHVuc2lnbmVkIGlu dCBwaXBlLAogewogCXN0cnVjdCBkcm1fdmJsYW5rX2NydGMgKnZibGFuayA9ICZkZXYtPnZibGFu a1twaXBlXTsKIAlzdHJ1Y3QgZHJtX3BlbmRpbmdfdmJsYW5rX2V2ZW50ICplOwotCXN0cnVjdCB0 aW1ldmFsIG5vdzsKKwlrdGltZV90IG5vdzsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXVuc2ln bmVkIGludCBzZXE7CiAJaW50IHJldDsKQEAgLTEzNjcsNyArMTM2OSw3IEBAIHN0YXRpYyBpbnQg ZHJtX3F1ZXVlX3ZibGFua19ldmVudChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1bnNpZ25lZCBp bnQgcGlwZSwKIAllLT5ldmVudC5zZXF1ZW5jZSA9IHZibHdhaXQtPnJlcXVlc3Quc2VxdWVuY2U7 CiAJaWYgKHZibGFua19wYXNzZWQoc2VxLCB2Ymx3YWl0LT5yZXF1ZXN0LnNlcXVlbmNlKSkgewog CQlkcm1fdmJsYW5rX3B1dChkZXYsIHBpcGUpOwotCQlzZW5kX3ZibGFua19ldmVudChkZXYsIGUs IHNlcSwgJm5vdyk7CisJCXNlbmRfdmJsYW5rX2V2ZW50KGRldiwgZSwgc2VxLCBub3cpOwogCQl2 Ymx3YWl0LT5yZXBseS5zZXF1ZW5jZSA9IHNlcTsKIAl9IGVsc2UgewogCQkvKiBkcm1faGFuZGxl X3ZibGFua19ldmVudHMgd2lsbCBjYWxsIGRybV92YmxhbmtfcHV0ICovCkBAIC0xMzk4LDYgKzE0 MDAsMjQgQEAgc3RhdGljIGJvb2wgZHJtX3dhaXRfdmJsYW5rX2lzX3F1ZXJ5KHVuaW9uIGRybV93 YWl0X3ZibGFuayAqdmJsd2FpdCkKIAkJCQkJICBfRFJNX1ZCTEFOS19ORVhUT05NSVNTKSk7CiB9 CiAKK3N0YXRpYyB2b2lkIGRybV93YWl0X3ZibGFua19yZXBseShzdHJ1Y3QgZHJtX2RldmljZSAq ZGV2LCB1bnNpZ25lZCBpbnQgcGlwZSwKKwkJCQkgIHN0cnVjdCBkcm1fd2FpdF92YmxhbmtfcmVw bHkgKnJlcGx5KQoreworCWt0aW1lX3Qgbm93OworCXN0cnVjdCB0aW1lc3BlYzY0IHRzOworCisJ LyoKKwkgKiBkcm1fd2FpdF92YmxhbmtfcmVwbHkgaXMgYSBVQVBJIHN0cnVjdHVyZSB0aGF0IHVz ZXMgJ2xvbmcnCisJICogdG8gc3RvcmUgdGhlIHNlY29uZHMuIFRoaXMgd2lsbCBvdmVyZmxvdyBp biB5MjAzOCBvbiAzMi1iaXQKKwkgKiBhcmNoaXRlY3R1cmVzIHdpdGggZHJtX3RpbWVzdGFtcF9t b25vdG9uaWM9PTAsIGJ1dCBub3Qgd2l0aAorCSAqIGRybV90aW1lc3RhbXBfbW9ub3RvbmljPT0x ICh0aGUgZGVmYXVsdCkuCisJICovCisJcmVwbHktPnNlcXVlbmNlID0gZHJtX3ZibGFua19jb3Vu dF9hbmRfdGltZShkZXYsIHBpcGUsICZub3cpOworCXRzID0ga3RpbWVfdG9fdGltZXNwZWM2NChu b3cpOworCXJlcGx5LT50dmFsX3NlYyA9ICh1MzIpdHMudHZfc2VjOworCXJlcGx5LT50dmFsX3Vz ZWMgPSB0cy50dl9uc2VjIC8gMTAwMDsKK30KKwogaW50IGRybV93YWl0X3ZibGFua19pb2N0bChz dHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lkICpkYXRhLAogCQkJICBzdHJ1Y3QgZHJtX2ZpbGUg KmZpbGVfcHJpdikKIHsKQEAgLTE0MzksMTIgKzE0NTksNyBAQCBpbnQgZHJtX3dhaXRfdmJsYW5r X2lvY3RsKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCiAJaWYgKGRldi0+dmJs YW5rX2Rpc2FibGVfaW1tZWRpYXRlICYmCiAJICAgIGRybV93YWl0X3ZibGFua19pc19xdWVyeSh2 Ymx3YWl0KSAmJgogCSAgICBSRUFEX09OQ0UodmJsYW5rLT5lbmFibGVkKSkgewotCQlzdHJ1Y3Qg dGltZXZhbCBub3c7Ci0KLQkJdmJsd2FpdC0+cmVwbHkuc2VxdWVuY2UgPQotCQkJZHJtX3ZibGFu a19jb3VudF9hbmRfdGltZShkZXYsIHBpcGUsICZub3cpOwotCQl2Ymx3YWl0LT5yZXBseS50dmFs X3NlYyA9IG5vdy50dl9zZWM7Ci0JCXZibHdhaXQtPnJlcGx5LnR2YWxfdXNlYyA9IG5vdy50dl91 c2VjOworCQlkcm1fd2FpdF92YmxhbmtfcmVwbHkoZGV2LCBwaXBlLCAmdmJsd2FpdC0+cmVwbHkp OwogCQlyZXR1cm4gMDsKIAl9CiAKQEAgLTE0ODcsMTEgKzE1MDIsNyBAQCBpbnQgZHJtX3dhaXRf dmJsYW5rX2lvY3RsKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCiAJfQogCiAJ aWYgKHJldCAhPSAtRUlOVFIpIHsKLQkJc3RydWN0IHRpbWV2YWwgbm93OwotCi0JCXZibHdhaXQt PnJlcGx5LnNlcXVlbmNlID0gZHJtX3ZibGFua19jb3VudF9hbmRfdGltZShkZXYsIHBpcGUsICZu b3cpOwotCQl2Ymx3YWl0LT5yZXBseS50dmFsX3NlYyA9IG5vdy50dl9zZWM7Ci0JCXZibHdhaXQt PnJlcGx5LnR2YWxfdXNlYyA9IG5vdy50dl91c2VjOworCQlkcm1fd2FpdF92YmxhbmtfcmVwbHko ZGV2LCBwaXBlLCAmdmJsd2FpdC0+cmVwbHkpOwogCiAJCURSTV9ERUJVRygiY3J0YyAlZCByZXR1 cm5pbmcgJXUgdG8gY2xpZW50XG4iLAogCQkJICBwaXBlLCB2Ymx3YWl0LT5yZXBseS5zZXF1ZW5j ZSk7CkBAIC0xNTA3LDcgKzE1MTgsNyBAQCBpbnQgZHJtX3dhaXRfdmJsYW5rX2lvY3RsKHN0cnVj dCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCiBzdGF0aWMgdm9pZCBkcm1faGFuZGxlX3Zi bGFua19ldmVudHMoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IHBpcGUpCiB7 CiAJc3RydWN0IGRybV9wZW5kaW5nX3ZibGFua19ldmVudCAqZSwgKnQ7Ci0Jc3RydWN0IHRpbWV2 YWwgbm93OworCWt0aW1lX3Qgbm93OwogCXVuc2lnbmVkIGludCBzZXE7CiAKIAlhc3NlcnRfc3Bp bl9sb2NrZWQoJmRldi0+ZXZlbnRfbG9jayk7CkBAIC0xNTI1LDcgKzE1MzYsNyBAQCBzdGF0aWMg dm9pZCBkcm1faGFuZGxlX3ZibGFua19ldmVudHMoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdW5z aWduZWQgaW50IHBpcGUpCiAKIAkJbGlzdF9kZWwoJmUtPmJhc2UubGluayk7CiAJCWRybV92Ymxh bmtfcHV0KGRldiwgcGlwZSk7Ci0JCXNlbmRfdmJsYW5rX2V2ZW50KGRldiwgZSwgc2VxLCAmbm93 KTsKKwkJc2VuZF92YmxhbmtfZXZlbnQoZGV2LCBlLCBzZXEsIG5vdyk7CiAJfQogCiAJdHJhY2Vf ZHJtX3ZibGFua19ldmVudChwaXBlLCBzZXEpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJt X2Rydi5oIGIvaW5jbHVkZS9kcm0vZHJtX2Rydi5oCmluZGV4IGVlMDZlY2Q2YzAxZi4uNDEyZTgz YTRkM2RiIDEwMDY0NAotLS0gYS9pbmNsdWRlL2RybS9kcm1fZHJ2LmgKKysrIGIvaW5jbHVkZS9k cm0vZHJtX2Rydi5oCkBAIC0zMjQsNyArMzI0LDcgQEAgc3RydWN0IGRybV9kcml2ZXIgewogCSAq LwogCWJvb2wgKCpnZXRfdmJsYW5rX3RpbWVzdGFtcCkgKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYs IHVuc2lnbmVkIGludCBwaXBlLAogCQkJCSAgICAgaW50ICptYXhfZXJyb3IsCi0JCQkJICAgICBz dHJ1Y3QgdGltZXZhbCAqdmJsYW5rX3RpbWUsCisJCQkJICAgICBrdGltZV90ICp2YmxhbmtfdGlt ZSwKIAkJCQkgICAgIGJvb2wgaW5fdmJsYW5rX2lycSk7CiAKIAkvKioKZGlmZiAtLWdpdCBhL2lu Y2x1ZGUvZHJtL2RybV92YmxhbmsuaCBiL2luY2x1ZGUvZHJtL2RybV92YmxhbmsuaAppbmRleCA3 ZmJhOWVmZTQ5NTEuLjZhNThlMmU5MWEwZiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJtX3Zi bGFuay5oCisrKyBiL2luY2x1ZGUvZHJtL2RybV92YmxhbmsuaApAQCAtOTIsNyArOTIsNyBAQCBz dHJ1Y3QgZHJtX3ZibGFua19jcnRjIHsKIAkvKioKIAkgKiBAdGltZTogVmJsYW5rIHRpbWVzdGFt cCBjb3JyZXNwb25kaW5nIHRvIEBjb3VudC4KIAkgKi8KLQlzdHJ1Y3QgdGltZXZhbCB0aW1lOwor CWt0aW1lX3QgdGltZTsKIAogCS8qKgogCSAqIEByZWZjb3VudDogTnVtYmVyIG9mIHVzZXJzL3dh aXRlcnMgb2YgdGhlIHZibGFuayBpbnRlcnJ1cHQuIE9ubHkgd2hlbgpAQCAtMTU0LDcgKzE1NCw3 IEBAIHN0cnVjdCBkcm1fdmJsYW5rX2NydGMgewogaW50IGRybV92YmxhbmtfaW5pdChzdHJ1Y3Qg ZHJtX2RldmljZSAqZGV2LCB1bnNpZ25lZCBpbnQgbnVtX2NydGNzKTsKIHUzMiBkcm1fY3J0Y192 YmxhbmtfY291bnQoc3RydWN0IGRybV9jcnRjICpjcnRjKTsKIHUzMiBkcm1fY3J0Y192Ymxhbmtf Y291bnRfYW5kX3RpbWUoc3RydWN0IGRybV9jcnRjICpjcnRjLAotCQkJCSAgIHN0cnVjdCB0aW1l dmFsICp2Ymxhbmt0aW1lKTsKKwkJCQkgICBrdGltZV90ICp2Ymxhbmt0aW1lKTsKIHZvaWQgZHJt X2NydGNfc2VuZF92YmxhbmtfZXZlbnQoc3RydWN0IGRybV9jcnRjICpjcnRjLAogCQkJICAgICAg IHN0cnVjdCBkcm1fcGVuZGluZ192YmxhbmtfZXZlbnQgKmUpOwogdm9pZCBkcm1fY3J0Y19hcm1f dmJsYW5rX2V2ZW50KHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKQEAgLTE3Miw3ICsxNzIsNyBAQCB1 MzIgZHJtX2NydGNfYWNjdXJhdGVfdmJsYW5rX2NvdW50KHN0cnVjdCBkcm1fY3J0YyAqY3J0Yyk7 CiAKIGJvb2wgZHJtX2NhbGNfdmJsdGltZXN0YW1wX2Zyb21fc2Nhbm91dHBvcyhzdHJ1Y3QgZHJt X2RldmljZSAqZGV2LAogCQkJCQkgICB1bnNpZ25lZCBpbnQgcGlwZSwgaW50ICptYXhfZXJyb3Is Ci0JCQkJCSAgIHN0cnVjdCB0aW1ldmFsICp2YmxhbmtfdGltZSwKKwkJCQkJICAga3RpbWVfdCAq dmJsYW5rX3RpbWUsCiAJCQkJCSAgIGJvb2wgaW5fdmJsYW5rX2lycSk7CiB2b2lkIGRybV9jYWxj X3RpbWVzdGFtcGluZ19jb25zdGFudHMoc3RydWN0IGRybV9jcnRjICpjcnRjLAogCQkJCSAgICAg Y29uc3Qgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1vZGUpOwotLSAKMi45LjAKCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5n IGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVk ZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=