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 80877C4332F for ; Thu, 17 Mar 2022 15:13:41 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235665AbiCQPOz (ORCPT ); Thu, 17 Mar 2022 11:14:55 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59076 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235664AbiCQPOy (ORCPT ); Thu, 17 Mar 2022 11:14:54 -0400 Received: from sin.source.kernel.org (sin.source.kernel.org [145.40.73.55]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 090ED9A9B4; Thu, 17 Mar 2022 08:13:36 -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 sin.source.kernel.org (Postfix) with ESMTPS id 89B56CE0622; Thu, 17 Mar 2022 15:13:34 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id B95AFC340E9; Thu, 17 Mar 2022 15:13:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1647530012; bh=3Gzmo6yhg4CSO7pzc6bkyN6wEITFveIES9j5diOg5bY=; h=Date:From:To:Cc:Subject:In-Reply-To:References:From; b=Y77D8UJroGPR3MjsxfvZyWLjdarxKWkr6hBcdmrX3n7XEHdnLK4AXrTJfPjopX6fx Dm9Bn9pB+kfdUPw0NKU4fhuBnlbQUHf2oWQWTyq9+XVh84bekYdX3iaG2ZEXHe+B0h PezUT/f77rz1bzwnxdhJRKouS712WpSY/9sI3kg5Y9ZDny+ME0Z49c3LszPXZRvq2W n7wHBiLY3C1fygf0bS4mxepJmW8ab4djKpusbUX9tLYskYJoLKdK9pDJIdsIb4Qi3r CwFi1xxmJo8r6wfJ0OZBIro0BoVN2jR/aRdPQ3mQiMQK+ZgqypiVR2HTi++39lHkDA jHxS8JX7sMG7w== Received: from disco-boy.misterjones.org ([51.254.78.96] helo=www.loen.fr) by disco-boy.misterjones.org with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1nUrog-00FDYW-E2; Thu, 17 Mar 2022 15:13:30 +0000 MIME-Version: 1.0 Date: Thu, 17 Mar 2022 15:13:30 +0000 From: Marc Zyngier To: Pierre Gondois Cc: linux-kernel@vger.kernel.org, Ionela.Voinescu@arm.com, Lukasz.Luba@arm.com, Morten.Rasmussen@arm.com, Dietmar.Eggemann@arm.com, mka@chromium.org, daniel.lezcano@linaro.org, Catalin Marinas , Will Deacon , "Rafael J. Wysocki" , Viresh Kumar , Mark Rutland , Ard Biesheuvel , Fuad Tabba , Valentin Schneider , Rob Herring , linux-arm-kernel@lists.infradead.org, linux-pm@vger.kernel.org Subject: Re: [PATCH v1 2/3] cpufreq: CPPC: Add per_cpu efficiency_class In-Reply-To: <20220317133419.3901736-3-Pierre.Gondois@arm.com> References: <20220317133419.3901736-1-Pierre.Gondois@arm.com> <20220317133419.3901736-3-Pierre.Gondois@arm.com> User-Agent: Roundcube Webmail/1.4.13 Message-ID: X-Sender: maz@kernel.org Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit X-SA-Exim-Connect-IP: 51.254.78.96 X-SA-Exim-Rcpt-To: Pierre.Gondois@arm.com, linux-kernel@vger.kernel.org, Ionela.Voinescu@arm.com, Lukasz.Luba@arm.com, Morten.Rasmussen@arm.com, Dietmar.Eggemann@arm.com, mka@chromium.org, daniel.lezcano@linaro.org, catalin.marinas@arm.com, will@kernel.org, rafael@kernel.org, viresh.kumar@linaro.org, mark.rutland@arm.com, ardb@kernel.org, tabba@google.com, valentin.schneider@arm.com, robh@kernel.org, linux-arm-kernel@lists.infradead.org, linux-pm@vger.kernel.org X-SA-Exim-Mail-From: maz@kernel.org X-SA-Exim-Scanned: No (on disco-boy.misterjones.org); SAEximRunCond expanded to false Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org On 2022-03-17 13:34, Pierre Gondois wrote: > In ACPI, describing power efficiency of CPUs can be done through the > following arm specific field: > ACPI 6.4, s5.2.12.14 'GIC CPU Interface (GICC) Structure', > 'Processor Power Efficiency Class field': > Describes the relative power efficiency of the associated pro- > cessor. Lower efficiency class numbers are more efficient than > higher ones (e.g. efficiency class 0 should be treated as more > efficient than efficiency class 1). However, absolute values > of this number have no meaning: 2 isn’t necessarily half as > efficient as 1. > > The efficiency_class field is stored in the GicC structure of the > ACPI MADT table and it's currently supported in Linux for arm64 only. > Thus, this new functionality is introduced for arm64 only. > > To allow the cppc_cpufreq driver to know and preprocess the > efficiency_class values of all the CPUs, add a per_cpu efficiency_class > variable to store them. Also add a static efficiency_class_populated > to let the driver know efficiency_class values are usable and register > an artificial Energy Model (EM) based on normalized class values. > > At least 2 different efficiency classes must be present, > otherwise there is no use in creating an Energy Model. > > The efficiency_class values are squeezed in [0:#efficiency_class-1] > while conserving the order. For instance, efficiency classes of: > [111, 212, 250] > will be mapped to: > [0 (was 111), 1 (was 212), 2 (was 250)]. > > Each policy being independently registered in the driver, populating > the per_cpu efficiency_class is done only once at the driver > initialization. This prevents from having each policy re-searching the > efficiency_class values of other CPUs. > > The patch also exports acpi_cpu_get_madt_gicc() to fetch the GicC > structure of the ACPI MADT table for each CPU. > > Signed-off-by: Pierre Gondois > --- > arch/arm64/kernel/smp.c | 1 + > drivers/cpufreq/cppc_cpufreq.c | 55 ++++++++++++++++++++++++++++++++++ > 2 files changed, 56 insertions(+) > > diff --git a/arch/arm64/kernel/smp.c b/arch/arm64/kernel/smp.c > index 27df5c1e6baa..56637cbea5d6 100644 > --- a/arch/arm64/kernel/smp.c > +++ b/arch/arm64/kernel/smp.c > @@ -512,6 +512,7 @@ struct acpi_madt_generic_interrupt > *acpi_cpu_get_madt_gicc(int cpu) > { > return &cpu_madt_gicc[cpu]; > } > +EXPORT_SYMBOL(acpi_cpu_get_madt_gicc); Why not EXPORT_SYMBOL_GPL()? > > /* > * acpi_map_gic_cpu_interface - parse processor MADT entry > diff --git a/drivers/cpufreq/cppc_cpufreq.c > b/drivers/cpufreq/cppc_cpufreq.c > index 8f950fe72765..a6cd95c3b474 100644 > --- a/drivers/cpufreq/cppc_cpufreq.c > +++ b/drivers/cpufreq/cppc_cpufreq.c > @@ -422,12 +422,66 @@ static unsigned int > cppc_cpufreq_get_transition_delay_us(unsigned int cpu) > return cppc_get_transition_latency(cpu) / NSEC_PER_USEC; > } > > +static bool efficiency_class_populated; > +static DEFINE_PER_CPU(unsigned int, efficiency_class); > + > +static int populate_efficiency_class(void) > +{ > + unsigned int min = UINT_MAX, max = 0, class; > + struct acpi_madt_generic_interrupt *gicc; > + int cpu; > + > + for_each_possible_cpu(cpu) { > + gicc = acpi_cpu_get_madt_gicc(cpu); > + if (!gicc) > + return -ENODEV; How can that happen if you made it here using ACPI? > + > + per_cpu(efficiency_class, cpu) = gicc->efficiency_class; > + min = min_t(unsigned int, min, gicc->efficiency_class); > + max = max_t(unsigned int, max, gicc->efficiency_class); > + } Why don't you use a temporary bitmap of 256 bits, tracking the classes that are actually being used? > + > + if (min == max) { This would become (bitmap_weight(used_classes) <= 1). Then from the same construct you know how many different classes you have. You also have the min, max, and all the values in between. > + pr_debug("Efficiency classes are all equal (=%d). " > + "No EM registered", max); > + return -EINVAL; > + } > + > + /* > + * Squeeze efficiency class values on [0:#efficiency_class-1]. > + * Values are per spec in [0:255]. > + */ > + for (class = 0; class < 256; class++) { > + unsigned int new_min, curr; > + > + new_min = UINT_MAX; > + for_each_possible_cpu(cpu) { > + curr = per_cpu(efficiency_class, cpu); > + if (curr == min) > + per_cpu(efficiency_class, cpu) = class; > + else if (curr > min) > + new_min = min(new_min, curr); > + } > + > + if (new_min == UINT_MAX) > + break; > + min = new_min; > + } I find it really hard to reason about this because you are dynamically rewriting the values you keep reevaluating. How about something like this, which I find more readable: DECLARE_BITMAP(used_classes, 256) = {}; int class, index, cpu; for_each_possible_cpu(cpu) { unsigned int ec; ec = acpi_cpu_get_madt_gicc(cpu)->efficiency_class & 0xff; bitmap_set(ec, &used_classes); } if (bitmap_weight(&used_classes, 256) <= 1) return; index = 0; for_each_set_bit(class, &used_classes, 256) { for_each_possible_cpu(cpu) { if (acpi_cpu_get_madt_gicc(cpu)->efficiency_class == class) per_cpu(efficiency_class, cpu) = index; } index++; } Thanks, M. -- Jazz is not dead. It just smells funny... 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 7407FC433F5 for ; Thu, 17 Mar 2022 15:15:34 +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-Type: Content-Transfer-Encoding:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:Message-ID:References:In-Reply-To:Subject:Cc:To:From :Date:MIME-Version:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=2rq1qoovAZfd8fD/IGnvtbWbzmJXnn8rqUqzAC//bqo=; b=P3OFdZUnK9EP47CfBMKopIXagD mLNtTl8cPdRjDYdgj13rKiUuq0fKZszGPgOxZbiOYv3QrOImWndbwHIGGanJ0wRleXgqUx/Ow6Wvk 98X879WTIBDil1EHM00vKj/shjbDIJcrwv+s5Mc+Z4SgvZBmjaBFP9wghmb+kvWUW5he/DfqMGSmi +8EWs2O/9loEx+7dubBHrbo4LYSu0xTjKZR6nPBikKpfmzkFlPfQsWyFpYZi5dQ2JEJ2d2nuFTO18 FxV+8cYmmKNouQLVnKvAZNa9UU53SdTHUMJLvu5yDOOiRw1POhxAOCgUAeAiEORJ64j3l9H3UR71s vxbQ9q0w==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nUrop-00Gb0k-SU; Thu, 17 Mar 2022 15:13:40 +0000 Received: from ams.source.kernel.org ([2604:1380:4601:e00::1]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nUrol-00Gazs-Mm for linux-arm-kernel@lists.infradead.org; Thu, 17 Mar 2022 15:13:37 +0000 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 ams.source.kernel.org (Postfix) with ESMTPS id 1D8EFB81ECE; Thu, 17 Mar 2022 15:13:34 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id B95AFC340E9; Thu, 17 Mar 2022 15:13:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1647530012; bh=3Gzmo6yhg4CSO7pzc6bkyN6wEITFveIES9j5diOg5bY=; h=Date:From:To:Cc:Subject:In-Reply-To:References:From; b=Y77D8UJroGPR3MjsxfvZyWLjdarxKWkr6hBcdmrX3n7XEHdnLK4AXrTJfPjopX6fx Dm9Bn9pB+kfdUPw0NKU4fhuBnlbQUHf2oWQWTyq9+XVh84bekYdX3iaG2ZEXHe+B0h PezUT/f77rz1bzwnxdhJRKouS712WpSY/9sI3kg5Y9ZDny+ME0Z49c3LszPXZRvq2W n7wHBiLY3C1fygf0bS4mxepJmW8ab4djKpusbUX9tLYskYJoLKdK9pDJIdsIb4Qi3r CwFi1xxmJo8r6wfJ0OZBIro0BoVN2jR/aRdPQ3mQiMQK+ZgqypiVR2HTi++39lHkDA jHxS8JX7sMG7w== Received: from disco-boy.misterjones.org ([51.254.78.96] helo=www.loen.fr) by disco-boy.misterjones.org with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1nUrog-00FDYW-E2; Thu, 17 Mar 2022 15:13:30 +0000 MIME-Version: 1.0 Date: Thu, 17 Mar 2022 15:13:30 +0000 From: Marc Zyngier To: Pierre Gondois Cc: linux-kernel@vger.kernel.org, Ionela.Voinescu@arm.com, Lukasz.Luba@arm.com, Morten.Rasmussen@arm.com, Dietmar.Eggemann@arm.com, mka@chromium.org, daniel.lezcano@linaro.org, Catalin Marinas , Will Deacon , "Rafael J. Wysocki" , Viresh Kumar , Mark Rutland , Ard Biesheuvel , Fuad Tabba , Valentin Schneider , Rob Herring , linux-arm-kernel@lists.infradead.org, linux-pm@vger.kernel.org Subject: Re: [PATCH v1 2/3] cpufreq: CPPC: Add per_cpu efficiency_class In-Reply-To: <20220317133419.3901736-3-Pierre.Gondois@arm.com> References: <20220317133419.3901736-1-Pierre.Gondois@arm.com> <20220317133419.3901736-3-Pierre.Gondois@arm.com> User-Agent: Roundcube Webmail/1.4.13 Message-ID: X-Sender: maz@kernel.org X-SA-Exim-Connect-IP: 51.254.78.96 X-SA-Exim-Rcpt-To: Pierre.Gondois@arm.com, linux-kernel@vger.kernel.org, Ionela.Voinescu@arm.com, Lukasz.Luba@arm.com, Morten.Rasmussen@arm.com, Dietmar.Eggemann@arm.com, mka@chromium.org, daniel.lezcano@linaro.org, catalin.marinas@arm.com, will@kernel.org, rafael@kernel.org, viresh.kumar@linaro.org, mark.rutland@arm.com, ardb@kernel.org, tabba@google.com, valentin.schneider@arm.com, robh@kernel.org, linux-arm-kernel@lists.infradead.org, linux-pm@vger.kernel.org X-SA-Exim-Mail-From: maz@kernel.org X-SA-Exim-Scanned: No (on disco-boy.misterjones.org); SAEximRunCond expanded to false X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220317_081336_074781_3767646D X-CRM114-Status: GOOD ( 35.65 ) 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-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org T24gMjAyMi0wMy0xNyAxMzozNCwgUGllcnJlIEdvbmRvaXMgd3JvdGU6Cj4gSW4gQUNQSSwgZGVz Y3JpYmluZyBwb3dlciBlZmZpY2llbmN5IG9mIENQVXMgY2FuIGJlIGRvbmUgdGhyb3VnaCB0aGUK PiBmb2xsb3dpbmcgYXJtIHNwZWNpZmljIGZpZWxkOgo+IEFDUEkgNi40LCBzNS4yLjEyLjE0ICdH SUMgQ1BVIEludGVyZmFjZSAoR0lDQykgU3RydWN0dXJlJywKPiAnUHJvY2Vzc29yIFBvd2VyIEVm ZmljaWVuY3kgQ2xhc3MgZmllbGQnOgo+ICAgRGVzY3JpYmVzIHRoZSByZWxhdGl2ZSBwb3dlciBl ZmZpY2llbmN5IG9mIHRoZSBhc3NvY2lhdGVkIHByby0KPiAgIGNlc3Nvci4gTG93ZXIgZWZmaWNp ZW5jeSBjbGFzcyBudW1iZXJzIGFyZSBtb3JlIGVmZmljaWVudCB0aGFuCj4gICBoaWdoZXIgb25l cyAoZS5nLiBlZmZpY2llbmN5IGNsYXNzIDAgc2hvdWxkIGJlIHRyZWF0ZWQgYXMgbW9yZQo+ICAg ZWZmaWNpZW50IHRoYW4gZWZmaWNpZW5jeSBjbGFzcyAxKS4gSG93ZXZlciwgYWJzb2x1dGUgdmFs dWVzCj4gICBvZiB0aGlzIG51bWJlciBoYXZlIG5vIG1lYW5pbmc6IDIgaXNu4oCZdCBuZWNlc3Nh cmlseSBoYWxmIGFzCj4gICBlZmZpY2llbnQgYXMgMS4KPiAKPiBUaGUgZWZmaWNpZW5jeV9jbGFz cyBmaWVsZCBpcyBzdG9yZWQgaW4gdGhlIEdpY0Mgc3RydWN0dXJlIG9mIHRoZQo+IEFDUEkgTUFE VCB0YWJsZSBhbmQgaXQncyBjdXJyZW50bHkgc3VwcG9ydGVkIGluIExpbnV4IGZvciBhcm02NCBv bmx5Lgo+IFRodXMsIHRoaXMgbmV3IGZ1bmN0aW9uYWxpdHkgaXMgaW50cm9kdWNlZCBmb3IgYXJt NjQgb25seS4KPiAKPiBUbyBhbGxvdyB0aGUgY3BwY19jcHVmcmVxIGRyaXZlciB0byBrbm93IGFu ZCBwcmVwcm9jZXNzIHRoZQo+IGVmZmljaWVuY3lfY2xhc3MgdmFsdWVzIG9mIGFsbCB0aGUgQ1BV cywgYWRkIGEgcGVyX2NwdSBlZmZpY2llbmN5X2NsYXNzCj4gdmFyaWFibGUgdG8gc3RvcmUgdGhl bS4gQWxzbyBhZGQgYSBzdGF0aWMgZWZmaWNpZW5jeV9jbGFzc19wb3B1bGF0ZWQKPiB0byBsZXQg dGhlIGRyaXZlciBrbm93IGVmZmljaWVuY3lfY2xhc3MgdmFsdWVzIGFyZSB1c2FibGUgYW5kIHJl Z2lzdGVyCj4gYW4gYXJ0aWZpY2lhbCBFbmVyZ3kgTW9kZWwgKEVNKSBiYXNlZCBvbiBub3JtYWxp emVkIGNsYXNzIHZhbHVlcy4KPiAKPiBBdCBsZWFzdCAyIGRpZmZlcmVudCBlZmZpY2llbmN5IGNs YXNzZXMgbXVzdCBiZSBwcmVzZW50LAo+IG90aGVyd2lzZSB0aGVyZSBpcyBubyB1c2UgaW4gY3Jl YXRpbmcgYW4gRW5lcmd5IE1vZGVsLgo+IAo+IFRoZSBlZmZpY2llbmN5X2NsYXNzIHZhbHVlcyBh cmUgc3F1ZWV6ZWQgaW4gWzA6I2VmZmljaWVuY3lfY2xhc3MtMV0KPiB3aGlsZSBjb25zZXJ2aW5n IHRoZSBvcmRlci4gRm9yIGluc3RhbmNlLCBlZmZpY2llbmN5IGNsYXNzZXMgb2Y6Cj4gICBbMTEx LCAyMTIsIDI1MF0KPiB3aWxsIGJlIG1hcHBlZCB0bzoKPiAgIFswICh3YXMgMTExKSwgMSAod2Fz IDIxMiksIDIgKHdhcyAyNTApXS4KPiAKPiBFYWNoIHBvbGljeSBiZWluZyBpbmRlcGVuZGVudGx5 IHJlZ2lzdGVyZWQgaW4gdGhlIGRyaXZlciwgcG9wdWxhdGluZwo+IHRoZSBwZXJfY3B1IGVmZmlj aWVuY3lfY2xhc3MgaXMgZG9uZSBvbmx5IG9uY2UgYXQgdGhlIGRyaXZlcgo+IGluaXRpYWxpemF0 aW9uLiBUaGlzIHByZXZlbnRzIGZyb20gaGF2aW5nIGVhY2ggcG9saWN5IHJlLXNlYXJjaGluZyB0 aGUKPiBlZmZpY2llbmN5X2NsYXNzIHZhbHVlcyBvZiBvdGhlciBDUFVzLgo+IAo+IFRoZSBwYXRj aCBhbHNvIGV4cG9ydHMgYWNwaV9jcHVfZ2V0X21hZHRfZ2ljYygpIHRvIGZldGNoIHRoZSBHaWND Cj4gc3RydWN0dXJlIG9mIHRoZSBBQ1BJIE1BRFQgdGFibGUgZm9yIGVhY2ggQ1BVLgo+IAo+IFNp Z25lZC1vZmYtYnk6IFBpZXJyZSBHb25kb2lzIDxQaWVycmUuR29uZG9pc0Bhcm0uY29tPgo+IC0t LQo+ICBhcmNoL2FybTY0L2tlcm5lbC9zbXAuYyAgICAgICAgfCAgMSArCj4gIGRyaXZlcnMvY3B1 ZnJlcS9jcHBjX2NwdWZyZXEuYyB8IDU1ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysKPiAgMiBmaWxlcyBjaGFuZ2VkLCA1NiBpbnNlcnRpb25zKCspCj4gCj4gZGlmZiAtLWdpdCBh L2FyY2gvYXJtNjQva2VybmVsL3NtcC5jIGIvYXJjaC9hcm02NC9rZXJuZWwvc21wLmMKPiBpbmRl eCAyN2RmNWMxZTZiYWEuLjU2NjM3Y2JlYTVkNiAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0L2tl cm5lbC9zbXAuYwo+ICsrKyBiL2FyY2gvYXJtNjQva2VybmVsL3NtcC5jCj4gQEAgLTUxMiw2ICs1 MTIsNyBAQCBzdHJ1Y3QgYWNwaV9tYWR0X2dlbmVyaWNfaW50ZXJydXB0Cj4gKmFjcGlfY3B1X2dl dF9tYWR0X2dpY2MoaW50IGNwdSkKPiAgewo+ICAJcmV0dXJuICZjcHVfbWFkdF9naWNjW2NwdV07 Cj4gIH0KPiArRVhQT1JUX1NZTUJPTChhY3BpX2NwdV9nZXRfbWFkdF9naWNjKTsKCldoeSBub3Qg RVhQT1JUX1NZTUJPTF9HUEwoKT8KCj4gCj4gIC8qCj4gICAqIGFjcGlfbWFwX2dpY19jcHVfaW50 ZXJmYWNlIC0gcGFyc2UgcHJvY2Vzc29yIE1BRFQgZW50cnkKPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9jcHVmcmVxL2NwcGNfY3B1ZnJlcS5jIAo+IGIvZHJpdmVycy9jcHVmcmVxL2NwcGNfY3B1ZnJl cS5jCj4gaW5kZXggOGY5NTBmZTcyNzY1Li5hNmNkOTVjM2I0NzQgMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9jcHVmcmVxL2NwcGNfY3B1ZnJlcS5jCj4gKysrIGIvZHJpdmVycy9jcHVmcmVxL2NwcGNf Y3B1ZnJlcS5jCj4gQEAgLTQyMiwxMiArNDIyLDY2IEBAIHN0YXRpYyB1bnNpZ25lZCBpbnQKPiBj cHBjX2NwdWZyZXFfZ2V0X3RyYW5zaXRpb25fZGVsYXlfdXModW5zaWduZWQgaW50IGNwdSkKPiAg CXJldHVybiBjcHBjX2dldF90cmFuc2l0aW9uX2xhdGVuY3koY3B1KSAvIE5TRUNfUEVSX1VTRUM7 Cj4gIH0KPiAKPiArc3RhdGljIGJvb2wgZWZmaWNpZW5jeV9jbGFzc19wb3B1bGF0ZWQ7Cj4gK3N0 YXRpYyBERUZJTkVfUEVSX0NQVSh1bnNpZ25lZCBpbnQsIGVmZmljaWVuY3lfY2xhc3MpOwo+ICsK PiArc3RhdGljIGludCBwb3B1bGF0ZV9lZmZpY2llbmN5X2NsYXNzKHZvaWQpCj4gK3sKPiArCXVu c2lnbmVkIGludCBtaW4gPSBVSU5UX01BWCwgbWF4ID0gMCwgY2xhc3M7Cj4gKwlzdHJ1Y3QgYWNw aV9tYWR0X2dlbmVyaWNfaW50ZXJydXB0ICpnaWNjOwo+ICsJaW50IGNwdTsKPiArCj4gKwlmb3Jf ZWFjaF9wb3NzaWJsZV9jcHUoY3B1KSB7Cj4gKwkJZ2ljYyA9IGFjcGlfY3B1X2dldF9tYWR0X2dp Y2MoY3B1KTsKPiArCQlpZiAoIWdpY2MpCj4gKwkJCXJldHVybiAtRU5PREVWOwoKSG93IGNhbiB0 aGF0IGhhcHBlbiBpZiB5b3UgbWFkZSBpdCBoZXJlIHVzaW5nIEFDUEk/Cgo+ICsKPiArCQlwZXJf Y3B1KGVmZmljaWVuY3lfY2xhc3MsIGNwdSkgPSBnaWNjLT5lZmZpY2llbmN5X2NsYXNzOwo+ICsJ CW1pbiA9IG1pbl90KHVuc2lnbmVkIGludCwgbWluLCBnaWNjLT5lZmZpY2llbmN5X2NsYXNzKTsK PiArCQltYXggPSBtYXhfdCh1bnNpZ25lZCBpbnQsIG1heCwgZ2ljYy0+ZWZmaWNpZW5jeV9jbGFz cyk7Cj4gKwl9CgpXaHkgZG9uJ3QgeW91IHVzZSBhIHRlbXBvcmFyeSBiaXRtYXAgb2YgMjU2IGJp dHMsIHRyYWNraW5nCnRoZSBjbGFzc2VzIHRoYXQgYXJlIGFjdHVhbGx5IGJlaW5nIHVzZWQ/Cgo+ ICsKPiArCWlmIChtaW4gPT0gbWF4KSB7CgpUaGlzIHdvdWxkIGJlY29tZSAoYml0bWFwX3dlaWdo dCh1c2VkX2NsYXNzZXMpIDw9IDEpLiBUaGVuIGZyb20KdGhlIHNhbWUgY29uc3RydWN0IHlvdSBr bm93IGhvdyBtYW55IGRpZmZlcmVudCBjbGFzc2VzIHlvdSBoYXZlLgpZb3UgYWxzbyBoYXZlIHRo ZSBtaW4sIG1heCwgYW5kIGFsbCB0aGUgdmFsdWVzIGluIGJldHdlZW4uCgo+ICsJCXByX2RlYnVn KCJFZmZpY2llbmN5IGNsYXNzZXMgYXJlIGFsbCBlcXVhbCAoPSVkKS4gIgo+ICsJCQkiTm8gRU0g cmVnaXN0ZXJlZCIsIG1heCk7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJLyoK PiArCSAqIFNxdWVlemUgZWZmaWNpZW5jeSBjbGFzcyB2YWx1ZXMgb24gWzA6I2VmZmljaWVuY3lf Y2xhc3MtMV0uCj4gKwkgKiBWYWx1ZXMgYXJlIHBlciBzcGVjIGluIFswOjI1NV0uCj4gKwkgKi8K PiArCWZvciAoY2xhc3MgPSAwOyBjbGFzcyA8IDI1NjsgY2xhc3MrKykgewo+ICsJCXVuc2lnbmVk IGludCBuZXdfbWluLCBjdXJyOwo+ICsKPiArCQluZXdfbWluID0gVUlOVF9NQVg7Cj4gKwkJZm9y X2VhY2hfcG9zc2libGVfY3B1KGNwdSkgewo+ICsJCQljdXJyID0gcGVyX2NwdShlZmZpY2llbmN5 X2NsYXNzLCBjcHUpOwo+ICsJCQlpZiAoY3VyciA9PSBtaW4pCj4gKwkJCQlwZXJfY3B1KGVmZmlj aWVuY3lfY2xhc3MsIGNwdSkgPSBjbGFzczsKPiArCQkJZWxzZSBpZiAoY3VyciA+IG1pbikKPiAr CQkJCW5ld19taW4gPSBtaW4obmV3X21pbiwgY3Vycik7Cj4gKwkJfQo+ICsKPiArCQlpZiAobmV3 X21pbiA9PSBVSU5UX01BWCkKPiArCQkJYnJlYWs7Cj4gKwkJbWluID0gbmV3X21pbjsKPiArCX0K CkkgZmluZCBpdCByZWFsbHkgaGFyZCB0byByZWFzb24gYWJvdXQgdGhpcyBiZWNhdXNlIHlvdSBh cmUKZHluYW1pY2FsbHkgcmV3cml0aW5nIHRoZSB2YWx1ZXMgeW91IGtlZXAgcmVldmFsdWF0aW5n LgoKSG93IGFib3V0IHNvbWV0aGluZyBsaWtlIHRoaXMsIHdoaWNoIEkgZmluZCBtb3JlIHJlYWRh YmxlOgoKCURFQ0xBUkVfQklUTUFQKHVzZWRfY2xhc3NlcywgMjU2KSA9IHt9OwoJaW50IGNsYXNz LCBpbmRleCwgY3B1OwoKCWZvcl9lYWNoX3Bvc3NpYmxlX2NwdShjcHUpIHsKCQl1bnNpZ25lZCBp bnQgZWM7CgoJCWVjID0gYWNwaV9jcHVfZ2V0X21hZHRfZ2ljYyhjcHUpLT5lZmZpY2llbmN5X2Ns YXNzICYgMHhmZjsKCQliaXRtYXBfc2V0KGVjLCAmdXNlZF9jbGFzc2VzKTsKCX0KCglpZiAoYml0 bWFwX3dlaWdodCgmdXNlZF9jbGFzc2VzLCAyNTYpIDw9IDEpCgkJcmV0dXJuOwoKCWluZGV4ID0g MDsKCglmb3JfZWFjaF9zZXRfYml0KGNsYXNzLCAmdXNlZF9jbGFzc2VzLCAyNTYpIHsKCQlmb3Jf ZWFjaF9wb3NzaWJsZV9jcHUoY3B1KSB7CgkJCWlmIChhY3BpX2NwdV9nZXRfbWFkdF9naWNjKGNw dSktPmVmZmljaWVuY3lfY2xhc3MgPT0gY2xhc3MpCgkJCQlwZXJfY3B1KGVmZmljaWVuY3lfY2xh c3MsIGNwdSkgPSBpbmRleDsKCQl9CgoJCWluZGV4Kys7Cgl9CgoKVGhhbmtzLAoKICAgICAgICAg TS4KLS0gCkphenogaXMgbm90IGRlYWQuIEl0IGp1c3Qgc21lbGxzIGZ1bm55Li4uCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVs IG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDov L2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==