From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-wm0-f41.google.com ([74.125.82.41]:53783 "EHLO mail-wm0-f41.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1757286AbeD0GRu (ORCPT ); Fri, 27 Apr 2018 02:17:50 -0400 Received: by mail-wm0-f41.google.com with SMTP id 66so698554wmd.3 for ; Thu, 26 Apr 2018 23:17:49 -0700 (PDT) From: Daniel Vetter To: DRI Development Cc: Intel Graphics Development , Daniel Vetter , Sumit Semwal , Gustavo Padovan , linux-media@vger.kernel.org, linaro-mm-sig@lists.linaro.org Subject: [PATCH 17/17] dma-fence: Polish kernel-doc for dma-fence.c Date: Fri, 27 Apr 2018 08:17:24 +0200 Message-Id: <20180427061724.28497-18-daniel.vetter@ffwll.ch> In-Reply-To: <20180427061724.28497-1-daniel.vetter@ffwll.ch> References: <20180427061724.28497-1-daniel.vetter@ffwll.ch> Sender: linux-media-owner@vger.kernel.org List-ID: - Intro section that links to how this is exposed to userspace. - Lots more hyperlinks. - Minor clarifications and style polish Signed-off-by: Daniel Vetter Cc: Sumit Semwal Cc: Gustavo Padovan Cc: linux-media@vger.kernel.org Cc: linaro-mm-sig@lists.linaro.org --- Documentation/driver-api/dma-buf.rst | 6 ++ drivers/dma-buf/dma-fence.c | 140 ++++++++++++++++++--------- 2 files changed, 102 insertions(+), 44 deletions(-) diff --git a/Documentation/driver-api/dma-buf.rst b/Documentation/driver-api/dma-buf.rst index dc384f2f7f34..b541e97c7ab1 100644 --- a/Documentation/driver-api/dma-buf.rst +++ b/Documentation/driver-api/dma-buf.rst @@ -130,6 +130,12 @@ Reservation Objects DMA Fences ---------- +.. kernel-doc:: drivers/dma-buf/dma-fence.c + :doc: DMA fences overview + +DMA Fences Functions Reference +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + .. kernel-doc:: drivers/dma-buf/dma-fence.c :export: diff --git a/drivers/dma-buf/dma-fence.c b/drivers/dma-buf/dma-fence.c index 30fcbe415ff4..4e931e1de198 100644 --- a/drivers/dma-buf/dma-fence.c +++ b/drivers/dma-buf/dma-fence.c @@ -38,12 +38,43 @@ EXPORT_TRACEPOINT_SYMBOL(dma_fence_enable_signal); */ static atomic64_t dma_fence_context_counter = ATOMIC64_INIT(0); +/** + * DOC: DMA fences overview + * + * DMA fences, represented by &struct dma_fence, are the kernel internal + * synchronization primitive for DMA operations like GPU rendering, video + * encoding/decoding, or displaying buffers on a screen. + * + * A fence is initialized using dma_fence_init() and completed using + * dma_fence_signal(). Fences are associated with a context, allocated through + * dma_fence_context_alloc(), and all fences on the same context are + * fully ordered. + * + * Since the purposes of fences is to facilitate cross-device and + * cross-application synchronization, there's multiple ways to use one: + * + * - Individual fences can be exposed as a &sync_file, accessed as a file + * descriptor from userspace, created by calling sync_file_create(). This is + * called explicit fencing, since userspace passes around explicit + * synchronization points. + * + * - Some subsystems also have their own explicit fencing primitives, like + * &drm_syncobj. Compared to &sync_file, a &drm_syncobj allows the underlying + * fence to be updated. + * + * - Then there's also implicit fencing, where the synchronization points are + * implicitly passed around as part of shared &dma_buf instances. Such + * implicit fences are stored in &struct reservation_object through the + * &dma_buf.resv pointer. + */ + /** * dma_fence_context_alloc - allocate an array of fence contexts - * @num: [in] amount of contexts to allocate + * @num: amount of contexts to allocate * - * This function will return the first index of the number of fences allocated. - * The fence context is used for setting fence->context to a unique number. + * This function will return the first index of the number of fence contexts + * allocated. The fence context is used for setting &dma_fence.context to a + * unique number by passing the context to dma_fence_init(). */ u64 dma_fence_context_alloc(unsigned num) { @@ -59,10 +90,14 @@ EXPORT_SYMBOL(dma_fence_context_alloc); * Signal completion for software callbacks on a fence, this will unblock * dma_fence_wait() calls and run all the callbacks added with * dma_fence_add_callback(). Can be called multiple times, but since a fence - * can only go from unsignaled to signaled state, it will only be effective - * the first time. + * can only go from the unsignaled to the signaled state and not back, it will + * only be effective the first time. * - * Unlike dma_fence_signal, this function must be called with fence->lock held. + * Unlike dma_fence_signal(), this function must be called with &dma_fence.lock + * held. + * + * Returns 0 on success and a negative error value when @fence has been + * signalled already. */ int dma_fence_signal_locked(struct dma_fence *fence) { @@ -102,8 +137,11 @@ EXPORT_SYMBOL(dma_fence_signal_locked); * Signal completion for software callbacks on a fence, this will unblock * dma_fence_wait() calls and run all the callbacks added with * dma_fence_add_callback(). Can be called multiple times, but since a fence - * can only go from unsignaled to signaled state, it will only be effective - * the first time. + * can only go from the unsignaled to the signaled state and not back, it will + * only be effective the first time. + * + * Returns 0 on success and a negative error value when @fence has been + * signalled already. */ int dma_fence_signal(struct dma_fence *fence) { @@ -136,9 +174,9 @@ EXPORT_SYMBOL(dma_fence_signal); /** * dma_fence_wait_timeout - sleep until the fence gets signaled * or until timeout elapses - * @fence: [in] the fence to wait on - * @intr: [in] if true, do an interruptible wait - * @timeout: [in] timeout value in jiffies, or MAX_SCHEDULE_TIMEOUT + * @fence: the fence to wait on + * @intr: if true, do an interruptible wait + * @timeout: timeout value in jiffies, or MAX_SCHEDULE_TIMEOUT * * Returns -ERESTARTSYS if interrupted, 0 if the wait timed out, or the * remaining timeout in jiffies on success. Other error values may be @@ -148,6 +186,8 @@ EXPORT_SYMBOL(dma_fence_signal); * directly or indirectly (buf-mgr between reservation and committing) * holds a reference to the fence, otherwise the fence might be * freed before return, resulting in undefined behavior. + * + * See also dma_fence_wait() and dma_fence_wait_any_timeout(). */ signed long dma_fence_wait_timeout(struct dma_fence *fence, bool intr, signed long timeout) @@ -167,6 +207,13 @@ dma_fence_wait_timeout(struct dma_fence *fence, bool intr, signed long timeout) } EXPORT_SYMBOL(dma_fence_wait_timeout); +/** + * dma_fence_release - default relese function for fences + * @kref: &dma_fence.recfount + * + * This is the default release functions for &dma_fence. Drivers shouldn't call + * this directly, but instead call dma_fence_put(). + */ void dma_fence_release(struct kref *kref) { struct dma_fence *fence = @@ -199,10 +246,11 @@ EXPORT_SYMBOL(dma_fence_free); /** * dma_fence_enable_sw_signaling - enable signaling on fence - * @fence: [in] the fence to enable + * @fence: the fence to enable * - * this will request for sw signaling to be enabled, to make the fence - * complete as soon as possible + * This will request for sw signaling to be enabled, to make the fence + * complete as soon as possible. This calls &dma_fence_ops.enable_signaling + * internally. */ void dma_fence_enable_sw_signaling(struct dma_fence *fence) { @@ -226,24 +274,24 @@ EXPORT_SYMBOL(dma_fence_enable_sw_signaling); /** * dma_fence_add_callback - add a callback to be called when the fence * is signaled - * @fence: [in] the fence to wait on - * @cb: [in] the callback to register - * @func: [in] the function to call + * @fence: the fence to wait on + * @cb: the callback to register + * @func: the function to call * - * cb will be initialized by dma_fence_add_callback, no initialization + * @cb will be initialized by dma_fence_add_callback(), no initialization * by the caller is required. Any number of callbacks can be registered * to a fence, but a callback can only be registered to one fence at a time. * * Note that the callback can be called from an atomic context. If * fence is already signaled, this function will return -ENOENT (and - * *not* call the callback) + * *not* call the callback). * * Add a software callback to the fence. Same restrictions apply to - * refcount as it does to dma_fence_wait, however the caller doesn't need to - * keep a refcount to fence afterwards: when software access is enabled, - * the creator of the fence is required to keep the fence alive until - * after it signals with dma_fence_signal. The callback itself can be called - * from irq context. + * refcount as it does to dma_fence_wait(), however the caller doesn't need to + * keep a refcount to fence afterward dma_fence_add_callback() has returned: + * when software access is enabled, the creator of the fence is required to keep + * the fence alive until after it signals with dma_fence_signal(). The callback + * itself can be called from irq context. * * Returns 0 in case of success, -ENOENT if the fence is already signaled * and -EINVAL in case of error. @@ -292,7 +340,7 @@ EXPORT_SYMBOL(dma_fence_add_callback); /** * dma_fence_get_status - returns the status upon completion - * @fence: [in] the dma_fence to query + * @fence: the dma_fence to query * * This wraps dma_fence_get_status_locked() to return the error status * condition on a signaled fence. See dma_fence_get_status_locked() for more @@ -317,8 +365,8 @@ EXPORT_SYMBOL(dma_fence_get_status); /** * dma_fence_remove_callback - remove a callback from the signaling list - * @fence: [in] the fence to wait on - * @cb: [in] the callback to remove + * @fence: the fence to wait on + * @cb: the callback to remove * * Remove a previously queued callback from the fence. This function returns * true if the callback is successfully removed, or false if the fence has @@ -329,6 +377,9 @@ EXPORT_SYMBOL(dma_fence_get_status); * doing, since deadlocks and race conditions could occur all too easily. For * this reason, it should only ever be done on hardware lockup recovery, * with a reference held to the fence. + * + * Behaviour is undefined if @cb has not been added to @fence using + * dma_fence_add_callback() beforehand. */ bool dma_fence_remove_callback(struct dma_fence *fence, struct dma_fence_cb *cb) @@ -365,9 +416,9 @@ dma_fence_default_wait_cb(struct dma_fence *fence, struct dma_fence_cb *cb) /** * dma_fence_default_wait - default sleep until the fence gets signaled * or until timeout elapses - * @fence: [in] the fence to wait on - * @intr: [in] if true, do an interruptible wait - * @timeout: [in] timeout value in jiffies, or MAX_SCHEDULE_TIMEOUT + * @fence: the fence to wait on + * @intr: if true, do an interruptible wait + * @timeout: timeout value in jiffies, or MAX_SCHEDULE_TIMEOUT * * Returns -ERESTARTSYS if interrupted, 0 if the wait timed out, or the * remaining timeout in jiffies on success. If timeout is zero the value one is @@ -460,12 +511,12 @@ dma_fence_test_signaled_any(struct dma_fence **fences, uint32_t count, /** * dma_fence_wait_any_timeout - sleep until any fence gets signaled * or until timeout elapses - * @fences: [in] array of fences to wait on - * @count: [in] number of fences to wait on - * @intr: [in] if true, do an interruptible wait - * @timeout: [in] timeout value in jiffies, or MAX_SCHEDULE_TIMEOUT - * @idx: [out] the first signaled fence index, meaningful only on - * positive return + * @fences: array of fences to wait on + * @count: number of fences to wait on + * @intr: if true, do an interruptible wait + * @timeout: timeout value in jiffies, or MAX_SCHEDULE_TIMEOUT + * @idx: used to store the first signaled fence index, meaningful only on + * positive return * * Returns -EINVAL on custom fence wait implementation, -ERESTARTSYS if * interrupted, 0 if the wait timed out, or the remaining timeout in jiffies @@ -474,6 +525,8 @@ dma_fence_test_signaled_any(struct dma_fence **fences, uint32_t count, * Synchronous waits for the first fence in the array to be signaled. The * caller needs to hold a reference to all fences in the array, otherwise a * fence might be freed before return, resulting in undefined behavior. + * + * See also dma_fence_wait() and dma_fence_wait_timeout(). */ signed long dma_fence_wait_any_timeout(struct dma_fence **fences, uint32_t count, @@ -546,19 +599,18 @@ EXPORT_SYMBOL(dma_fence_wait_any_timeout); /** * dma_fence_init - Initialize a custom fence. - * @fence: [in] the fence to initialize - * @ops: [in] the dma_fence_ops for operations on this fence - * @lock: [in] the irqsafe spinlock to use for locking this fence - * @context: [in] the execution context this fence is run on - * @seqno: [in] a linear increasing sequence number for this context + * @fence: the fence to initialize + * @ops: the dma_fence_ops for operations on this fence + * @lock: the irqsafe spinlock to use for locking this fence + * @context: the execution context this fence is run on + * @seqno: a linear increasing sequence number for this context * * Initializes an allocated fence, the caller doesn't have to keep its * refcount after committing with this fence, but it will need to hold a - * refcount again if dma_fence_ops.enable_signaling gets called. This can - * be used for other implementing other types of fence. + * refcount again if &dma_fence_ops.enable_signaling gets called. * * context and seqno are used for easy comparison between fences, allowing - * to check which fence is later by simply using dma_fence_later. + * to check which fence is later by simply using dma_fence_later(). */ void dma_fence_init(struct dma_fence *fence, const struct dma_fence_ops *ops, -- 2.17.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: [PATCH 17/17] dma-fence: Polish kernel-doc for dma-fence.c Date: Fri, 27 Apr 2018 08:17:24 +0200 Message-ID: <20180427061724.28497-18-daniel.vetter@ffwll.ch> References: <20180427061724.28497-1-daniel.vetter@ffwll.ch> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180427061724.28497-1-daniel.vetter@ffwll.ch> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: DRI Development Cc: Daniel Vetter , Intel Graphics Development , linaro-mm-sig@lists.linaro.org, Sumit Semwal , linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org LSBJbnRybyBzZWN0aW9uIHRoYXQgbGlua3MgdG8gaG93IHRoaXMgaXMgZXhwb3NlZCB0byB1c2Vy c3BhY2UuCi0gTG90cyBtb3JlIGh5cGVybGlua3MuCi0gTWlub3IgY2xhcmlmaWNhdGlvbnMgYW5k IHN0eWxlIHBvbGlzaAoKU2lnbmVkLW9mZi1ieTogRGFuaWVsIFZldHRlciA8ZGFuaWVsLnZldHRl ckBmZndsbC5jaD4KQ2M6IFN1bWl0IFNlbXdhbCA8c3VtaXQuc2Vtd2FsQGxpbmFyby5vcmc+CkNj OiBHdXN0YXZvIFBhZG92YW4gPGd1c3Rhdm9AcGFkb3Zhbi5vcmc+CkNjOiBsaW51eC1tZWRpYUB2 Z2VyLmtlcm5lbC5vcmcKQ2M6IGxpbmFyby1tbS1zaWdAbGlzdHMubGluYXJvLm9yZwotLS0KIERv Y3VtZW50YXRpb24vZHJpdmVyLWFwaS9kbWEtYnVmLnJzdCB8ICAgNiArKwogZHJpdmVycy9kbWEt YnVmL2RtYS1mZW5jZS5jICAgICAgICAgIHwgMTQwICsrKysrKysrKysrKysrKysrKy0tLS0tLS0t LQogMiBmaWxlcyBjaGFuZ2VkLCAxMDIgaW5zZXJ0aW9ucygrKSwgNDQgZGVsZXRpb25zKC0pCgpk aWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0IGIvRG9jdW1l bnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0CmluZGV4IGRjMzg0ZjJmN2YzNC4uYjU0MWU5 N2M3YWIxIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZG1hLWJ1Zi5yc3QK KysrIGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0CkBAIC0xMzAsNiArMTMw LDEyIEBAIFJlc2VydmF0aW9uIE9iamVjdHMKIERNQSBGZW5jZXMKIC0tLS0tLS0tLS0KIAorLi4g a2VybmVsLWRvYzo6IGRyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVuY2UuYworICAgOmRvYzogRE1BIGZl bmNlcyBvdmVydmlldworCitETUEgRmVuY2VzIEZ1bmN0aW9ucyBSZWZlcmVuY2UKK35+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorCiAuLiBrZXJuZWwtZG9jOjogZHJpdmVycy9kbWEtYnVm L2RtYS1mZW5jZS5jCiAgICA6ZXhwb3J0OgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYv ZG1hLWZlbmNlLmMgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKaW5kZXggMzBmY2JlNDE1 ZmY0Li40ZTkzMWUxZGUxOTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVuY2Uu YworKysgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKQEAgLTM4LDEyICszOCw0MyBAQCBF WFBPUlRfVFJBQ0VQT0lOVF9TWU1CT0woZG1hX2ZlbmNlX2VuYWJsZV9zaWduYWwpOwogICovCiBz dGF0aWMgYXRvbWljNjRfdCBkbWFfZmVuY2VfY29udGV4dF9jb3VudGVyID0gQVRPTUlDNjRfSU5J VCgwKTsKIAorLyoqCisgKiBET0M6IERNQSBmZW5jZXMgb3ZlcnZpZXcKKyAqCisgKiBETUEgZmVu Y2VzLCByZXByZXNlbnRlZCBieSAmc3RydWN0IGRtYV9mZW5jZSwgYXJlIHRoZSBrZXJuZWwgaW50 ZXJuYWwKKyAqIHN5bmNocm9uaXphdGlvbiBwcmltaXRpdmUgZm9yIERNQSBvcGVyYXRpb25zIGxp a2UgR1BVIHJlbmRlcmluZywgdmlkZW8KKyAqIGVuY29kaW5nL2RlY29kaW5nLCBvciBkaXNwbGF5 aW5nIGJ1ZmZlcnMgb24gYSBzY3JlZW4uCisgKgorICogQSBmZW5jZSBpcyBpbml0aWFsaXplZCB1 c2luZyBkbWFfZmVuY2VfaW5pdCgpIGFuZCBjb21wbGV0ZWQgdXNpbmcKKyAqIGRtYV9mZW5jZV9z aWduYWwoKS4gRmVuY2VzIGFyZSBhc3NvY2lhdGVkIHdpdGggYSBjb250ZXh0LCBhbGxvY2F0ZWQg dGhyb3VnaAorICogZG1hX2ZlbmNlX2NvbnRleHRfYWxsb2MoKSwgYW5kIGFsbCBmZW5jZXMgb24g dGhlIHNhbWUgY29udGV4dCBhcmUKKyAqIGZ1bGx5IG9yZGVyZWQuCisgKgorICogU2luY2UgdGhl IHB1cnBvc2VzIG9mIGZlbmNlcyBpcyB0byBmYWNpbGl0YXRlIGNyb3NzLWRldmljZSBhbmQKKyAq IGNyb3NzLWFwcGxpY2F0aW9uIHN5bmNocm9uaXphdGlvbiwgdGhlcmUncyBtdWx0aXBsZSB3YXlz IHRvIHVzZSBvbmU6CisgKgorICogLSBJbmRpdmlkdWFsIGZlbmNlcyBjYW4gYmUgZXhwb3NlZCBh cyBhICZzeW5jX2ZpbGUsIGFjY2Vzc2VkIGFzIGEgZmlsZQorICogICBkZXNjcmlwdG9yIGZyb20g dXNlcnNwYWNlLCBjcmVhdGVkIGJ5IGNhbGxpbmcgc3luY19maWxlX2NyZWF0ZSgpLiBUaGlzIGlz CisgKiAgIGNhbGxlZCBleHBsaWNpdCBmZW5jaW5nLCBzaW5jZSB1c2Vyc3BhY2UgcGFzc2VzIGFy b3VuZCBleHBsaWNpdAorICogICBzeW5jaHJvbml6YXRpb24gcG9pbnRzLgorICoKKyAqIC0gU29t ZSBzdWJzeXN0ZW1zIGFsc28gaGF2ZSB0aGVpciBvd24gZXhwbGljaXQgZmVuY2luZyBwcmltaXRp dmVzLCBsaWtlCisgKiAgICZkcm1fc3luY29iai4gQ29tcGFyZWQgdG8gJnN5bmNfZmlsZSwgYSAm ZHJtX3N5bmNvYmogYWxsb3dzIHRoZSB1bmRlcmx5aW5nCisgKiAgIGZlbmNlIHRvIGJlIHVwZGF0 ZWQuCisgKgorICogLSBUaGVuIHRoZXJlJ3MgYWxzbyBpbXBsaWNpdCBmZW5jaW5nLCB3aGVyZSB0 aGUgc3luY2hyb25pemF0aW9uIHBvaW50cyBhcmUKKyAqICAgaW1wbGljaXRseSBwYXNzZWQgYXJv dW5kIGFzIHBhcnQgb2Ygc2hhcmVkICZkbWFfYnVmIGluc3RhbmNlcy4gU3VjaAorICogICBpbXBs aWNpdCBmZW5jZXMgYXJlIHN0b3JlZCBpbiAmc3RydWN0IHJlc2VydmF0aW9uX29iamVjdCB0aHJv dWdoIHRoZQorICogICAmZG1hX2J1Zi5yZXN2IHBvaW50ZXIuCisgKi8KKwogLyoqCiAgKiBkbWFf ZmVuY2VfY29udGV4dF9hbGxvYyAtIGFsbG9jYXRlIGFuIGFycmF5IG9mIGZlbmNlIGNvbnRleHRz Ci0gKiBAbnVtOglbaW5dCWFtb3VudCBvZiBjb250ZXh0cyB0byBhbGxvY2F0ZQorICogQG51bTog YW1vdW50IG9mIGNvbnRleHRzIHRvIGFsbG9jYXRlCiAgKgotICogVGhpcyBmdW5jdGlvbiB3aWxs IHJldHVybiB0aGUgZmlyc3QgaW5kZXggb2YgdGhlIG51bWJlciBvZiBmZW5jZXMgYWxsb2NhdGVk LgotICogVGhlIGZlbmNlIGNvbnRleHQgaXMgdXNlZCBmb3Igc2V0dGluZyBmZW5jZS0+Y29udGV4 dCB0byBhIHVuaXF1ZSBudW1iZXIuCisgKiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmV0dXJuIHRoZSBm aXJzdCBpbmRleCBvZiB0aGUgbnVtYmVyIG9mIGZlbmNlIGNvbnRleHRzCisgKiBhbGxvY2F0ZWQu ICBUaGUgZmVuY2UgY29udGV4dCBpcyB1c2VkIGZvciBzZXR0aW5nICZkbWFfZmVuY2UuY29udGV4 dCB0byBhCisgKiB1bmlxdWUgbnVtYmVyIGJ5IHBhc3NpbmcgdGhlIGNvbnRleHQgdG8gZG1hX2Zl bmNlX2luaXQoKS4KICAqLwogdTY0IGRtYV9mZW5jZV9jb250ZXh0X2FsbG9jKHVuc2lnbmVkIG51 bSkKIHsKQEAgLTU5LDEwICs5MCwxNCBAQCBFWFBPUlRfU1lNQk9MKGRtYV9mZW5jZV9jb250ZXh0 X2FsbG9jKTsKICAqIFNpZ25hbCBjb21wbGV0aW9uIGZvciBzb2Z0d2FyZSBjYWxsYmFja3Mgb24g YSBmZW5jZSwgdGhpcyB3aWxsIHVuYmxvY2sKICAqIGRtYV9mZW5jZV93YWl0KCkgY2FsbHMgYW5k IHJ1biBhbGwgdGhlIGNhbGxiYWNrcyBhZGRlZCB3aXRoCiAgKiBkbWFfZmVuY2VfYWRkX2NhbGxi YWNrKCkuIENhbiBiZSBjYWxsZWQgbXVsdGlwbGUgdGltZXMsIGJ1dCBzaW5jZSBhIGZlbmNlCi0g KiBjYW4gb25seSBnbyBmcm9tIHVuc2lnbmFsZWQgdG8gc2lnbmFsZWQgc3RhdGUsIGl0IHdpbGwg b25seSBiZSBlZmZlY3RpdmUKLSAqIHRoZSBmaXJzdCB0aW1lLgorICogY2FuIG9ubHkgZ28gZnJv bSB0aGUgdW5zaWduYWxlZCB0byB0aGUgc2lnbmFsZWQgc3RhdGUgYW5kIG5vdCBiYWNrLCBpdCB3 aWxsCisgKiBvbmx5IGJlIGVmZmVjdGl2ZSB0aGUgZmlyc3QgdGltZS4KICAqCi0gKiBVbmxpa2Ug ZG1hX2ZlbmNlX3NpZ25hbCwgdGhpcyBmdW5jdGlvbiBtdXN0IGJlIGNhbGxlZCB3aXRoIGZlbmNl LT5sb2NrIGhlbGQuCisgKiBVbmxpa2UgZG1hX2ZlbmNlX3NpZ25hbCgpLCB0aGlzIGZ1bmN0aW9u IG11c3QgYmUgY2FsbGVkIHdpdGggJmRtYV9mZW5jZS5sb2NrCisgKiBoZWxkLgorICoKKyAqIFJl dHVybnMgMCBvbiBzdWNjZXNzIGFuZCBhIG5lZ2F0aXZlIGVycm9yIHZhbHVlIHdoZW4gQGZlbmNl IGhhcyBiZWVuCisgKiBzaWduYWxsZWQgYWxyZWFkeS4KICAqLwogaW50IGRtYV9mZW5jZV9zaWdu YWxfbG9ja2VkKHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlKQogewpAQCAtMTAyLDggKzEzNywxMSBA QCBFWFBPUlRfU1lNQk9MKGRtYV9mZW5jZV9zaWduYWxfbG9ja2VkKTsKICAqIFNpZ25hbCBjb21w bGV0aW9uIGZvciBzb2Z0d2FyZSBjYWxsYmFja3Mgb24gYSBmZW5jZSwgdGhpcyB3aWxsIHVuYmxv Y2sKICAqIGRtYV9mZW5jZV93YWl0KCkgY2FsbHMgYW5kIHJ1biBhbGwgdGhlIGNhbGxiYWNrcyBh ZGRlZCB3aXRoCiAgKiBkbWFfZmVuY2VfYWRkX2NhbGxiYWNrKCkuIENhbiBiZSBjYWxsZWQgbXVs dGlwbGUgdGltZXMsIGJ1dCBzaW5jZSBhIGZlbmNlCi0gKiBjYW4gb25seSBnbyBmcm9tIHVuc2ln bmFsZWQgdG8gc2lnbmFsZWQgc3RhdGUsIGl0IHdpbGwgb25seSBiZSBlZmZlY3RpdmUKLSAqIHRo ZSBmaXJzdCB0aW1lLgorICogY2FuIG9ubHkgZ28gZnJvbSB0aGUgdW5zaWduYWxlZCB0byB0aGUg c2lnbmFsZWQgc3RhdGUgYW5kIG5vdCBiYWNrLCBpdCB3aWxsCisgKiBvbmx5IGJlIGVmZmVjdGl2 ZSB0aGUgZmlyc3QgdGltZS4KKyAqCisgKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBhbmQgYSBuZWdh dGl2ZSBlcnJvciB2YWx1ZSB3aGVuIEBmZW5jZSBoYXMgYmVlbgorICogc2lnbmFsbGVkIGFscmVh ZHkuCiAgKi8KIGludCBkbWFfZmVuY2Vfc2lnbmFsKHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlKQog ewpAQCAtMTM2LDkgKzE3NCw5IEBAIEVYUE9SVF9TWU1CT0woZG1hX2ZlbmNlX3NpZ25hbCk7CiAv KioKICAqIGRtYV9mZW5jZV93YWl0X3RpbWVvdXQgLSBzbGVlcCB1bnRpbCB0aGUgZmVuY2UgZ2V0 cyBzaWduYWxlZAogICogb3IgdW50aWwgdGltZW91dCBlbGFwc2VzCi0gKiBAZmVuY2U6CVtpbl0J dGhlIGZlbmNlIHRvIHdhaXQgb24KLSAqIEBpbnRyOglbaW5dCWlmIHRydWUsIGRvIGFuIGludGVy cnVwdGlibGUgd2FpdAotICogQHRpbWVvdXQ6CVtpbl0JdGltZW91dCB2YWx1ZSBpbiBqaWZmaWVz LCBvciBNQVhfU0NIRURVTEVfVElNRU9VVAorICogQGZlbmNlOiB0aGUgZmVuY2UgdG8gd2FpdCBv bgorICogQGludHI6IGlmIHRydWUsIGRvIGFuIGludGVycnVwdGlibGUgd2FpdAorICogQHRpbWVv dXQ6IHRpbWVvdXQgdmFsdWUgaW4gamlmZmllcywgb3IgTUFYX1NDSEVEVUxFX1RJTUVPVVQKICAq CiAgKiBSZXR1cm5zIC1FUkVTVEFSVFNZUyBpZiBpbnRlcnJ1cHRlZCwgMCBpZiB0aGUgd2FpdCB0 aW1lZCBvdXQsIG9yIHRoZQogICogcmVtYWluaW5nIHRpbWVvdXQgaW4gamlmZmllcyBvbiBzdWNj ZXNzLiBPdGhlciBlcnJvciB2YWx1ZXMgbWF5IGJlCkBAIC0xNDgsNiArMTg2LDggQEAgRVhQT1JU X1NZTUJPTChkbWFfZmVuY2Vfc2lnbmFsKTsKICAqIGRpcmVjdGx5IG9yIGluZGlyZWN0bHkgKGJ1 Zi1tZ3IgYmV0d2VlbiByZXNlcnZhdGlvbiBhbmQgY29tbWl0dGluZykKICAqIGhvbGRzIGEgcmVm ZXJlbmNlIHRvIHRoZSBmZW5jZSwgb3RoZXJ3aXNlIHRoZSBmZW5jZSBtaWdodCBiZQogICogZnJl ZWQgYmVmb3JlIHJldHVybiwgcmVzdWx0aW5nIGluIHVuZGVmaW5lZCBiZWhhdmlvci4KKyAqCisg KiBTZWUgYWxzbyBkbWFfZmVuY2Vfd2FpdCgpIGFuZCBkbWFfZmVuY2Vfd2FpdF9hbnlfdGltZW91 dCgpLgogICovCiBzaWduZWQgbG9uZwogZG1hX2ZlbmNlX3dhaXRfdGltZW91dChzdHJ1Y3QgZG1h X2ZlbmNlICpmZW5jZSwgYm9vbCBpbnRyLCBzaWduZWQgbG9uZyB0aW1lb3V0KQpAQCAtMTY3LDYg KzIwNywxMyBAQCBkbWFfZmVuY2Vfd2FpdF90aW1lb3V0KHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNl LCBib29sIGludHIsIHNpZ25lZCBsb25nIHRpbWVvdXQpCiB9CiBFWFBPUlRfU1lNQk9MKGRtYV9m ZW5jZV93YWl0X3RpbWVvdXQpOwogCisvKioKKyAqIGRtYV9mZW5jZV9yZWxlYXNlIC0gZGVmYXVs dCByZWxlc2UgZnVuY3Rpb24gZm9yIGZlbmNlcworICogQGtyZWY6ICZkbWFfZmVuY2UucmVjZm91 bnQKKyAqCisgKiBUaGlzIGlzIHRoZSBkZWZhdWx0IHJlbGVhc2UgZnVuY3Rpb25zIGZvciAmZG1h X2ZlbmNlLiBEcml2ZXJzIHNob3VsZG4ndCBjYWxsCisgKiB0aGlzIGRpcmVjdGx5LCBidXQgaW5z dGVhZCBjYWxsIGRtYV9mZW5jZV9wdXQoKS4KKyAqLwogdm9pZCBkbWFfZmVuY2VfcmVsZWFzZShz dHJ1Y3Qga3JlZiAqa3JlZikKIHsKIAlzdHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSA9CkBAIC0xOTks MTAgKzI0NiwxMSBAQCBFWFBPUlRfU1lNQk9MKGRtYV9mZW5jZV9mcmVlKTsKIAogLyoqCiAgKiBk bWFfZmVuY2VfZW5hYmxlX3N3X3NpZ25hbGluZyAtIGVuYWJsZSBzaWduYWxpbmcgb24gZmVuY2UK LSAqIEBmZW5jZToJW2luXQl0aGUgZmVuY2UgdG8gZW5hYmxlCisgKiBAZmVuY2U6IHRoZSBmZW5j ZSB0byBlbmFibGUKICAqCi0gKiB0aGlzIHdpbGwgcmVxdWVzdCBmb3Igc3cgc2lnbmFsaW5nIHRv IGJlIGVuYWJsZWQsIHRvIG1ha2UgdGhlIGZlbmNlCi0gKiBjb21wbGV0ZSBhcyBzb29uIGFzIHBv c3NpYmxlCisgKiBUaGlzIHdpbGwgcmVxdWVzdCBmb3Igc3cgc2lnbmFsaW5nIHRvIGJlIGVuYWJs ZWQsIHRvIG1ha2UgdGhlIGZlbmNlCisgKiBjb21wbGV0ZSBhcyBzb29uIGFzIHBvc3NpYmxlLiBU aGlzIGNhbGxzICZkbWFfZmVuY2Vfb3BzLmVuYWJsZV9zaWduYWxpbmcKKyAqIGludGVybmFsbHku CiAgKi8KIHZvaWQgZG1hX2ZlbmNlX2VuYWJsZV9zd19zaWduYWxpbmcoc3RydWN0IGRtYV9mZW5j ZSAqZmVuY2UpCiB7CkBAIC0yMjYsMjQgKzI3NCwyNCBAQCBFWFBPUlRfU1lNQk9MKGRtYV9mZW5j ZV9lbmFibGVfc3dfc2lnbmFsaW5nKTsKIC8qKgogICogZG1hX2ZlbmNlX2FkZF9jYWxsYmFjayAt IGFkZCBhIGNhbGxiYWNrIHRvIGJlIGNhbGxlZCB3aGVuIHRoZSBmZW5jZQogICogaXMgc2lnbmFs ZWQKLSAqIEBmZW5jZToJW2luXQl0aGUgZmVuY2UgdG8gd2FpdCBvbgotICogQGNiOgkJW2luXQl0 aGUgY2FsbGJhY2sgdG8gcmVnaXN0ZXIKLSAqIEBmdW5jOglbaW5dCXRoZSBmdW5jdGlvbiB0byBj YWxsCisgKiBAZmVuY2U6IHRoZSBmZW5jZSB0byB3YWl0IG9uCisgKiBAY2I6IHRoZSBjYWxsYmFj ayB0byByZWdpc3RlcgorICogQGZ1bmM6IHRoZSBmdW5jdGlvbiB0byBjYWxsCiAgKgotICogY2Ig d2lsbCBiZSBpbml0aWFsaXplZCBieSBkbWFfZmVuY2VfYWRkX2NhbGxiYWNrLCBubyBpbml0aWFs aXphdGlvbgorICogQGNiIHdpbGwgYmUgaW5pdGlhbGl6ZWQgYnkgZG1hX2ZlbmNlX2FkZF9jYWxs YmFjaygpLCBubyBpbml0aWFsaXphdGlvbgogICogYnkgdGhlIGNhbGxlciBpcyByZXF1aXJlZC4g QW55IG51bWJlciBvZiBjYWxsYmFja3MgY2FuIGJlIHJlZ2lzdGVyZWQKICAqIHRvIGEgZmVuY2Us IGJ1dCBhIGNhbGxiYWNrIGNhbiBvbmx5IGJlIHJlZ2lzdGVyZWQgdG8gb25lIGZlbmNlIGF0IGEg dGltZS4KICAqCiAgKiBOb3RlIHRoYXQgdGhlIGNhbGxiYWNrIGNhbiBiZSBjYWxsZWQgZnJvbSBh biBhdG9taWMgY29udGV4dC4gIElmCiAgKiBmZW5jZSBpcyBhbHJlYWR5IHNpZ25hbGVkLCB0aGlz IGZ1bmN0aW9uIHdpbGwgcmV0dXJuIC1FTk9FTlQgKGFuZAotICogKm5vdCogY2FsbCB0aGUgY2Fs bGJhY2spCisgKiAqbm90KiBjYWxsIHRoZSBjYWxsYmFjaykuCiAgKgogICogQWRkIGEgc29mdHdh cmUgY2FsbGJhY2sgdG8gdGhlIGZlbmNlLiBTYW1lIHJlc3RyaWN0aW9ucyBhcHBseSB0bwotICog cmVmY291bnQgYXMgaXQgZG9lcyB0byBkbWFfZmVuY2Vfd2FpdCwgaG93ZXZlciB0aGUgY2FsbGVy IGRvZXNuJ3QgbmVlZCB0bwotICoga2VlcCBhIHJlZmNvdW50IHRvIGZlbmNlIGFmdGVyd2FyZHM6 IHdoZW4gc29mdHdhcmUgYWNjZXNzIGlzIGVuYWJsZWQsCi0gKiB0aGUgY3JlYXRvciBvZiB0aGUg ZmVuY2UgaXMgcmVxdWlyZWQgdG8ga2VlcCB0aGUgZmVuY2UgYWxpdmUgdW50aWwKLSAqIGFmdGVy IGl0IHNpZ25hbHMgd2l0aCBkbWFfZmVuY2Vfc2lnbmFsLiBUaGUgY2FsbGJhY2sgaXRzZWxmIGNh biBiZSBjYWxsZWQKLSAqIGZyb20gaXJxIGNvbnRleHQuCisgKiByZWZjb3VudCBhcyBpdCBkb2Vz IHRvIGRtYV9mZW5jZV93YWl0KCksIGhvd2V2ZXIgdGhlIGNhbGxlciBkb2Vzbid0IG5lZWQgdG8K KyAqIGtlZXAgYSByZWZjb3VudCB0byBmZW5jZSBhZnRlcndhcmQgZG1hX2ZlbmNlX2FkZF9jYWxs YmFjaygpIGhhcyByZXR1cm5lZDoKKyAqIHdoZW4gc29mdHdhcmUgYWNjZXNzIGlzIGVuYWJsZWQs IHRoZSBjcmVhdG9yIG9mIHRoZSBmZW5jZSBpcyByZXF1aXJlZCB0byBrZWVwCisgKiB0aGUgZmVu Y2UgYWxpdmUgdW50aWwgYWZ0ZXIgaXQgc2lnbmFscyB3aXRoIGRtYV9mZW5jZV9zaWduYWwoKS4g VGhlIGNhbGxiYWNrCisgKiBpdHNlbGYgY2FuIGJlIGNhbGxlZCBmcm9tIGlycSBjb250ZXh0Lgog ICoKICAqIFJldHVybnMgMCBpbiBjYXNlIG9mIHN1Y2Nlc3MsIC1FTk9FTlQgaWYgdGhlIGZlbmNl IGlzIGFscmVhZHkgc2lnbmFsZWQKICAqIGFuZCAtRUlOVkFMIGluIGNhc2Ugb2YgZXJyb3IuCkBA IC0yOTIsNyArMzQwLDcgQEAgRVhQT1JUX1NZTUJPTChkbWFfZmVuY2VfYWRkX2NhbGxiYWNrKTsK IAogLyoqCiAgKiBkbWFfZmVuY2VfZ2V0X3N0YXR1cyAtIHJldHVybnMgdGhlIHN0YXR1cyB1cG9u IGNvbXBsZXRpb24KLSAqIEBmZW5jZTogW2luXQl0aGUgZG1hX2ZlbmNlIHRvIHF1ZXJ5CisgKiBA ZmVuY2U6IHRoZSBkbWFfZmVuY2UgdG8gcXVlcnkKICAqCiAgKiBUaGlzIHdyYXBzIGRtYV9mZW5j ZV9nZXRfc3RhdHVzX2xvY2tlZCgpIHRvIHJldHVybiB0aGUgZXJyb3Igc3RhdHVzCiAgKiBjb25k aXRpb24gb24gYSBzaWduYWxlZCBmZW5jZS4gU2VlIGRtYV9mZW5jZV9nZXRfc3RhdHVzX2xvY2tl ZCgpIGZvciBtb3JlCkBAIC0zMTcsOCArMzY1LDggQEAgRVhQT1JUX1NZTUJPTChkbWFfZmVuY2Vf Z2V0X3N0YXR1cyk7CiAKIC8qKgogICogZG1hX2ZlbmNlX3JlbW92ZV9jYWxsYmFjayAtIHJlbW92 ZSBhIGNhbGxiYWNrIGZyb20gdGhlIHNpZ25hbGluZyBsaXN0Ci0gKiBAZmVuY2U6CVtpbl0JdGhl IGZlbmNlIHRvIHdhaXQgb24KLSAqIEBjYjoJCVtpbl0JdGhlIGNhbGxiYWNrIHRvIHJlbW92ZQor ICogQGZlbmNlOiB0aGUgZmVuY2UgdG8gd2FpdCBvbgorICogQGNiOiB0aGUgY2FsbGJhY2sgdG8g cmVtb3ZlCiAgKgogICogUmVtb3ZlIGEgcHJldmlvdXNseSBxdWV1ZWQgY2FsbGJhY2sgZnJvbSB0 aGUgZmVuY2UuIFRoaXMgZnVuY3Rpb24gcmV0dXJucwogICogdHJ1ZSBpZiB0aGUgY2FsbGJhY2sg aXMgc3VjY2Vzc2Z1bGx5IHJlbW92ZWQsIG9yIGZhbHNlIGlmIHRoZSBmZW5jZSBoYXMKQEAgLTMy OSw2ICszNzcsOSBAQCBFWFBPUlRfU1lNQk9MKGRtYV9mZW5jZV9nZXRfc3RhdHVzKTsKICAqIGRv aW5nLCBzaW5jZSBkZWFkbG9ja3MgYW5kIHJhY2UgY29uZGl0aW9ucyBjb3VsZCBvY2N1ciBhbGwg dG9vIGVhc2lseS4gRm9yCiAgKiB0aGlzIHJlYXNvbiwgaXQgc2hvdWxkIG9ubHkgZXZlciBiZSBk b25lIG9uIGhhcmR3YXJlIGxvY2t1cCByZWNvdmVyeSwKICAqIHdpdGggYSByZWZlcmVuY2UgaGVs ZCB0byB0aGUgZmVuY2UuCisgKgorICogQmVoYXZpb3VyIGlzIHVuZGVmaW5lZCBpZiBAY2IgaGFz IG5vdCBiZWVuIGFkZGVkIHRvIEBmZW5jZSB1c2luZworICogZG1hX2ZlbmNlX2FkZF9jYWxsYmFj aygpIGJlZm9yZWhhbmQuCiAgKi8KIGJvb2wKIGRtYV9mZW5jZV9yZW1vdmVfY2FsbGJhY2soc3Ry dWN0IGRtYV9mZW5jZSAqZmVuY2UsIHN0cnVjdCBkbWFfZmVuY2VfY2IgKmNiKQpAQCAtMzY1LDkg KzQxNiw5IEBAIGRtYV9mZW5jZV9kZWZhdWx0X3dhaXRfY2Ioc3RydWN0IGRtYV9mZW5jZSAqZmVu Y2UsIHN0cnVjdCBkbWFfZmVuY2VfY2IgKmNiKQogLyoqCiAgKiBkbWFfZmVuY2VfZGVmYXVsdF93 YWl0IC0gZGVmYXVsdCBzbGVlcCB1bnRpbCB0aGUgZmVuY2UgZ2V0cyBzaWduYWxlZAogICogb3Ig dW50aWwgdGltZW91dCBlbGFwc2VzCi0gKiBAZmVuY2U6CVtpbl0JdGhlIGZlbmNlIHRvIHdhaXQg b24KLSAqIEBpbnRyOglbaW5dCWlmIHRydWUsIGRvIGFuIGludGVycnVwdGlibGUgd2FpdAotICog QHRpbWVvdXQ6CVtpbl0JdGltZW91dCB2YWx1ZSBpbiBqaWZmaWVzLCBvciBNQVhfU0NIRURVTEVf VElNRU9VVAorICogQGZlbmNlOiB0aGUgZmVuY2UgdG8gd2FpdCBvbgorICogQGludHI6IGlmIHRy dWUsIGRvIGFuIGludGVycnVwdGlibGUgd2FpdAorICogQHRpbWVvdXQ6IHRpbWVvdXQgdmFsdWUg aW4gamlmZmllcywgb3IgTUFYX1NDSEVEVUxFX1RJTUVPVVQKICAqCiAgKiBSZXR1cm5zIC1FUkVT VEFSVFNZUyBpZiBpbnRlcnJ1cHRlZCwgMCBpZiB0aGUgd2FpdCB0aW1lZCBvdXQsIG9yIHRoZQog ICogcmVtYWluaW5nIHRpbWVvdXQgaW4gamlmZmllcyBvbiBzdWNjZXNzLiBJZiB0aW1lb3V0IGlz IHplcm8gdGhlIHZhbHVlIG9uZSBpcwpAQCAtNDYwLDEyICs1MTEsMTIgQEAgZG1hX2ZlbmNlX3Rl c3Rfc2lnbmFsZWRfYW55KHN0cnVjdCBkbWFfZmVuY2UgKipmZW5jZXMsIHVpbnQzMl90IGNvdW50 LAogLyoqCiAgKiBkbWFfZmVuY2Vfd2FpdF9hbnlfdGltZW91dCAtIHNsZWVwIHVudGlsIGFueSBm ZW5jZSBnZXRzIHNpZ25hbGVkCiAgKiBvciB1bnRpbCB0aW1lb3V0IGVsYXBzZXMKLSAqIEBmZW5j ZXM6CVtpbl0JYXJyYXkgb2YgZmVuY2VzIHRvIHdhaXQgb24KLSAqIEBjb3VudDoJW2luXQludW1i ZXIgb2YgZmVuY2VzIHRvIHdhaXQgb24KLSAqIEBpbnRyOglbaW5dCWlmIHRydWUsIGRvIGFuIGlu dGVycnVwdGlibGUgd2FpdAotICogQHRpbWVvdXQ6CVtpbl0JdGltZW91dCB2YWx1ZSBpbiBqaWZm aWVzLCBvciBNQVhfU0NIRURVTEVfVElNRU9VVAotICogQGlkeDogICAgICAgW291dF0JdGhlIGZp cnN0IHNpZ25hbGVkIGZlbmNlIGluZGV4LCBtZWFuaW5nZnVsIG9ubHkgb24KLSAqCQkJcG9zaXRp dmUgcmV0dXJuCisgKiBAZmVuY2VzOiBhcnJheSBvZiBmZW5jZXMgdG8gd2FpdCBvbgorICogQGNv dW50OiBudW1iZXIgb2YgZmVuY2VzIHRvIHdhaXQgb24KKyAqIEBpbnRyOiBpZiB0cnVlLCBkbyBh biBpbnRlcnJ1cHRpYmxlIHdhaXQKKyAqIEB0aW1lb3V0OiB0aW1lb3V0IHZhbHVlIGluIGppZmZp ZXMsIG9yIE1BWF9TQ0hFRFVMRV9USU1FT1VUCisgKiBAaWR4OiB1c2VkIHRvIHN0b3JlIHRoZSBm aXJzdCBzaWduYWxlZCBmZW5jZSBpbmRleCwgbWVhbmluZ2Z1bCBvbmx5IG9uCisgKglwb3NpdGl2 ZSByZXR1cm4KICAqCiAgKiBSZXR1cm5zIC1FSU5WQUwgb24gY3VzdG9tIGZlbmNlIHdhaXQgaW1w bGVtZW50YXRpb24sIC1FUkVTVEFSVFNZUyBpZgogICogaW50ZXJydXB0ZWQsIDAgaWYgdGhlIHdh aXQgdGltZWQgb3V0LCBvciB0aGUgcmVtYWluaW5nIHRpbWVvdXQgaW4gamlmZmllcwpAQCAtNDc0 LDYgKzUyNSw4IEBAIGRtYV9mZW5jZV90ZXN0X3NpZ25hbGVkX2FueShzdHJ1Y3QgZG1hX2ZlbmNl ICoqZmVuY2VzLCB1aW50MzJfdCBjb3VudCwKICAqIFN5bmNocm9ub3VzIHdhaXRzIGZvciB0aGUg Zmlyc3QgZmVuY2UgaW4gdGhlIGFycmF5IHRvIGJlIHNpZ25hbGVkLiBUaGUKICAqIGNhbGxlciBu ZWVkcyB0byBob2xkIGEgcmVmZXJlbmNlIHRvIGFsbCBmZW5jZXMgaW4gdGhlIGFycmF5LCBvdGhl cndpc2UgYQogICogZmVuY2UgbWlnaHQgYmUgZnJlZWQgYmVmb3JlIHJldHVybiwgcmVzdWx0aW5n IGluIHVuZGVmaW5lZCBiZWhhdmlvci4KKyAqCisgKiBTZWUgYWxzbyBkbWFfZmVuY2Vfd2FpdCgp IGFuZCBkbWFfZmVuY2Vfd2FpdF90aW1lb3V0KCkuCiAgKi8KIHNpZ25lZCBsb25nCiBkbWFfZmVu Y2Vfd2FpdF9hbnlfdGltZW91dChzdHJ1Y3QgZG1hX2ZlbmNlICoqZmVuY2VzLCB1aW50MzJfdCBj b3VudCwKQEAgLTU0NiwxOSArNTk5LDE4IEBAIEVYUE9SVF9TWU1CT0woZG1hX2ZlbmNlX3dhaXRf YW55X3RpbWVvdXQpOwogCiAvKioKICAqIGRtYV9mZW5jZV9pbml0IC0gSW5pdGlhbGl6ZSBhIGN1 c3RvbSBmZW5jZS4KLSAqIEBmZW5jZToJW2luXQl0aGUgZmVuY2UgdG8gaW5pdGlhbGl6ZQotICog QG9wczoJW2luXQl0aGUgZG1hX2ZlbmNlX29wcyBmb3Igb3BlcmF0aW9ucyBvbiB0aGlzIGZlbmNl Ci0gKiBAbG9jazoJW2luXQl0aGUgaXJxc2FmZSBzcGlubG9jayB0byB1c2UgZm9yIGxvY2tpbmcg dGhpcyBmZW5jZQotICogQGNvbnRleHQ6CVtpbl0JdGhlIGV4ZWN1dGlvbiBjb250ZXh0IHRoaXMg ZmVuY2UgaXMgcnVuIG9uCi0gKiBAc2Vxbm86CVtpbl0JYSBsaW5lYXIgaW5jcmVhc2luZyBzZXF1 ZW5jZSBudW1iZXIgZm9yIHRoaXMgY29udGV4dAorICogQGZlbmNlOiB0aGUgZmVuY2UgdG8gaW5p dGlhbGl6ZQorICogQG9wczogdGhlIGRtYV9mZW5jZV9vcHMgZm9yIG9wZXJhdGlvbnMgb24gdGhp cyBmZW5jZQorICogQGxvY2s6IHRoZSBpcnFzYWZlIHNwaW5sb2NrIHRvIHVzZSBmb3IgbG9ja2lu ZyB0aGlzIGZlbmNlCisgKiBAY29udGV4dDogdGhlIGV4ZWN1dGlvbiBjb250ZXh0IHRoaXMgZmVu Y2UgaXMgcnVuIG9uCisgKiBAc2Vxbm86IGEgbGluZWFyIGluY3JlYXNpbmcgc2VxdWVuY2UgbnVt YmVyIGZvciB0aGlzIGNvbnRleHQKICAqCiAgKiBJbml0aWFsaXplcyBhbiBhbGxvY2F0ZWQgZmVu Y2UsIHRoZSBjYWxsZXIgZG9lc24ndCBoYXZlIHRvIGtlZXAgaXRzCiAgKiByZWZjb3VudCBhZnRl ciBjb21taXR0aW5nIHdpdGggdGhpcyBmZW5jZSwgYnV0IGl0IHdpbGwgbmVlZCB0byBob2xkIGEK LSAqIHJlZmNvdW50IGFnYWluIGlmIGRtYV9mZW5jZV9vcHMuZW5hYmxlX3NpZ25hbGluZyBnZXRz IGNhbGxlZC4gVGhpcyBjYW4KLSAqIGJlIHVzZWQgZm9yIG90aGVyIGltcGxlbWVudGluZyBvdGhl ciB0eXBlcyBvZiBmZW5jZS4KKyAqIHJlZmNvdW50IGFnYWluIGlmICZkbWFfZmVuY2Vfb3BzLmVu YWJsZV9zaWduYWxpbmcgZ2V0cyBjYWxsZWQuCiAgKgogICogY29udGV4dCBhbmQgc2Vxbm8gYXJl IHVzZWQgZm9yIGVhc3kgY29tcGFyaXNvbiBiZXR3ZWVuIGZlbmNlcywgYWxsb3dpbmcKLSAqIHRv IGNoZWNrIHdoaWNoIGZlbmNlIGlzIGxhdGVyIGJ5IHNpbXBseSB1c2luZyBkbWFfZmVuY2VfbGF0 ZXIuCisgKiB0byBjaGVjayB3aGljaCBmZW5jZSBpcyBsYXRlciBieSBzaW1wbHkgdXNpbmcgZG1h X2ZlbmNlX2xhdGVyKCkuCiAgKi8KIHZvaWQKIGRtYV9mZW5jZV9pbml0KHN0cnVjdCBkbWFfZmVu Y2UgKmZlbmNlLCBjb25zdCBzdHJ1Y3QgZG1hX2ZlbmNlX29wcyAqb3BzLAotLSAKMi4xNy4wCgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZngg bWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0 cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK