From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id BFC8CC54EBD for ; Thu, 12 Jan 2023 06:49:12 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229751AbjALGtK (ORCPT ); Thu, 12 Jan 2023 01:49:10 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40888 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229921AbjALGtI (ORCPT ); Thu, 12 Jan 2023 01:49:08 -0500 Received: from szxga03-in.huawei.com (szxga03-in.huawei.com [45.249.212.189]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id BFDD94A978; Wed, 11 Jan 2023 22:49:05 -0800 (PST) Received: from kwepemm600010.china.huawei.com (unknown [172.30.72.56]) by szxga03-in.huawei.com (SkyGuard) with ESMTP id 4Nsw5b2xypzJqH5; Thu, 12 Jan 2023 14:44:51 +0800 (CST) Received: from [10.67.110.237] (10.67.110.237) by kwepemm600010.china.huawei.com (7.193.23.86) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.34; Thu, 12 Jan 2023 14:48:59 +0800 Subject: Re: [PATCH 4/8] ftrace: Add DYNAMIC_FTRACE_WITH_CALL_OPS To: Mark Rutland CC: , , , , , , , , , , , , , References: <20230109135828.879136-1-mark.rutland@arm.com> <20230109135828.879136-5-mark.rutland@arm.com> From: Li Huafei Message-ID: Date: Thu, 12 Jan 2023 14:48:45 +0800 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.9.0 MIME-Version: 1.0 In-Reply-To: <20230109135828.879136-5-mark.rutland@arm.com> Content-Type: text/plain; charset="utf-8" Content-Language: en-US Content-Transfer-Encoding: 8bit X-Originating-IP: [10.67.110.237] X-ClientProxiedBy: dggems705-chm.china.huawei.com (10.3.19.182) To kwepemm600010.china.huawei.com (7.193.23.86) X-CFilter-Loop: Reflected Precedence: bulk List-ID: X-Mailing-List: linux-acpi@vger.kernel.org On 2023/1/9 21:58, Mark Rutland wrote: > Architectures without dynamic ftrace trampolines incur an overhead when > multiple ftrace_ops are enabled with distinct filters. in these cases, > each call site calls a common trampoline which uses > ftrace_ops_list_func() to iterate over all enabled ftrace functions, and > so incurs an overhead relative to the size of this list (including RCU > protection overhead). > > Architectures with dynamic ftrace trampolines avoid this overhead for > call sites which have a single associated ftrace_ops. In these cases, > the dynamic trampoline is customized to branch directly to the relevant > ftrace function, avoiding the list overhead. > > On some architectures it's impractical and/or undesirable to implement > dynamic ftrace trampolines. For example, arm64 has limited branch ranges > and cannot always directly branch from a call site to an arbitrary > address (e.g. from a kernel text address to an arbitrary module > address). Calls from modules to core kernel text can be indirected via > PLTs (allocated at module load time) to address this, but the same is > not possible from calls from core kernel text. > > Using an indirect branch from a call site to an arbitrary trampoline is > possible, but requires several more instructions in the function > prologue (or immediately before it), and/or comes with far more complex > requirements for patching. > > Instead, this patch adds a new option, where an architecture can > associate each call site with a pointer to an ftrace_ops, placed at a > fixed offset from the call site. A shared trampoline can recover this > pointer and call ftrace_ops::func() without needing to go via > ftrace_ops_list_func(), avoiding the associated overhead. > > This avoids issues with branch range limitations, and avoids the need to > allocate and manipulate dynamic trampolines, making it far simpler to > implement and maintain, while having similar performance > characteristics. > > Note that this allows for dynamic ftrace_ops to be invoked directly from > an architecture's ftrace_caller trampoline, whereas existing code forces > the use of ftrace_ops_get_list_func(), which is in part necessary to > permit the ftrace_ops to be freed once unregistereed *and* to avoid > branch/address-generation range limitation on some architectures (e.g. > where ops->func is a module address, and may be outside of the direct > branch range for callsites within the main kernel image). > > The CALL_OPS approach avoids this problems and is safe as: > > * The existing synchronization in ftrace_shutdown() using > ftrace_shutdown() using synchronize_rcu_tasks_rude() (and > synchronize_rcu_tasks()) ensures that no tasks hold a stale reference > to an ftrace_ops (e.g. in the middle of the ftrace_caller trampoline, > or while invoking ftrace_ops::func), when that ftrace_ops is > unregistered. > > Arguably this could also be relied upon for the existing scheme, > permitting dynamic ftrace_ops to be invoked directly when ops->func is > in range, but this will require additional logic to handle branch > range limitations, and is not handled by this patch. > > * Each callsite's ftrace_ops pointer literal can hold any valid kernel > address, and is updated atomically. As an architecture's ftrace_caller > trampoline will atomically load the ops pointer then derefrence > ops->func, there is no risk of invoking ops->func with a mismatches > ops pointer, and updates to the ops pointer do not require special > care. > > A subsequent patch will implement architectures support for arm64. There > should be no functional change as a result of this patch alone. > > Signed-off-by: Mark Rutland > Cc: Catalin Marinas > Cc: Florent Revest > Cc: Masami Hiramatsu > Cc: Peter Zijlstra > Cc: Steven Rostedt > Cc: Will Deacon > --- > include/linux/ftrace.h | 15 +++++- > kernel/trace/Kconfig | 7 +++ > kernel/trace/ftrace.c | 109 +++++++++++++++++++++++++++++++++++++++-- > 3 files changed, 124 insertions(+), 7 deletions(-) > > diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h > index 99f1146614c04..5eeb2776124c5 100644 > --- a/include/linux/ftrace.h > +++ b/include/linux/ftrace.h > @@ -57,6 +57,9 @@ void arch_ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip); > void arch_ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip, > struct ftrace_ops *op, struct ftrace_regs *fregs); > #endif > +extern const struct ftrace_ops ftrace_nop_ops; > +extern const struct ftrace_ops ftrace_list_ops; > +struct ftrace_ops *ftrace_find_unique_ops(struct dyn_ftrace *rec); Hi Mark, This patch has build issues on x86: CC mm/readahead.o In file included from include/linux/perf_event.h:52:0, from arch/x86/events/amd/lbr.c:2: include/linux/ftrace.h:62:50: error: ‘struct dyn_ftrace’ declared inside parameter list will not be visible outside of this definition or declaration [-Werror] struct ftrace_ops *ftrace_find_unique_ops(struct dyn_ftrace *rec); Here we should need 'struct dyn_ftrace' forward declaration. Thanks, Huafei > #endif /* CONFIG_FUNCTION_TRACER */ > > /* Main tracing buffer and events set up */ > @@ -563,6 +566,8 @@ bool is_ftrace_trampoline(unsigned long addr); > * IPMODIFY - the record allows for the IP address to be changed. > * DISABLED - the record is not ready to be touched yet > * DIRECT - there is a direct function to call > + * CALL_OPS - the record can use callsite-specific ops > + * CALL_OPS_EN - the function is set up to use callsite-specific ops > * > * When a new ftrace_ops is registered and wants a function to save > * pt_regs, the rec->flags REGS is set. When the function has been > @@ -580,9 +585,11 @@ enum { > FTRACE_FL_DISABLED = (1UL << 25), > FTRACE_FL_DIRECT = (1UL << 24), > FTRACE_FL_DIRECT_EN = (1UL << 23), > + FTRACE_FL_CALL_OPS = (1UL << 22), > + FTRACE_FL_CALL_OPS_EN = (1UL << 21), > }; > > -#define FTRACE_REF_MAX_SHIFT 23 > +#define FTRACE_REF_MAX_SHIFT 21 > #define FTRACE_REF_MAX ((1UL << FTRACE_REF_MAX_SHIFT) - 1) > > #define ftrace_rec_count(rec) ((rec)->flags & FTRACE_REF_MAX) > @@ -820,7 +827,8 @@ static inline int ftrace_init_nop(struct module *mod, struct dyn_ftrace *rec) > */ > extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr); > > -#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS > +#if defined(CONFIG_DYNAMIC_FTRACE_WITH_REGS) || \ > + defined(CONFIG_DYNAMIC_FTRACE_WITH_CALL_OPS) > /** > * ftrace_modify_call - convert from one addr to another (no nop) > * @rec: the call site record (e.g. mcount/fentry) > @@ -833,6 +841,9 @@ extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr); > * what we expect it to be, and then on success of the compare, > * it should write to the location. > * > + * When using call ops, this is called when the associated ops change, even > + * when (addr == old_addr). > + * > * The code segment at @rec->ip should be a caller to @old_addr > * > * Return must be: > diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig > index 197545241ab83..5df427a2321df 100644 > --- a/kernel/trace/Kconfig > +++ b/kernel/trace/Kconfig > @@ -42,6 +42,9 @@ config HAVE_DYNAMIC_FTRACE_WITH_REGS > config HAVE_DYNAMIC_FTRACE_WITH_DIRECT_CALLS > bool > > +config HAVE_DYNAMIC_FTRACE_WITH_CALL_OPS > + bool > + > config HAVE_DYNAMIC_FTRACE_WITH_ARGS > bool > help > @@ -257,6 +260,10 @@ config DYNAMIC_FTRACE_WITH_DIRECT_CALLS > depends on DYNAMIC_FTRACE_WITH_REGS > depends on HAVE_DYNAMIC_FTRACE_WITH_DIRECT_CALLS > > +config DYNAMIC_FTRACE_WITH_CALL_OPS > + def_bool y > + depends on HAVE_DYNAMIC_FTRACE_WITH_CALL_OPS > + > config DYNAMIC_FTRACE_WITH_ARGS > def_bool y > depends on DYNAMIC_FTRACE > diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c > index 442438b93fe98..c0b219ab89d2f 100644 > --- a/kernel/trace/ftrace.c > +++ b/kernel/trace/ftrace.c > @@ -125,6 +125,33 @@ struct ftrace_ops global_ops; > void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip, > struct ftrace_ops *op, struct ftrace_regs *fregs); > > +#ifdef CONFIG_DYNAMIC_FTRACE_WITH_CALL_OPS > +/* > + * Stub used to invoke the list ops without requiring a separate trampoline. > + */ > +const struct ftrace_ops ftrace_list_ops = { > + .func = ftrace_ops_list_func, > + .flags = FTRACE_OPS_FL_STUB, > +}; > + > +static void ftrace_ops_nop_func(unsigned long ip, unsigned long parent_ip, > + struct ftrace_ops *op, > + struct ftrace_regs *fregs) > +{ > + /* do nothing */ > +} > + > +/* > + * Stub used when a call site is disabled. May be called transiently by threads > + * which have made it into ftrace_caller but haven't yet recovered the ops at > + * the point the call site is disabled. > + */ > +const struct ftrace_ops ftrace_nop_ops = { > + .func = ftrace_ops_nop_func, > + .flags = FTRACE_OPS_FL_STUB, > +}; > +#endif > + > static inline void ftrace_ops_init(struct ftrace_ops *ops) > { > #ifdef CONFIG_DYNAMIC_FTRACE > @@ -1814,6 +1841,18 @@ static bool __ftrace_hash_rec_update(struct ftrace_ops *ops, > * if rec count is zero. > */ > } > + > + /* > + * If the rec has a single associated ops, and ops->func can be > + * called directly, allow the call site to call via the ops. > + */ > + if (IS_ENABLED(CONFIG_DYNAMIC_FTRACE_WITH_CALL_OPS) && > + ftrace_rec_count(rec) == 1 && > + ftrace_ops_get_func(ops) == ops->func) > + rec->flags |= FTRACE_FL_CALL_OPS; > + else > + rec->flags &= ~FTRACE_FL_CALL_OPS; > + > count++; > > /* Must match FTRACE_UPDATE_CALLS in ftrace_modify_all_code() */ > @@ -2108,8 +2147,9 @@ void ftrace_bug(int failed, struct dyn_ftrace *rec) > struct ftrace_ops *ops = NULL; > > pr_info("ftrace record flags: %lx\n", rec->flags); > - pr_cont(" (%ld)%s", ftrace_rec_count(rec), > - rec->flags & FTRACE_FL_REGS ? " R" : " "); > + pr_cont(" (%ld)%s%s", ftrace_rec_count(rec), > + rec->flags & FTRACE_FL_REGS ? " R" : " ", > + rec->flags & FTRACE_FL_CALL_OPS ? " O" : " "); > if (rec->flags & FTRACE_FL_TRAMP_EN) { > ops = ftrace_find_tramp_ops_any(rec); > if (ops) { > @@ -2177,6 +2217,7 @@ static int ftrace_check_record(struct dyn_ftrace *rec, bool enable, bool update) > * want the direct enabled (it will be done via the > * direct helper). But if DIRECT_EN is set, and > * the count is not one, we need to clear it. > + * > */ > if (ftrace_rec_count(rec) == 1) { > if (!(rec->flags & FTRACE_FL_DIRECT) != > @@ -2185,6 +2226,19 @@ static int ftrace_check_record(struct dyn_ftrace *rec, bool enable, bool update) > } else if (rec->flags & FTRACE_FL_DIRECT_EN) { > flag |= FTRACE_FL_DIRECT; > } > + > + /* > + * Ops calls are special, as count matters. > + * As with direct calls, they must only be enabled when count > + * is one, otherwise they'll be handled via the list ops. > + */ > + if (ftrace_rec_count(rec) == 1) { > + if (!(rec->flags & FTRACE_FL_CALL_OPS) != > + !(rec->flags & FTRACE_FL_CALL_OPS_EN)) > + flag |= FTRACE_FL_CALL_OPS; > + } else if (rec->flags & FTRACE_FL_CALL_OPS_EN) { > + flag |= FTRACE_FL_CALL_OPS; > + } > } > > /* If the state of this record hasn't changed, then do nothing */ > @@ -2229,6 +2283,21 @@ static int ftrace_check_record(struct dyn_ftrace *rec, bool enable, bool update) > rec->flags &= ~FTRACE_FL_DIRECT_EN; > } > } > + > + if (flag & FTRACE_FL_CALL_OPS) { > + if (ftrace_rec_count(rec) == 1) { > + if (rec->flags & FTRACE_FL_CALL_OPS) > + rec->flags |= FTRACE_FL_CALL_OPS_EN; > + else > + rec->flags &= ~FTRACE_FL_CALL_OPS_EN; > + } else { > + /* > + * Can only call directly if there's > + * only one sets of associated ops. > + */ > + rec->flags &= ~FTRACE_FL_CALL_OPS_EN; > + } > + } > } > > /* > @@ -2258,7 +2327,8 @@ static int ftrace_check_record(struct dyn_ftrace *rec, bool enable, bool update) > * and REGS states. The _EN flags must be disabled though. > */ > rec->flags &= ~(FTRACE_FL_ENABLED | FTRACE_FL_TRAMP_EN | > - FTRACE_FL_REGS_EN | FTRACE_FL_DIRECT_EN); > + FTRACE_FL_REGS_EN | FTRACE_FL_DIRECT_EN | > + FTRACE_FL_CALL_OPS_EN); > } > > ftrace_bug_type = FTRACE_BUG_NOP; > @@ -2431,6 +2501,25 @@ ftrace_find_tramp_ops_new(struct dyn_ftrace *rec) > return NULL; > } > > +struct ftrace_ops * > +ftrace_find_unique_ops(struct dyn_ftrace *rec) > +{ > + struct ftrace_ops *op, *found = NULL; > + unsigned long ip = rec->ip; > + > + do_for_each_ftrace_op(op, ftrace_ops_list) { > + > + if (hash_contains_ip(ip, op->func_hash)) { > + if (found) > + return NULL; > + found = op; > + } > + > + } while_for_each_ftrace_op(op); > + > + return found; > +} > + > #ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS > /* Protected by rcu_tasks for reading, and direct_mutex for writing */ > static struct ftrace_hash *direct_functions = EMPTY_HASH; > @@ -3780,11 +3869,12 @@ static int t_show(struct seq_file *m, void *v) > if (iter->flags & FTRACE_ITER_ENABLED) { > struct ftrace_ops *ops; > > - seq_printf(m, " (%ld)%s%s%s", > + seq_printf(m, " (%ld)%s%s%s%s", > ftrace_rec_count(rec), > rec->flags & FTRACE_FL_REGS ? " R" : " ", > rec->flags & FTRACE_FL_IPMODIFY ? " I" : " ", > - rec->flags & FTRACE_FL_DIRECT ? " D" : " "); > + rec->flags & FTRACE_FL_DIRECT ? " D" : " ", > + rec->flags & FTRACE_FL_CALL_OPS ? " O" : " "); > if (rec->flags & FTRACE_FL_TRAMP_EN) { > ops = ftrace_find_tramp_ops_any(rec); > if (ops) { > @@ -3800,6 +3890,15 @@ static int t_show(struct seq_file *m, void *v) > } else { > add_trampoline_func(m, NULL, rec); > } > + if (rec->flags & FTRACE_FL_CALL_OPS_EN) { > + ops = ftrace_find_unique_ops(rec); > + if (ops) { > + seq_printf(m, "\tops: %pS (%pS)", > + ops, ops->func); > + } else { > + seq_puts(m, "\tops: ERROR!"); > + } > + } > if (rec->flags & FTRACE_FL_DIRECT) { > unsigned long direct; > > From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id E3B82C54EBC for ; Thu, 12 Jan 2023 06:50:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:Date: Message-ID:From:References:CC:To:Subject:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=qBRG1y/VAXBXo5nGftwORD51tAMlWx8AhW9BuTqn32Y=; b=H3TtRy9lW5AFtMXeyzvJUMa4D0 2YOcsS9ylIKW/D82VvZ5Kp9cDk2vXEGccqE9ymSdGzP9ccSrfG9MObQ9loekvEM5MVw9+qMfn0c4g vxSf5x5hgYZ3OIPW/Et9Nv0YVmfhnX/4h0uiD3uVVpyvR+/QLe813uZJfoUDwvEBmEfJkzHBXVVdF 2MRWJF30zyhqxubfV0PtnjuE9fe3VE+a1ihq03hHEvGXLjVBwKpqlEW7Zwli2kcqULUFzZKkr2xuI FPGr2HrKzGzw6mUluyMEDC3h8qlGLh6zqccjDfF0NBZKCa7kjS1yUANq9teO7IQVQToz6rrrg4maD 40pyce+A==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1pFrOt-00Dvtw-Ve; Thu, 12 Jan 2023 06:49:24 +0000 Received: from szxga03-in.huawei.com ([45.249.212.189]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1pFrOp-00DvrF-MP for linux-arm-kernel@lists.infradead.org; Thu, 12 Jan 2023 06:49:22 +0000 Received: from kwepemm600010.china.huawei.com (unknown [172.30.72.56]) by szxga03-in.huawei.com (SkyGuard) with ESMTP id 4Nsw5b2xypzJqH5; Thu, 12 Jan 2023 14:44:51 +0800 (CST) Received: from [10.67.110.237] (10.67.110.237) by kwepemm600010.china.huawei.com (7.193.23.86) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.34; Thu, 12 Jan 2023 14:48:59 +0800 Subject: Re: [PATCH 4/8] ftrace: Add DYNAMIC_FTRACE_WITH_CALL_OPS To: Mark Rutland CC: , , , , , , , , , , , , , References: <20230109135828.879136-1-mark.rutland@arm.com> <20230109135828.879136-5-mark.rutland@arm.com> From: Li Huafei Message-ID: Date: Thu, 12 Jan 2023 14:48:45 +0800 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.9.0 MIME-Version: 1.0 In-Reply-To: <20230109135828.879136-5-mark.rutland@arm.com> Content-Language: en-US X-Originating-IP: [10.67.110.237] X-ClientProxiedBy: dggems705-chm.china.huawei.com (10.3.19.182) To kwepemm600010.china.huawei.com (7.193.23.86) X-CFilter-Loop: Reflected X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20230111_224920_208826_80F98743 X-CRM114-Status: GOOD ( 62.53 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org CgpPbiAyMDIzLzEvOSAyMTo1OCwgTWFyayBSdXRsYW5kIHdyb3RlOgo+IEFyY2hpdGVjdHVyZXMg d2l0aG91dCBkeW5hbWljIGZ0cmFjZSB0cmFtcG9saW5lcyBpbmN1ciBhbiBvdmVyaGVhZCB3aGVu Cj4gbXVsdGlwbGUgZnRyYWNlX29wcyBhcmUgZW5hYmxlZCB3aXRoIGRpc3RpbmN0IGZpbHRlcnMu IGluIHRoZXNlIGNhc2VzLAo+IGVhY2ggY2FsbCBzaXRlIGNhbGxzIGEgY29tbW9uIHRyYW1wb2xp bmUgd2hpY2ggdXNlcwo+IGZ0cmFjZV9vcHNfbGlzdF9mdW5jKCkgdG8gaXRlcmF0ZSBvdmVyIGFs bCBlbmFibGVkIGZ0cmFjZSBmdW5jdGlvbnMsIGFuZAo+IHNvIGluY3VycyBhbiBvdmVyaGVhZCBy ZWxhdGl2ZSB0byB0aGUgc2l6ZSBvZiB0aGlzIGxpc3QgKGluY2x1ZGluZyBSQ1UKPiBwcm90ZWN0 aW9uIG92ZXJoZWFkKS4KPiAKPiBBcmNoaXRlY3R1cmVzIHdpdGggZHluYW1pYyBmdHJhY2UgdHJh bXBvbGluZXMgYXZvaWQgdGhpcyBvdmVyaGVhZCBmb3IKPiBjYWxsIHNpdGVzIHdoaWNoIGhhdmUg YSBzaW5nbGUgYXNzb2NpYXRlZCBmdHJhY2Vfb3BzLiBJbiB0aGVzZSBjYXNlcywKPiB0aGUgZHlu YW1pYyB0cmFtcG9saW5lIGlzIGN1c3RvbWl6ZWQgdG8gYnJhbmNoIGRpcmVjdGx5IHRvIHRoZSBy ZWxldmFudAo+IGZ0cmFjZSBmdW5jdGlvbiwgYXZvaWRpbmcgdGhlIGxpc3Qgb3ZlcmhlYWQuCj4g Cj4gT24gc29tZSBhcmNoaXRlY3R1cmVzIGl0J3MgaW1wcmFjdGljYWwgYW5kL29yIHVuZGVzaXJh YmxlIHRvIGltcGxlbWVudAo+IGR5bmFtaWMgZnRyYWNlIHRyYW1wb2xpbmVzLiBGb3IgZXhhbXBs ZSwgYXJtNjQgaGFzIGxpbWl0ZWQgYnJhbmNoIHJhbmdlcwo+IGFuZCBjYW5ub3QgYWx3YXlzIGRp cmVjdGx5IGJyYW5jaCBmcm9tIGEgY2FsbCBzaXRlIHRvIGFuIGFyYml0cmFyeQo+IGFkZHJlc3Mg KGUuZy4gZnJvbSBhIGtlcm5lbCB0ZXh0IGFkZHJlc3MgdG8gYW4gYXJiaXRyYXJ5IG1vZHVsZQo+ IGFkZHJlc3MpLiBDYWxscyBmcm9tIG1vZHVsZXMgdG8gY29yZSBrZXJuZWwgdGV4dCBjYW4gYmUg aW5kaXJlY3RlZCB2aWEKPiBQTFRzIChhbGxvY2F0ZWQgYXQgbW9kdWxlIGxvYWQgdGltZSkgdG8g YWRkcmVzcyB0aGlzLCBidXQgdGhlIHNhbWUgaXMKPiBub3QgcG9zc2libGUgZnJvbSBjYWxscyBm cm9tIGNvcmUga2VybmVsIHRleHQuCj4gCj4gVXNpbmcgYW4gaW5kaXJlY3QgYnJhbmNoIGZyb20g YSBjYWxsIHNpdGUgdG8gYW4gYXJiaXRyYXJ5IHRyYW1wb2xpbmUgaXMKPiBwb3NzaWJsZSwgYnV0 IHJlcXVpcmVzIHNldmVyYWwgbW9yZSBpbnN0cnVjdGlvbnMgaW4gdGhlIGZ1bmN0aW9uCj4gcHJv bG9ndWUgKG9yIGltbWVkaWF0ZWx5IGJlZm9yZSBpdCksIGFuZC9vciBjb21lcyB3aXRoIGZhciBt b3JlIGNvbXBsZXgKPiByZXF1aXJlbWVudHMgZm9yIHBhdGNoaW5nLgo+IAo+IEluc3RlYWQsIHRo aXMgcGF0Y2ggYWRkcyBhIG5ldyBvcHRpb24sIHdoZXJlIGFuIGFyY2hpdGVjdHVyZSBjYW4KPiBh c3NvY2lhdGUgZWFjaCBjYWxsIHNpdGUgd2l0aCBhIHBvaW50ZXIgdG8gYW4gZnRyYWNlX29wcywg cGxhY2VkIGF0IGEKPiBmaXhlZCBvZmZzZXQgZnJvbSB0aGUgY2FsbCBzaXRlLiBBIHNoYXJlZCB0 cmFtcG9saW5lIGNhbiByZWNvdmVyIHRoaXMKPiBwb2ludGVyIGFuZCBjYWxsIGZ0cmFjZV9vcHM6 OmZ1bmMoKSB3aXRob3V0IG5lZWRpbmcgdG8gZ28gdmlhCj4gZnRyYWNlX29wc19saXN0X2Z1bmMo KSwgYXZvaWRpbmcgdGhlIGFzc29jaWF0ZWQgb3ZlcmhlYWQuCj4gCj4gVGhpcyBhdm9pZHMgaXNz dWVzIHdpdGggYnJhbmNoIHJhbmdlIGxpbWl0YXRpb25zLCBhbmQgYXZvaWRzIHRoZSBuZWVkIHRv Cj4gYWxsb2NhdGUgYW5kIG1hbmlwdWxhdGUgZHluYW1pYyB0cmFtcG9saW5lcywgbWFraW5nIGl0 IGZhciBzaW1wbGVyIHRvCj4gaW1wbGVtZW50IGFuZCBtYWludGFpbiwgd2hpbGUgaGF2aW5nIHNp bWlsYXIgcGVyZm9ybWFuY2UKPiBjaGFyYWN0ZXJpc3RpY3MuCj4gCj4gTm90ZSB0aGF0IHRoaXMg YWxsb3dzIGZvciBkeW5hbWljIGZ0cmFjZV9vcHMgdG8gYmUgaW52b2tlZCBkaXJlY3RseSBmcm9t Cj4gYW4gYXJjaGl0ZWN0dXJlJ3MgZnRyYWNlX2NhbGxlciB0cmFtcG9saW5lLCB3aGVyZWFzIGV4 aXN0aW5nIGNvZGUgZm9yY2VzCj4gdGhlIHVzZSBvZiBmdHJhY2Vfb3BzX2dldF9saXN0X2Z1bmMo KSwgd2hpY2ggaXMgaW4gcGFydCBuZWNlc3NhcnkgdG8KPiBwZXJtaXQgdGhlIGZ0cmFjZV9vcHMg dG8gYmUgZnJlZWQgb25jZSB1bnJlZ2lzdGVyZWVkICphbmQqIHRvIGF2b2lkCj4gYnJhbmNoL2Fk ZHJlc3MtZ2VuZXJhdGlvbiByYW5nZSBsaW1pdGF0aW9uIG9uIHNvbWUgYXJjaGl0ZWN0dXJlcyAo ZS5nLgo+IHdoZXJlIG9wcy0+ZnVuYyBpcyBhIG1vZHVsZSBhZGRyZXNzLCBhbmQgbWF5IGJlIG91 dHNpZGUgb2YgdGhlIGRpcmVjdAo+IGJyYW5jaCByYW5nZSBmb3IgY2FsbHNpdGVzIHdpdGhpbiB0 aGUgbWFpbiBrZXJuZWwgaW1hZ2UpLgo+IAo+IFRoZSBDQUxMX09QUyBhcHByb2FjaCBhdm9pZHMg dGhpcyBwcm9ibGVtcyBhbmQgaXMgc2FmZSBhczoKPiAKPiAqIFRoZSBleGlzdGluZyBzeW5jaHJv bml6YXRpb24gaW4gZnRyYWNlX3NodXRkb3duKCkgdXNpbmcKPiAgIGZ0cmFjZV9zaHV0ZG93bigp IHVzaW5nIHN5bmNocm9uaXplX3JjdV90YXNrc19ydWRlKCkgKGFuZAo+ICAgc3luY2hyb25pemVf cmN1X3Rhc2tzKCkpIGVuc3VyZXMgdGhhdCBubyB0YXNrcyBob2xkIGEgc3RhbGUgcmVmZXJlbmNl Cj4gICB0byBhbiBmdHJhY2Vfb3BzIChlLmcuIGluIHRoZSBtaWRkbGUgb2YgdGhlIGZ0cmFjZV9j YWxsZXIgdHJhbXBvbGluZSwKPiAgIG9yIHdoaWxlIGludm9raW5nIGZ0cmFjZV9vcHM6OmZ1bmMp LCB3aGVuIHRoYXQgZnRyYWNlX29wcyBpcwo+ICAgdW5yZWdpc3RlcmVkLgo+IAo+ICAgQXJndWFi bHkgdGhpcyBjb3VsZCBhbHNvIGJlIHJlbGllZCB1cG9uIGZvciB0aGUgZXhpc3Rpbmcgc2NoZW1l LAo+ICAgcGVybWl0dGluZyBkeW5hbWljIGZ0cmFjZV9vcHMgdG8gYmUgaW52b2tlZCBkaXJlY3Rs eSB3aGVuIG9wcy0+ZnVuYyBpcwo+ICAgaW4gcmFuZ2UsIGJ1dCB0aGlzIHdpbGwgcmVxdWlyZSBh ZGRpdGlvbmFsIGxvZ2ljIHRvIGhhbmRsZSBicmFuY2gKPiAgIHJhbmdlIGxpbWl0YXRpb25zLCBh bmQgaXMgbm90IGhhbmRsZWQgYnkgdGhpcyBwYXRjaC4KPiAKPiAqIEVhY2ggY2FsbHNpdGUncyBm dHJhY2Vfb3BzIHBvaW50ZXIgbGl0ZXJhbCBjYW4gaG9sZCBhbnkgdmFsaWQga2VybmVsCj4gICBh ZGRyZXNzLCBhbmQgaXMgdXBkYXRlZCBhdG9taWNhbGx5LiBBcyBhbiBhcmNoaXRlY3R1cmUncyBm dHJhY2VfY2FsbGVyCj4gICB0cmFtcG9saW5lIHdpbGwgYXRvbWljYWxseSBsb2FkIHRoZSBvcHMg cG9pbnRlciB0aGVuIGRlcmVmcmVuY2UKPiAgIG9wcy0+ZnVuYywgdGhlcmUgaXMgbm8gcmlzayBv ZiBpbnZva2luZyBvcHMtPmZ1bmMgd2l0aCBhIG1pc21hdGNoZXMKPiAgIG9wcyBwb2ludGVyLCBh bmQgdXBkYXRlcyB0byB0aGUgb3BzIHBvaW50ZXIgZG8gbm90IHJlcXVpcmUgc3BlY2lhbAo+ICAg Y2FyZS4KPiAKPiBBIHN1YnNlcXVlbnQgcGF0Y2ggd2lsbCBpbXBsZW1lbnQgYXJjaGl0ZWN0dXJl cyBzdXBwb3J0IGZvciBhcm02NC4gVGhlcmUKPiBzaG91bGQgYmUgbm8gZnVuY3Rpb25hbCBjaGFu Z2UgYXMgYSByZXN1bHQgb2YgdGhpcyBwYXRjaCBhbG9uZS4KPiAKPiBTaWduZWQtb2ZmLWJ5OiBN YXJrIFJ1dGxhbmQgPG1hcmsucnV0bGFuZEBhcm0uY29tPgo+IENjOiBDYXRhbGluIE1hcmluYXMg PGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29tPgo+IENjOiBGbG9yZW50IFJldmVzdCA8cmV2ZXN0QGNo cm9taXVtLm9yZz4KPiBDYzogTWFzYW1pIEhpcmFtYXRzdSA8bWhpcmFtYXRAa2VybmVsLm9yZz4K PiBDYzogUGV0ZXIgWmlqbHN0cmEgPHBldGVyekBpbmZyYWRlYWQub3JnPgo+IENjOiBTdGV2ZW4g Um9zdGVkdCA8cm9zdGVkdEBnb29kbWlzLm9yZz4KPiBDYzogV2lsbCBEZWFjb24gPHdpbGxAa2Vy bmVsLm9yZz4KPiAtLS0KPiAgaW5jbHVkZS9saW51eC9mdHJhY2UuaCB8ICAxNSArKysrKy0KPiAg a2VybmVsL3RyYWNlL0tjb25maWcgICB8ICAgNyArKysKPiAga2VybmVsL3RyYWNlL2Z0cmFjZS5j ICB8IDEwOSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLQo+ICAzIGZp bGVzIGNoYW5nZWQsIDEyNCBpbnNlcnRpb25zKCspLCA3IGRlbGV0aW9ucygtKQo+IAo+IGRpZmYg LS1naXQgYS9pbmNsdWRlL2xpbnV4L2Z0cmFjZS5oIGIvaW5jbHVkZS9saW51eC9mdHJhY2UuaAo+ IGluZGV4IDk5ZjExNDY2MTRjMDQuLjVlZWIyNzc2MTI0YzUgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVk ZS9saW51eC9mdHJhY2UuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvZnRyYWNlLmgKPiBAQCAtNTcs NiArNTcsOSBAQCB2b2lkIGFyY2hfZnRyYWNlX29wc19saXN0X2Z1bmModW5zaWduZWQgbG9uZyBp cCwgdW5zaWduZWQgbG9uZyBwYXJlbnRfaXApOwo+ICB2b2lkIGFyY2hfZnRyYWNlX29wc19saXN0 X2Z1bmModW5zaWduZWQgbG9uZyBpcCwgdW5zaWduZWQgbG9uZyBwYXJlbnRfaXAsCj4gIAkJCSAg ICAgICBzdHJ1Y3QgZnRyYWNlX29wcyAqb3AsIHN0cnVjdCBmdHJhY2VfcmVncyAqZnJlZ3MpOwo+ ICAjZW5kaWYKPiArZXh0ZXJuIGNvbnN0IHN0cnVjdCBmdHJhY2Vfb3BzIGZ0cmFjZV9ub3Bfb3Bz Owo+ICtleHRlcm4gY29uc3Qgc3RydWN0IGZ0cmFjZV9vcHMgZnRyYWNlX2xpc3Rfb3BzOwo+ICtz dHJ1Y3QgZnRyYWNlX29wcyAqZnRyYWNlX2ZpbmRfdW5pcXVlX29wcyhzdHJ1Y3QgZHluX2Z0cmFj ZSAqcmVjKTsKCkhpIE1hcmssCgpUaGlzIHBhdGNoIGhhcyBidWlsZCBpc3N1ZXMgb24geDg2OgoK ICAgIENDICAgICAgbW0vcmVhZGFoZWFkLm8KICBJbiBmaWxlIGluY2x1ZGVkIGZyb20gaW5jbHVk ZS9saW51eC9wZXJmX2V2ZW50Lmg6NTI6MCwKICAgICAgICAgICAgICAgICAgIGZyb20gYXJjaC94 ODYvZXZlbnRzL2FtZC9sYnIuYzoyOgogIGluY2x1ZGUvbGludXgvZnRyYWNlLmg6NjI6NTA6IGVy cm9yOiDigJhzdHJ1Y3QgZHluX2Z0cmFjZeKAmSBkZWNsYXJlZCBpbnNpZGUgcGFyYW1ldGVyIGxp c3Qgd2lsbCBub3QgYmUgdmlzaWJsZSBvdXRzaWRlIG9mIHRoaXMgZGVmaW5pdGlvbiBvciBkZWNs YXJhdGlvbiBbLVdlcnJvcl0KICAgc3RydWN0IGZ0cmFjZV9vcHMgKmZ0cmFjZV9maW5kX3VuaXF1 ZV9vcHMoc3RydWN0IGR5bl9mdHJhY2UgKnJlYyk7CgpIZXJlIHdlIHNob3VsZCBuZWVkICdzdHJ1 Y3QgZHluX2Z0cmFjZScgZm9yd2FyZCBkZWNsYXJhdGlvbi4KClRoYW5rcywKSHVhZmVpCgo+ICAj ZW5kaWYgLyogQ09ORklHX0ZVTkNUSU9OX1RSQUNFUiAqLwo+ICAKPiAgLyogTWFpbiB0cmFjaW5n IGJ1ZmZlciBhbmQgZXZlbnRzIHNldCB1cCAqLwo+IEBAIC01NjMsNiArNTY2LDggQEAgYm9vbCBp c19mdHJhY2VfdHJhbXBvbGluZSh1bnNpZ25lZCBsb25nIGFkZHIpOwo+ICAgKiAgSVBNT0RJRlkg LSB0aGUgcmVjb3JkIGFsbG93cyBmb3IgdGhlIElQIGFkZHJlc3MgdG8gYmUgY2hhbmdlZC4KPiAg ICogIERJU0FCTEVEIC0gdGhlIHJlY29yZCBpcyBub3QgcmVhZHkgdG8gYmUgdG91Y2hlZCB5ZXQK PiAgICogIERJUkVDVCAgIC0gdGhlcmUgaXMgYSBkaXJlY3QgZnVuY3Rpb24gdG8gY2FsbAo+ICsg KiAgQ0FMTF9PUFMgLSB0aGUgcmVjb3JkIGNhbiB1c2UgY2FsbHNpdGUtc3BlY2lmaWMgb3BzCj4g KyAqICBDQUxMX09QU19FTiAtIHRoZSBmdW5jdGlvbiBpcyBzZXQgdXAgdG8gdXNlIGNhbGxzaXRl LXNwZWNpZmljIG9wcwo+ICAgKgo+ICAgKiBXaGVuIGEgbmV3IGZ0cmFjZV9vcHMgaXMgcmVnaXN0 ZXJlZCBhbmQgd2FudHMgYSBmdW5jdGlvbiB0byBzYXZlCj4gICAqIHB0X3JlZ3MsIHRoZSByZWMt PmZsYWdzIFJFR1MgaXMgc2V0LiBXaGVuIHRoZSBmdW5jdGlvbiBoYXMgYmVlbgo+IEBAIC01ODAs OSArNTg1LDExIEBAIGVudW0gewo+ICAJRlRSQUNFX0ZMX0RJU0FCTEVECT0gKDFVTCA8PCAyNSks Cj4gIAlGVFJBQ0VfRkxfRElSRUNUCT0gKDFVTCA8PCAyNCksCj4gIAlGVFJBQ0VfRkxfRElSRUNU X0VOCT0gKDFVTCA8PCAyMyksCj4gKwlGVFJBQ0VfRkxfQ0FMTF9PUFMJPSAoMVVMIDw8IDIyKSwK PiArCUZUUkFDRV9GTF9DQUxMX09QU19FTgk9ICgxVUwgPDwgMjEpLAo+ICB9Owo+ICAKPiAtI2Rl ZmluZSBGVFJBQ0VfUkVGX01BWF9TSElGVAkyMwo+ICsjZGVmaW5lIEZUUkFDRV9SRUZfTUFYX1NI SUZUCTIxCj4gICNkZWZpbmUgRlRSQUNFX1JFRl9NQVgJCSgoMVVMIDw8IEZUUkFDRV9SRUZfTUFY X1NISUZUKSAtIDEpCj4gIAo+ICAjZGVmaW5lIGZ0cmFjZV9yZWNfY291bnQocmVjKQkoKHJlYykt PmZsYWdzICYgRlRSQUNFX1JFRl9NQVgpCj4gQEAgLTgyMCw3ICs4MjcsOCBAQCBzdGF0aWMgaW5s aW5lIGludCBmdHJhY2VfaW5pdF9ub3Aoc3RydWN0IG1vZHVsZSAqbW9kLCBzdHJ1Y3QgZHluX2Z0 cmFjZSAqcmVjKQo+ICAgKi8KPiAgZXh0ZXJuIGludCBmdHJhY2VfbWFrZV9jYWxsKHN0cnVjdCBk eW5fZnRyYWNlICpyZWMsIHVuc2lnbmVkIGxvbmcgYWRkcik7Cj4gIAo+IC0jaWZkZWYgQ09ORklH X0RZTkFNSUNfRlRSQUNFX1dJVEhfUkVHUwo+ICsjaWYgZGVmaW5lZChDT05GSUdfRFlOQU1JQ19G VFJBQ0VfV0lUSF9SRUdTKSB8fCBcCj4gKwlkZWZpbmVkKENPTkZJR19EWU5BTUlDX0ZUUkFDRV9X SVRIX0NBTExfT1BTKQo+ICAvKioKPiAgICogZnRyYWNlX21vZGlmeV9jYWxsIC0gY29udmVydCBm cm9tIG9uZSBhZGRyIHRvIGFub3RoZXIgKG5vIG5vcCkKPiAgICogQHJlYzogdGhlIGNhbGwgc2l0 ZSByZWNvcmQgKGUuZy4gbWNvdW50L2ZlbnRyeSkKPiBAQCAtODMzLDYgKzg0MSw5IEBAIGV4dGVy biBpbnQgZnRyYWNlX21ha2VfY2FsbChzdHJ1Y3QgZHluX2Z0cmFjZSAqcmVjLCB1bnNpZ25lZCBs b25nIGFkZHIpOwo+ICAgKiB3aGF0IHdlIGV4cGVjdCBpdCB0byBiZSwgYW5kIHRoZW4gb24gc3Vj Y2VzcyBvZiB0aGUgY29tcGFyZSwKPiAgICogaXQgc2hvdWxkIHdyaXRlIHRvIHRoZSBsb2NhdGlv bi4KPiAgICoKPiArICogV2hlbiB1c2luZyBjYWxsIG9wcywgdGhpcyBpcyBjYWxsZWQgd2hlbiB0 aGUgYXNzb2NpYXRlZCBvcHMgY2hhbmdlLCBldmVuCj4gKyAqIHdoZW4gKGFkZHIgPT0gb2xkX2Fk ZHIpLgo+ICsgKgo+ICAgKiBUaGUgY29kZSBzZWdtZW50IGF0IEByZWMtPmlwIHNob3VsZCBiZSBh IGNhbGxlciB0byBAb2xkX2FkZHIKPiAgICoKPiAgICogUmV0dXJuIG11c3QgYmU6Cj4gZGlmZiAt LWdpdCBhL2tlcm5lbC90cmFjZS9LY29uZmlnIGIva2VybmVsL3RyYWNlL0tjb25maWcKPiBpbmRl eCAxOTc1NDUyNDFhYjgzLi41ZGY0MjdhMjMyMWRmIDEwMDY0NAo+IC0tLSBhL2tlcm5lbC90cmFj ZS9LY29uZmlnCj4gKysrIGIva2VybmVsL3RyYWNlL0tjb25maWcKPiBAQCAtNDIsNiArNDIsOSBA QCBjb25maWcgSEFWRV9EWU5BTUlDX0ZUUkFDRV9XSVRIX1JFR1MKPiAgY29uZmlnIEhBVkVfRFlO QU1JQ19GVFJBQ0VfV0lUSF9ESVJFQ1RfQ0FMTFMKPiAgCWJvb2wKPiAgCj4gK2NvbmZpZyBIQVZF X0RZTkFNSUNfRlRSQUNFX1dJVEhfQ0FMTF9PUFMKPiArCWJvb2wKPiArCj4gIGNvbmZpZyBIQVZF X0RZTkFNSUNfRlRSQUNFX1dJVEhfQVJHUwo+ICAJYm9vbAo+ICAJaGVscAo+IEBAIC0yNTcsNiAr MjYwLDEwIEBAIGNvbmZpZyBEWU5BTUlDX0ZUUkFDRV9XSVRIX0RJUkVDVF9DQUxMUwo+ICAJZGVw ZW5kcyBvbiBEWU5BTUlDX0ZUUkFDRV9XSVRIX1JFR1MKPiAgCWRlcGVuZHMgb24gSEFWRV9EWU5B TUlDX0ZUUkFDRV9XSVRIX0RJUkVDVF9DQUxMUwo+ICAKPiArY29uZmlnIERZTkFNSUNfRlRSQUNF X1dJVEhfQ0FMTF9PUFMKPiArCWRlZl9ib29sIHkKPiArCWRlcGVuZHMgb24gSEFWRV9EWU5BTUlD X0ZUUkFDRV9XSVRIX0NBTExfT1BTCj4gKwo+ICBjb25maWcgRFlOQU1JQ19GVFJBQ0VfV0lUSF9B UkdTCj4gIAlkZWZfYm9vbCB5Cj4gIAlkZXBlbmRzIG9uIERZTkFNSUNfRlRSQUNFCj4gZGlmZiAt LWdpdCBhL2tlcm5lbC90cmFjZS9mdHJhY2UuYyBiL2tlcm5lbC90cmFjZS9mdHJhY2UuYwo+IGlu ZGV4IDQ0MjQzOGI5M2ZlOTguLmMwYjIxOWFiODlkMmYgMTAwNjQ0Cj4gLS0tIGEva2VybmVsL3Ry YWNlL2Z0cmFjZS5jCj4gKysrIGIva2VybmVsL3RyYWNlL2Z0cmFjZS5jCj4gQEAgLTEyNSw2ICsx MjUsMzMgQEAgc3RydWN0IGZ0cmFjZV9vcHMgZ2xvYmFsX29wczsKPiAgdm9pZCBmdHJhY2Vfb3Bz X2xpc3RfZnVuYyh1bnNpZ25lZCBsb25nIGlwLCB1bnNpZ25lZCBsb25nIHBhcmVudF9pcCwKPiAg CQkJICBzdHJ1Y3QgZnRyYWNlX29wcyAqb3AsIHN0cnVjdCBmdHJhY2VfcmVncyAqZnJlZ3MpOwo+ ICAKPiArI2lmZGVmIENPTkZJR19EWU5BTUlDX0ZUUkFDRV9XSVRIX0NBTExfT1BTCj4gKy8qCj4g KyAqIFN0dWIgdXNlZCB0byBpbnZva2UgdGhlIGxpc3Qgb3BzIHdpdGhvdXQgcmVxdWlyaW5nIGEg c2VwYXJhdGUgdHJhbXBvbGluZS4KPiArICovCj4gK2NvbnN0IHN0cnVjdCBmdHJhY2Vfb3BzIGZ0 cmFjZV9saXN0X29wcyA9IHsKPiArCS5mdW5jCT0gZnRyYWNlX29wc19saXN0X2Z1bmMsCj4gKwku ZmxhZ3MJPSBGVFJBQ0VfT1BTX0ZMX1NUVUIsCj4gK307Cj4gKwo+ICtzdGF0aWMgdm9pZCBmdHJh Y2Vfb3BzX25vcF9mdW5jKHVuc2lnbmVkIGxvbmcgaXAsIHVuc2lnbmVkIGxvbmcgcGFyZW50X2lw LAo+ICsJCQkJc3RydWN0IGZ0cmFjZV9vcHMgKm9wLAo+ICsJCQkJc3RydWN0IGZ0cmFjZV9yZWdz ICpmcmVncykKPiArewo+ICsJLyogZG8gbm90aGluZyAqLwo+ICt9Cj4gKwo+ICsvKgo+ICsgKiBT dHViIHVzZWQgd2hlbiBhIGNhbGwgc2l0ZSBpcyBkaXNhYmxlZC4gTWF5IGJlIGNhbGxlZCB0cmFu c2llbnRseSBieSB0aHJlYWRzCj4gKyAqIHdoaWNoIGhhdmUgbWFkZSBpdCBpbnRvIGZ0cmFjZV9j YWxsZXIgYnV0IGhhdmVuJ3QgeWV0IHJlY292ZXJlZCB0aGUgb3BzIGF0Cj4gKyAqIHRoZSBwb2lu dCB0aGUgY2FsbCBzaXRlIGlzIGRpc2FibGVkLgo+ICsgKi8KPiArY29uc3Qgc3RydWN0IGZ0cmFj ZV9vcHMgZnRyYWNlX25vcF9vcHMgPSB7Cj4gKwkuZnVuYwk9IGZ0cmFjZV9vcHNfbm9wX2Z1bmMs Cj4gKwkuZmxhZ3MgID0gRlRSQUNFX09QU19GTF9TVFVCLAo+ICt9Owo+ICsjZW5kaWYKPiArCj4g IHN0YXRpYyBpbmxpbmUgdm9pZCBmdHJhY2Vfb3BzX2luaXQoc3RydWN0IGZ0cmFjZV9vcHMgKm9w cykKPiAgewo+ICAjaWZkZWYgQ09ORklHX0RZTkFNSUNfRlRSQUNFCj4gQEAgLTE4MTQsNiArMTg0 MSwxOCBAQCBzdGF0aWMgYm9vbCBfX2Z0cmFjZV9oYXNoX3JlY191cGRhdGUoc3RydWN0IGZ0cmFj ZV9vcHMgKm9wcywKPiAgCQkJICogaWYgcmVjIGNvdW50IGlzIHplcm8uCj4gIAkJCSAqLwo+ICAJ CX0KPiArCj4gKwkJLyoKPiArCQkgKiBJZiB0aGUgcmVjIGhhcyBhIHNpbmdsZSBhc3NvY2lhdGVk IG9wcywgYW5kIG9wcy0+ZnVuYyBjYW4gYmUKPiArCQkgKiBjYWxsZWQgZGlyZWN0bHksIGFsbG93 IHRoZSBjYWxsIHNpdGUgdG8gY2FsbCB2aWEgdGhlIG9wcy4KPiArCQkgKi8KPiArCQlpZiAoSVNf RU5BQkxFRChDT05GSUdfRFlOQU1JQ19GVFJBQ0VfV0lUSF9DQUxMX09QUykgJiYKPiArCQkgICAg ZnRyYWNlX3JlY19jb3VudChyZWMpID09IDEgJiYKPiArCQkgICAgZnRyYWNlX29wc19nZXRfZnVu YyhvcHMpID09IG9wcy0+ZnVuYykKPiArCQkJcmVjLT5mbGFncyB8PSBGVFJBQ0VfRkxfQ0FMTF9P UFM7Cj4gKwkJZWxzZQo+ICsJCQlyZWMtPmZsYWdzICY9IH5GVFJBQ0VfRkxfQ0FMTF9PUFM7Cj4g Kwo+ICAJCWNvdW50Kys7Cj4gIAo+ICAJCS8qIE11c3QgbWF0Y2ggRlRSQUNFX1VQREFURV9DQUxM UyBpbiBmdHJhY2VfbW9kaWZ5X2FsbF9jb2RlKCkgKi8KPiBAQCAtMjEwOCw4ICsyMTQ3LDkgQEAg dm9pZCBmdHJhY2VfYnVnKGludCBmYWlsZWQsIHN0cnVjdCBkeW5fZnRyYWNlICpyZWMpCj4gIAkJ c3RydWN0IGZ0cmFjZV9vcHMgKm9wcyA9IE5VTEw7Cj4gIAo+ICAJCXByX2luZm8oImZ0cmFjZSBy ZWNvcmQgZmxhZ3M6ICVseFxuIiwgcmVjLT5mbGFncyk7Cj4gLQkJcHJfY29udCgiICglbGQpJXMi LCBmdHJhY2VfcmVjX2NvdW50KHJlYyksCj4gLQkJCXJlYy0+ZmxhZ3MgJiBGVFJBQ0VfRkxfUkVH UyA/ICIgUiIgOiAiICAiKTsKPiArCQlwcl9jb250KCIgKCVsZCklcyVzIiwgZnRyYWNlX3JlY19j b3VudChyZWMpLAo+ICsJCQlyZWMtPmZsYWdzICYgRlRSQUNFX0ZMX1JFR1MgPyAiIFIiIDogIiAg IiwKPiArCQkJcmVjLT5mbGFncyAmIEZUUkFDRV9GTF9DQUxMX09QUyA/ICIgTyIgOiAiICAiKTsK PiAgCQlpZiAocmVjLT5mbGFncyAmIEZUUkFDRV9GTF9UUkFNUF9FTikgewo+ICAJCQlvcHMgPSBm dHJhY2VfZmluZF90cmFtcF9vcHNfYW55KHJlYyk7Cj4gIAkJCWlmIChvcHMpIHsKPiBAQCAtMjE3 Nyw2ICsyMjE3LDcgQEAgc3RhdGljIGludCBmdHJhY2VfY2hlY2tfcmVjb3JkKHN0cnVjdCBkeW5f ZnRyYWNlICpyZWMsIGJvb2wgZW5hYmxlLCBib29sIHVwZGF0ZSkKPiAgCQkgKiB3YW50IHRoZSBk aXJlY3QgZW5hYmxlZCAoaXQgd2lsbCBiZSBkb25lIHZpYSB0aGUKPiAgCQkgKiBkaXJlY3QgaGVs cGVyKS4gQnV0IGlmIERJUkVDVF9FTiBpcyBzZXQsIGFuZAo+ICAJCSAqIHRoZSBjb3VudCBpcyBu b3Qgb25lLCB3ZSBuZWVkIHRvIGNsZWFyIGl0Lgo+ICsJCSAqCj4gIAkJICovCj4gIAkJaWYgKGZ0 cmFjZV9yZWNfY291bnQocmVjKSA9PSAxKSB7Cj4gIAkJCWlmICghKHJlYy0+ZmxhZ3MgJiBGVFJB Q0VfRkxfRElSRUNUKSAhPQo+IEBAIC0yMTg1LDYgKzIyMjYsMTkgQEAgc3RhdGljIGludCBmdHJh Y2VfY2hlY2tfcmVjb3JkKHN0cnVjdCBkeW5fZnRyYWNlICpyZWMsIGJvb2wgZW5hYmxlLCBib29s IHVwZGF0ZSkKPiAgCQl9IGVsc2UgaWYgKHJlYy0+ZmxhZ3MgJiBGVFJBQ0VfRkxfRElSRUNUX0VO KSB7Cj4gIAkJCWZsYWcgfD0gRlRSQUNFX0ZMX0RJUkVDVDsKPiAgCQl9Cj4gKwo+ICsJCS8qCj4g KwkJICogT3BzIGNhbGxzIGFyZSBzcGVjaWFsLCBhcyBjb3VudCBtYXR0ZXJzLgo+ICsJCSAqIEFz IHdpdGggZGlyZWN0IGNhbGxzLCB0aGV5IG11c3Qgb25seSBiZSBlbmFibGVkIHdoZW4gY291bnQK PiArCQkgKiBpcyBvbmUsIG90aGVyd2lzZSB0aGV5J2xsIGJlIGhhbmRsZWQgdmlhIHRoZSBsaXN0 IG9wcy4KPiArCQkgKi8KPiArCQlpZiAoZnRyYWNlX3JlY19jb3VudChyZWMpID09IDEpIHsKPiAr CQkJaWYgKCEocmVjLT5mbGFncyAmIEZUUkFDRV9GTF9DQUxMX09QUykgIT0KPiArCQkJICAgICEo cmVjLT5mbGFncyAmIEZUUkFDRV9GTF9DQUxMX09QU19FTikpCj4gKwkJCQlmbGFnIHw9IEZUUkFD RV9GTF9DQUxMX09QUzsKPiArCQl9IGVsc2UgaWYgKHJlYy0+ZmxhZ3MgJiBGVFJBQ0VfRkxfQ0FM TF9PUFNfRU4pIHsKPiArCQkJZmxhZyB8PSBGVFJBQ0VfRkxfQ0FMTF9PUFM7Cj4gKwkJfQo+ICAJ fQo+ICAKPiAgCS8qIElmIHRoZSBzdGF0ZSBvZiB0aGlzIHJlY29yZCBoYXNuJ3QgY2hhbmdlZCwg dGhlbiBkbyBub3RoaW5nICovCj4gQEAgLTIyMjksNiArMjI4MywyMSBAQCBzdGF0aWMgaW50IGZ0 cmFjZV9jaGVja19yZWNvcmQoc3RydWN0IGR5bl9mdHJhY2UgKnJlYywgYm9vbCBlbmFibGUsIGJv b2wgdXBkYXRlKQo+ICAJCQkJCXJlYy0+ZmxhZ3MgJj0gfkZUUkFDRV9GTF9ESVJFQ1RfRU47Cj4g IAkJCQl9Cj4gIAkJCX0KPiArCj4gKwkJCWlmIChmbGFnICYgRlRSQUNFX0ZMX0NBTExfT1BTKSB7 Cj4gKwkJCQlpZiAoZnRyYWNlX3JlY19jb3VudChyZWMpID09IDEpIHsKPiArCQkJCQlpZiAocmVj LT5mbGFncyAmIEZUUkFDRV9GTF9DQUxMX09QUykKPiArCQkJCQkJcmVjLT5mbGFncyB8PSBGVFJB Q0VfRkxfQ0FMTF9PUFNfRU47Cj4gKwkJCQkJZWxzZQo+ICsJCQkJCQlyZWMtPmZsYWdzICY9IH5G VFJBQ0VfRkxfQ0FMTF9PUFNfRU47Cj4gKwkJCQl9IGVsc2Ugewo+ICsJCQkJCS8qCj4gKwkJCQkJ ICogQ2FuIG9ubHkgY2FsbCBkaXJlY3RseSBpZiB0aGVyZSdzCj4gKwkJCQkJICogb25seSBvbmUg c2V0cyBvZiBhc3NvY2lhdGVkIG9wcy4KPiArCQkJCQkgKi8KPiArCQkJCQlyZWMtPmZsYWdzICY9 IH5GVFJBQ0VfRkxfQ0FMTF9PUFNfRU47Cj4gKwkJCQl9Cj4gKwkJCX0KPiAgCQl9Cj4gIAo+ICAJ CS8qCj4gQEAgLTIyNTgsNyArMjMyNyw4IEBAIHN0YXRpYyBpbnQgZnRyYWNlX2NoZWNrX3JlY29y ZChzdHJ1Y3QgZHluX2Z0cmFjZSAqcmVjLCBib29sIGVuYWJsZSwgYm9vbCB1cGRhdGUpCj4gIAkJ CSAqIGFuZCBSRUdTIHN0YXRlcy4gVGhlIF9FTiBmbGFncyBtdXN0IGJlIGRpc2FibGVkIHRob3Vn aC4KPiAgCQkJICovCj4gIAkJCXJlYy0+ZmxhZ3MgJj0gfihGVFJBQ0VfRkxfRU5BQkxFRCB8IEZU UkFDRV9GTF9UUkFNUF9FTiB8Cj4gLQkJCQkJRlRSQUNFX0ZMX1JFR1NfRU4gfCBGVFJBQ0VfRkxf RElSRUNUX0VOKTsKPiArCQkJCQlGVFJBQ0VfRkxfUkVHU19FTiB8IEZUUkFDRV9GTF9ESVJFQ1Rf RU4gfAo+ICsJCQkJCUZUUkFDRV9GTF9DQUxMX09QU19FTik7Cj4gIAl9Cj4gIAo+ICAJZnRyYWNl X2J1Z190eXBlID0gRlRSQUNFX0JVR19OT1A7Cj4gQEAgLTI0MzEsNiArMjUwMSwyNSBAQCBmdHJh Y2VfZmluZF90cmFtcF9vcHNfbmV3KHN0cnVjdCBkeW5fZnRyYWNlICpyZWMpCj4gIAlyZXR1cm4g TlVMTDsKPiAgfQo+ICAKPiArc3RydWN0IGZ0cmFjZV9vcHMgKgo+ICtmdHJhY2VfZmluZF91bmlx dWVfb3BzKHN0cnVjdCBkeW5fZnRyYWNlICpyZWMpCj4gK3sKPiArCXN0cnVjdCBmdHJhY2Vfb3Bz ICpvcCwgKmZvdW5kID0gTlVMTDsKPiArCXVuc2lnbmVkIGxvbmcgaXAgPSByZWMtPmlwOwo+ICsK PiArCWRvX2Zvcl9lYWNoX2Z0cmFjZV9vcChvcCwgZnRyYWNlX29wc19saXN0KSB7Cj4gKwo+ICsJ CWlmIChoYXNoX2NvbnRhaW5zX2lwKGlwLCBvcC0+ZnVuY19oYXNoKSkgewo+ICsJCQlpZiAoZm91 bmQpCj4gKwkJCQlyZXR1cm4gTlVMTDsKPiArCQkJZm91bmQgPSBvcDsKPiArCQl9Cj4gKwo+ICsJ fSB3aGlsZV9mb3JfZWFjaF9mdHJhY2Vfb3Aob3ApOwo+ICsKPiArCXJldHVybiBmb3VuZDsKPiAr fQo+ICsKPiAgI2lmZGVmIENPTkZJR19EWU5BTUlDX0ZUUkFDRV9XSVRIX0RJUkVDVF9DQUxMUwo+ ICAvKiBQcm90ZWN0ZWQgYnkgcmN1X3Rhc2tzIGZvciByZWFkaW5nLCBhbmQgZGlyZWN0X211dGV4 IGZvciB3cml0aW5nICovCj4gIHN0YXRpYyBzdHJ1Y3QgZnRyYWNlX2hhc2ggKmRpcmVjdF9mdW5j dGlvbnMgPSBFTVBUWV9IQVNIOwo+IEBAIC0zNzgwLDExICszODY5LDEyIEBAIHN0YXRpYyBpbnQg dF9zaG93KHN0cnVjdCBzZXFfZmlsZSAqbSwgdm9pZCAqdikKPiAgCWlmIChpdGVyLT5mbGFncyAm IEZUUkFDRV9JVEVSX0VOQUJMRUQpIHsKPiAgCQlzdHJ1Y3QgZnRyYWNlX29wcyAqb3BzOwo+ICAK PiAtCQlzZXFfcHJpbnRmKG0sICIgKCVsZCklcyVzJXMiLAo+ICsJCXNlcV9wcmludGYobSwgIiAo JWxkKSVzJXMlcyVzIiwKPiAgCQkJICAgZnRyYWNlX3JlY19jb3VudChyZWMpLAo+ICAJCQkgICBy ZWMtPmZsYWdzICYgRlRSQUNFX0ZMX1JFR1MgPyAiIFIiIDogIiAgIiwKPiAgCQkJICAgcmVjLT5m bGFncyAmIEZUUkFDRV9GTF9JUE1PRElGWSA/ICIgSSIgOiAiICAiLAo+IC0JCQkgICByZWMtPmZs YWdzICYgRlRSQUNFX0ZMX0RJUkVDVCA/ICIgRCIgOiAiICAiKTsKPiArCQkJICAgcmVjLT5mbGFn cyAmIEZUUkFDRV9GTF9ESVJFQ1QgPyAiIEQiIDogIiAgIiwKPiArCQkJICAgcmVjLT5mbGFncyAm IEZUUkFDRV9GTF9DQUxMX09QUyA/ICIgTyIgOiAiICAiKTsKPiAgCQlpZiAocmVjLT5mbGFncyAm IEZUUkFDRV9GTF9UUkFNUF9FTikgewo+ICAJCQlvcHMgPSBmdHJhY2VfZmluZF90cmFtcF9vcHNf YW55KHJlYyk7Cj4gIAkJCWlmIChvcHMpIHsKPiBAQCAtMzgwMCw2ICszODkwLDE1IEBAIHN0YXRp YyBpbnQgdF9zaG93KHN0cnVjdCBzZXFfZmlsZSAqbSwgdm9pZCAqdikKPiAgCQl9IGVsc2Ugewo+ ICAJCQlhZGRfdHJhbXBvbGluZV9mdW5jKG0sIE5VTEwsIHJlYyk7Cj4gIAkJfQo+ICsJCWlmIChy ZWMtPmZsYWdzICYgRlRSQUNFX0ZMX0NBTExfT1BTX0VOKSB7Cj4gKwkJCW9wcyA9IGZ0cmFjZV9m aW5kX3VuaXF1ZV9vcHMocmVjKTsKPiArCQkJaWYgKG9wcykgewo+ICsJCQkJc2VxX3ByaW50Ziht LCAiXHRvcHM6ICVwUyAoJXBTKSIsCj4gKwkJCQkJICAgb3BzLCBvcHMtPmZ1bmMpOwo+ICsJCQl9 IGVsc2Ugewo+ICsJCQkJc2VxX3B1dHMobSwgIlx0b3BzOiBFUlJPUiEiKTsKPiArCQkJfQo+ICsJ CX0KPiAgCQlpZiAocmVjLT5mbGFncyAmIEZUUkFDRV9GTF9ESVJFQ1QpIHsKPiAgCQkJdW5zaWdu ZWQgbG9uZyBkaXJlY3Q7Cj4gIAo+IAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtl cm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxt YW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=