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 DCBD2C77B73 for ; Sat, 27 May 2023 01:46:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S243355AbjE0BqA (ORCPT ); Fri, 26 May 2023 21:46:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38788 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237583AbjE0Bpz (ORCPT ); Fri, 26 May 2023 21:45:55 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 59ED1FB; Fri, 26 May 2023 18:45:33 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 25065617C3; Sat, 27 May 2023 01:45:26 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1CF14C433EF; Sat, 27 May 2023 01:45:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1685151925; bh=jWg2ubvJDgLw8hoGNig/7tjb1LiEjtQF+MV9ioJEH2U=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=kk0mmwgD15XAqvZqFSC3+eVJA2ItIh1UHhmddP9xpwYUwvSYE/PkMbf9CEB9rMEU6 Iady2NAqcGn4+G+/Zyam6T3oRQR4r7qZ5+MmhzSPHigMCTEJaMe9zAEhvl79tsJ2A5 kD+uOu54LFjurPu2F0h6T9nyc9KpXXrBnXq7YozNUgtmJiSW6B39GbgGPb2sdSJCP6 OxOBgYxwWYP/R188p6YBUB0a0xkqKzYw7rRTroxs19D6FU8ndXUOODv36Bbmb1vqDI qFkEhnjDXD1cRcLbhYk+XVBTzmgFoHhjjfNX1xOHN5G4+drlk3G9os69IthsTKmpvf TIw+TmnyQRxZg== Received: by quaco.ghostprotocols.net (Postfix, from userid 1000) id 4C265403B5; Fri, 26 May 2023 22:45:22 -0300 (-03) Date: Fri, 26 May 2023 22:45:22 -0300 From: Arnaldo Carvalho de Melo To: Ian Rogers Cc: Suzuki K Poulose , Mike Leach , Leo Yan , John Garry , Will Deacon , James Clark , Peter Zijlstra , Ingo Molnar , Mark Rutland , Alexander Shishkin , Jiri Olsa , Namhyung Kim , Adrian Hunter , Kajol Jain , Jing Zhang , Kan Liang , Zhengjun Xing , Ravi Bangoria , Madhavan Srinivasan , Athira Rajeev , Ming Wang , Huacai Chen , Sandipan Das , Dmitrii Dolgov <9erthalion6@gmail.com>, Sean Christopherson , Ali Saidi , Rob Herring , Thomas Richter , Kang Minchul , linux-kernel@vger.kernel.org, coresight@lists.linaro.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org Subject: Re: [PATCH v4 14/35] perf evlist: Remove __evlist__add_default Message-ID: References: <20230526215410.2435674-1-irogers@google.com> <20230526215410.2435674-15-irogers@google.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20230526215410.2435674-15-irogers@google.com> X-Url: http://acmel.wordpress.com Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Em Fri, May 26, 2023 at 02:53:49PM -0700, Ian Rogers escreveu: > __evlist__add_default adds a cycles event to a typically empty evlist > and was extended for hybrid with evlist__add_default_hybrid, as more > than 1 PMU was necessary. Rather than have dedicated logic for the > cycles event, this change switches to parsing 'cycles:P' which will > handle wildcarding the PMUs appropriately for hybrid. I think I reported this earlier, but at this point 'perf test python' breaks, I fixed it in the tmp.perf-tools-next: 19: 'import perf' in python : FAILED! ⬢[acme@toolbox perf-tools-next]$ git log --oneline -1 fe4f622c4fc7a02a (HEAD) perf evlist: Remove __evlist__add_default ⬢[acme@toolbox perf-tools-next]$ ⬢[acme@toolbox perf-tools-next]$ perf test -v python Couldn't bump rlimit(MEMLOCK), failures may take place when creating BPF maps, etc 19: 'import perf' in python : --- start --- test child forked, pid 2976621 python usage test: "echo "import sys ; sys.path.append('/tmp/build/perf-tools-next/python'); import perf" | '/usr/bin/python3' " Traceback (most recent call last): File "", line 1, in ImportError: /tmp/build/perf-tools-next/python/perf.cpython-310-x86_64-linux-gnu.so: undefined symbol: parse_event test child finished with -1 ---- end ---- 'import perf' in python: FAILED! ⬢[acme@toolbox perf-tools-next]$ Probably there will be a few more cases in the next patches, please check. - Arnaldo > Signed-off-by: Ian Rogers > Reviewed-by: Kan Liang > --- > tools/perf/arch/x86/util/evsel.c | 20 -------------- > tools/perf/builtin-record.c | 13 +++------ > tools/perf/builtin-top.c | 10 ++++--- > tools/perf/util/evlist-hybrid.c | 25 ----------------- > tools/perf/util/evlist-hybrid.h | 1 - > tools/perf/util/evlist.c | 22 ++++++--------- > tools/perf/util/evlist.h | 7 ----- > tools/perf/util/evsel.c | 46 -------------------------------- > tools/perf/util/evsel.h | 3 --- > 9 files changed, 17 insertions(+), 130 deletions(-) > > diff --git a/tools/perf/arch/x86/util/evsel.c b/tools/perf/arch/x86/util/evsel.c > index ea3972d785d1..153cdca94cd4 100644 > --- a/tools/perf/arch/x86/util/evsel.c > +++ b/tools/perf/arch/x86/util/evsel.c > @@ -16,26 +16,6 @@ void arch_evsel__set_sample_weight(struct evsel *evsel) > evsel__set_sample_bit(evsel, WEIGHT_STRUCT); > } > > -void arch_evsel__fixup_new_cycles(struct perf_event_attr *attr) > -{ > - struct perf_env env = { .total_mem = 0, } ; > - > - if (!perf_env__cpuid(&env)) > - return; > - > - /* > - * On AMD, precise cycles event sampling internally uses IBS pmu. > - * But IBS does not have filtering capabilities and perf by default > - * sets exclude_guest = 1. This makes IBS pmu event init fail and > - * thus perf ends up doing non-precise sampling. Avoid it by clearing > - * exclude_guest. > - */ > - if (env.cpuid && strstarts(env.cpuid, "AuthenticAMD")) > - attr->exclude_guest = 0; > - > - free(env.cpuid); > -} > - > /* Check whether the evsel's PMU supports the perf metrics */ > bool evsel__sys_has_perf_metrics(const struct evsel *evsel) > { > diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c > index 88f7b4241153..d80b54a6f450 100644 > --- a/tools/perf/builtin-record.c > +++ b/tools/perf/builtin-record.c > @@ -4161,18 +4161,11 @@ int cmd_record(int argc, const char **argv) > record.opts.tail_synthesize = true; > > if (rec->evlist->core.nr_entries == 0) { > - if (perf_pmu__has_hybrid()) { > - err = evlist__add_default_hybrid(rec->evlist, > - !record.opts.no_samples); > - } else { > - err = __evlist__add_default(rec->evlist, > - !record.opts.no_samples); > - } > + bool can_profile_kernel = perf_event_paranoid_check(1); > > - if (err < 0) { > - pr_err("Not enough memory for event selector list\n"); > + err = parse_event(rec->evlist, can_profile_kernel ? "cycles:P" : "cycles:Pu"); > + if (err) > goto out; > - } > } > > if (rec->opts.target.tid && !rec->opts.no_inherit_set) > diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c > index 48ee49e95c5e..27a7f068207d 100644 > --- a/tools/perf/builtin-top.c > +++ b/tools/perf/builtin-top.c > @@ -1653,10 +1653,12 @@ int cmd_top(int argc, const char **argv) > if (annotate_check_args(&top.annotation_opts) < 0) > goto out_delete_evlist; > > - if (!top.evlist->core.nr_entries && > - evlist__add_default(top.evlist) < 0) { > - pr_err("Not enough memory for event selector list\n"); > - goto out_delete_evlist; > + if (!top.evlist->core.nr_entries) { > + bool can_profile_kernel = perf_event_paranoid_check(1); > + int err = parse_event(top.evlist, can_profile_kernel ? "cycles:P" : "cycles:Pu"); > + > + if (err) > + goto out_delete_evlist; > } > > status = evswitch__init(&top.evswitch, top.evlist, stderr); > diff --git a/tools/perf/util/evlist-hybrid.c b/tools/perf/util/evlist-hybrid.c > index 0f59c80f27b2..64f78d06fe19 100644 > --- a/tools/perf/util/evlist-hybrid.c > +++ b/tools/perf/util/evlist-hybrid.c > @@ -16,31 +16,6 @@ > #include > #include > > -int evlist__add_default_hybrid(struct evlist *evlist, bool precise) > -{ > - struct evsel *evsel; > - struct perf_pmu *pmu; > - __u64 config; > - struct perf_cpu_map *cpus; > - > - perf_pmu__for_each_hybrid_pmu(pmu) { > - config = PERF_COUNT_HW_CPU_CYCLES | > - ((__u64)pmu->type << PERF_PMU_TYPE_SHIFT); > - evsel = evsel__new_cycles(precise, PERF_TYPE_HARDWARE, > - config); > - if (!evsel) > - return -ENOMEM; > - > - cpus = perf_cpu_map__get(pmu->cpus); > - evsel->core.cpus = cpus; > - evsel->core.own_cpus = perf_cpu_map__get(cpus); > - evsel->pmu_name = strdup(pmu->name); > - evlist__add(evlist, evsel); > - } > - > - return 0; > -} > - > bool evlist__has_hybrid(struct evlist *evlist) > { > struct evsel *evsel; > diff --git a/tools/perf/util/evlist-hybrid.h b/tools/perf/util/evlist-hybrid.h > index 4b000eda6626..0cded76eb344 100644 > --- a/tools/perf/util/evlist-hybrid.h > +++ b/tools/perf/util/evlist-hybrid.h > @@ -7,7 +7,6 @@ > #include "evlist.h" > #include > > -int evlist__add_default_hybrid(struct evlist *evlist, bool precise); > bool evlist__has_hybrid(struct evlist *evlist); > > #endif /* __PERF_EVLIST_HYBRID_H */ > diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c > index 9dfa977193b3..63f8821a5395 100644 > --- a/tools/perf/util/evlist.c > +++ b/tools/perf/util/evlist.c > @@ -93,8 +93,15 @@ struct evlist *evlist__new(void) > struct evlist *evlist__new_default(void) > { > struct evlist *evlist = evlist__new(); > + bool can_profile_kernel; > + int err; > + > + if (!evlist) > + return NULL; > > - if (evlist && evlist__add_default(evlist)) { > + can_profile_kernel = perf_event_paranoid_check(1); > + err = parse_event(evlist, can_profile_kernel ? "cycles:P" : "cycles:Pu"); > + if (err) { > evlist__delete(evlist); > evlist = NULL; > } > @@ -237,19 +244,6 @@ static void evlist__set_leader(struct evlist *evlist) > perf_evlist__set_leader(&evlist->core); > } > > -int __evlist__add_default(struct evlist *evlist, bool precise) > -{ > - struct evsel *evsel; > - > - evsel = evsel__new_cycles(precise, PERF_TYPE_HARDWARE, > - PERF_COUNT_HW_CPU_CYCLES); > - if (evsel == NULL) > - return -ENOMEM; > - > - evlist__add(evlist, evsel); > - return 0; > -} > - > static struct evsel *evlist__dummy_event(struct evlist *evlist) > { > struct perf_event_attr attr = { > diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h > index 5e7ff44f3043..664c6bf7b3e0 100644 > --- a/tools/perf/util/evlist.h > +++ b/tools/perf/util/evlist.h > @@ -100,13 +100,6 @@ void evlist__delete(struct evlist *evlist); > void evlist__add(struct evlist *evlist, struct evsel *entry); > void evlist__remove(struct evlist *evlist, struct evsel *evsel); > > -int __evlist__add_default(struct evlist *evlist, bool precise); > - > -static inline int evlist__add_default(struct evlist *evlist) > -{ > - return __evlist__add_default(evlist, true); > -} > - > int evlist__add_attrs(struct evlist *evlist, struct perf_event_attr *attrs, size_t nr_attrs); > > int __evlist__add_default_attrs(struct evlist *evlist, > diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c > index 8c8f371ea2b5..1df8f967d2eb 100644 > --- a/tools/perf/util/evsel.c > +++ b/tools/perf/util/evsel.c > @@ -316,48 +316,6 @@ struct evsel *evsel__new_idx(struct perf_event_attr *attr, int idx) > return evsel; > } > > -static bool perf_event_can_profile_kernel(void) > -{ > - return perf_event_paranoid_check(1); > -} > - > -struct evsel *evsel__new_cycles(bool precise __maybe_unused, __u32 type, __u64 config) > -{ > - struct perf_event_attr attr = { > - .type = type, > - .config = config, > - .exclude_kernel = !perf_event_can_profile_kernel(), > - }; > - struct evsel *evsel; > - > - event_attr_init(&attr); > - > - /* > - * Now let the usual logic to set up the perf_event_attr defaults > - * to kick in when we return and before perf_evsel__open() is called. > - */ > - evsel = evsel__new(&attr); > - if (evsel == NULL) > - goto out; > - > - arch_evsel__fixup_new_cycles(&evsel->core.attr); > - > - evsel->precise_max = true; > - > - /* use asprintf() because free(evsel) assumes name is allocated */ > - if (asprintf(&evsel->name, "cycles%s%s%.*s", > - (attr.precise_ip || attr.exclude_kernel) ? ":" : "", > - attr.exclude_kernel ? "u" : "", > - attr.precise_ip ? attr.precise_ip + 1 : 0, "ppp") < 0) > - goto error_free; > -out: > - return evsel; > -error_free: > - evsel__delete(evsel); > - evsel = NULL; > - goto out; > -} > - > int copy_config_terms(struct list_head *dst, struct list_head *src) > { > struct evsel_config_term *pos, *tmp; > @@ -1131,10 +1089,6 @@ void __weak arch_evsel__set_sample_weight(struct evsel *evsel) > evsel__set_sample_bit(evsel, WEIGHT); > } > > -void __weak arch_evsel__fixup_new_cycles(struct perf_event_attr *attr __maybe_unused) > -{ > -} > - > void __weak arch__post_evsel_config(struct evsel *evsel __maybe_unused, > struct perf_event_attr *attr __maybe_unused) > { > diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h > index df8928745fc6..429b172cc94d 100644 > --- a/tools/perf/util/evsel.h > +++ b/tools/perf/util/evsel.h > @@ -243,8 +243,6 @@ static inline struct evsel *evsel__newtp(const char *sys, const char *name) > } > #endif > > -struct evsel *evsel__new_cycles(bool precise, __u32 type, __u64 config); > - > #ifdef HAVE_LIBTRACEEVENT > struct tep_event *event_format__new(const char *sys, const char *name); > #endif > @@ -312,7 +310,6 @@ void __evsel__reset_sample_bit(struct evsel *evsel, enum perf_event_sample_forma > void evsel__set_sample_id(struct evsel *evsel, bool use_sample_identifier); > > void arch_evsel__set_sample_weight(struct evsel *evsel); > -void arch_evsel__fixup_new_cycles(struct perf_event_attr *attr); > void arch__post_evsel_config(struct evsel *evsel, struct perf_event_attr *attr); > > int evsel__set_filter(struct evsel *evsel, const char *filter); > -- > 2.41.0.rc0.172.g3f132b7071-goog > -- - Arnaldo 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 6F39BC77B73 for ; Sat, 27 May 2023 01:46: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:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=CAAXeT1Y937snEc6xPO1Hl3yhusEhlBu/A+7UaXb7Vc=; b=cxzb4HXnmJKHM8 0lpK7mk+WHFLA/rFUGiISeQArYoqamSxO1y5muP5c1fmYuueFS1ZSlfHLivY+TkqoETr7Wmg8NEqY POBYLnWa+qENzvNIubk6rI8qeyCbdSP9apJY7yYipoO2+uRwficRodFD2TCL9m0kytTjAUVreZOTh p/hIYqkx14bWYvPUcALdcyQ2YR+FfXm3Mzd9zNDPvN2PnQd9Syiyr+EcE1UhpLIuvv3gdmhPEM6qt 4uuC/n5HKvHknHKPeSjWtRVfdBf1+eS1WA/mETnYGHjNbXg6oVuspVsco0PmHwhD8r0FBa0WG5L7j i6Kxv/HWLmyuaBFnfbWg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1q2j0i-004a1R-2F; Sat, 27 May 2023 01:46:24 +0000 Received: from desiato.infradead.org ([2001:8b0:10b:1:d65d:64ff:fe57:4e05]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1q2j0h-004a10-20 for linux-arm-kernel@bombadil.infradead.org; Sat, 27 May 2023 01:46:23 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=desiato.20200630; h=In-Reply-To:Content-Transfer-Encoding: Content-Type:MIME-Version:References:Message-ID:Subject:Cc:To:From:Date: Sender:Reply-To:Content-ID:Content-Description; bh=+lTlt7Rhhyp3wgwX3mjHZm2VKdtABPFuHhIcbyE3UDM=; b=PGg9PHwHT7kbIrSoOeSVI5rQsx 8LsXne016SFEvQENdPSM6iCy7u+JupOFLB4lwoR3zsxvR4UU0FTwwbvJ0yklH3KukczkvCFOuHaOA 1HvypWkCgwBVPU1pwhv6B9CqFkNlujobVQZDshxGWG/nkJavy0tqsVRzStuB/cn2yx+MQiHEnScqs 4wDoZI0L3QdRslofpddQSQgNMI9m8oE+FOoWRvV0Xvr7DWQlicEG4+SUS3iEday1wFgr0+HUcT8tV YoGhRqgHDmsrczugsK6YV58BO/MIITIJp4nkMPCbwEizlYnnSqLIemeLWFmU3+LOUphZQFF784X6H JhFRGGnw==; Received: from [179.97.37.151] (helo=quaco.ghostprotocols.net) by desiato.infradead.org with esmtpsa (Exim 4.96 #2 (Red Hat Linux)) id 1q2izm-007mBv-0m; Sat, 27 May 2023 01:45:29 +0000 Received: by quaco.ghostprotocols.net (Postfix, from userid 1000) id 4C265403B5; Fri, 26 May 2023 22:45:22 -0300 (-03) Date: Fri, 26 May 2023 22:45:22 -0300 From: Arnaldo Carvalho de Melo To: Ian Rogers Cc: Suzuki K Poulose , Mike Leach , Leo Yan , John Garry , Will Deacon , James Clark , Peter Zijlstra , Ingo Molnar , Mark Rutland , Alexander Shishkin , Jiri Olsa , Namhyung Kim , Adrian Hunter , Kajol Jain , Jing Zhang , Kan Liang , Zhengjun Xing , Ravi Bangoria , Madhavan Srinivasan , Athira Rajeev , Ming Wang , Huacai Chen , Sandipan Das , Dmitrii Dolgov <9erthalion6@gmail.com>, Sean Christopherson , Ali Saidi , Rob Herring , Thomas Richter , Kang Minchul , linux-kernel@vger.kernel.org, coresight@lists.linaro.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org Subject: Re: [PATCH v4 14/35] perf evlist: Remove __evlist__add_default Message-ID: References: <20230526215410.2435674-1-irogers@google.com> <20230526215410.2435674-15-irogers@google.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20230526215410.2435674-15-irogers@google.com> X-Url: http://acmel.wordpress.com 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 RW0gRnJpLCBNYXkgMjYsIDIwMjMgYXQgMDI6NTM6NDlQTSAtMDcwMCwgSWFuIFJvZ2VycyBlc2Ny ZXZldToKPiBfX2V2bGlzdF9fYWRkX2RlZmF1bHQgYWRkcyBhIGN5Y2xlcyBldmVudCB0byBhIHR5 cGljYWxseSBlbXB0eSBldmxpc3QKPiBhbmQgd2FzIGV4dGVuZGVkIGZvciBoeWJyaWQgd2l0aCBl dmxpc3RfX2FkZF9kZWZhdWx0X2h5YnJpZCwgYXMgbW9yZQo+IHRoYW4gMSBQTVUgd2FzIG5lY2Vz c2FyeS4gUmF0aGVyIHRoYW4gaGF2ZSBkZWRpY2F0ZWQgbG9naWMgZm9yIHRoZQo+IGN5Y2xlcyBl dmVudCwgdGhpcyBjaGFuZ2Ugc3dpdGNoZXMgdG8gcGFyc2luZyAnY3ljbGVzOlAnIHdoaWNoIHdp bGwKPiBoYW5kbGUgd2lsZGNhcmRpbmcgdGhlIFBNVXMgYXBwcm9wcmlhdGVseSBmb3IgaHlicmlk LgoKSSB0aGluayBJIHJlcG9ydGVkIHRoaXMgZWFybGllciwgYnV0IGF0IHRoaXMgcG9pbnQgJ3Bl cmYgdGVzdCBweXRob24nCmJyZWFrcywgSSBmaXhlZCBpdCBpbiB0aGUgdG1wLnBlcmYtdG9vbHMt bmV4dDoKCiAxOTogJ2ltcG9ydCBwZXJmJyBpbiBweXRob24gICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIDogRkFJTEVEIQrirKJbYWNtZUB0b29sYm94IHBlcmYtdG9vbHMt bmV4dF0kIGdpdCBsb2cgLS1vbmVsaW5lIC0xCmZlNGY2MjJjNGZjN2EwMmEgKEhFQUQpIHBlcmYg ZXZsaXN0OiBSZW1vdmUgX19ldmxpc3RfX2FkZF9kZWZhdWx0CuKsolthY21lQHRvb2xib3ggcGVy Zi10b29scy1uZXh0XSQK4qyiW2FjbWVAdG9vbGJveCBwZXJmLXRvb2xzLW5leHRdJCBwZXJmIHRl c3QgLXYgcHl0aG9uCkNvdWxkbid0IGJ1bXAgcmxpbWl0KE1FTUxPQ0spLCBmYWlsdXJlcyBtYXkg dGFrZSBwbGFjZSB3aGVuIGNyZWF0aW5nIEJQRiBtYXBzLCBldGMKIDE5OiAnaW1wb3J0IHBlcmYn IGluIHB5dGhvbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOgotLS0g c3RhcnQgLS0tCnRlc3QgY2hpbGQgZm9ya2VkLCBwaWQgMjk3NjYyMQpweXRob24gdXNhZ2UgdGVz dDogImVjaG8gImltcG9ydCBzeXMgOyBzeXMucGF0aC5hcHBlbmQoJy90bXAvYnVpbGQvcGVyZi10 b29scy1uZXh0L3B5dGhvbicpOyBpbXBvcnQgcGVyZiIgfCAnL3Vzci9iaW4vcHl0aG9uMycgIgpU cmFjZWJhY2sgKG1vc3QgcmVjZW50IGNhbGwgbGFzdCk6CiAgRmlsZSAiPHN0ZGluPiIsIGxpbmUg MSwgaW4gPG1vZHVsZT4KSW1wb3J0RXJyb3I6IC90bXAvYnVpbGQvcGVyZi10b29scy1uZXh0L3B5 dGhvbi9wZXJmLmNweXRob24tMzEwLXg4Nl82NC1saW51eC1nbnUuc286IHVuZGVmaW5lZCBzeW1i b2w6IHBhcnNlX2V2ZW50CnRlc3QgY2hpbGQgZmluaXNoZWQgd2l0aCAtMQotLS0tIGVuZCAtLS0t CidpbXBvcnQgcGVyZicgaW4gcHl0aG9uOiBGQUlMRUQhCuKsolthY21lQHRvb2xib3ggcGVyZi10 b29scy1uZXh0XSQKClByb2JhYmx5IHRoZXJlIHdpbGwgYmUgYSBmZXcgbW9yZSBjYXNlcyBpbiB0 aGUgbmV4dCBwYXRjaGVzLCBwbGVhc2UKY2hlY2suCgotIEFybmFsZG8KIAo+IFNpZ25lZC1vZmYt Ynk6IElhbiBSb2dlcnMgPGlyb2dlcnNAZ29vZ2xlLmNvbT4KPiBSZXZpZXdlZC1ieTogS2FuIExp YW5nIDxrYW4ubGlhbmdAbGludXguaW50ZWwuY29tPgo+IC0tLQo+ICB0b29scy9wZXJmL2FyY2gv eDg2L3V0aWwvZXZzZWwuYyB8IDIwIC0tLS0tLS0tLS0tLS0tCj4gIHRvb2xzL3BlcmYvYnVpbHRp bi1yZWNvcmQuYyAgICAgIHwgMTMgKysrLS0tLS0tCj4gIHRvb2xzL3BlcmYvYnVpbHRpbi10b3Au YyAgICAgICAgIHwgMTAgKysrKy0tLQo+ICB0b29scy9wZXJmL3V0aWwvZXZsaXN0LWh5YnJpZC5j ICB8IDI1IC0tLS0tLS0tLS0tLS0tLS0tCj4gIHRvb2xzL3BlcmYvdXRpbC9ldmxpc3QtaHlicmlk LmggIHwgIDEgLQo+ICB0b29scy9wZXJmL3V0aWwvZXZsaXN0LmMgICAgICAgICB8IDIyICsrKysr Ky0tLS0tLS0tLQo+ICB0b29scy9wZXJmL3V0aWwvZXZsaXN0LmggICAgICAgICB8ICA3IC0tLS0t Cj4gIHRvb2xzL3BlcmYvdXRpbC9ldnNlbC5jICAgICAgICAgIHwgNDYgLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KPiAgdG9vbHMvcGVyZi91dGlsL2V2c2VsLmggICAgICAgICAgfCAg MyAtLS0KPiAgOSBmaWxlcyBjaGFuZ2VkLCAxNyBpbnNlcnRpb25zKCspLCAxMzAgZGVsZXRpb25z KC0pCj4gCj4gZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvYXJjaC94ODYvdXRpbC9ldnNlbC5jIGIv dG9vbHMvcGVyZi9hcmNoL3g4Ni91dGlsL2V2c2VsLmMKPiBpbmRleCBlYTM5NzJkNzg1ZDEuLjE1 M2NkY2E5NGNkNCAxMDA2NDQKPiAtLS0gYS90b29scy9wZXJmL2FyY2gveDg2L3V0aWwvZXZzZWwu Ywo+ICsrKyBiL3Rvb2xzL3BlcmYvYXJjaC94ODYvdXRpbC9ldnNlbC5jCj4gQEAgLTE2LDI2ICsx Niw2IEBAIHZvaWQgYXJjaF9ldnNlbF9fc2V0X3NhbXBsZV93ZWlnaHQoc3RydWN0IGV2c2VsICpl dnNlbCkKPiAgCWV2c2VsX19zZXRfc2FtcGxlX2JpdChldnNlbCwgV0VJR0hUX1NUUlVDVCk7Cj4g IH0KPiAgCj4gLXZvaWQgYXJjaF9ldnNlbF9fZml4dXBfbmV3X2N5Y2xlcyhzdHJ1Y3QgcGVyZl9l dmVudF9hdHRyICphdHRyKQo+IC17Cj4gLQlzdHJ1Y3QgcGVyZl9lbnYgZW52ID0geyAudG90YWxf bWVtID0gMCwgfSA7Cj4gLQo+IC0JaWYgKCFwZXJmX2Vudl9fY3B1aWQoJmVudikpCj4gLQkJcmV0 dXJuOwo+IC0KPiAtCS8qCj4gLQkgKiBPbiBBTUQsIHByZWNpc2UgY3ljbGVzIGV2ZW50IHNhbXBs aW5nIGludGVybmFsbHkgdXNlcyBJQlMgcG11Lgo+IC0JICogQnV0IElCUyBkb2VzIG5vdCBoYXZl IGZpbHRlcmluZyBjYXBhYmlsaXRpZXMgYW5kIHBlcmYgYnkgZGVmYXVsdAo+IC0JICogc2V0cyBl eGNsdWRlX2d1ZXN0ID0gMS4gVGhpcyBtYWtlcyBJQlMgcG11IGV2ZW50IGluaXQgZmFpbCBhbmQK PiAtCSAqIHRodXMgcGVyZiBlbmRzIHVwIGRvaW5nIG5vbi1wcmVjaXNlIHNhbXBsaW5nLiBBdm9p ZCBpdCBieSBjbGVhcmluZwo+IC0JICogZXhjbHVkZV9ndWVzdC4KPiAtCSAqLwo+IC0JaWYgKGVu di5jcHVpZCAmJiBzdHJzdGFydHMoZW52LmNwdWlkLCAiQXV0aGVudGljQU1EIikpCj4gLQkJYXR0 ci0+ZXhjbHVkZV9ndWVzdCA9IDA7Cj4gLQo+IC0JZnJlZShlbnYuY3B1aWQpOwo+IC19Cj4gLQo+ ICAvKiBDaGVjayB3aGV0aGVyIHRoZSBldnNlbCdzIFBNVSBzdXBwb3J0cyB0aGUgcGVyZiBtZXRy aWNzICovCj4gIGJvb2wgZXZzZWxfX3N5c19oYXNfcGVyZl9tZXRyaWNzKGNvbnN0IHN0cnVjdCBl dnNlbCAqZXZzZWwpCj4gIHsKPiBkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9idWlsdGluLXJlY29y ZC5jIGIvdG9vbHMvcGVyZi9idWlsdGluLXJlY29yZC5jCj4gaW5kZXggODhmN2I0MjQxMTUzLi5k ODBiNTRhNmY0NTAgMTAwNjQ0Cj4gLS0tIGEvdG9vbHMvcGVyZi9idWlsdGluLXJlY29yZC5jCj4g KysrIGIvdG9vbHMvcGVyZi9idWlsdGluLXJlY29yZC5jCj4gQEAgLTQxNjEsMTggKzQxNjEsMTEg QEAgaW50IGNtZF9yZWNvcmQoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2KQo+ICAJCXJlY29y ZC5vcHRzLnRhaWxfc3ludGhlc2l6ZSA9IHRydWU7Cj4gIAo+ICAJaWYgKHJlYy0+ZXZsaXN0LT5j b3JlLm5yX2VudHJpZXMgPT0gMCkgewo+IC0JCWlmIChwZXJmX3BtdV9faGFzX2h5YnJpZCgpKSB7 Cj4gLQkJCWVyciA9IGV2bGlzdF9fYWRkX2RlZmF1bHRfaHlicmlkKHJlYy0+ZXZsaXN0LAo+IC0J CQkJCQkJICFyZWNvcmQub3B0cy5ub19zYW1wbGVzKTsKPiAtCQl9IGVsc2Ugewo+IC0JCQllcnIg PSBfX2V2bGlzdF9fYWRkX2RlZmF1bHQocmVjLT5ldmxpc3QsCj4gLQkJCQkJCSAgICAhcmVjb3Jk Lm9wdHMubm9fc2FtcGxlcyk7Cj4gLQkJfQo+ICsJCWJvb2wgY2FuX3Byb2ZpbGVfa2VybmVsID0g cGVyZl9ldmVudF9wYXJhbm9pZF9jaGVjaygxKTsKPiAgCj4gLQkJaWYgKGVyciA8IDApIHsKPiAt CQkJcHJfZXJyKCJOb3QgZW5vdWdoIG1lbW9yeSBmb3IgZXZlbnQgc2VsZWN0b3IgbGlzdFxuIik7 Cj4gKwkJZXJyID0gcGFyc2VfZXZlbnQocmVjLT5ldmxpc3QsIGNhbl9wcm9maWxlX2tlcm5lbCA/ ICJjeWNsZXM6UCIgOiAiY3ljbGVzOlB1Iik7Cj4gKwkJaWYgKGVycikKPiAgCQkJZ290byBvdXQ7 Cj4gLQkJfQo+ICAJfQo+ICAKPiAgCWlmIChyZWMtPm9wdHMudGFyZ2V0LnRpZCAmJiAhcmVjLT5v cHRzLm5vX2luaGVyaXRfc2V0KQo+IGRpZmYgLS1naXQgYS90b29scy9wZXJmL2J1aWx0aW4tdG9w LmMgYi90b29scy9wZXJmL2J1aWx0aW4tdG9wLmMKPiBpbmRleCA0OGVlNDllOTVjNWUuLjI3YTdm MDY4MjA3ZCAxMDA2NDQKPiAtLS0gYS90b29scy9wZXJmL2J1aWx0aW4tdG9wLmMKPiArKysgYi90 b29scy9wZXJmL2J1aWx0aW4tdG9wLmMKPiBAQCAtMTY1MywxMCArMTY1MywxMiBAQCBpbnQgY21k X3RvcChpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YpCj4gIAlpZiAoYW5ub3RhdGVfY2hlY2tf YXJncygmdG9wLmFubm90YXRpb25fb3B0cykgPCAwKQo+ICAJCWdvdG8gb3V0X2RlbGV0ZV9ldmxp c3Q7Cj4gIAo+IC0JaWYgKCF0b3AuZXZsaXN0LT5jb3JlLm5yX2VudHJpZXMgJiYKPiAtCSAgICBl dmxpc3RfX2FkZF9kZWZhdWx0KHRvcC5ldmxpc3QpIDwgMCkgewo+IC0JCXByX2VycigiTm90IGVu b3VnaCBtZW1vcnkgZm9yIGV2ZW50IHNlbGVjdG9yIGxpc3RcbiIpOwo+IC0JCWdvdG8gb3V0X2Rl bGV0ZV9ldmxpc3Q7Cj4gKwlpZiAoIXRvcC5ldmxpc3QtPmNvcmUubnJfZW50cmllcykgewo+ICsJ CWJvb2wgY2FuX3Byb2ZpbGVfa2VybmVsID0gcGVyZl9ldmVudF9wYXJhbm9pZF9jaGVjaygxKTsK PiArCQlpbnQgZXJyID0gcGFyc2VfZXZlbnQodG9wLmV2bGlzdCwgY2FuX3Byb2ZpbGVfa2VybmVs ID8gImN5Y2xlczpQIiA6ICJjeWNsZXM6UHUiKTsKPiArCj4gKwkJaWYgKGVycikKPiArCQkJZ290 byBvdXRfZGVsZXRlX2V2bGlzdDsKPiAgCX0KPiAgCj4gIAlzdGF0dXMgPSBldnN3aXRjaF9faW5p dCgmdG9wLmV2c3dpdGNoLCB0b3AuZXZsaXN0LCBzdGRlcnIpOwo+IGRpZmYgLS1naXQgYS90b29s cy9wZXJmL3V0aWwvZXZsaXN0LWh5YnJpZC5jIGIvdG9vbHMvcGVyZi91dGlsL2V2bGlzdC1oeWJy aWQuYwo+IGluZGV4IDBmNTljODBmMjdiMi4uNjRmNzhkMDZmZTE5IDEwMDY0NAo+IC0tLSBhL3Rv b2xzL3BlcmYvdXRpbC9ldmxpc3QtaHlicmlkLmMKPiArKysgYi90b29scy9wZXJmL3V0aWwvZXZs aXN0LWh5YnJpZC5jCj4gQEAgLTE2LDMxICsxNiw2IEBACj4gICNpbmNsdWRlIDxwZXJmL2V2c2Vs Lmg+Cj4gICNpbmNsdWRlIDxwZXJmL2NwdW1hcC5oPgo+ICAKPiAtaW50IGV2bGlzdF9fYWRkX2Rl ZmF1bHRfaHlicmlkKHN0cnVjdCBldmxpc3QgKmV2bGlzdCwgYm9vbCBwcmVjaXNlKQo+IC17Cj4g LQlzdHJ1Y3QgZXZzZWwgKmV2c2VsOwo+IC0Jc3RydWN0IHBlcmZfcG11ICpwbXU7Cj4gLQlfX3U2 NCBjb25maWc7Cj4gLQlzdHJ1Y3QgcGVyZl9jcHVfbWFwICpjcHVzOwo+IC0KPiAtCXBlcmZfcG11 X19mb3JfZWFjaF9oeWJyaWRfcG11KHBtdSkgewo+IC0JCWNvbmZpZyA9IFBFUkZfQ09VTlRfSFdf Q1BVX0NZQ0xFUyB8Cj4gLQkJCSAoKF9fdTY0KXBtdS0+dHlwZSA8PCBQRVJGX1BNVV9UWVBFX1NI SUZUKTsKPiAtCQlldnNlbCA9IGV2c2VsX19uZXdfY3ljbGVzKHByZWNpc2UsIFBFUkZfVFlQRV9I QVJEV0FSRSwKPiAtCQkJCQkgIGNvbmZpZyk7Cj4gLQkJaWYgKCFldnNlbCkKPiAtCQkJcmV0dXJu IC1FTk9NRU07Cj4gLQo+IC0JCWNwdXMgPSBwZXJmX2NwdV9tYXBfX2dldChwbXUtPmNwdXMpOwo+ IC0JCWV2c2VsLT5jb3JlLmNwdXMgPSBjcHVzOwo+IC0JCWV2c2VsLT5jb3JlLm93bl9jcHVzID0g cGVyZl9jcHVfbWFwX19nZXQoY3B1cyk7Cj4gLQkJZXZzZWwtPnBtdV9uYW1lID0gc3RyZHVwKHBt dS0+bmFtZSk7Cj4gLQkJZXZsaXN0X19hZGQoZXZsaXN0LCBldnNlbCk7Cj4gLQl9Cj4gLQo+IC0J cmV0dXJuIDA7Cj4gLX0KPiAtCj4gIGJvb2wgZXZsaXN0X19oYXNfaHlicmlkKHN0cnVjdCBldmxp c3QgKmV2bGlzdCkKPiAgewo+ICAJc3RydWN0IGV2c2VsICpldnNlbDsKPiBkaWZmIC0tZ2l0IGEv dG9vbHMvcGVyZi91dGlsL2V2bGlzdC1oeWJyaWQuaCBiL3Rvb2xzL3BlcmYvdXRpbC9ldmxpc3Qt aHlicmlkLmgKPiBpbmRleCA0YjAwMGVkYTY2MjYuLjBjZGVkNzZlYjM0NCAxMDA2NDQKPiAtLS0g YS90b29scy9wZXJmL3V0aWwvZXZsaXN0LWh5YnJpZC5oCj4gKysrIGIvdG9vbHMvcGVyZi91dGls L2V2bGlzdC1oeWJyaWQuaAo+IEBAIC03LDcgKzcsNiBAQAo+ICAjaW5jbHVkZSAiZXZsaXN0Lmgi Cj4gICNpbmNsdWRlIDx1bmlzdGQuaD4KPiAgCj4gLWludCBldmxpc3RfX2FkZF9kZWZhdWx0X2h5 YnJpZChzdHJ1Y3QgZXZsaXN0ICpldmxpc3QsIGJvb2wgcHJlY2lzZSk7Cj4gIGJvb2wgZXZsaXN0 X19oYXNfaHlicmlkKHN0cnVjdCBldmxpc3QgKmV2bGlzdCk7Cj4gIAo+ICAjZW5kaWYgLyogX19Q RVJGX0VWTElTVF9IWUJSSURfSCAqLwo+IGRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvZXZs aXN0LmMgYi90b29scy9wZXJmL3V0aWwvZXZsaXN0LmMKPiBpbmRleCA5ZGZhOTc3MTkzYjMuLjYz Zjg4MjFhNTM5NSAxMDA2NDQKPiAtLS0gYS90b29scy9wZXJmL3V0aWwvZXZsaXN0LmMKPiArKysg Yi90b29scy9wZXJmL3V0aWwvZXZsaXN0LmMKPiBAQCAtOTMsOCArOTMsMTUgQEAgc3RydWN0IGV2 bGlzdCAqZXZsaXN0X19uZXcodm9pZCkKPiAgc3RydWN0IGV2bGlzdCAqZXZsaXN0X19uZXdfZGVm YXVsdCh2b2lkKQo+ICB7Cj4gIAlzdHJ1Y3QgZXZsaXN0ICpldmxpc3QgPSBldmxpc3RfX25ldygp Owo+ICsJYm9vbCBjYW5fcHJvZmlsZV9rZXJuZWw7Cj4gKwlpbnQgZXJyOwo+ICsKPiArCWlmICgh ZXZsaXN0KQo+ICsJCXJldHVybiBOVUxMOwo+ICAKPiAtCWlmIChldmxpc3QgJiYgZXZsaXN0X19h ZGRfZGVmYXVsdChldmxpc3QpKSB7Cj4gKwljYW5fcHJvZmlsZV9rZXJuZWwgPSBwZXJmX2V2ZW50 X3BhcmFub2lkX2NoZWNrKDEpOwo+ICsJZXJyID0gcGFyc2VfZXZlbnQoZXZsaXN0LCBjYW5fcHJv ZmlsZV9rZXJuZWwgPyAiY3ljbGVzOlAiIDogImN5Y2xlczpQdSIpOwo+ICsJaWYgKGVycikgewo+ ICAJCWV2bGlzdF9fZGVsZXRlKGV2bGlzdCk7Cj4gIAkJZXZsaXN0ID0gTlVMTDsKPiAgCX0KPiBA QCAtMjM3LDE5ICsyNDQsNiBAQCBzdGF0aWMgdm9pZCBldmxpc3RfX3NldF9sZWFkZXIoc3RydWN0 IGV2bGlzdCAqZXZsaXN0KQo+ICAJcGVyZl9ldmxpc3RfX3NldF9sZWFkZXIoJmV2bGlzdC0+Y29y ZSk7Cj4gIH0KPiAgCj4gLWludCBfX2V2bGlzdF9fYWRkX2RlZmF1bHQoc3RydWN0IGV2bGlzdCAq ZXZsaXN0LCBib29sIHByZWNpc2UpCj4gLXsKPiAtCXN0cnVjdCBldnNlbCAqZXZzZWw7Cj4gLQo+ IC0JZXZzZWwgPSBldnNlbF9fbmV3X2N5Y2xlcyhwcmVjaXNlLCBQRVJGX1RZUEVfSEFSRFdBUkUs Cj4gLQkJCQkgIFBFUkZfQ09VTlRfSFdfQ1BVX0NZQ0xFUyk7Cj4gLQlpZiAoZXZzZWwgPT0gTlVM TCkKPiAtCQlyZXR1cm4gLUVOT01FTTsKPiAtCj4gLQlldmxpc3RfX2FkZChldmxpc3QsIGV2c2Vs KTsKPiAtCXJldHVybiAwOwo+IC19Cj4gLQo+ICBzdGF0aWMgc3RydWN0IGV2c2VsICpldmxpc3Rf X2R1bW15X2V2ZW50KHN0cnVjdCBldmxpc3QgKmV2bGlzdCkKPiAgewo+ICAJc3RydWN0IHBlcmZf ZXZlbnRfYXR0ciBhdHRyID0gewo+IGRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvZXZsaXN0 LmggYi90b29scy9wZXJmL3V0aWwvZXZsaXN0LmgKPiBpbmRleCA1ZTdmZjQ0ZjMwNDMuLjY2NGM2 YmY3YjNlMCAxMDA2NDQKPiAtLS0gYS90b29scy9wZXJmL3V0aWwvZXZsaXN0LmgKPiArKysgYi90 b29scy9wZXJmL3V0aWwvZXZsaXN0LmgKPiBAQCAtMTAwLDEzICsxMDAsNiBAQCB2b2lkIGV2bGlz dF9fZGVsZXRlKHN0cnVjdCBldmxpc3QgKmV2bGlzdCk7Cj4gIHZvaWQgZXZsaXN0X19hZGQoc3Ry dWN0IGV2bGlzdCAqZXZsaXN0LCBzdHJ1Y3QgZXZzZWwgKmVudHJ5KTsKPiAgdm9pZCBldmxpc3Rf X3JlbW92ZShzdHJ1Y3QgZXZsaXN0ICpldmxpc3QsIHN0cnVjdCBldnNlbCAqZXZzZWwpOwo+ICAK PiAtaW50IF9fZXZsaXN0X19hZGRfZGVmYXVsdChzdHJ1Y3QgZXZsaXN0ICpldmxpc3QsIGJvb2wg cHJlY2lzZSk7Cj4gLQo+IC1zdGF0aWMgaW5saW5lIGludCBldmxpc3RfX2FkZF9kZWZhdWx0KHN0 cnVjdCBldmxpc3QgKmV2bGlzdCkKPiAtewo+IC0JcmV0dXJuIF9fZXZsaXN0X19hZGRfZGVmYXVs dChldmxpc3QsIHRydWUpOwo+IC19Cj4gLQo+ICBpbnQgZXZsaXN0X19hZGRfYXR0cnMoc3RydWN0 IGV2bGlzdCAqZXZsaXN0LCBzdHJ1Y3QgcGVyZl9ldmVudF9hdHRyICphdHRycywgc2l6ZV90IG5y X2F0dHJzKTsKPiAgCj4gIGludCBfX2V2bGlzdF9fYWRkX2RlZmF1bHRfYXR0cnMoc3RydWN0IGV2 bGlzdCAqZXZsaXN0LAo+IGRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvZXZzZWwuYyBiL3Rv b2xzL3BlcmYvdXRpbC9ldnNlbC5jCj4gaW5kZXggOGM4ZjM3MWVhMmI1Li4xZGY4Zjk2N2QyZWIg MTAwNjQ0Cj4gLS0tIGEvdG9vbHMvcGVyZi91dGlsL2V2c2VsLmMKPiArKysgYi90b29scy9wZXJm L3V0aWwvZXZzZWwuYwo+IEBAIC0zMTYsNDggKzMxNiw2IEBAIHN0cnVjdCBldnNlbCAqZXZzZWxf X25ld19pZHgoc3RydWN0IHBlcmZfZXZlbnRfYXR0ciAqYXR0ciwgaW50IGlkeCkKPiAgCXJldHVy biBldnNlbDsKPiAgfQo+ICAKPiAtc3RhdGljIGJvb2wgcGVyZl9ldmVudF9jYW5fcHJvZmlsZV9r ZXJuZWwodm9pZCkKPiAtewo+IC0JcmV0dXJuIHBlcmZfZXZlbnRfcGFyYW5vaWRfY2hlY2soMSk7 Cj4gLX0KPiAtCj4gLXN0cnVjdCBldnNlbCAqZXZzZWxfX25ld19jeWNsZXMoYm9vbCBwcmVjaXNl IF9fbWF5YmVfdW51c2VkLCBfX3UzMiB0eXBlLCBfX3U2NCBjb25maWcpCj4gLXsKPiAtCXN0cnVj dCBwZXJmX2V2ZW50X2F0dHIgYXR0ciA9IHsKPiAtCQkudHlwZQk9IHR5cGUsCj4gLQkJLmNvbmZp Zwk9IGNvbmZpZywKPiAtCQkuZXhjbHVkZV9rZXJuZWwJPSAhcGVyZl9ldmVudF9jYW5fcHJvZmls ZV9rZXJuZWwoKSwKPiAtCX07Cj4gLQlzdHJ1Y3QgZXZzZWwgKmV2c2VsOwo+IC0KPiAtCWV2ZW50 X2F0dHJfaW5pdCgmYXR0cik7Cj4gLQo+IC0JLyoKPiAtCSAqIE5vdyBsZXQgdGhlIHVzdWFsIGxv Z2ljIHRvIHNldCB1cCB0aGUgcGVyZl9ldmVudF9hdHRyIGRlZmF1bHRzCj4gLQkgKiB0byBraWNr IGluIHdoZW4gd2UgcmV0dXJuIGFuZCBiZWZvcmUgcGVyZl9ldnNlbF9fb3BlbigpIGlzIGNhbGxl ZC4KPiAtCSAqLwo+IC0JZXZzZWwgPSBldnNlbF9fbmV3KCZhdHRyKTsKPiAtCWlmIChldnNlbCA9 PSBOVUxMKQo+IC0JCWdvdG8gb3V0Owo+IC0KPiAtCWFyY2hfZXZzZWxfX2ZpeHVwX25ld19jeWNs ZXMoJmV2c2VsLT5jb3JlLmF0dHIpOwo+IC0KPiAtCWV2c2VsLT5wcmVjaXNlX21heCA9IHRydWU7 Cj4gLQo+IC0JLyogdXNlIGFzcHJpbnRmKCkgYmVjYXVzZSBmcmVlKGV2c2VsKSBhc3N1bWVzIG5h bWUgaXMgYWxsb2NhdGVkICovCj4gLQlpZiAoYXNwcmludGYoJmV2c2VsLT5uYW1lLCAiY3ljbGVz JXMlcyUuKnMiLAo+IC0JCSAgICAgKGF0dHIucHJlY2lzZV9pcCB8fCBhdHRyLmV4Y2x1ZGVfa2Vy bmVsKSA/ICI6IiA6ICIiLAo+IC0JCSAgICAgYXR0ci5leGNsdWRlX2tlcm5lbCA/ICJ1IiA6ICIi LAo+IC0JCSAgICAgYXR0ci5wcmVjaXNlX2lwID8gYXR0ci5wcmVjaXNlX2lwICsgMSA6IDAsICJw cHAiKSA8IDApCj4gLQkJZ290byBlcnJvcl9mcmVlOwo+IC1vdXQ6Cj4gLQlyZXR1cm4gZXZzZWw7 Cj4gLWVycm9yX2ZyZWU6Cj4gLQlldnNlbF9fZGVsZXRlKGV2c2VsKTsKPiAtCWV2c2VsID0gTlVM TDsKPiAtCWdvdG8gb3V0Owo+IC19Cj4gLQo+ICBpbnQgY29weV9jb25maWdfdGVybXMoc3RydWN0 IGxpc3RfaGVhZCAqZHN0LCBzdHJ1Y3QgbGlzdF9oZWFkICpzcmMpCj4gIHsKPiAgCXN0cnVjdCBl dnNlbF9jb25maWdfdGVybSAqcG9zLCAqdG1wOwo+IEBAIC0xMTMxLDEwICsxMDg5LDYgQEAgdm9p ZCBfX3dlYWsgYXJjaF9ldnNlbF9fc2V0X3NhbXBsZV93ZWlnaHQoc3RydWN0IGV2c2VsICpldnNl bCkKPiAgCWV2c2VsX19zZXRfc2FtcGxlX2JpdChldnNlbCwgV0VJR0hUKTsKPiAgfQo+ICAKPiAt dm9pZCBfX3dlYWsgYXJjaF9ldnNlbF9fZml4dXBfbmV3X2N5Y2xlcyhzdHJ1Y3QgcGVyZl9ldmVu dF9hdHRyICphdHRyIF9fbWF5YmVfdW51c2VkKQo+IC17Cj4gLX0KPiAtCj4gIHZvaWQgX193ZWFr IGFyY2hfX3Bvc3RfZXZzZWxfY29uZmlnKHN0cnVjdCBldnNlbCAqZXZzZWwgX19tYXliZV91bnVz ZWQsCj4gIAkJCQkgICAgc3RydWN0IHBlcmZfZXZlbnRfYXR0ciAqYXR0ciBfX21heWJlX3VudXNl ZCkKPiAgewo+IGRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvZXZzZWwuaCBiL3Rvb2xzL3Bl cmYvdXRpbC9ldnNlbC5oCj4gaW5kZXggZGY4OTI4NzQ1ZmM2Li40MjliMTcyY2M5NGQgMTAwNjQ0 Cj4gLS0tIGEvdG9vbHMvcGVyZi91dGlsL2V2c2VsLmgKPiArKysgYi90b29scy9wZXJmL3V0aWwv ZXZzZWwuaAo+IEBAIC0yNDMsOCArMjQzLDYgQEAgc3RhdGljIGlubGluZSBzdHJ1Y3QgZXZzZWwg KmV2c2VsX19uZXd0cChjb25zdCBjaGFyICpzeXMsIGNvbnN0IGNoYXIgKm5hbWUpCj4gIH0KPiAg I2VuZGlmCj4gIAo+IC1zdHJ1Y3QgZXZzZWwgKmV2c2VsX19uZXdfY3ljbGVzKGJvb2wgcHJlY2lz ZSwgX191MzIgdHlwZSwgX191NjQgY29uZmlnKTsKPiAtCj4gICNpZmRlZiBIQVZFX0xJQlRSQUNF RVZFTlQKPiAgc3RydWN0IHRlcF9ldmVudCAqZXZlbnRfZm9ybWF0X19uZXcoY29uc3QgY2hhciAq c3lzLCBjb25zdCBjaGFyICpuYW1lKTsKPiAgI2VuZGlmCj4gQEAgLTMxMiw3ICszMTAsNiBAQCB2 b2lkIF9fZXZzZWxfX3Jlc2V0X3NhbXBsZV9iaXQoc3RydWN0IGV2c2VsICpldnNlbCwgZW51bSBw ZXJmX2V2ZW50X3NhbXBsZV9mb3JtYQo+ICB2b2lkIGV2c2VsX19zZXRfc2FtcGxlX2lkKHN0cnVj dCBldnNlbCAqZXZzZWwsIGJvb2wgdXNlX3NhbXBsZV9pZGVudGlmaWVyKTsKPiAgCj4gIHZvaWQg YXJjaF9ldnNlbF9fc2V0X3NhbXBsZV93ZWlnaHQoc3RydWN0IGV2c2VsICpldnNlbCk7Cj4gLXZv aWQgYXJjaF9ldnNlbF9fZml4dXBfbmV3X2N5Y2xlcyhzdHJ1Y3QgcGVyZl9ldmVudF9hdHRyICph dHRyKTsKPiAgdm9pZCBhcmNoX19wb3N0X2V2c2VsX2NvbmZpZyhzdHJ1Y3QgZXZzZWwgKmV2c2Vs LCBzdHJ1Y3QgcGVyZl9ldmVudF9hdHRyICphdHRyKTsKPiAgCj4gIGludCBldnNlbF9fc2V0X2Zp bHRlcihzdHJ1Y3QgZXZzZWwgKmV2c2VsLCBjb25zdCBjaGFyICpmaWx0ZXIpOwo+IC0tIAo+IDIu NDEuMC5yYzAuMTcyLmczZjEzMmI3MDcxLWdvb2cKPiAKCi0tIAoKLSBBcm5hbGRvCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVs IG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDov L2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==