From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-wm0-f48.google.com ([74.125.82.48]:52312 "EHLO mail-wm0-f48.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751348AbeD0GRc (ORCPT ); Fri, 27 Apr 2018 02:17:32 -0400 Received: by mail-wm0-f48.google.com with SMTP id m70so381356wma.2 for ; Thu, 26 Apr 2018 23:17:31 -0700 (PDT) From: Daniel Vetter To: DRI Development Cc: Intel Graphics Development , Daniel Vetter , Sumit Semwal , linux-media@vger.kernel.org, linaro-mm-sig@lists.linaro.org Subject: [PATCH 01/17] dma-fence: Some kerneldoc polish for dma-fence.h Date: Fri, 27 Apr 2018 08:17:08 +0200 Message-Id: <20180427061724.28497-2-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: - Switch to inline member docs for dma_fence_ops. - Mild polish all around. - hyperlink all the things! v2: - Remove the various [in] annotations, they seem really uncommon in kerneldoc and look funny. Signed-off-by: Daniel Vetter Cc: Sumit Semwal Cc: linux-media@vger.kernel.org Cc: linaro-mm-sig@lists.linaro.org --- include/linux/dma-fence.h | 235 +++++++++++++++++++++++++------------- 1 file changed, 154 insertions(+), 81 deletions(-) diff --git a/include/linux/dma-fence.h b/include/linux/dma-fence.h index 4c008170fe65..9d6f39bf2111 100644 --- a/include/linux/dma-fence.h +++ b/include/linux/dma-fence.h @@ -94,11 +94,11 @@ typedef void (*dma_fence_func_t)(struct dma_fence *fence, struct dma_fence_cb *cb); /** - * struct dma_fence_cb - callback for dma_fence_add_callback - * @node: used by dma_fence_add_callback to append this struct to fence::cb_list + * struct dma_fence_cb - callback for dma_fence_add_callback() + * @node: used by dma_fence_add_callback() to append this struct to fence::cb_list * @func: dma_fence_func_t to call * - * This struct will be initialized by dma_fence_add_callback, additional + * This struct will be initialized by dma_fence_add_callback(), additional * data can be passed along by embedding dma_fence_cb in another struct. */ struct dma_fence_cb { @@ -108,75 +108,142 @@ struct dma_fence_cb { /** * struct dma_fence_ops - operations implemented for fence - * @get_driver_name: returns the driver name. - * @get_timeline_name: return the name of the context this fence belongs to. - * @enable_signaling: enable software signaling of fence. - * @signaled: [optional] peek whether the fence is signaled, can be null. - * @wait: custom wait implementation, or dma_fence_default_wait. - * @release: [optional] called on destruction of fence, can be null - * @fill_driver_data: [optional] callback to fill in free-form debug info - * Returns amount of bytes filled, or -errno. - * @fence_value_str: [optional] fills in the value of the fence as a string - * @timeline_value_str: [optional] fills in the current value of the timeline - * as a string * - * Notes on enable_signaling: - * For fence implementations that have the capability for hw->hw - * signaling, they can implement this op to enable the necessary - * irqs, or insert commands into cmdstream, etc. This is called - * in the first wait() or add_callback() path to let the fence - * implementation know that there is another driver waiting on - * the signal (ie. hw->sw case). - * - * This function can be called from atomic context, but not - * from irq context, so normal spinlocks can be used. - * - * A return value of false indicates the fence already passed, - * or some failure occurred that made it impossible to enable - * signaling. True indicates successful enabling. - * - * fence->error may be set in enable_signaling, but only when false is - * returned. - * - * Calling dma_fence_signal before enable_signaling is called allows - * for a tiny race window in which enable_signaling is called during, - * before, or after dma_fence_signal. To fight this, it is recommended - * that before enable_signaling returns true an extra reference is - * taken on the fence, to be released when the fence is signaled. - * This will mean dma_fence_signal will still be called twice, but - * the second time will be a noop since it was already signaled. - * - * Notes on signaled: - * May set fence->error if returning true. - * - * Notes on wait: - * Must not be NULL, set to dma_fence_default_wait for default implementation. - * the dma_fence_default_wait implementation should work for any fence, as long - * as enable_signaling works correctly. - * - * Must return -ERESTARTSYS if the wait is intr = true and the wait was - * interrupted, and remaining jiffies if fence has signaled, or 0 if wait - * timed out. Can also return other error values on custom implementations, - * which should be treated as if the fence is signaled. For example a hardware - * lockup could be reported like that. - * - * Notes on release: - * Can be NULL, this function allows additional commands to run on - * destruction of the fence. Can be called from irq context. - * If pointer is set to NULL, kfree will get called instead. */ - struct dma_fence_ops { + /** + * @get_driver_name: + * + * Returns the driver name. This is a callback to allow drivers to + * compute the name at runtime, without having it to store permanently + * for each fence, or build a cache of some sort. + * + * This callback is mandatory. + */ const char * (*get_driver_name)(struct dma_fence *fence); + + /** + * @get_timeline_name: + * + * Return the name of the context this fence belongs to. This is a + * callback to allow drivers to compute the name at runtime, without + * having it to store permanently for each fence, or build a cache of + * some sort. + * + * This callback is mandatory. + */ const char * (*get_timeline_name)(struct dma_fence *fence); + + /** + * @enable_signaling: + * + * Enable software signaling of fence. + * + * For fence implementations that have the capability for hw->hw + * signaling, they can implement this op to enable the necessary + * interrupts, or insert commands into cmdstream, etc, to avoid these + * costly operations for the common case where only hw->hw + * synchronization is required. This is called in the first + * dma_fence_wait() or dma_fence_add_callback() path to let the fence + * implementation know that there is another driver waiting on the + * signal (ie. hw->sw case). + * + * This function can be called from atomic context, but not + * from irq context, so normal spinlocks can be used. + * + * A return value of false indicates the fence already passed, + * or some failure occurred that made it impossible to enable + * signaling. True indicates successful enabling. + * + * &dma_fence.error may be set in enable_signaling, but only when false + * is returned. + * + * Since many implementations can call dma_fence_signal() even when before + * @enable_signaling has been called there's a race window, where the + * dma_fence_signal() might result in the final fence reference being + * released and its memory freed. To avoid this, implementations of this + * callback should grab their own reference using dma_fence_get(), to be + * released when the fence is signalled (through e.g. the interrupt + * handler). + * + * This callback is mandatory. + */ bool (*enable_signaling)(struct dma_fence *fence); + + /** + * @signaled: + * + * Peek whether the fence is signaled, as a fastpath optimization for + * e.g. dma_fence_wait() or dma_fence_add_callback(). Note that this + * callback does not need to make any guarantees beyond that a fence + * once indicates as signalled must always return true from this + * callback. This callback may return false even if the fence has + * completed already, in this case information hasn't propogated throug + * the system yet. See also dma_fence_is_signaled(). + * + * May set &dma_fence.error if returning true. + * + * This callback is optional. + */ bool (*signaled)(struct dma_fence *fence); + + /** + * @wait: + * + * Custom wait implementation, or dma_fence_default_wait. + * + * Must not be NULL, set to dma_fence_default_wait for default implementation. + * the dma_fence_default_wait implementation should work for any fence, as long + * as enable_signaling works correctly. + * + * Must return -ERESTARTSYS if the wait is intr = true and the wait was + * interrupted, and remaining jiffies if fence has signaled, or 0 if wait + * timed out. Can also return other error values on custom implementations, + * which should be treated as if the fence is signaled. For example a hardware + * lockup could be reported like that. + * + * This callback is mandatory. + */ signed long (*wait)(struct dma_fence *fence, bool intr, signed long timeout); + + /** + * @release: + * + * Called on destruction of fence to release additional resources. + * Can be called from irq context. This callback is optional. If it is + * NULL, then dma_fence_free() is instead called as the default + * implementation. + */ void (*release)(struct dma_fence *fence); + /** + * @fill_driver_data: + * + * Callback to fill in free-form debug info Returns amount of bytes + * filled, or negative error on failure. + * + * This callback is optional. + */ int (*fill_driver_data)(struct dma_fence *fence, void *data, int size); + + /** + * @fence_value_str: + * + * Callback to fill in free-form debug info specific to this fence, like + * the sequence number. + * + * This callback is optional. + */ void (*fence_value_str)(struct dma_fence *fence, char *str, int size); + + /** + * @timeline_value_str: + * + * Fills in the current value of the timeline as a string, like the + * sequence number. This should match what @fill_driver_data prints for + * the most recently signalled fence (assuming no delayed signalling). + */ void (*timeline_value_str)(struct dma_fence *fence, char *str, int size); }; @@ -189,7 +256,7 @@ void dma_fence_free(struct dma_fence *fence); /** * dma_fence_put - decreases refcount of the fence - * @fence: [in] fence to reduce refcount of + * @fence: fence to reduce refcount of */ static inline void dma_fence_put(struct dma_fence *fence) { @@ -199,7 +266,7 @@ static inline void dma_fence_put(struct dma_fence *fence) /** * dma_fence_get - increases refcount of the fence - * @fence: [in] fence to increase refcount of + * @fence: fence to increase refcount of * * Returns the same fence, with refcount increased by 1. */ @@ -213,7 +280,7 @@ static inline struct dma_fence *dma_fence_get(struct dma_fence *fence) /** * dma_fence_get_rcu - get a fence from a reservation_object_list with * rcu read lock - * @fence: [in] fence to increase refcount of + * @fence: fence to increase refcount of * * Function returns NULL if no refcount could be obtained, or the fence. */ @@ -227,7 +294,7 @@ static inline struct dma_fence *dma_fence_get_rcu(struct dma_fence *fence) /** * dma_fence_get_rcu_safe - acquire a reference to an RCU tracked fence - * @fencep: [in] pointer to fence to increase refcount of + * @fencep: pointer to fence to increase refcount of * * Function returns NULL if no refcount could be obtained, or the fence. * This function handles acquiring a reference to a fence that may be @@ -289,14 +356,16 @@ void dma_fence_enable_sw_signaling(struct dma_fence *fence); /** * dma_fence_is_signaled_locked - Return an indication if the fence * is signaled yet. - * @fence: [in] the fence to check + * @fence: the fence to check * * Returns true if the fence was already signaled, false if not. Since this * function doesn't enable signaling, it is not guaranteed to ever return - * true if dma_fence_add_callback, dma_fence_wait or - * dma_fence_enable_sw_signaling haven't been called before. + * true if dma_fence_add_callback(), dma_fence_wait() or + * dma_fence_enable_sw_signaling() haven't been called before. * - * This function requires fence->lock to be held. + * This function requires &dma_fence.lock to be held. + * + * See also dma_fence_is_signaled(). */ static inline bool dma_fence_is_signaled_locked(struct dma_fence *fence) @@ -314,17 +383,19 @@ dma_fence_is_signaled_locked(struct dma_fence *fence) /** * dma_fence_is_signaled - Return an indication if the fence is signaled yet. - * @fence: [in] the fence to check + * @fence: the fence to check * * Returns true if the fence was already signaled, false if not. Since this * function doesn't enable signaling, it is not guaranteed to ever return - * true if dma_fence_add_callback, dma_fence_wait or - * dma_fence_enable_sw_signaling haven't been called before. + * true if dma_fence_add_callback(), dma_fence_wait() or + * dma_fence_enable_sw_signaling() haven't been called before. * * It's recommended for seqno fences to call dma_fence_signal when the * operation is complete, it makes it possible to prevent issues from * wraparound between time of issue and time of use by checking the return * value of this function before calling hardware-specific wait instructions. + * + * See also dma_fence_is_signaled_locked(). */ static inline bool dma_fence_is_signaled(struct dma_fence *fence) @@ -342,8 +413,8 @@ dma_fence_is_signaled(struct dma_fence *fence) /** * __dma_fence_is_later - return if f1 is chronologically later than f2 - * @f1: [in] the first fence's seqno - * @f2: [in] the second fence's seqno from the same context + * @f1: the first fence's seqno + * @f2: the second fence's seqno from the same context * * Returns true if f1 is chronologically later than f2. Both fences must be * from the same context, since a seqno is not common across contexts. @@ -355,8 +426,8 @@ static inline bool __dma_fence_is_later(u32 f1, u32 f2) /** * dma_fence_is_later - return if f1 is chronologically later than f2 - * @f1: [in] the first fence from the same context - * @f2: [in] the second fence from the same context + * @f1: the first fence from the same context + * @f2: the second fence from the same context * * Returns true if f1 is chronologically later than f2. Both fences must be * from the same context, since a seqno is not re-used across contexts. @@ -372,8 +443,8 @@ static inline bool dma_fence_is_later(struct dma_fence *f1, /** * dma_fence_later - return the chronologically later fence - * @f1: [in] the first fence from the same context - * @f2: [in] the second fence from the same context + * @f1: the first fence from the same context + * @f2: the second fence from the same context * * Returns NULL if both fences are signaled, otherwise the fence that would be * signaled last. Both fences must be from the same context, since a seqno is @@ -398,7 +469,7 @@ static inline struct dma_fence *dma_fence_later(struct dma_fence *f1, /** * dma_fence_get_status_locked - returns the status upon completion - * @fence: [in] the dma_fence to query + * @fence: the dma_fence to query * * Drivers can supply an optional error status condition before they signal * the fence (to indicate whether the fence was completed due to an error @@ -422,8 +493,8 @@ int dma_fence_get_status(struct dma_fence *fence); /** * dma_fence_set_error - flag an error condition on the fence - * @fence: [in] the dma_fence - * @error: [in] the error to store + * @fence: the dma_fence + * @error: the error to store * * Drivers can supply an optional error status condition before they signal * the fence, to indicate that the fence was completed due to an error @@ -449,8 +520,8 @@ signed long dma_fence_wait_any_timeout(struct dma_fence **fences, /** * dma_fence_wait - sleep until the fence gets signaled - * @fence: [in] the fence to wait on - * @intr: [in] if true, do an interruptible wait + * @fence: the fence to wait on + * @intr: if true, do an interruptible wait * * This function will return -ERESTARTSYS if interrupted by a signal, * or 0 if the fence was signaled. Other error values may be @@ -459,6 +530,8 @@ signed long dma_fence_wait_any_timeout(struct dma_fence **fences, * Performs a synchronous wait on this fence. It is assumed the caller * directly or indirectly holds a reference to the fence, otherwise the * fence might be freed before return, resulting in undefined behavior. + * + * See also dma_fence_wait_timeout() and dma_fence_wait_any_timeout(). */ static inline signed long dma_fence_wait(struct dma_fence *fence, bool intr) { -- 2.17.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: [PATCH 01/17] dma-fence: Some kerneldoc polish for dma-fence.h Date: Fri, 27 Apr 2018 08:17:08 +0200 Message-ID: <20180427061724.28497-2-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: linaro-mm-sig@lists.linaro.org, Daniel Vetter , Intel Graphics Development , Sumit Semwal , linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org LSBTd2l0Y2ggdG8gaW5saW5lIG1lbWJlciBkb2NzIGZvciBkbWFfZmVuY2Vfb3BzLgotIE1pbGQg cG9saXNoIGFsbCBhcm91bmQuCi0gaHlwZXJsaW5rIGFsbCB0aGUgdGhpbmdzIQoKdjI6IC0gUmVt b3ZlIHRoZSB2YXJpb3VzIFtpbl0gYW5ub3RhdGlvbnMsIHRoZXkgc2VlbSByZWFsbHkgdW5jb21t b24KaW4ga2VybmVsZG9jIGFuZCBsb29rIGZ1bm55LgoKU2lnbmVkLW9mZi1ieTogRGFuaWVsIFZl dHRlciA8ZGFuaWVsLnZldHRlckBmZndsbC5jaD4KQ2M6IFN1bWl0IFNlbXdhbCA8c3VtaXQuc2Vt d2FsQGxpbmFyby5vcmc+CkNjOiBsaW51eC1tZWRpYUB2Z2VyLmtlcm5lbC5vcmcKQ2M6IGxpbmFy by1tbS1zaWdAbGlzdHMubGluYXJvLm9yZwotLS0KIGluY2x1ZGUvbGludXgvZG1hLWZlbmNlLmgg fCAyMzUgKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0KIDEgZmlsZSBjaGFu Z2VkLCAxNTQgaW5zZXJ0aW9ucygrKSwgODEgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvaW5j bHVkZS9saW51eC9kbWEtZmVuY2UuaCBiL2luY2x1ZGUvbGludXgvZG1hLWZlbmNlLmgKaW5kZXgg NGMwMDgxNzBmZTY1Li45ZDZmMzliZjIxMTEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZG1h LWZlbmNlLmgKKysrIGIvaW5jbHVkZS9saW51eC9kbWEtZmVuY2UuaApAQCAtOTQsMTEgKzk0LDEx IEBAIHR5cGVkZWYgdm9pZCAoKmRtYV9mZW5jZV9mdW5jX3QpKHN0cnVjdCBkbWFfZmVuY2UgKmZl bmNlLAogCQkJCSBzdHJ1Y3QgZG1hX2ZlbmNlX2NiICpjYik7CiAKIC8qKgotICogc3RydWN0IGRt YV9mZW5jZV9jYiAtIGNhbGxiYWNrIGZvciBkbWFfZmVuY2VfYWRkX2NhbGxiYWNrCi0gKiBAbm9k ZTogdXNlZCBieSBkbWFfZmVuY2VfYWRkX2NhbGxiYWNrIHRvIGFwcGVuZCB0aGlzIHN0cnVjdCB0 byBmZW5jZTo6Y2JfbGlzdAorICogc3RydWN0IGRtYV9mZW5jZV9jYiAtIGNhbGxiYWNrIGZvciBk bWFfZmVuY2VfYWRkX2NhbGxiYWNrKCkKKyAqIEBub2RlOiB1c2VkIGJ5IGRtYV9mZW5jZV9hZGRf Y2FsbGJhY2soKSB0byBhcHBlbmQgdGhpcyBzdHJ1Y3QgdG8gZmVuY2U6OmNiX2xpc3QKICAqIEBm dW5jOiBkbWFfZmVuY2VfZnVuY190IHRvIGNhbGwKICAqCi0gKiBUaGlzIHN0cnVjdCB3aWxsIGJl IGluaXRpYWxpemVkIGJ5IGRtYV9mZW5jZV9hZGRfY2FsbGJhY2ssIGFkZGl0aW9uYWwKKyAqIFRo aXMgc3RydWN0IHdpbGwgYmUgaW5pdGlhbGl6ZWQgYnkgZG1hX2ZlbmNlX2FkZF9jYWxsYmFjaygp LCBhZGRpdGlvbmFsCiAgKiBkYXRhIGNhbiBiZSBwYXNzZWQgYWxvbmcgYnkgZW1iZWRkaW5nIGRt YV9mZW5jZV9jYiBpbiBhbm90aGVyIHN0cnVjdC4KICAqLwogc3RydWN0IGRtYV9mZW5jZV9jYiB7 CkBAIC0xMDgsNzUgKzEwOCwxNDIgQEAgc3RydWN0IGRtYV9mZW5jZV9jYiB7CiAKIC8qKgogICog c3RydWN0IGRtYV9mZW5jZV9vcHMgLSBvcGVyYXRpb25zIGltcGxlbWVudGVkIGZvciBmZW5jZQot ICogQGdldF9kcml2ZXJfbmFtZTogcmV0dXJucyB0aGUgZHJpdmVyIG5hbWUuCi0gKiBAZ2V0X3Rp bWVsaW5lX25hbWU6IHJldHVybiB0aGUgbmFtZSBvZiB0aGUgY29udGV4dCB0aGlzIGZlbmNlIGJl bG9uZ3MgdG8uCi0gKiBAZW5hYmxlX3NpZ25hbGluZzogZW5hYmxlIHNvZnR3YXJlIHNpZ25hbGlu ZyBvZiBmZW5jZS4KLSAqIEBzaWduYWxlZDogW29wdGlvbmFsXSBwZWVrIHdoZXRoZXIgdGhlIGZl bmNlIGlzIHNpZ25hbGVkLCBjYW4gYmUgbnVsbC4KLSAqIEB3YWl0OiBjdXN0b20gd2FpdCBpbXBs ZW1lbnRhdGlvbiwgb3IgZG1hX2ZlbmNlX2RlZmF1bHRfd2FpdC4KLSAqIEByZWxlYXNlOiBbb3B0 aW9uYWxdIGNhbGxlZCBvbiBkZXN0cnVjdGlvbiBvZiBmZW5jZSwgY2FuIGJlIG51bGwKLSAqIEBm aWxsX2RyaXZlcl9kYXRhOiBbb3B0aW9uYWxdIGNhbGxiYWNrIHRvIGZpbGwgaW4gZnJlZS1mb3Jt IGRlYnVnIGluZm8KLSAqIFJldHVybnMgYW1vdW50IG9mIGJ5dGVzIGZpbGxlZCwgb3IgLWVycm5v LgotICogQGZlbmNlX3ZhbHVlX3N0cjogW29wdGlvbmFsXSBmaWxscyBpbiB0aGUgdmFsdWUgb2Yg dGhlIGZlbmNlIGFzIGEgc3RyaW5nCi0gKiBAdGltZWxpbmVfdmFsdWVfc3RyOiBbb3B0aW9uYWxd IGZpbGxzIGluIHRoZSBjdXJyZW50IHZhbHVlIG9mIHRoZSB0aW1lbGluZQotICogYXMgYSBzdHJp bmcKICAqCi0gKiBOb3RlcyBvbiBlbmFibGVfc2lnbmFsaW5nOgotICogRm9yIGZlbmNlIGltcGxl bWVudGF0aW9ucyB0aGF0IGhhdmUgdGhlIGNhcGFiaWxpdHkgZm9yIGh3LT5odwotICogc2lnbmFs aW5nLCB0aGV5IGNhbiBpbXBsZW1lbnQgdGhpcyBvcCB0byBlbmFibGUgdGhlIG5lY2Vzc2FyeQot ICogaXJxcywgb3IgaW5zZXJ0IGNvbW1hbmRzIGludG8gY21kc3RyZWFtLCBldGMuICBUaGlzIGlz IGNhbGxlZAotICogaW4gdGhlIGZpcnN0IHdhaXQoKSBvciBhZGRfY2FsbGJhY2soKSBwYXRoIHRv IGxldCB0aGUgZmVuY2UKLSAqIGltcGxlbWVudGF0aW9uIGtub3cgdGhhdCB0aGVyZSBpcyBhbm90 aGVyIGRyaXZlciB3YWl0aW5nIG9uCi0gKiB0aGUgc2lnbmFsIChpZS4gaHctPnN3IGNhc2UpLgot ICoKLSAqIFRoaXMgZnVuY3Rpb24gY2FuIGJlIGNhbGxlZCBmcm9tIGF0b21pYyBjb250ZXh0LCBi dXQgbm90Ci0gKiBmcm9tIGlycSBjb250ZXh0LCBzbyBub3JtYWwgc3BpbmxvY2tzIGNhbiBiZSB1 c2VkLgotICoKLSAqIEEgcmV0dXJuIHZhbHVlIG9mIGZhbHNlIGluZGljYXRlcyB0aGUgZmVuY2Ug YWxyZWFkeSBwYXNzZWQsCi0gKiBvciBzb21lIGZhaWx1cmUgb2NjdXJyZWQgdGhhdCBtYWRlIGl0 IGltcG9zc2libGUgdG8gZW5hYmxlCi0gKiBzaWduYWxpbmcuIFRydWUgaW5kaWNhdGVzIHN1Y2Nl c3NmdWwgZW5hYmxpbmcuCi0gKgotICogZmVuY2UtPmVycm9yIG1heSBiZSBzZXQgaW4gZW5hYmxl X3NpZ25hbGluZywgYnV0IG9ubHkgd2hlbiBmYWxzZSBpcwotICogcmV0dXJuZWQuCi0gKgotICog Q2FsbGluZyBkbWFfZmVuY2Vfc2lnbmFsIGJlZm9yZSBlbmFibGVfc2lnbmFsaW5nIGlzIGNhbGxl ZCBhbGxvd3MKLSAqIGZvciBhIHRpbnkgcmFjZSB3aW5kb3cgaW4gd2hpY2ggZW5hYmxlX3NpZ25h bGluZyBpcyBjYWxsZWQgZHVyaW5nLAotICogYmVmb3JlLCBvciBhZnRlciBkbWFfZmVuY2Vfc2ln bmFsLiBUbyBmaWdodCB0aGlzLCBpdCBpcyByZWNvbW1lbmRlZAotICogdGhhdCBiZWZvcmUgZW5h YmxlX3NpZ25hbGluZyByZXR1cm5zIHRydWUgYW4gZXh0cmEgcmVmZXJlbmNlIGlzCi0gKiB0YWtl biBvbiB0aGUgZmVuY2UsIHRvIGJlIHJlbGVhc2VkIHdoZW4gdGhlIGZlbmNlIGlzIHNpZ25hbGVk LgotICogVGhpcyB3aWxsIG1lYW4gZG1hX2ZlbmNlX3NpZ25hbCB3aWxsIHN0aWxsIGJlIGNhbGxl ZCB0d2ljZSwgYnV0Ci0gKiB0aGUgc2Vjb25kIHRpbWUgd2lsbCBiZSBhIG5vb3Agc2luY2UgaXQg d2FzIGFscmVhZHkgc2lnbmFsZWQuCi0gKgotICogTm90ZXMgb24gc2lnbmFsZWQ6Ci0gKiBNYXkg c2V0IGZlbmNlLT5lcnJvciBpZiByZXR1cm5pbmcgdHJ1ZS4KLSAqCi0gKiBOb3RlcyBvbiB3YWl0 OgotICogTXVzdCBub3QgYmUgTlVMTCwgc2V0IHRvIGRtYV9mZW5jZV9kZWZhdWx0X3dhaXQgZm9y IGRlZmF1bHQgaW1wbGVtZW50YXRpb24uCi0gKiB0aGUgZG1hX2ZlbmNlX2RlZmF1bHRfd2FpdCBp bXBsZW1lbnRhdGlvbiBzaG91bGQgd29yayBmb3IgYW55IGZlbmNlLCBhcyBsb25nCi0gKiBhcyBl bmFibGVfc2lnbmFsaW5nIHdvcmtzIGNvcnJlY3RseS4KLSAqCi0gKiBNdXN0IHJldHVybiAtRVJF U1RBUlRTWVMgaWYgdGhlIHdhaXQgaXMgaW50ciA9IHRydWUgYW5kIHRoZSB3YWl0IHdhcwotICog aW50ZXJydXB0ZWQsIGFuZCByZW1haW5pbmcgamlmZmllcyBpZiBmZW5jZSBoYXMgc2lnbmFsZWQs IG9yIDAgaWYgd2FpdAotICogdGltZWQgb3V0LiBDYW4gYWxzbyByZXR1cm4gb3RoZXIgZXJyb3Ig dmFsdWVzIG9uIGN1c3RvbSBpbXBsZW1lbnRhdGlvbnMsCi0gKiB3aGljaCBzaG91bGQgYmUgdHJl YXRlZCBhcyBpZiB0aGUgZmVuY2UgaXMgc2lnbmFsZWQuIEZvciBleGFtcGxlIGEgaGFyZHdhcmUK LSAqIGxvY2t1cCBjb3VsZCBiZSByZXBvcnRlZCBsaWtlIHRoYXQuCi0gKgotICogTm90ZXMgb24g cmVsZWFzZToKLSAqIENhbiBiZSBOVUxMLCB0aGlzIGZ1bmN0aW9uIGFsbG93cyBhZGRpdGlvbmFs IGNvbW1hbmRzIHRvIHJ1biBvbgotICogZGVzdHJ1Y3Rpb24gb2YgdGhlIGZlbmNlLiBDYW4gYmUg Y2FsbGVkIGZyb20gaXJxIGNvbnRleHQuCi0gKiBJZiBwb2ludGVyIGlzIHNldCB0byBOVUxMLCBr ZnJlZSB3aWxsIGdldCBjYWxsZWQgaW5zdGVhZC4KICAqLwotCiBzdHJ1Y3QgZG1hX2ZlbmNlX29w cyB7CisJLyoqCisJICogQGdldF9kcml2ZXJfbmFtZToKKwkgKgorCSAqIFJldHVybnMgdGhlIGRy aXZlciBuYW1lLiBUaGlzIGlzIGEgY2FsbGJhY2sgdG8gYWxsb3cgZHJpdmVycyB0bworCSAqIGNv bXB1dGUgdGhlIG5hbWUgYXQgcnVudGltZSwgd2l0aG91dCBoYXZpbmcgaXQgdG8gc3RvcmUgcGVy bWFuZW50bHkKKwkgKiBmb3IgZWFjaCBmZW5jZSwgb3IgYnVpbGQgYSBjYWNoZSBvZiBzb21lIHNv cnQuCisJICoKKwkgKiBUaGlzIGNhbGxiYWNrIGlzIG1hbmRhdG9yeS4KKwkgKi8KIAljb25zdCBj aGFyICogKCpnZXRfZHJpdmVyX25hbWUpKHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlKTsKKworCS8q KgorCSAqIEBnZXRfdGltZWxpbmVfbmFtZToKKwkgKgorCSAqIFJldHVybiB0aGUgbmFtZSBvZiB0 aGUgY29udGV4dCB0aGlzIGZlbmNlIGJlbG9uZ3MgdG8uIFRoaXMgaXMgYQorCSAqIGNhbGxiYWNr IHRvIGFsbG93IGRyaXZlcnMgdG8gY29tcHV0ZSB0aGUgbmFtZSBhdCBydW50aW1lLCB3aXRob3V0 CisJICogaGF2aW5nIGl0IHRvIHN0b3JlIHBlcm1hbmVudGx5IGZvciBlYWNoIGZlbmNlLCBvciBi dWlsZCBhIGNhY2hlIG9mCisJICogc29tZSBzb3J0LgorCSAqCisJICogVGhpcyBjYWxsYmFjayBp cyBtYW5kYXRvcnkuCisJICovCiAJY29uc3QgY2hhciAqICgqZ2V0X3RpbWVsaW5lX25hbWUpKHN0 cnVjdCBkbWFfZmVuY2UgKmZlbmNlKTsKKworCS8qKgorCSAqIEBlbmFibGVfc2lnbmFsaW5nOgor CSAqCisJICogRW5hYmxlIHNvZnR3YXJlIHNpZ25hbGluZyBvZiBmZW5jZS4KKwkgKgorCSAqIEZv ciBmZW5jZSBpbXBsZW1lbnRhdGlvbnMgdGhhdCBoYXZlIHRoZSBjYXBhYmlsaXR5IGZvciBody0+ aHcKKwkgKiBzaWduYWxpbmcsIHRoZXkgY2FuIGltcGxlbWVudCB0aGlzIG9wIHRvIGVuYWJsZSB0 aGUgbmVjZXNzYXJ5CisJICogaW50ZXJydXB0cywgb3IgaW5zZXJ0IGNvbW1hbmRzIGludG8gY21k c3RyZWFtLCBldGMsIHRvIGF2b2lkIHRoZXNlCisJICogY29zdGx5IG9wZXJhdGlvbnMgZm9yIHRo ZSBjb21tb24gY2FzZSB3aGVyZSBvbmx5IGh3LT5odworCSAqIHN5bmNocm9uaXphdGlvbiBpcyBy ZXF1aXJlZC4gIFRoaXMgaXMgY2FsbGVkIGluIHRoZSBmaXJzdAorCSAqIGRtYV9mZW5jZV93YWl0 KCkgb3IgZG1hX2ZlbmNlX2FkZF9jYWxsYmFjaygpIHBhdGggdG8gbGV0IHRoZSBmZW5jZQorCSAq IGltcGxlbWVudGF0aW9uIGtub3cgdGhhdCB0aGVyZSBpcyBhbm90aGVyIGRyaXZlciB3YWl0aW5n IG9uIHRoZQorCSAqIHNpZ25hbCAoaWUuIGh3LT5zdyBjYXNlKS4KKwkgKgorCSAqIFRoaXMgZnVu Y3Rpb24gY2FuIGJlIGNhbGxlZCBmcm9tIGF0b21pYyBjb250ZXh0LCBidXQgbm90CisJICogZnJv bSBpcnEgY29udGV4dCwgc28gbm9ybWFsIHNwaW5sb2NrcyBjYW4gYmUgdXNlZC4KKwkgKgorCSAq IEEgcmV0dXJuIHZhbHVlIG9mIGZhbHNlIGluZGljYXRlcyB0aGUgZmVuY2UgYWxyZWFkeSBwYXNz ZWQsCisJICogb3Igc29tZSBmYWlsdXJlIG9jY3VycmVkIHRoYXQgbWFkZSBpdCBpbXBvc3NpYmxl IHRvIGVuYWJsZQorCSAqIHNpZ25hbGluZy4gVHJ1ZSBpbmRpY2F0ZXMgc3VjY2Vzc2Z1bCBlbmFi bGluZy4KKwkgKgorCSAqICZkbWFfZmVuY2UuZXJyb3IgbWF5IGJlIHNldCBpbiBlbmFibGVfc2ln bmFsaW5nLCBidXQgb25seSB3aGVuIGZhbHNlCisJICogaXMgcmV0dXJuZWQuCisJICoKKwkgKiBT aW5jZSBtYW55IGltcGxlbWVudGF0aW9ucyBjYW4gY2FsbCBkbWFfZmVuY2Vfc2lnbmFsKCkgZXZl biB3aGVuIGJlZm9yZQorCSAqIEBlbmFibGVfc2lnbmFsaW5nIGhhcyBiZWVuIGNhbGxlZCB0aGVy ZSdzIGEgcmFjZSB3aW5kb3csIHdoZXJlIHRoZQorCSAqIGRtYV9mZW5jZV9zaWduYWwoKSBtaWdo dCByZXN1bHQgaW4gdGhlIGZpbmFsIGZlbmNlIHJlZmVyZW5jZSBiZWluZworCSAqIHJlbGVhc2Vk IGFuZCBpdHMgbWVtb3J5IGZyZWVkLiBUbyBhdm9pZCB0aGlzLCBpbXBsZW1lbnRhdGlvbnMgb2Yg dGhpcworCSAqIGNhbGxiYWNrIHNob3VsZCBncmFiIHRoZWlyIG93biByZWZlcmVuY2UgdXNpbmcg ZG1hX2ZlbmNlX2dldCgpLCB0byBiZQorCSAqIHJlbGVhc2VkIHdoZW4gdGhlIGZlbmNlIGlzIHNp Z25hbGxlZCAodGhyb3VnaCBlLmcuIHRoZSBpbnRlcnJ1cHQKKwkgKiBoYW5kbGVyKS4KKwkgKgor CSAqIFRoaXMgY2FsbGJhY2sgaXMgbWFuZGF0b3J5LgorCSAqLwogCWJvb2wgKCplbmFibGVfc2ln bmFsaW5nKShzdHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSk7CisKKwkvKioKKwkgKiBAc2lnbmFsZWQ6 CisJICoKKwkgKiBQZWVrIHdoZXRoZXIgdGhlIGZlbmNlIGlzIHNpZ25hbGVkLCBhcyBhIGZhc3Rw YXRoIG9wdGltaXphdGlvbiBmb3IKKwkgKiBlLmcuIGRtYV9mZW5jZV93YWl0KCkgb3IgZG1hX2Zl bmNlX2FkZF9jYWxsYmFjaygpLiBOb3RlIHRoYXQgdGhpcworCSAqIGNhbGxiYWNrIGRvZXMgbm90 IG5lZWQgdG8gbWFrZSBhbnkgZ3VhcmFudGVlcyBiZXlvbmQgdGhhdCBhIGZlbmNlCisJICogb25j ZSBpbmRpY2F0ZXMgYXMgc2lnbmFsbGVkIG11c3QgYWx3YXlzIHJldHVybiB0cnVlIGZyb20gdGhp cworCSAqIGNhbGxiYWNrLiBUaGlzIGNhbGxiYWNrIG1heSByZXR1cm4gZmFsc2UgZXZlbiBpZiB0 aGUgZmVuY2UgaGFzCisJICogY29tcGxldGVkIGFscmVhZHksIGluIHRoaXMgY2FzZSBpbmZvcm1h dGlvbiBoYXNuJ3QgcHJvcG9nYXRlZCB0aHJvdWcKKwkgKiB0aGUgc3lzdGVtIHlldC4gU2VlIGFs c28gZG1hX2ZlbmNlX2lzX3NpZ25hbGVkKCkuCisJICoKKwkgKiBNYXkgc2V0ICZkbWFfZmVuY2Uu ZXJyb3IgaWYgcmV0dXJuaW5nIHRydWUuCisJICoKKwkgKiBUaGlzIGNhbGxiYWNrIGlzIG9wdGlv bmFsLgorCSAqLwogCWJvb2wgKCpzaWduYWxlZCkoc3RydWN0IGRtYV9mZW5jZSAqZmVuY2UpOwor CisJLyoqCisJICogQHdhaXQ6CisJICoKKwkgKiBDdXN0b20gd2FpdCBpbXBsZW1lbnRhdGlvbiwg b3IgZG1hX2ZlbmNlX2RlZmF1bHRfd2FpdC4KKwkgKgorCSAqIE11c3Qgbm90IGJlIE5VTEwsIHNl dCB0byBkbWFfZmVuY2VfZGVmYXVsdF93YWl0IGZvciBkZWZhdWx0IGltcGxlbWVudGF0aW9uLgor CSAqIHRoZSBkbWFfZmVuY2VfZGVmYXVsdF93YWl0IGltcGxlbWVudGF0aW9uIHNob3VsZCB3b3Jr IGZvciBhbnkgZmVuY2UsIGFzIGxvbmcKKwkgKiBhcyBlbmFibGVfc2lnbmFsaW5nIHdvcmtzIGNv cnJlY3RseS4KKwkgKgorCSAqIE11c3QgcmV0dXJuIC1FUkVTVEFSVFNZUyBpZiB0aGUgd2FpdCBp cyBpbnRyID0gdHJ1ZSBhbmQgdGhlIHdhaXQgd2FzCisJICogaW50ZXJydXB0ZWQsIGFuZCByZW1h aW5pbmcgamlmZmllcyBpZiBmZW5jZSBoYXMgc2lnbmFsZWQsIG9yIDAgaWYgd2FpdAorCSAqIHRp bWVkIG91dC4gQ2FuIGFsc28gcmV0dXJuIG90aGVyIGVycm9yIHZhbHVlcyBvbiBjdXN0b20gaW1w bGVtZW50YXRpb25zLAorCSAqIHdoaWNoIHNob3VsZCBiZSB0cmVhdGVkIGFzIGlmIHRoZSBmZW5j ZSBpcyBzaWduYWxlZC4gRm9yIGV4YW1wbGUgYSBoYXJkd2FyZQorCSAqIGxvY2t1cCBjb3VsZCBi ZSByZXBvcnRlZCBsaWtlIHRoYXQuCisJICoKKwkgKiBUaGlzIGNhbGxiYWNrIGlzIG1hbmRhdG9y eS4KKwkgKi8KIAlzaWduZWQgbG9uZyAoKndhaXQpKHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlLAog CQkJICAgIGJvb2wgaW50ciwgc2lnbmVkIGxvbmcgdGltZW91dCk7CisKKwkvKioKKwkgKiBAcmVs ZWFzZToKKwkgKgorCSAqIENhbGxlZCBvbiBkZXN0cnVjdGlvbiBvZiBmZW5jZSB0byByZWxlYXNl IGFkZGl0aW9uYWwgcmVzb3VyY2VzLgorCSAqIENhbiBiZSBjYWxsZWQgZnJvbSBpcnEgY29udGV4 dC4gIFRoaXMgY2FsbGJhY2sgaXMgb3B0aW9uYWwuIElmIGl0IGlzCisJICogTlVMTCwgdGhlbiBk bWFfZmVuY2VfZnJlZSgpIGlzIGluc3RlYWQgY2FsbGVkIGFzIHRoZSBkZWZhdWx0CisJICogaW1w bGVtZW50YXRpb24uCisJICovCiAJdm9pZCAoKnJlbGVhc2UpKHN0cnVjdCBkbWFfZmVuY2UgKmZl bmNlKTsKIAorCS8qKgorCSAqIEBmaWxsX2RyaXZlcl9kYXRhOgorCSAqCisJICogQ2FsbGJhY2sg dG8gZmlsbCBpbiBmcmVlLWZvcm0gZGVidWcgaW5mbyBSZXR1cm5zIGFtb3VudCBvZiBieXRlcwor CSAqIGZpbGxlZCwgb3IgbmVnYXRpdmUgZXJyb3Igb24gZmFpbHVyZS4KKwkgKgorCSAqIFRoaXMg Y2FsbGJhY2sgaXMgb3B0aW9uYWwuCisJICovCiAJaW50ICgqZmlsbF9kcml2ZXJfZGF0YSkoc3Ry dWN0IGRtYV9mZW5jZSAqZmVuY2UsIHZvaWQgKmRhdGEsIGludCBzaXplKTsKKworCS8qKgorCSAq IEBmZW5jZV92YWx1ZV9zdHI6CisJICoKKwkgKiBDYWxsYmFjayB0byBmaWxsIGluIGZyZWUtZm9y bSBkZWJ1ZyBpbmZvIHNwZWNpZmljIHRvIHRoaXMgZmVuY2UsIGxpa2UKKwkgKiB0aGUgc2VxdWVu Y2UgbnVtYmVyLgorCSAqCisJICogVGhpcyBjYWxsYmFjayBpcyBvcHRpb25hbC4KKwkgKi8KIAl2 b2lkICgqZmVuY2VfdmFsdWVfc3RyKShzdHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSwgY2hhciAqc3Ry LCBpbnQgc2l6ZSk7CisKKwkvKioKKwkgKiBAdGltZWxpbmVfdmFsdWVfc3RyOgorCSAqCisJICog RmlsbHMgaW4gdGhlIGN1cnJlbnQgdmFsdWUgb2YgdGhlIHRpbWVsaW5lIGFzIGEgc3RyaW5nLCBs aWtlIHRoZQorCSAqIHNlcXVlbmNlIG51bWJlci4gVGhpcyBzaG91bGQgbWF0Y2ggd2hhdCBAZmls bF9kcml2ZXJfZGF0YSBwcmludHMgZm9yCisJICogdGhlIG1vc3QgcmVjZW50bHkgc2lnbmFsbGVk IGZlbmNlIChhc3N1bWluZyBubyBkZWxheWVkIHNpZ25hbGxpbmcpLgorCSAqLwogCXZvaWQgKCp0 aW1lbGluZV92YWx1ZV9zdHIpKHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlLAogCQkJCSAgIGNoYXIg KnN0ciwgaW50IHNpemUpOwogfTsKQEAgLTE4OSw3ICsyNTYsNyBAQCB2b2lkIGRtYV9mZW5jZV9m cmVlKHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlKTsKIAogLyoqCiAgKiBkbWFfZmVuY2VfcHV0IC0g ZGVjcmVhc2VzIHJlZmNvdW50IG9mIHRoZSBmZW5jZQotICogQGZlbmNlOglbaW5dCWZlbmNlIHRv IHJlZHVjZSByZWZjb3VudCBvZgorICogQGZlbmNlOiBmZW5jZSB0byByZWR1Y2UgcmVmY291bnQg b2YKICAqLwogc3RhdGljIGlubGluZSB2b2lkIGRtYV9mZW5jZV9wdXQoc3RydWN0IGRtYV9mZW5j ZSAqZmVuY2UpCiB7CkBAIC0xOTksNyArMjY2LDcgQEAgc3RhdGljIGlubGluZSB2b2lkIGRtYV9m ZW5jZV9wdXQoc3RydWN0IGRtYV9mZW5jZSAqZmVuY2UpCiAKIC8qKgogICogZG1hX2ZlbmNlX2dl dCAtIGluY3JlYXNlcyByZWZjb3VudCBvZiB0aGUgZmVuY2UKLSAqIEBmZW5jZToJW2luXQlmZW5j ZSB0byBpbmNyZWFzZSByZWZjb3VudCBvZgorICogQGZlbmNlOiBmZW5jZSB0byBpbmNyZWFzZSBy ZWZjb3VudCBvZgogICoKICAqIFJldHVybnMgdGhlIHNhbWUgZmVuY2UsIHdpdGggcmVmY291bnQg aW5jcmVhc2VkIGJ5IDEuCiAgKi8KQEAgLTIxMyw3ICsyODAsNyBAQCBzdGF0aWMgaW5saW5lIHN0 cnVjdCBkbWFfZmVuY2UgKmRtYV9mZW5jZV9nZXQoc3RydWN0IGRtYV9mZW5jZSAqZmVuY2UpCiAv KioKICAqIGRtYV9mZW5jZV9nZXRfcmN1IC0gZ2V0IGEgZmVuY2UgZnJvbSBhIHJlc2VydmF0aW9u X29iamVjdF9saXN0IHdpdGgKICAqICAgICAgICAgICAgICAgICAgICAgcmN1IHJlYWQgbG9jawot ICogQGZlbmNlOglbaW5dCWZlbmNlIHRvIGluY3JlYXNlIHJlZmNvdW50IG9mCisgKiBAZmVuY2U6 IGZlbmNlIHRvIGluY3JlYXNlIHJlZmNvdW50IG9mCiAgKgogICogRnVuY3Rpb24gcmV0dXJucyBO VUxMIGlmIG5vIHJlZmNvdW50IGNvdWxkIGJlIG9idGFpbmVkLCBvciB0aGUgZmVuY2UuCiAgKi8K QEAgLTIyNyw3ICsyOTQsNyBAQCBzdGF0aWMgaW5saW5lIHN0cnVjdCBkbWFfZmVuY2UgKmRtYV9m ZW5jZV9nZXRfcmN1KHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlKQogCiAvKioKICAqIGRtYV9mZW5j ZV9nZXRfcmN1X3NhZmUgIC0gYWNxdWlyZSBhIHJlZmVyZW5jZSB0byBhbiBSQ1UgdHJhY2tlZCBm ZW5jZQotICogQGZlbmNlcDoJW2luXQlwb2ludGVyIHRvIGZlbmNlIHRvIGluY3JlYXNlIHJlZmNv dW50IG9mCisgKiBAZmVuY2VwOiBwb2ludGVyIHRvIGZlbmNlIHRvIGluY3JlYXNlIHJlZmNvdW50 IG9mCiAgKgogICogRnVuY3Rpb24gcmV0dXJucyBOVUxMIGlmIG5vIHJlZmNvdW50IGNvdWxkIGJl IG9idGFpbmVkLCBvciB0aGUgZmVuY2UuCiAgKiBUaGlzIGZ1bmN0aW9uIGhhbmRsZXMgYWNxdWly aW5nIGEgcmVmZXJlbmNlIHRvIGEgZmVuY2UgdGhhdCBtYXkgYmUKQEAgLTI4OSwxNCArMzU2LDE2 IEBAIHZvaWQgZG1hX2ZlbmNlX2VuYWJsZV9zd19zaWduYWxpbmcoc3RydWN0IGRtYV9mZW5jZSAq ZmVuY2UpOwogLyoqCiAgKiBkbWFfZmVuY2VfaXNfc2lnbmFsZWRfbG9ja2VkIC0gUmV0dXJuIGFu IGluZGljYXRpb24gaWYgdGhlIGZlbmNlCiAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgaXMgc2lnbmFsZWQgeWV0LgotICogQGZlbmNlOglbaW5dCXRoZSBmZW5jZSB0byBjaGVjawor ICogQGZlbmNlOiB0aGUgZmVuY2UgdG8gY2hlY2sKICAqCiAgKiBSZXR1cm5zIHRydWUgaWYgdGhl IGZlbmNlIHdhcyBhbHJlYWR5IHNpZ25hbGVkLCBmYWxzZSBpZiBub3QuIFNpbmNlIHRoaXMKICAq IGZ1bmN0aW9uIGRvZXNuJ3QgZW5hYmxlIHNpZ25hbGluZywgaXQgaXMgbm90IGd1YXJhbnRlZWQg dG8gZXZlciByZXR1cm4KLSAqIHRydWUgaWYgZG1hX2ZlbmNlX2FkZF9jYWxsYmFjaywgZG1hX2Zl bmNlX3dhaXQgb3IKLSAqIGRtYV9mZW5jZV9lbmFibGVfc3dfc2lnbmFsaW5nIGhhdmVuJ3QgYmVl biBjYWxsZWQgYmVmb3JlLgorICogdHJ1ZSBpZiBkbWFfZmVuY2VfYWRkX2NhbGxiYWNrKCksIGRt YV9mZW5jZV93YWl0KCkgb3IKKyAqIGRtYV9mZW5jZV9lbmFibGVfc3dfc2lnbmFsaW5nKCkgaGF2 ZW4ndCBiZWVuIGNhbGxlZCBiZWZvcmUuCiAgKgotICogVGhpcyBmdW5jdGlvbiByZXF1aXJlcyBm ZW5jZS0+bG9jayB0byBiZSBoZWxkLgorICogVGhpcyBmdW5jdGlvbiByZXF1aXJlcyAmZG1hX2Zl bmNlLmxvY2sgdG8gYmUgaGVsZC4KKyAqCisgKiBTZWUgYWxzbyBkbWFfZmVuY2VfaXNfc2lnbmFs ZWQoKS4KICAqLwogc3RhdGljIGlubGluZSBib29sCiBkbWFfZmVuY2VfaXNfc2lnbmFsZWRfbG9j a2VkKHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlKQpAQCAtMzE0LDE3ICszODMsMTkgQEAgZG1hX2Zl bmNlX2lzX3NpZ25hbGVkX2xvY2tlZChzdHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSkKIAogLyoqCiAg KiBkbWFfZmVuY2VfaXNfc2lnbmFsZWQgLSBSZXR1cm4gYW4gaW5kaWNhdGlvbiBpZiB0aGUgZmVu Y2UgaXMgc2lnbmFsZWQgeWV0LgotICogQGZlbmNlOglbaW5dCXRoZSBmZW5jZSB0byBjaGVjawor ICogQGZlbmNlOiB0aGUgZmVuY2UgdG8gY2hlY2sKICAqCiAgKiBSZXR1cm5zIHRydWUgaWYgdGhl IGZlbmNlIHdhcyBhbHJlYWR5IHNpZ25hbGVkLCBmYWxzZSBpZiBub3QuIFNpbmNlIHRoaXMKICAq IGZ1bmN0aW9uIGRvZXNuJ3QgZW5hYmxlIHNpZ25hbGluZywgaXQgaXMgbm90IGd1YXJhbnRlZWQg dG8gZXZlciByZXR1cm4KLSAqIHRydWUgaWYgZG1hX2ZlbmNlX2FkZF9jYWxsYmFjaywgZG1hX2Zl bmNlX3dhaXQgb3IKLSAqIGRtYV9mZW5jZV9lbmFibGVfc3dfc2lnbmFsaW5nIGhhdmVuJ3QgYmVl biBjYWxsZWQgYmVmb3JlLgorICogdHJ1ZSBpZiBkbWFfZmVuY2VfYWRkX2NhbGxiYWNrKCksIGRt YV9mZW5jZV93YWl0KCkgb3IKKyAqIGRtYV9mZW5jZV9lbmFibGVfc3dfc2lnbmFsaW5nKCkgaGF2 ZW4ndCBiZWVuIGNhbGxlZCBiZWZvcmUuCiAgKgogICogSXQncyByZWNvbW1lbmRlZCBmb3Igc2Vx bm8gZmVuY2VzIHRvIGNhbGwgZG1hX2ZlbmNlX3NpZ25hbCB3aGVuIHRoZQogICogb3BlcmF0aW9u IGlzIGNvbXBsZXRlLCBpdCBtYWtlcyBpdCBwb3NzaWJsZSB0byBwcmV2ZW50IGlzc3VlcyBmcm9t CiAgKiB3cmFwYXJvdW5kIGJldHdlZW4gdGltZSBvZiBpc3N1ZSBhbmQgdGltZSBvZiB1c2UgYnkg Y2hlY2tpbmcgdGhlIHJldHVybgogICogdmFsdWUgb2YgdGhpcyBmdW5jdGlvbiBiZWZvcmUgY2Fs bGluZyBoYXJkd2FyZS1zcGVjaWZpYyB3YWl0IGluc3RydWN0aW9ucy4KKyAqCisgKiBTZWUgYWxz byBkbWFfZmVuY2VfaXNfc2lnbmFsZWRfbG9ja2VkKCkuCiAgKi8KIHN0YXRpYyBpbmxpbmUgYm9v bAogZG1hX2ZlbmNlX2lzX3NpZ25hbGVkKHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlKQpAQCAtMzQy LDggKzQxMyw4IEBAIGRtYV9mZW5jZV9pc19zaWduYWxlZChzdHJ1Y3QgZG1hX2ZlbmNlICpmZW5j ZSkKIAogLyoqCiAgKiBfX2RtYV9mZW5jZV9pc19sYXRlciAtIHJldHVybiBpZiBmMSBpcyBjaHJv bm9sb2dpY2FsbHkgbGF0ZXIgdGhhbiBmMgotICogQGYxOglbaW5dCXRoZSBmaXJzdCBmZW5jZSdz IHNlcW5vCi0gKiBAZjI6CVtpbl0JdGhlIHNlY29uZCBmZW5jZSdzIHNlcW5vIGZyb20gdGhlIHNh bWUgY29udGV4dAorICogQGYxOiB0aGUgZmlyc3QgZmVuY2UncyBzZXFubworICogQGYyOiB0aGUg c2Vjb25kIGZlbmNlJ3Mgc2Vxbm8gZnJvbSB0aGUgc2FtZSBjb250ZXh0CiAgKgogICogUmV0dXJu cyB0cnVlIGlmIGYxIGlzIGNocm9ub2xvZ2ljYWxseSBsYXRlciB0aGFuIGYyLiBCb3RoIGZlbmNl cyBtdXN0IGJlCiAgKiBmcm9tIHRoZSBzYW1lIGNvbnRleHQsIHNpbmNlIGEgc2Vxbm8gaXMgbm90 IGNvbW1vbiBhY3Jvc3MgY29udGV4dHMuCkBAIC0zNTUsOCArNDI2LDggQEAgc3RhdGljIGlubGlu ZSBib29sIF9fZG1hX2ZlbmNlX2lzX2xhdGVyKHUzMiBmMSwgdTMyIGYyKQogCiAvKioKICAqIGRt YV9mZW5jZV9pc19sYXRlciAtIHJldHVybiBpZiBmMSBpcyBjaHJvbm9sb2dpY2FsbHkgbGF0ZXIg dGhhbiBmMgotICogQGYxOglbaW5dCXRoZSBmaXJzdCBmZW5jZSBmcm9tIHRoZSBzYW1lIGNvbnRl eHQKLSAqIEBmMjoJW2luXQl0aGUgc2Vjb25kIGZlbmNlIGZyb20gdGhlIHNhbWUgY29udGV4dAor ICogQGYxOiB0aGUgZmlyc3QgZmVuY2UgZnJvbSB0aGUgc2FtZSBjb250ZXh0CisgKiBAZjI6IHRo ZSBzZWNvbmQgZmVuY2UgZnJvbSB0aGUgc2FtZSBjb250ZXh0CiAgKgogICogUmV0dXJucyB0cnVl IGlmIGYxIGlzIGNocm9ub2xvZ2ljYWxseSBsYXRlciB0aGFuIGYyLiBCb3RoIGZlbmNlcyBtdXN0 IGJlCiAgKiBmcm9tIHRoZSBzYW1lIGNvbnRleHQsIHNpbmNlIGEgc2Vxbm8gaXMgbm90IHJlLXVz ZWQgYWNyb3NzIGNvbnRleHRzLgpAQCAtMzcyLDggKzQ0Myw4IEBAIHN0YXRpYyBpbmxpbmUgYm9v bCBkbWFfZmVuY2VfaXNfbGF0ZXIoc3RydWN0IGRtYV9mZW5jZSAqZjEsCiAKIC8qKgogICogZG1h X2ZlbmNlX2xhdGVyIC0gcmV0dXJuIHRoZSBjaHJvbm9sb2dpY2FsbHkgbGF0ZXIgZmVuY2UKLSAq IEBmMToJW2luXQl0aGUgZmlyc3QgZmVuY2UgZnJvbSB0aGUgc2FtZSBjb250ZXh0Ci0gKiBAZjI6 CVtpbl0JdGhlIHNlY29uZCBmZW5jZSBmcm9tIHRoZSBzYW1lIGNvbnRleHQKKyAqIEBmMToJdGhl IGZpcnN0IGZlbmNlIGZyb20gdGhlIHNhbWUgY29udGV4dAorICogQGYyOgl0aGUgc2Vjb25kIGZl bmNlIGZyb20gdGhlIHNhbWUgY29udGV4dAogICoKICAqIFJldHVybnMgTlVMTCBpZiBib3RoIGZl bmNlcyBhcmUgc2lnbmFsZWQsIG90aGVyd2lzZSB0aGUgZmVuY2UgdGhhdCB3b3VsZCBiZQogICog c2lnbmFsZWQgbGFzdC4gQm90aCBmZW5jZXMgbXVzdCBiZSBmcm9tIHRoZSBzYW1lIGNvbnRleHQs IHNpbmNlIGEgc2Vxbm8gaXMKQEAgLTM5OCw3ICs0NjksNyBAQCBzdGF0aWMgaW5saW5lIHN0cnVj dCBkbWFfZmVuY2UgKmRtYV9mZW5jZV9sYXRlcihzdHJ1Y3QgZG1hX2ZlbmNlICpmMSwKIAogLyoq CiAgKiBkbWFfZmVuY2VfZ2V0X3N0YXR1c19sb2NrZWQgLSByZXR1cm5zIHRoZSBzdGF0dXMgdXBv biBjb21wbGV0aW9uCi0gKiBAZmVuY2U6IFtpbl0JdGhlIGRtYV9mZW5jZSB0byBxdWVyeQorICog QGZlbmNlOiB0aGUgZG1hX2ZlbmNlIHRvIHF1ZXJ5CiAgKgogICogRHJpdmVycyBjYW4gc3VwcGx5 IGFuIG9wdGlvbmFsIGVycm9yIHN0YXR1cyBjb25kaXRpb24gYmVmb3JlIHRoZXkgc2lnbmFsCiAg KiB0aGUgZmVuY2UgKHRvIGluZGljYXRlIHdoZXRoZXIgdGhlIGZlbmNlIHdhcyBjb21wbGV0ZWQg ZHVlIHRvIGFuIGVycm9yCkBAIC00MjIsOCArNDkzLDggQEAgaW50IGRtYV9mZW5jZV9nZXRfc3Rh dHVzKHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlKTsKIAogLyoqCiAgKiBkbWFfZmVuY2Vfc2V0X2Vy cm9yIC0gZmxhZyBhbiBlcnJvciBjb25kaXRpb24gb24gdGhlIGZlbmNlCi0gKiBAZmVuY2U6IFtp bl0JdGhlIGRtYV9mZW5jZQotICogQGVycm9yOiBbaW5dCXRoZSBlcnJvciB0byBzdG9yZQorICog QGZlbmNlOiB0aGUgZG1hX2ZlbmNlCisgKiBAZXJyb3I6IHRoZSBlcnJvciB0byBzdG9yZQogICoK ICAqIERyaXZlcnMgY2FuIHN1cHBseSBhbiBvcHRpb25hbCBlcnJvciBzdGF0dXMgY29uZGl0aW9u IGJlZm9yZSB0aGV5IHNpZ25hbAogICogdGhlIGZlbmNlLCB0byBpbmRpY2F0ZSB0aGF0IHRoZSBm ZW5jZSB3YXMgY29tcGxldGVkIGR1ZSB0byBhbiBlcnJvcgpAQCAtNDQ5LDggKzUyMCw4IEBAIHNp Z25lZCBsb25nIGRtYV9mZW5jZV93YWl0X2FueV90aW1lb3V0KHN0cnVjdCBkbWFfZmVuY2UgKipm ZW5jZXMsCiAKIC8qKgogICogZG1hX2ZlbmNlX3dhaXQgLSBzbGVlcCB1bnRpbCB0aGUgZmVuY2Ug Z2V0cyBzaWduYWxlZAotICogQGZlbmNlOglbaW5dCXRoZSBmZW5jZSB0byB3YWl0IG9uCi0gKiBA aW50cjoJW2luXQlpZiB0cnVlLCBkbyBhbiBpbnRlcnJ1cHRpYmxlIHdhaXQKKyAqIEBmZW5jZTog dGhlIGZlbmNlIHRvIHdhaXQgb24KKyAqIEBpbnRyOiBpZiB0cnVlLCBkbyBhbiBpbnRlcnJ1cHRp YmxlIHdhaXQKICAqCiAgKiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmV0dXJuIC1FUkVTVEFSVFNZUyBp ZiBpbnRlcnJ1cHRlZCBieSBhIHNpZ25hbCwKICAqIG9yIDAgaWYgdGhlIGZlbmNlIHdhcyBzaWdu YWxlZC4gT3RoZXIgZXJyb3IgdmFsdWVzIG1heSBiZQpAQCAtNDU5LDYgKzUzMCw4IEBAIHNpZ25l ZCBsb25nIGRtYV9mZW5jZV93YWl0X2FueV90aW1lb3V0KHN0cnVjdCBkbWFfZmVuY2UgKipmZW5j ZXMsCiAgKiBQZXJmb3JtcyBhIHN5bmNocm9ub3VzIHdhaXQgb24gdGhpcyBmZW5jZS4gSXQgaXMg YXNzdW1lZCB0aGUgY2FsbGVyCiAgKiBkaXJlY3RseSBvciBpbmRpcmVjdGx5IGhvbGRzIGEgcmVm ZXJlbmNlIHRvIHRoZSBmZW5jZSwgb3RoZXJ3aXNlIHRoZQogICogZmVuY2UgbWlnaHQgYmUgZnJl ZWQgYmVmb3JlIHJldHVybiwgcmVzdWx0aW5nIGluIHVuZGVmaW5lZCBiZWhhdmlvci4KKyAqCisg KiBTZWUgYWxzbyBkbWFfZmVuY2Vfd2FpdF90aW1lb3V0KCkgYW5kIGRtYV9mZW5jZV93YWl0X2Fu eV90aW1lb3V0KCkuCiAgKi8KIHN0YXRpYyBpbmxpbmUgc2lnbmVkIGxvbmcgZG1hX2ZlbmNlX3dh aXQoc3RydWN0IGRtYV9mZW5jZSAqZmVuY2UsIGJvb2wgaW50cikKIHsKLS0gCjIuMTcuMAoKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1h aWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMu ZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg==