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 X-Spam-Level: X-Spam-Status: No, score=-2.3 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,SPF_HELO_NONE, SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=no autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1E360C2BB86 for ; Thu, 9 Apr 2020 10:29:45 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id E380E2083E for ; Thu, 9 Apr 2020 10:29:44 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="IS2IOiCn" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725972AbgDIK3n (ORCPT ); Thu, 9 Apr 2020 06:29:43 -0400 Received: from mail-wr1-f67.google.com ([209.85.221.67]:43208 "EHLO mail-wr1-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726536AbgDIK3m (ORCPT ); Thu, 9 Apr 2020 06:29:42 -0400 Received: by mail-wr1-f67.google.com with SMTP id i10so5012227wrv.10 for ; Thu, 09 Apr 2020 03:29:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-language:content-transfer-encoding; bh=jkRgOsveN5qmBJ0M4R1dAo5UKj2A3MYQ96PvB4Jc5CE=; b=IS2IOiCnk4iXdbES0KEBbw/6SOqjQFLsN7lNB5d2C7/qoY2xTbXshqURo/fi5dG5Iz GXidyQ9Yw4Y3rzMWM9+RlALOsdgTx1qBDnDGPUGOQecWQ1sYCpxC2ivVw5pvJQ5HWy7+ F18RqGaCzpTT+BZ+Bs3FwV62hWNomqyVufK9NA0jJ90/UHeK50PV54czICyTNPXNxHrh I/07xFpmOdYw/7Iu29LSylka2lsyVgLOHmsu/dg36kOhGJg7F/qKmNlyCvcb5WNa/AeP DE2LLRmoXYB60pusRlUwULBGHPbFo0FfIEq5jTWr15i6N8eVjZJYIdKyf7qdCfXZcq9s 2GEQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-language :content-transfer-encoding; bh=jkRgOsveN5qmBJ0M4R1dAo5UKj2A3MYQ96PvB4Jc5CE=; b=QzJjgrGgbzYlCPYPW1IYOLHFQ+hCqwFLDRYeERuthIU5U+D7nOjfnYHWnj6b0uRqWO AeYl879yUJKfTDO3gQkELo81+f0AOwHx7CNZETG0dCWUvIBCFkSJCbOqXZbK2aDpMM4K LLu/1XazVPj/EXx1IJsO56qxOUyk/UHaCP2Ala8jDLCQFcB027/s9xCSsgHnMB1S+D1r CyoiDBAPqp7HMXcSbj/vq+9KaBgm2vKvyVbT+Sx0HZA1tXnhXEckJdslXdyf8qEs8WrV wDIYv6MuDb+aGKO8Omx/OCHug2ibJDqe9RQ2lt0PfLvjuHCJmaVIqQ4LI31L4TvdR1+Y VgOA== X-Gm-Message-State: AGi0PuYJG1zrcCGz/nZPa96f5gZFvMTlU5MPLpRsOyHLIk9YjlrZOZDT ienSodzYV4XLJLrT9uWuTqBj6w== X-Google-Smtp-Source: APiQypJ5A9CM3Ob4OXn4XWWblUTVqk+zAuAyVWAIgpRUXU7di1gR50JYOWdb6bfOss/zcEyE+jw/ig== X-Received: by 2002:adf:fe03:: with SMTP id n3mr195558wrr.315.1586428179858; Thu, 09 Apr 2020 03:29:39 -0700 (PDT) Received: from ?IPv6:2a01:e34:ed2f:f020:e1dc:4371:fecd:8292? ([2a01:e34:ed2f:f020:e1dc:4371:fecd:8292]) by smtp.googlemail.com with ESMTPSA id e2sm6240723wrr.84.2020.04.09.03.29.36 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 09 Apr 2020 03:29:39 -0700 (PDT) Subject: Re: [RFC 0/8] Stop monitoring disabled devices To: Andrzej Pietrasiewicz , linux-pm@vger.kernel.org Cc: Zhang Rui , "Rafael J . Wysocki" , Len Brown , Jiri Pirko , Ido Schimmel , "David S . Miller" , Peter Kaestle , Darren Hart , Andy Shevchenko , Support Opensource , Amit Kucheria , Shawn Guo , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , NXP Linux Team , Allison Randal , Enrico Weigelt , Gayatri Kammela , Thomas Gleixner , linux-acpi@vger.kernel.org, netdev@vger.kernel.org, platform-driver-x86@vger.kernel.org, linux-arm-kernel@lists.infradead.org, kernel@collabora.com References: <20200407174926.23971-1-andrzej.p@collabora.com> From: Daniel Lezcano Message-ID: <2bc5a902-acde-526a-11a5-2357d899916c@linaro.org> Date: Thu, 9 Apr 2020 12:29:35 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.4.1 MIME-Version: 1.0 In-Reply-To: <20200407174926.23971-1-andrzej.p@collabora.com> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 8bit Sender: linux-acpi-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-acpi@vger.kernel.org On 07/04/2020 19:49, Andrzej Pietrasiewicz wrote: > The current kernel behavior is to keep polling the thermal zone devices > regardless of their current mode. This is not desired, as all such "disabled" > devices are meant to be handled by userspace,> so polling them makes no sense. Thanks for proposing these changes. I've been (quickly) through the series and the description below. I have the feeling the series makes more complex while the current code which would deserve a cleanup. Why not first: - Add a 'mode' field in the thermal zone device - Kill all set/get_mode callbacks in the drivers which are duplicated code. - Add a function: enum thermal_device_mode thermal_zone_get_mode( *tz) { ... if (tz->ops->get_mode) return tz->ops->get_mode(); return tz->mode; } int thermal_zone_set_mode(..*tz, enum thermal_device_mode mode) { ... if (tz->ops->set_mode) return tz->ops->set_mode(tz, mode); tz->mode = mode; return 0; } static inline thermal_zone_enable(... *tz) { thermal_zone_set_mode(tz, THERMAL_DEVICE_ENABLED); } static inline thermal_zone_disable(... *tz) { thermal_zone_set_mode(tz, THERMAL_DEVICE_DISABLED); } And then when the code is consolidated, use the mode to enable/disable the polling and continue killing the duplicated code in of-thermal.c and anywhere else. > There was an attempt to solve this issue: > > https://lkml.org/lkml/2018/2/26/498 > > and it ultimately has not succeeded: > > https://lkml.org/lkml/2018/2/27/910 > > This is a new attempt addressing all the relevant drivers, and I have > identified them with: > > $ git grep "thermal_zone_device_ops" | grep "= {" | cut -f1 -d: | sort | uniq > > The idea is to modify thermal_zone_device_update() and monitor_thermal_zone() > in such a way that they stop polling a disabled device. To do decide what to > do they should call ->get_mode() operation of the specialized thermal zone > device in question (e.g. drivers/acpi/thermal.c's). But here comes problem: > sometimes a thermal zone device must be initially disabled and becomes enabled > only after its sensors appear on the system. If such thermal zone's > ->get_mode() /* in the context of thermal_zone_device_update() or > monitor_thermal_zone() */ is called _before_ the sensors are available, it will > be reported as "disabled" and consequently polling it will be ceased. This is > a change in behavior from userspace's perspective. > > To solve the above described problem I want to introduce the third mode of a > thermal_zone_device: initial. The idea is that when the device is in its > initial mode, then its polling will be handled as it is now. This is a good > thing: should the temperature be just about hitting the critical treshnold > early during the boot process, it might be too late if we wait for the > userspace to run to save the system from overheating. The initial mode should > be reported in sysfs as "enabled" to keep the userspace interface intact. > From the initial mode there will be two possible transitions: to enabled or > disabled mode, but there will be no transition back to initial. If the > transition is from initial to enabled, then keep polling. If the transition is > from initial to disabled, then stop polling. If the transition is from enabled > to disabled, then stop polling. The transition from disabled to enabled must > be handled in a special way: there must be a mandatory call to > monitor_thermal_zone(), otherwise the polling will not start. If this > transition is triggeted from sysfs, then it can be easily handled at the > thermal framework level. However, if drivers call their own ->set_mode() > operation then they must also call "monitor_thermal_zone()" afterwards. > The latter being a sensible thing anyway, so perhaps all/most of the drivers > in question do. The plan for implementation is this: > > - ensure ALL users use symbolic enum names (THERMAL_DEVICE_DISABLED, > THERMAL_DEVICE_ENABLED) for thermal device mode rather than the numeric > values of enum thermal_device_mode elements > - add THERMAL_DEVICE_INITIAL to the said enum making its value 0 (so that > kzalloc() results in the initial state) > - modify thermal zone device's mode_show() (thermal framework level) so that > it reports "enabled" for THERMAL_DEVICE_INITIAL > - modify thermal zone device's mode_store() (thermal framework level) so that > it calls monitor_thermal_zone() upon mode change > - modify ALL thermal drivers so that their code is prepared to return > THERMAL_DEVICE_INITIAL before they call thermal_zone_device_register(); when > the invocation of the latter completes then polling is expected to be started > - verify ALL drivers which call their own ->set_mode() to ensure they do call > monitor_thermal_zone() afterwards > - modify thermal_zone_device_update() and monitor_thermal_zone() so that they > cancel polling for disabled thermal zone devices (but not for those in > THERMAL_DEVICE_INITIAL mode) > > This RFC series does all the above steps in more or less that order. > > I kindly ask for comments/suggestions/improvements. > > Rebased onto v5.6. > > Andrzej Pietrasiewicz (8): > thermal: int3400_thermal: Statically initialize > .get_mode()/.set_mode() ops > thermal: Properly handle mode values in .set_mode() > thermal: Store thermal mode in a dedicated enum > thermal: core: Introduce THERMAL_DEVICE_INITIAL > thermal: core: Monitor thermal zone after mode change > thermal: Set initial state to THERMAL_DEVICE_INITIAL > thermal: of: Monitor thermal zone after enabling it > thermal: Stop polling DISABLED thermal devices > > drivers/acpi/thermal.c | 28 +++++----- > .../ethernet/mellanox/mlxsw/core_thermal.c | 11 +++- > drivers/platform/x86/acerhdf.c | 17 ++++-- > drivers/thermal/da9062-thermal.c | 2 +- > drivers/thermal/imx_thermal.c | 5 +- > .../intel/int340x_thermal/int3400_thermal.c | 24 ++++----- > .../thermal/intel/intel_quark_dts_thermal.c | 6 ++- > drivers/thermal/of-thermal.c | 9 +++- > drivers/thermal/thermal_core.c | 52 ++++++++++++++++++- > drivers/thermal/thermal_core.h | 2 + > drivers/thermal/thermal_sysfs.c | 12 +++-- > include/linux/thermal.h | 3 +- > 12 files changed, 123 insertions(+), 48 deletions(-) > -- Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Lezcano Subject: Re: [RFC 0/8] Stop monitoring disabled devices Date: Thu, 9 Apr 2020 12:29:35 +0200 Message-ID: <2bc5a902-acde-526a-11a5-2357d899916c@linaro.org> References: <20200407174926.23971-1-andrzej.p@collabora.com> Mime-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Return-path: In-Reply-To: <20200407174926.23971-1-andrzej.p@collabora.com> Content-Language: en-US Sender: linux-acpi-owner@vger.kernel.org To: Andrzej Pietrasiewicz , linux-pm@vger.kernel.org Cc: Zhang Rui , "Rafael J . Wysocki" , Len Brown , Jiri Pirko , Ido Schimmel , "David S . Miller" , Peter Kaestle , Darren Hart , Andy Shevchenko , Support Opensource , Amit Kucheria , Shawn Guo , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , NXP Linux Team , Allison Randal , Enrico Weigelt , Gayatri Kammela , Thomas Gleixner List-Id: platform-driver-x86.vger.kernel.org On 07/04/2020 19:49, Andrzej Pietrasiewicz wrote: > The current kernel behavior is to keep polling the thermal zone devices > regardless of their current mode. This is not desired, as all such "disabled" > devices are meant to be handled by userspace,> so polling them makes no sense. Thanks for proposing these changes. I've been (quickly) through the series and the description below. I have the feeling the series makes more complex while the current code which would deserve a cleanup. Why not first: - Add a 'mode' field in the thermal zone device - Kill all set/get_mode callbacks in the drivers which are duplicated code. - Add a function: enum thermal_device_mode thermal_zone_get_mode( *tz) { ... if (tz->ops->get_mode) return tz->ops->get_mode(); return tz->mode; } int thermal_zone_set_mode(..*tz, enum thermal_device_mode mode) { ... if (tz->ops->set_mode) return tz->ops->set_mode(tz, mode); tz->mode = mode; return 0; } static inline thermal_zone_enable(... *tz) { thermal_zone_set_mode(tz, THERMAL_DEVICE_ENABLED); } static inline thermal_zone_disable(... *tz) { thermal_zone_set_mode(tz, THERMAL_DEVICE_DISABLED); } And then when the code is consolidated, use the mode to enable/disable the polling and continue killing the duplicated code in of-thermal.c and anywhere else. > There was an attempt to solve this issue: > > https://lkml.org/lkml/2018/2/26/498 > > and it ultimately has not succeeded: > > https://lkml.org/lkml/2018/2/27/910 > > This is a new attempt addressing all the relevant drivers, and I have > identified them with: > > $ git grep "thermal_zone_device_ops" | grep "= {" | cut -f1 -d: | sort | uniq > > The idea is to modify thermal_zone_device_update() and monitor_thermal_zone() > in such a way that they stop polling a disabled device. To do decide what to > do they should call ->get_mode() operation of the specialized thermal zone > device in question (e.g. drivers/acpi/thermal.c's). But here comes problem: > sometimes a thermal zone device must be initially disabled and becomes enabled > only after its sensors appear on the system. If such thermal zone's > ->get_mode() /* in the context of thermal_zone_device_update() or > monitor_thermal_zone() */ is called _before_ the sensors are available, it will > be reported as "disabled" and consequently polling it will be ceased. This is > a change in behavior from userspace's perspective. > > To solve the above described problem I want to introduce the third mode of a > thermal_zone_device: initial. The idea is that when the device is in its > initial mode, then its polling will be handled as it is now. This is a good > thing: should the temperature be just about hitting the critical treshnold > early during the boot process, it might be too late if we wait for the > userspace to run to save the system from overheating. The initial mode should > be reported in sysfs as "enabled" to keep the userspace interface intact. > From the initial mode there will be two possible transitions: to enabled or > disabled mode, but there will be no transition back to initial. If the > transition is from initial to enabled, then keep polling. If the transition is > from initial to disabled, then stop polling. If the transition is from enabled > to disabled, then stop polling. The transition from disabled to enabled must > be handled in a special way: there must be a mandatory call to > monitor_thermal_zone(), otherwise the polling will not start. If this > transition is triggeted from sysfs, then it can be easily handled at the > thermal framework level. However, if drivers call their own ->set_mode() > operation then they must also call "monitor_thermal_zone()" afterwards. > The latter being a sensible thing anyway, so perhaps all/most of the drivers > in question do. The plan for implementation is this: > > - ensure ALL users use symbolic enum names (THERMAL_DEVICE_DISABLED, > THERMAL_DEVICE_ENABLED) for thermal device mode rather than the numeric > values of enum thermal_device_mode elements > - add THERMAL_DEVICE_INITIAL to the said enum making its value 0 (so that > kzalloc() results in the initial state) > - modify thermal zone device's mode_show() (thermal framework level) so that > it reports "enabled" for THERMAL_DEVICE_INITIAL > - modify thermal zone device's mode_store() (thermal framework level) so that > it calls monitor_thermal_zone() upon mode change > - modify ALL thermal drivers so that their code is prepared to return > THERMAL_DEVICE_INITIAL before they call thermal_zone_device_register(); when > the invocation of the latter completes then polling is expected to be started > - verify ALL drivers which call their own ->set_mode() to ensure they do call > monitor_thermal_zone() afterwards > - modify thermal_zone_device_update() and monitor_thermal_zone() so that they > cancel polling for disabled thermal zone devices (but not for those in > THERMAL_DEVICE_INITIAL mode) > > This RFC series does all the above steps in more or less that order. > > I kindly ask for comments/suggestions/improvements. > > Rebased onto v5.6. > > Andrzej Pietrasiewicz (8): > thermal: int3400_thermal: Statically initialize > .get_mode()/.set_mode() ops > thermal: Properly handle mode values in .set_mode() > thermal: Store thermal mode in a dedicated enum > thermal: core: Introduce THERMAL_DEVICE_INITIAL > thermal: core: Monitor thermal zone after mode change > thermal: Set initial state to THERMAL_DEVICE_INITIAL > thermal: of: Monitor thermal zone after enabling it > thermal: Stop polling DISABLED thermal devices > > drivers/acpi/thermal.c | 28 +++++----- > .../ethernet/mellanox/mlxsw/core_thermal.c | 11 +++- > drivers/platform/x86/acerhdf.c | 17 ++++-- > drivers/thermal/da9062-thermal.c | 2 +- > drivers/thermal/imx_thermal.c | 5 +- > .../intel/int340x_thermal/int3400_thermal.c | 24 ++++----- > .../thermal/intel/intel_quark_dts_thermal.c | 6 ++- > drivers/thermal/of-thermal.c | 9 +++- > drivers/thermal/thermal_core.c | 52 ++++++++++++++++++- > drivers/thermal/thermal_core.h | 2 + > drivers/thermal/thermal_sysfs.c | 12 +++-- > include/linux/thermal.h | 3 +- > 12 files changed, 123 insertions(+), 48 deletions(-) > -- Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog 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 X-Spam-Level: X-Spam-Status: No, score=-2.2 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,SPF_HELO_NONE, SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=no autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1E290C2BB86 for ; Thu, 9 Apr 2020 10:30:23 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id E0ADA2083E for ; Thu, 9 Apr 2020 10:30:22 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="S1zmjHRW"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="IS2IOiCn" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E0ADA2083E Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linaro.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:Date: Message-ID:From:References:To:Subject:Reply-To:Content-ID:Content-Description :Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=w+2EttHGtxIpaOYb2QZ+h22Q3rbErG4aMjSomia+TjA=; b=S1zmjHRWPIOi2o 6wRjAgOHYFAlIXjj0UNEgcwnVd3yL924cI7Rsaf6ijQ7OoeRryrj8qGYZwMC2Xov9oJvWisUHln+Z 0hy1F2CaM8zC2toz91oq2yuw6RX2bMkNfA5WNnL8KL0TGZDE9Do7UKmE40r6fZTSp5/k0XQlX5GMA bEIrl/OvILRKtOnzZqComzuZbSyD+9ctBX4dKrCls39zS93TL/LaXTX3MDdWAbZmuAs4rp5FE7apK zkFwz+F1JC6u6ixDbqLPEv2SQVxUfKrJegzpEJhh3aclpQGN/5Hhvo1W122nG/JbLnKiHs7T4FC1i eodxRJZK3VMS5WG2OGBg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jMURx-0006o2-Lw; Thu, 09 Apr 2020 10:30:21 +0000 Received: from mail-wr1-x444.google.com ([2a00:1450:4864:20::444]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jMURL-0004Lu-Pd for linux-arm-kernel@lists.infradead.org; Thu, 09 Apr 2020 10:29:46 +0000 Received: by mail-wr1-x444.google.com with SMTP id s8so11297299wrt.7 for ; Thu, 09 Apr 2020 03:29:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-language:content-transfer-encoding; bh=jkRgOsveN5qmBJ0M4R1dAo5UKj2A3MYQ96PvB4Jc5CE=; b=IS2IOiCnk4iXdbES0KEBbw/6SOqjQFLsN7lNB5d2C7/qoY2xTbXshqURo/fi5dG5Iz GXidyQ9Yw4Y3rzMWM9+RlALOsdgTx1qBDnDGPUGOQecWQ1sYCpxC2ivVw5pvJQ5HWy7+ F18RqGaCzpTT+BZ+Bs3FwV62hWNomqyVufK9NA0jJ90/UHeK50PV54czICyTNPXNxHrh I/07xFpmOdYw/7Iu29LSylka2lsyVgLOHmsu/dg36kOhGJg7F/qKmNlyCvcb5WNa/AeP DE2LLRmoXYB60pusRlUwULBGHPbFo0FfIEq5jTWr15i6N8eVjZJYIdKyf7qdCfXZcq9s 2GEQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-language :content-transfer-encoding; bh=jkRgOsveN5qmBJ0M4R1dAo5UKj2A3MYQ96PvB4Jc5CE=; b=XGyDBTjhKz+bCG7Lk6WIEDlNU7IVsA6tRy8ingWm1Nf7pA3AyD/ZPwBwIbIgiYB1Aq uTS+i2LOk9ffoVvl9xY8tkYuLgEQUZpE0uQNFwof88bwhEUfSh13NPGgWu19yurrRqOL Irr4MgCk7f5Rw05lhS6SZpH6m3Zi1RTctHwz0B1kpkeLdqmD1QQ0k6MawhErwN5RHnOJ wONaruLM6GAlzYkLcx2SW34ic4flXoLZ73lB7yRNSuLjtMLLlHZcGUW1TGGvlWdFsUCi CvedR81Y7opGEKlbUZ/j3DJr9YjUpkMDMjuK/6a340Ae+W8zGPvhAPnRunQXj6PyweYq 2P2A== X-Gm-Message-State: AGi0Pua6an8JVHtdHxJlxKLpNh0Rj0V6ovjd7XxBmFn82vVKVyAfUd9H K7cCH8gPzQZx5TAGCFuoCIqbIQ== X-Google-Smtp-Source: APiQypJ5A9CM3Ob4OXn4XWWblUTVqk+zAuAyVWAIgpRUXU7di1gR50JYOWdb6bfOss/zcEyE+jw/ig== X-Received: by 2002:adf:fe03:: with SMTP id n3mr195558wrr.315.1586428179858; Thu, 09 Apr 2020 03:29:39 -0700 (PDT) Received: from ?IPv6:2a01:e34:ed2f:f020:e1dc:4371:fecd:8292? ([2a01:e34:ed2f:f020:e1dc:4371:fecd:8292]) by smtp.googlemail.com with ESMTPSA id e2sm6240723wrr.84.2020.04.09.03.29.36 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 09 Apr 2020 03:29:39 -0700 (PDT) Subject: Re: [RFC 0/8] Stop monitoring disabled devices To: Andrzej Pietrasiewicz , linux-pm@vger.kernel.org References: <20200407174926.23971-1-andrzej.p@collabora.com> From: Daniel Lezcano Message-ID: <2bc5a902-acde-526a-11a5-2357d899916c@linaro.org> Date: Thu, 9 Apr 2020 12:29:35 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.4.1 MIME-Version: 1.0 In-Reply-To: <20200407174926.23971-1-andrzej.p@collabora.com> Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200409_032943_886063_782A2646 X-CRM114-Status: GOOD ( 30.86 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: "Rafael J . Wysocki" , platform-driver-x86@vger.kernel.org, Shawn Guo , kernel@collabora.com, Fabio Estevam , Amit Kucheria , linux-acpi@vger.kernel.org, NXP Linux Team , Darren Hart , Zhang Rui , Gayatri Kammela , Len Brown , Sascha Hauer , Ido Schimmel , Jiri Pirko , Thomas Gleixner , Allison Randal , linux-arm-kernel@lists.infradead.org, Support Opensource , netdev@vger.kernel.org, Peter Kaestle , Pengutronix Kernel Team , Enrico Weigelt , "David S . Miller" , Andy Shevchenko Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org T24gMDcvMDQvMjAyMCAxOTo0OSwgQW5kcnplaiBQaWV0cmFzaWV3aWN6IHdyb3RlOgo+IFRoZSBj dXJyZW50IGtlcm5lbCBiZWhhdmlvciBpcyB0byBrZWVwIHBvbGxpbmcgdGhlIHRoZXJtYWwgem9u ZSBkZXZpY2VzCj4gcmVnYXJkbGVzcyBvZiB0aGVpciBjdXJyZW50IG1vZGUuIFRoaXMgaXMgbm90 IGRlc2lyZWQsIGFzIGFsbCBzdWNoICJkaXNhYmxlZCIKPiBkZXZpY2VzIGFyZSBtZWFudCB0byBi ZSBoYW5kbGVkIGJ5IHVzZXJzcGFjZSw+IHNvIHBvbGxpbmcgdGhlbSBtYWtlcyBubyBzZW5zZS4K ClRoYW5rcyBmb3IgcHJvcG9zaW5nIHRoZXNlIGNoYW5nZXMuCgpJJ3ZlIGJlZW4gKHF1aWNrbHkp IHRocm91Z2ggdGhlIHNlcmllcyBhbmQgdGhlIGRlc2NyaXB0aW9uIGJlbG93LiBJIGhhdmUKdGhl IGZlZWxpbmcgdGhlIHNlcmllcyBtYWtlcyBtb3JlIGNvbXBsZXggd2hpbGUgdGhlIGN1cnJlbnQg Y29kZSB3aGljaAp3b3VsZCBkZXNlcnZlIGEgY2xlYW51cC4KCldoeSBub3QgZmlyc3Q6CgogLSBB ZGQgYSAnbW9kZScgZmllbGQgaW4gdGhlIHRoZXJtYWwgem9uZSBkZXZpY2UKIC0gS2lsbCBhbGwg c2V0L2dldF9tb2RlIGNhbGxiYWNrcyBpbiB0aGUgZHJpdmVycyB3aGljaCBhcmUgZHVwbGljYXRl ZCBjb2RlLgogLSBBZGQgYSBmdW5jdGlvbjoKCiBlbnVtIHRoZXJtYWxfZGV2aWNlX21vZGUgdGhl cm1hbF96b25lX2dldF9tb2RlKCAqdHopCiB7CgkuLi4KCWlmICh0ei0+b3BzLT5nZXRfbW9kZSkK CQlyZXR1cm4gdHotPm9wcy0+Z2V0X21vZGUoKTsKCglyZXR1cm4gdHotPm1vZGU7CiB9CgoKIGlu dCB0aGVybWFsX3pvbmVfc2V0X21vZGUoLi4qdHosIGVudW0gdGhlcm1hbF9kZXZpY2VfbW9kZSBt b2RlKQogewoJLi4uCglpZiAodHotPm9wcy0+c2V0X21vZGUpCgkJcmV0dXJuIHR6LT5vcHMtPnNl dF9tb2RlKHR6LCBtb2RlKTsKCgl0ei0+bW9kZSA9IG1vZGU7CgoJcmV0dXJuIDA7CiB9Cgogc3Rh dGljIGlubGluZSB0aGVybWFsX3pvbmVfZW5hYmxlKC4uLiAqdHopCiB7Cgl0aGVybWFsX3pvbmVf c2V0X21vZGUodHosIFRIRVJNQUxfREVWSUNFX0VOQUJMRUQpOwogfQoKIHN0YXRpYyBpbmxpbmUg dGhlcm1hbF96b25lX2Rpc2FibGUoLi4uICp0eikgewoJdGhlcm1hbF96b25lX3NldF9tb2RlKHR6 LCBUSEVSTUFMX0RFVklDRV9ESVNBQkxFRCk7CiB9CgpBbmQgdGhlbiB3aGVuIHRoZSBjb2RlIGlz IGNvbnNvbGlkYXRlZCwgdXNlIHRoZSBtb2RlIHRvIGVuYWJsZS9kaXNhYmxlCnRoZSBwb2xsaW5n IGFuZCBjb250aW51ZSBraWxsaW5nIHRoZSBkdXBsaWNhdGVkIGNvZGUgaW4gb2YtdGhlcm1hbC5j IGFuZAphbnl3aGVyZSBlbHNlLgoKCj4gVGhlcmUgd2FzIGFuIGF0dGVtcHQgdG8gc29sdmUgdGhp cyBpc3N1ZToKPiAKPiBodHRwczovL2xrbWwub3JnL2xrbWwvMjAxOC8yLzI2LzQ5OAo+IAo+IGFu ZCBpdCB1bHRpbWF0ZWx5IGhhcyBub3Qgc3VjY2VlZGVkOgo+IAo+IGh0dHBzOi8vbGttbC5vcmcv bGttbC8yMDE4LzIvMjcvOTEwCj4gCj4gVGhpcyBpcyBhIG5ldyBhdHRlbXB0IGFkZHJlc3Npbmcg YWxsIHRoZSByZWxldmFudCBkcml2ZXJzLCBhbmQgSSBoYXZlCj4gaWRlbnRpZmllZCB0aGVtIHdp dGg6Cj4gCj4gJCBnaXQgZ3JlcCAidGhlcm1hbF96b25lX2RldmljZV9vcHMiIHwgZ3JlcCAiPSB7 IiB8IGN1dCAtZjEgLWQ6IHwgc29ydCB8IHVuaXEKPiAKPiBUaGUgaWRlYSBpcyB0byBtb2RpZnkg dGhlcm1hbF96b25lX2RldmljZV91cGRhdGUoKSBhbmQgbW9uaXRvcl90aGVybWFsX3pvbmUoKQo+ IGluIHN1Y2ggYSB3YXkgdGhhdCB0aGV5IHN0b3AgcG9sbGluZyBhIGRpc2FibGVkIGRldmljZS4g VG8gZG8gZGVjaWRlIHdoYXQgdG8KPiBkbyB0aGV5IHNob3VsZCBjYWxsIC0+Z2V0X21vZGUoKSBv cGVyYXRpb24gb2YgdGhlIHNwZWNpYWxpemVkIHRoZXJtYWwgem9uZQo+IGRldmljZSBpbiBxdWVz dGlvbiAoZS5nLiBkcml2ZXJzL2FjcGkvdGhlcm1hbC5jJ3MpLiBCdXQgaGVyZSBjb21lcyBwcm9i bGVtOgo+IHNvbWV0aW1lcyBhIHRoZXJtYWwgem9uZSBkZXZpY2UgbXVzdCBiZSBpbml0aWFsbHkg ZGlzYWJsZWQgYW5kIGJlY29tZXMgZW5hYmxlZAo+IG9ubHkgYWZ0ZXIgaXRzIHNlbnNvcnMgYXBw ZWFyIG9uIHRoZSBzeXN0ZW0uIElmIHN1Y2ggdGhlcm1hbCB6b25lJ3MKPiAtPmdldF9tb2RlKCkg LyogaW4gdGhlIGNvbnRleHQgb2YgdGhlcm1hbF96b25lX2RldmljZV91cGRhdGUoKSBvcgo+IG1v bml0b3JfdGhlcm1hbF96b25lKCkgKi8gaXMgY2FsbGVkIF9iZWZvcmVfIHRoZSBzZW5zb3JzIGFy ZSBhdmFpbGFibGUsIGl0IHdpbGwKPiBiZSByZXBvcnRlZCBhcyAiZGlzYWJsZWQiIGFuZCBjb25z ZXF1ZW50bHkgcG9sbGluZyBpdCB3aWxsIGJlIGNlYXNlZC4gVGhpcyBpcwo+IGEgY2hhbmdlIGlu IGJlaGF2aW9yIGZyb20gdXNlcnNwYWNlJ3MgcGVyc3BlY3RpdmUuCj4gCj4gVG8gc29sdmUgdGhl IGFib3ZlIGRlc2NyaWJlZCBwcm9ibGVtIEkgd2FudCB0byBpbnRyb2R1Y2UgdGhlIHRoaXJkIG1v ZGUgb2YgYQo+IHRoZXJtYWxfem9uZV9kZXZpY2U6IGluaXRpYWwuIFRoZSBpZGVhIGlzIHRoYXQg d2hlbiB0aGUgZGV2aWNlIGlzIGluIGl0cwo+IGluaXRpYWwgbW9kZSwgdGhlbiBpdHMgcG9sbGlu ZyB3aWxsIGJlIGhhbmRsZWQgYXMgaXQgaXMgbm93LiBUaGlzIGlzIGEgZ29vZAo+IHRoaW5nOiBz aG91bGQgdGhlIHRlbXBlcmF0dXJlIGJlIGp1c3QgYWJvdXQgaGl0dGluZyB0aGUgY3JpdGljYWwg dHJlc2hub2xkCj4gZWFybHkgZHVyaW5nIHRoZSBib290IHByb2Nlc3MsIGl0IG1pZ2h0IGJlIHRv byBsYXRlIGlmIHdlIHdhaXQgZm9yIHRoZQo+IHVzZXJzcGFjZSB0byBydW4gdG8gc2F2ZSB0aGUg c3lzdGVtIGZyb20gb3ZlcmhlYXRpbmcuIFRoZSBpbml0aWFsIG1vZGUgc2hvdWxkCj4gYmUgcmVw b3J0ZWQgaW4gc3lzZnMgYXMgImVuYWJsZWQiIHRvIGtlZXAgdGhlIHVzZXJzcGFjZSBpbnRlcmZh Y2UgaW50YWN0Lgo+IEZyb20gdGhlIGluaXRpYWwgbW9kZSB0aGVyZSB3aWxsIGJlIHR3byBwb3Nz aWJsZSB0cmFuc2l0aW9uczogdG8gZW5hYmxlZCBvcgo+IGRpc2FibGVkIG1vZGUsIGJ1dCB0aGVy ZSB3aWxsIGJlIG5vIHRyYW5zaXRpb24gYmFjayB0byBpbml0aWFsLiBJZiB0aGUKPiB0cmFuc2l0 aW9uIGlzIGZyb20gaW5pdGlhbCB0byBlbmFibGVkLCB0aGVuIGtlZXAgcG9sbGluZy4gSWYgdGhl IHRyYW5zaXRpb24gaXMKPiBmcm9tIGluaXRpYWwgdG8gZGlzYWJsZWQsIHRoZW4gc3RvcCBwb2xs aW5nLiBJZiB0aGUgdHJhbnNpdGlvbiBpcyBmcm9tIGVuYWJsZWQKPiB0byBkaXNhYmxlZCwgdGhl biBzdG9wIHBvbGxpbmcuIFRoZSB0cmFuc2l0aW9uIGZyb20gZGlzYWJsZWQgdG8gZW5hYmxlZCBt dXN0Cj4gYmUgaGFuZGxlZCBpbiBhIHNwZWNpYWwgd2F5OiB0aGVyZSBtdXN0IGJlIGEgbWFuZGF0 b3J5IGNhbGwgdG8KPiBtb25pdG9yX3RoZXJtYWxfem9uZSgpLCBvdGhlcndpc2UgdGhlIHBvbGxp bmcgd2lsbCBub3Qgc3RhcnQuIElmIHRoaXMKPiB0cmFuc2l0aW9uIGlzIHRyaWdnZXRlZCBmcm9t IHN5c2ZzLCB0aGVuIGl0IGNhbiBiZSBlYXNpbHkgaGFuZGxlZCBhdCB0aGUKPiB0aGVybWFsIGZy YW1ld29yayBsZXZlbC4gSG93ZXZlciwgaWYgZHJpdmVycyBjYWxsIHRoZWlyIG93biAtPnNldF9t b2RlKCkKPiBvcGVyYXRpb24gdGhlbiB0aGV5IG11c3QgYWxzbyBjYWxsICJtb25pdG9yX3RoZXJt YWxfem9uZSgpIiBhZnRlcndhcmRzLgo+IFRoZSBsYXR0ZXIgYmVpbmcgYSBzZW5zaWJsZSB0aGlu ZyBhbnl3YXksIHNvIHBlcmhhcHMgYWxsL21vc3Qgb2YgdGhlIGRyaXZlcnMKPiBpbiBxdWVzdGlv biBkby4gVGhlIHBsYW4gZm9yIGltcGxlbWVudGF0aW9uIGlzIHRoaXM6Cj4gCj4gLSBlbnN1cmUg QUxMIHVzZXJzIHVzZSBzeW1ib2xpYyBlbnVtIG5hbWVzIChUSEVSTUFMX0RFVklDRV9ESVNBQkxF RCwKPiBUSEVSTUFMX0RFVklDRV9FTkFCTEVEKSBmb3IgdGhlcm1hbCBkZXZpY2UgbW9kZSByYXRo ZXIgdGhhbiB0aGUgbnVtZXJpYwo+IHZhbHVlcyBvZiBlbnVtIHRoZXJtYWxfZGV2aWNlX21vZGUg ZWxlbWVudHMKPiAtIGFkZCBUSEVSTUFMX0RFVklDRV9JTklUSUFMIHRvIHRoZSBzYWlkIGVudW0g bWFraW5nIGl0cyB2YWx1ZSAwIChzbyB0aGF0Cj4ga3phbGxvYygpIHJlc3VsdHMgaW4gdGhlIGlu aXRpYWwgc3RhdGUpCj4gLSBtb2RpZnkgdGhlcm1hbCB6b25lIGRldmljZSdzIG1vZGVfc2hvdygp ICh0aGVybWFsIGZyYW1ld29yayBsZXZlbCkgc28gdGhhdAo+IGl0IHJlcG9ydHMgImVuYWJsZWQi IGZvciBUSEVSTUFMX0RFVklDRV9JTklUSUFMCj4gLSBtb2RpZnkgdGhlcm1hbCB6b25lIGRldmlj ZSdzIG1vZGVfc3RvcmUoKSAodGhlcm1hbCBmcmFtZXdvcmsgbGV2ZWwpIHNvIHRoYXQKPiBpdCBj YWxscyBtb25pdG9yX3RoZXJtYWxfem9uZSgpIHVwb24gbW9kZSBjaGFuZ2UKPiAtIG1vZGlmeSBB TEwgdGhlcm1hbCBkcml2ZXJzIHNvIHRoYXQgdGhlaXIgY29kZSBpcyBwcmVwYXJlZCB0byByZXR1 cm4KPiBUSEVSTUFMX0RFVklDRV9JTklUSUFMIGJlZm9yZSB0aGV5IGNhbGwgdGhlcm1hbF96b25l X2RldmljZV9yZWdpc3RlcigpOyB3aGVuCj4gdGhlIGludm9jYXRpb24gb2YgdGhlIGxhdHRlciBj b21wbGV0ZXMgdGhlbiBwb2xsaW5nIGlzIGV4cGVjdGVkIHRvIGJlIHN0YXJ0ZWQKPiAtIHZlcmlm eSBBTEwgZHJpdmVycyB3aGljaCBjYWxsIHRoZWlyIG93biAtPnNldF9tb2RlKCkgdG8gZW5zdXJl IHRoZXkgZG8gY2FsbAo+IG1vbml0b3JfdGhlcm1hbF96b25lKCkgYWZ0ZXJ3YXJkcwo+IC0gbW9k aWZ5IHRoZXJtYWxfem9uZV9kZXZpY2VfdXBkYXRlKCkgYW5kIG1vbml0b3JfdGhlcm1hbF96b25l KCkgc28gdGhhdCB0aGV5Cj4gY2FuY2VsIHBvbGxpbmcgZm9yIGRpc2FibGVkIHRoZXJtYWwgem9u ZSBkZXZpY2VzIChidXQgbm90IGZvciB0aG9zZSBpbgo+IFRIRVJNQUxfREVWSUNFX0lOSVRJQUwg bW9kZSkKPiAKPiBUaGlzIFJGQyBzZXJpZXMgZG9lcyBhbGwgdGhlIGFib3ZlIHN0ZXBzIGluIG1v cmUgb3IgbGVzcyB0aGF0IG9yZGVyLgo+IAo+IEkga2luZGx5IGFzayBmb3IgY29tbWVudHMvc3Vn Z2VzdGlvbnMvaW1wcm92ZW1lbnRzLgo+IAo+IFJlYmFzZWQgb250byB2NS42Lgo+IAo+IEFuZHJ6 ZWogUGlldHJhc2lld2ljeiAoOCk6Cj4gICB0aGVybWFsOiBpbnQzNDAwX3RoZXJtYWw6IFN0YXRp Y2FsbHkgaW5pdGlhbGl6ZQo+ICAgICAuZ2V0X21vZGUoKS8uc2V0X21vZGUoKSBvcHMKPiAgIHRo ZXJtYWw6IFByb3Blcmx5IGhhbmRsZSBtb2RlIHZhbHVlcyBpbiAuc2V0X21vZGUoKQo+ICAgdGhl cm1hbDogU3RvcmUgdGhlcm1hbCBtb2RlIGluIGEgZGVkaWNhdGVkIGVudW0KPiAgIHRoZXJtYWw6 IGNvcmU6IEludHJvZHVjZSBUSEVSTUFMX0RFVklDRV9JTklUSUFMCj4gICB0aGVybWFsOiBjb3Jl OiBNb25pdG9yIHRoZXJtYWwgem9uZSBhZnRlciBtb2RlIGNoYW5nZQo+ICAgdGhlcm1hbDogU2V0 IGluaXRpYWwgc3RhdGUgdG8gVEhFUk1BTF9ERVZJQ0VfSU5JVElBTAo+ICAgdGhlcm1hbDogb2Y6 IE1vbml0b3IgdGhlcm1hbCB6b25lIGFmdGVyIGVuYWJsaW5nIGl0Cj4gICB0aGVybWFsOiBTdG9w IHBvbGxpbmcgRElTQUJMRUQgdGhlcm1hbCBkZXZpY2VzCj4gCj4gIGRyaXZlcnMvYWNwaS90aGVy bWFsLmMgICAgICAgICAgICAgICAgICAgICAgICB8IDI4ICsrKysrLS0tLS0KPiAgLi4uL2V0aGVy bmV0L21lbGxhbm94L21seHN3L2NvcmVfdGhlcm1hbC5jICAgIHwgMTEgKysrLQo+ICBkcml2ZXJz L3BsYXRmb3JtL3g4Ni9hY2VyaGRmLmMgICAgICAgICAgICAgICAgfCAxNyArKysrLS0KPiAgZHJp dmVycy90aGVybWFsL2RhOTA2Mi10aGVybWFsLmMgICAgICAgICAgICAgIHwgIDIgKy0KPiAgZHJp dmVycy90aGVybWFsL2lteF90aGVybWFsLmMgICAgICAgICAgICAgICAgIHwgIDUgKy0KPiAgLi4u L2ludGVsL2ludDM0MHhfdGhlcm1hbC9pbnQzNDAwX3RoZXJtYWwuYyAgIHwgMjQgKysrKy0tLS0t Cj4gIC4uLi90aGVybWFsL2ludGVsL2ludGVsX3F1YXJrX2R0c190aGVybWFsLmMgICB8ICA2ICsr LQo+ICBkcml2ZXJzL3RoZXJtYWwvb2YtdGhlcm1hbC5jICAgICAgICAgICAgICAgICAgfCAgOSAr KystCj4gIGRyaXZlcnMvdGhlcm1hbC90aGVybWFsX2NvcmUuYyAgICAgICAgICAgICAgICB8IDUy ICsrKysrKysrKysrKysrKysrKy0KPiAgZHJpdmVycy90aGVybWFsL3RoZXJtYWxfY29yZS5oICAg ICAgICAgICAgICAgIHwgIDIgKwo+ICBkcml2ZXJzL3RoZXJtYWwvdGhlcm1hbF9zeXNmcy5jICAg ICAgICAgICAgICAgfCAxMiArKystLQo+ICBpbmNsdWRlL2xpbnV4L3RoZXJtYWwuaCAgICAgICAg ICAgICAgICAgICAgICAgfCAgMyArLQo+ICAxMiBmaWxlcyBjaGFuZ2VkLCAxMjMgaW5zZXJ0aW9u cygrKSwgNDggZGVsZXRpb25zKC0pCj4gCgoKLS0gCjxodHRwOi8vd3d3LmxpbmFyby5vcmcvPiBM aW5hcm8ub3JnIOKUgiBPcGVuIHNvdXJjZSBzb2Z0d2FyZSBmb3IgQVJNIFNvQ3MKCkZvbGxvdyBM aW5hcm86ICA8aHR0cDovL3d3dy5mYWNlYm9vay5jb20vcGFnZXMvTGluYXJvPiBGYWNlYm9vayB8 CjxodHRwOi8vdHdpdHRlci5jb20vIyEvbGluYXJvb3JnPiBUd2l0dGVyIHwKPGh0dHA6Ly93d3cu bGluYXJvLm9yZy9saW5hcm8tYmxvZy8+IEJsb2cKCl9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4 LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK