From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1759356AbcCVLFI (ORCPT ); Tue, 22 Mar 2016 07:05:08 -0400 Received: from e28smtp07.in.ibm.com ([125.16.236.7]:52979 "EHLO e28smtp07.in.ibm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1759157AbcCVK67 (ORCPT ); Tue, 22 Mar 2016 06:58:59 -0400 X-IBM-Helo: d28relay05.in.ibm.com X-IBM-MailFrom: shilpa.bhat@linux.vnet.ibm.com X-IBM-RcptTo: linux-api@vger.kernel.org;linux-pm@vger.kernel.org;linux-kernel@vger.kernel.org From: Shilpasri G Bhat To: linuxppc-dev@ozlabs.org, linux-kernel@vger.kernel.org Cc: ego@linux.vnet.ibm.com, linux-pm@vger.kernel.org, viresh.kumar@linaro.org, rjw@rjwysocki.net, shreyas@linux.vnet.ibm.com, Shilpasri G Bhat , linux-api@vger.kernel.org Subject: [PATCH v12] cpufreq: powernv: Add sysfs attributes to show throttle stats Date: Tue, 22 Mar 2016 16:18:37 +0530 Message-Id: <1458643717-2847-1-git-send-email-shilpa.bhat@linux.vnet.ibm.com> X-Mailer: git-send-email 1.9.3 X-TM-AS-MML: disable x-cbid: 16032210-0025-0000-0000-00000ACBE977 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Create sysfs attributes to export throttle information in /sys/devices/system/cpu/cpuX/cpufreq/throttle_stats directory. The newly added sysfs files are as follows: 1)/sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/turbo_stat 2)/sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/sub-turbo_stat 3)/sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/unthrottle 4)/sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/powercap 5)/sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/overtemp 6)/sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/supply_fault 7)/sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/overcurrent 8)/sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/occ_reset Detailed explanation of each attribute is added to Documentation/ABI/testing/sysfs-devices-system-cpu CC: linux-api@vger.kernel.org Signed-off-by: Shilpasri G Bhat --- Changes from v11: - Removed '*create_throttle_sysfs' - policy->driver_data is used instead to maintain the flag for one-time creation of throttle sysfs files. Changes from v10: - Removed policy_notifiers to use driver->init() instead to create sysfs - sysfs attributes are removed by kobject_put(policy->kobj) - Rebased on top of http://lkml.iu.edu/hypermail/linux/kernel/1603.2/02268.html Changes from v9: - Modified documentation. - s/throttle_nominal/throttle_sub_turbo Changes from v8: - Moved the sysfs attributes from cpu/cpufreq/chipX to cpuX/cpufreq/throttle_stats - Adhering to one-value-per-file, replace throttle_table with multiple sysfs files. - Using CPUFREQ_POLICY_NOTIFIER to add/remove attribute_group. Documentation/ABI/testing/sysfs-devices-system-cpu | 69 ++++++++++++++++++++ drivers/cpufreq/powernv-cpufreq.c | 74 +++++++++++++++++++++- 2 files changed, 140 insertions(+), 3 deletions(-) diff --git a/Documentation/ABI/testing/sysfs-devices-system-cpu b/Documentation/ABI/testing/sysfs-devices-system-cpu index b683e8e..1650133 100644 --- a/Documentation/ABI/testing/sysfs-devices-system-cpu +++ b/Documentation/ABI/testing/sysfs-devices-system-cpu @@ -271,3 +271,72 @@ Description: Parameters for the CPU cache attributes - WriteBack: data is written only to the cache line and the modified cache line is written to main memory only when it is replaced + +What: /sys/devices/system/cpu/cpuX/cpufreq/throttle_stats + /sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/turbo_stat + /sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/sub_turbo_stat + /sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/unthrottle + /sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/powercap + /sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/overtemp + /sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/supply_fault + /sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/overcurrent + /sys/devices/system/cpu/cpuX/cpufreq/throttle_stats/occ_reset +Date: March 2016 +Contact: Linux kernel mailing list + Linux for PowerPC mailing list +Description: POWERNV CPUFreq driver's frequency throttle stats directory and + attributes + + 'cpuX/cpufreq/throttle_stats' directory contains the CPU frequency + throttle stat attributes for the chip. The throttle stats of a cpu + is common across all the cpus belonging to a chip. Below are the + throttle attributes exported in the 'throttle_stats' directory: + + - turbo_stat : This file gives the total number of times the max + frequency is throttled to lower frequency in turbo (at and above + nominal frequency) range of frequencies. + + - sub_turbo_stat : This file gives the total number of times the + max frequency is throttled to lower frequency in sub-turbo(below + nominal frequency) range of frequencies. + + - unthrottle : This file gives the total number of times the max + frequency is unthrottled after being throttled. + + - powercap : This file gives the total number of times the max + frequency is throttled due to 'Power Capping'. + + - overtemp : This file gives the total number of times the max + frequency is throttled due to 'CPU Over Temperature'. + + - supply_fault : This file gives the total number of times the + max frequency is throttled due to 'Power Supply Failure'. + + - overcurrent : This file gives the total number of times the + max frequency is throttled due to 'Overcurrent'. + + - occ_reset : This file gives the total number of times the max + frequency is throttled due to 'OCC Reset'. + + The sysfs attributes representing different throttle reasons like + powercap, overtemp, supply_fault, overcurrent and occ_reset map to + the reasons provided by OCC firmware for throttling the frequency. + +What: /sys/devices/system/cpu/cpufreq/policyX/throttle_stats + /sys/devices/system/cpu/cpufreq/policyX/throttle_stats/turbo_stat + /sys/devices/system/cpu/cpufreq/policyX/throttle_stats/sub_turbo_stat + /sys/devices/system/cpu/cpufreq/policyX/throttle_stats/unthrottle + /sys/devices/system/cpu/cpufreq/policyX/throttle_stats/powercap + /sys/devices/system/cpu/cpufreq/policyX/throttle_stats/overtemp + /sys/devices/system/cpu/cpufreq/policyX/throttle_stats/supply_fault + /sys/devices/system/cpu/cpufreq/policyX/throttle_stats/overcurrent + /sys/devices/system/cpu/cpufreq/policyX/throttle_stats/occ_reset +Date: March 2016 +Contact: Linux kernel mailing list + Linux for PowerPC mailing list +Description: POWERNV CPUFreq driver's frequency throttle stats directory and + attributes + + 'policyX/throttle_stats' directory and all the attributes are same as + the /sys/devices/system/cpu/cpuX/cpufreq/throttle_stats directory and + attributes which give the frequency throttle information of the chip. diff --git a/drivers/cpufreq/powernv-cpufreq.c b/drivers/cpufreq/powernv-cpufreq.c index a00bcc2..e17d654 100644 --- a/drivers/cpufreq/powernv-cpufreq.c +++ b/drivers/cpufreq/powernv-cpufreq.c @@ -54,6 +54,16 @@ static const char * const throttle_reason[] = { "OCC Reset" }; +enum throttle_reason_type { + NO_THROTTLE = 0, + POWERCAP, + CPU_OVERTEMP, + POWER_SUPPLY_FAILURE, + OVERCURRENT, + OCC_RESET_THROTTLE, + OCC_MAX_REASON +}; + static struct chip { unsigned int id; bool throttled; @@ -61,6 +71,9 @@ static struct chip { u8 throttle_reason; cpumask_t mask; struct work_struct throttle; + int throttle_turbo; + int throttle_sub_turbo; + int reason[OCC_MAX_REASON]; } *chips; static int nr_chips; @@ -196,6 +209,42 @@ static struct freq_attr *powernv_cpu_freq_attr[] = { NULL, }; +#define throttle_attr(name, member) \ +static ssize_t name##_show(struct cpufreq_policy *policy, char *buf) \ +{ \ + struct chip *chip = per_cpu(chip_info, policy->cpu); \ + \ + return sprintf(buf, "%u\n", chip->member); \ +} \ + \ +static struct freq_attr throttle_attr_##name = __ATTR_RO(name) \ + +throttle_attr(unthrottle, reason[NO_THROTTLE]); +throttle_attr(powercap, reason[POWERCAP]); +throttle_attr(overtemp, reason[CPU_OVERTEMP]); +throttle_attr(supply_fault, reason[POWER_SUPPLY_FAILURE]); +throttle_attr(overcurrent, reason[OVERCURRENT]); +throttle_attr(occ_reset, reason[OCC_RESET_THROTTLE]); +throttle_attr(turbo_stat, throttle_turbo); +throttle_attr(sub_turbo_stat, throttle_sub_turbo); + +static struct attribute *throttle_attrs[] = { + &throttle_attr_unthrottle.attr, + &throttle_attr_powercap.attr, + &throttle_attr_overtemp.attr, + &throttle_attr_supply_fault.attr, + &throttle_attr_overcurrent.attr, + &throttle_attr_occ_reset.attr, + &throttle_attr_turbo_stat.attr, + &throttle_attr_sub_turbo_stat.attr, + NULL, +}; + +static const struct attribute_group throttle_attr_grp = { + .name = "throttle_stats", + .attrs = throttle_attrs, +}; + /* Helper routines */ /* Access helpers to power mgt SPR */ @@ -338,10 +387,14 @@ static void powernv_cpufreq_throttle_check(void *data) if (chip->throttled) goto next; chip->throttled = true; - if (pmsr_pmax < powernv_pstate_info.nominal) + if (pmsr_pmax < powernv_pstate_info.nominal) { pr_warn_once("CPU %d on Chip %u has Pmax reduced below nominal frequency (%d < %d)\n", cpu, chip->id, pmsr_pmax, powernv_pstate_info.nominal); + chip->throttle_sub_turbo++; + } else { + chip->throttle_turbo++; + } trace_powernv_throttle(chip->id, throttle_reason[chip->throttle_reason], pmsr_pmax); @@ -401,13 +454,26 @@ static int powernv_cpufreq_target_index(struct cpufreq_policy *policy, static int powernv_cpufreq_cpu_init(struct cpufreq_policy *policy) { - int base, i; + int base, i, ret; base = cpu_first_thread_sibling(policy->cpu); for (i = 0; i < threads_per_core; i++) cpumask_set_cpu(base + i, policy->cpus); + if (!policy->driver_data) { + ret = sysfs_create_group(&policy->kobj, &throttle_attr_grp); + if (ret) { + pr_info("Failed to create throttle stats directory for cpu %d\n", + policy->cpu); + return ret; + } + /* + * policy->driver_data is used as a flag for one-time + * creation of throttle sysfs files. + */ + policy->driver_data = (void *)policy; + } return cpufreq_table_validate_and_show(policy, powernv_freqs); } @@ -514,8 +580,10 @@ static int powernv_cpufreq_occ_msg(struct notifier_block *nb, break; if (omsg.throttle_status >= 0 && - omsg.throttle_status <= OCC_MAX_THROTTLE_STATUS) + omsg.throttle_status <= OCC_MAX_THROTTLE_STATUS) { chips[i].throttle_reason = omsg.throttle_status; + chips[i].reason[omsg.throttle_status]++; + } if (!omsg.throttle_status) chips[i].restore = true; -- 1.9.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Shilpasri G Bhat Subject: [PATCH v12] cpufreq: powernv: Add sysfs attributes to show throttle stats Date: Tue, 22 Mar 2016 16:18:37 +0530 Message-ID: <1458643717-2847-1-git-send-email-shilpa.bhat@linux.vnet.ibm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: linuxppc-dev-bounces+glppe-linuxppc-embedded-2=m.gmane.org@lists.ozlabs.org Sender: "Linuxppc-dev" To: linuxppc-dev@ozlabs.org, linux-kernel@vger.kernel.org Cc: ego@linux.vnet.ibm.com, linux-pm@vger.kernel.org, shreyas@linux.vnet.ibm.com, rjw@rjwysocki.net, Shilpasri G Bhat , viresh.kumar@linaro.org, linux-api@vger.kernel.org List-Id: linux-api@vger.kernel.org Q3JlYXRlIHN5c2ZzIGF0dHJpYnV0ZXMgdG8gZXhwb3J0IHRocm90dGxlIGluZm9ybWF0aW9uIGlu Ci9zeXMvZGV2aWNlcy9zeXN0ZW0vY3B1L2NwdVgvY3B1ZnJlcS90aHJvdHRsZV9zdGF0cyBkaXJl Y3RvcnkuIFRoZQpuZXdseSBhZGRlZCBzeXNmcyBmaWxlcyBhcmUgYXMgZm9sbG93czoKCjEpL3N5 cy9kZXZpY2VzL3N5c3RlbS9jcHUvY3B1WC9jcHVmcmVxL3Rocm90dGxlX3N0YXRzL3R1cmJvX3N0 YXQKMikvc3lzL2RldmljZXMvc3lzdGVtL2NwdS9jcHVYL2NwdWZyZXEvdGhyb3R0bGVfc3RhdHMv c3ViLXR1cmJvX3N0YXQKMykvc3lzL2RldmljZXMvc3lzdGVtL2NwdS9jcHVYL2NwdWZyZXEvdGhy b3R0bGVfc3RhdHMvdW50aHJvdHRsZQo0KS9zeXMvZGV2aWNlcy9zeXN0ZW0vY3B1L2NwdVgvY3B1 ZnJlcS90aHJvdHRsZV9zdGF0cy9wb3dlcmNhcAo1KS9zeXMvZGV2aWNlcy9zeXN0ZW0vY3B1L2Nw dVgvY3B1ZnJlcS90aHJvdHRsZV9zdGF0cy9vdmVydGVtcAo2KS9zeXMvZGV2aWNlcy9zeXN0ZW0v Y3B1L2NwdVgvY3B1ZnJlcS90aHJvdHRsZV9zdGF0cy9zdXBwbHlfZmF1bHQKNykvc3lzL2Rldmlj ZXMvc3lzdGVtL2NwdS9jcHVYL2NwdWZyZXEvdGhyb3R0bGVfc3RhdHMvb3ZlcmN1cnJlbnQKOCkv c3lzL2RldmljZXMvc3lzdGVtL2NwdS9jcHVYL2NwdWZyZXEvdGhyb3R0bGVfc3RhdHMvb2NjX3Jl c2V0CgpEZXRhaWxlZCBleHBsYW5hdGlvbiBvZiBlYWNoIGF0dHJpYnV0ZSBpcyBhZGRlZCB0bwpE b2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLWRldmljZXMtc3lzdGVtLWNwdQoKQ0M6IGxp bnV4LWFwaUB2Z2VyLmtlcm5lbC5vcmcKU2lnbmVkLW9mZi1ieTogU2hpbHBhc3JpIEcgQmhhdCA8 c2hpbHBhLmJoYXRAbGludXgudm5ldC5pYm0uY29tPgotLS0KQ2hhbmdlcyBmcm9tIHYxMToKLSBS ZW1vdmVkICcqY3JlYXRlX3Rocm90dGxlX3N5c2ZzJyAKLSBwb2xpY3ktPmRyaXZlcl9kYXRhIGlz IHVzZWQgaW5zdGVhZCB0byBtYWludGFpbiB0aGUgZmxhZyBmb3IKICBvbmUtdGltZSBjcmVhdGlv biBvZiB0aHJvdHRsZSBzeXNmcyBmaWxlcy4KCkNoYW5nZXMgZnJvbSB2MTA6Ci0gUmVtb3ZlZCBw b2xpY3lfbm90aWZpZXJzIHRvIHVzZSBkcml2ZXItPmluaXQoKSBpbnN0ZWFkIHRvIGNyZWF0ZSBz eXNmcwotIHN5c2ZzIGF0dHJpYnV0ZXMgYXJlIHJlbW92ZWQgYnkga29iamVjdF9wdXQocG9saWN5 LT5rb2JqKQotIFJlYmFzZWQgb24gdG9wIG9mCiAgaHR0cDovL2xrbWwuaXUuZWR1L2h5cGVybWFp bC9saW51eC9rZXJuZWwvMTYwMy4yLzAyMjY4Lmh0bWwKCkNoYW5nZXMgZnJvbSB2OToKLSBNb2Rp ZmllZCBkb2N1bWVudGF0aW9uLgotIHMvdGhyb3R0bGVfbm9taW5hbC90aHJvdHRsZV9zdWJfdHVy Ym8KCkNoYW5nZXMgZnJvbSB2ODoKLSBNb3ZlZCB0aGUgc3lzZnMgYXR0cmlidXRlcyBmcm9tIGNw dS9jcHVmcmVxL2NoaXBYIHRvIGNwdVgvY3B1ZnJlcS90aHJvdHRsZV9zdGF0cwotIEFkaGVyaW5n IHRvIG9uZS12YWx1ZS1wZXItZmlsZSwgcmVwbGFjZSB0aHJvdHRsZV90YWJsZSB3aXRoIG11bHRp cGxlCiAgc3lzZnMgZmlsZXMuCi0gVXNpbmcgQ1BVRlJFUV9QT0xJQ1lfTk9USUZJRVIgdG8gYWRk L3JlbW92ZSBhdHRyaWJ1dGVfZ3JvdXAuCgogRG9jdW1lbnRhdGlvbi9BQkkvdGVzdGluZy9zeXNm cy1kZXZpY2VzLXN5c3RlbS1jcHUgfCA2OSArKysrKysrKysrKysrKysrKysrKwogZHJpdmVycy9j cHVmcmVxL3Bvd2VybnYtY3B1ZnJlcS5jICAgICAgICAgICAgICAgICAgfCA3NCArKysrKysrKysr KysrKysrKysrKystCiAyIGZpbGVzIGNoYW5nZWQsIDE0MCBpbnNlcnRpb25zKCspLCAzIGRlbGV0 aW9ucygtKQoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMtZGV2 aWNlcy1zeXN0ZW0tY3B1IGIvRG9jdW1lbnRhdGlvbi9BQkkvdGVzdGluZy9zeXNmcy1kZXZpY2Vz LXN5c3RlbS1jcHUKaW5kZXggYjY4M2U4ZS4uMTY1MDEzMyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRh dGlvbi9BQkkvdGVzdGluZy9zeXNmcy1kZXZpY2VzLXN5c3RlbS1jcHUKKysrIGIvRG9jdW1lbnRh dGlvbi9BQkkvdGVzdGluZy9zeXNmcy1kZXZpY2VzLXN5c3RlbS1jcHUKQEAgLTI3MSwzICsyNzEs NzIgQEAgRGVzY3JpcHRpb246CVBhcmFtZXRlcnMgZm9yIHRoZSBDUFUgY2FjaGUgYXR0cmlidXRl cwogCQkJLSBXcml0ZUJhY2s6IGRhdGEgaXMgd3JpdHRlbiBvbmx5IHRvIHRoZSBjYWNoZSBsaW5l IGFuZAogCQkJCSAgICAgdGhlIG1vZGlmaWVkIGNhY2hlIGxpbmUgaXMgd3JpdHRlbiB0byBtYWlu CiAJCQkJICAgICBtZW1vcnkgb25seSB3aGVuIGl0IGlzIHJlcGxhY2VkCisKK1doYXQ6CQkvc3lz L2RldmljZXMvc3lzdGVtL2NwdS9jcHVYL2NwdWZyZXEvdGhyb3R0bGVfc3RhdHMKKwkJL3N5cy9k ZXZpY2VzL3N5c3RlbS9jcHUvY3B1WC9jcHVmcmVxL3Rocm90dGxlX3N0YXRzL3R1cmJvX3N0YXQK KwkJL3N5cy9kZXZpY2VzL3N5c3RlbS9jcHUvY3B1WC9jcHVmcmVxL3Rocm90dGxlX3N0YXRzL3N1 Yl90dXJib19zdGF0CisJCS9zeXMvZGV2aWNlcy9zeXN0ZW0vY3B1L2NwdVgvY3B1ZnJlcS90aHJv dHRsZV9zdGF0cy91bnRocm90dGxlCisJCS9zeXMvZGV2aWNlcy9zeXN0ZW0vY3B1L2NwdVgvY3B1 ZnJlcS90aHJvdHRsZV9zdGF0cy9wb3dlcmNhcAorCQkvc3lzL2RldmljZXMvc3lzdGVtL2NwdS9j cHVYL2NwdWZyZXEvdGhyb3R0bGVfc3RhdHMvb3ZlcnRlbXAKKwkJL3N5cy9kZXZpY2VzL3N5c3Rl bS9jcHUvY3B1WC9jcHVmcmVxL3Rocm90dGxlX3N0YXRzL3N1cHBseV9mYXVsdAorCQkvc3lzL2Rl dmljZXMvc3lzdGVtL2NwdS9jcHVYL2NwdWZyZXEvdGhyb3R0bGVfc3RhdHMvb3ZlcmN1cnJlbnQK KwkJL3N5cy9kZXZpY2VzL3N5c3RlbS9jcHUvY3B1WC9jcHVmcmVxL3Rocm90dGxlX3N0YXRzL29j Y19yZXNldAorRGF0ZToJCU1hcmNoIDIwMTYKK0NvbnRhY3Q6CUxpbnV4IGtlcm5lbCBtYWlsaW5n IGxpc3QgPGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmc+CisJCUxpbnV4IGZvciBQb3dlclBD IG1haWxpbmcgbGlzdCA8bGludXhwcGMtZGV2QG96bGFicy5vcmc+CitEZXNjcmlwdGlvbjoJUE9X RVJOViBDUFVGcmVxIGRyaXZlcidzIGZyZXF1ZW5jeSB0aHJvdHRsZSBzdGF0cyBkaXJlY3Rvcnkg YW5kCisJCWF0dHJpYnV0ZXMKKworCQknY3B1WC9jcHVmcmVxL3Rocm90dGxlX3N0YXRzJyBkaXJl Y3RvcnkgY29udGFpbnMgdGhlIENQVSBmcmVxdWVuY3kKKwkJdGhyb3R0bGUgc3RhdCBhdHRyaWJ1 dGVzIGZvciB0aGUgY2hpcC4gVGhlIHRocm90dGxlIHN0YXRzIG9mIGEgY3B1CisJCWlzIGNvbW1v biBhY3Jvc3MgYWxsIHRoZSBjcHVzIGJlbG9uZ2luZyB0byBhIGNoaXAuIEJlbG93IGFyZSB0aGUK KwkJdGhyb3R0bGUgYXR0cmlidXRlcyBleHBvcnRlZCBpbiB0aGUgJ3Rocm90dGxlX3N0YXRzJyBk aXJlY3Rvcnk6CisKKwkJLSB0dXJib19zdGF0IDogVGhpcyBmaWxlIGdpdmVzIHRoZSB0b3RhbCBu dW1iZXIgb2YgdGltZXMgdGhlIG1heAorCQlmcmVxdWVuY3kgaXMgdGhyb3R0bGVkIHRvIGxvd2Vy IGZyZXF1ZW5jeSBpbiB0dXJibyAoYXQgYW5kIGFib3ZlCisJCW5vbWluYWwgZnJlcXVlbmN5KSBy YW5nZSBvZiBmcmVxdWVuY2llcy4KKworCQktIHN1Yl90dXJib19zdGF0IDogVGhpcyBmaWxlIGdp dmVzIHRoZSB0b3RhbCBudW1iZXIgb2YgdGltZXMgdGhlCisJCW1heCBmcmVxdWVuY3kgaXMgdGhy b3R0bGVkIHRvIGxvd2VyIGZyZXF1ZW5jeSBpbiBzdWItdHVyYm8oYmVsb3cKKwkJbm9taW5hbCBm cmVxdWVuY3kpIHJhbmdlIG9mIGZyZXF1ZW5jaWVzLgorCisJCS0gdW50aHJvdHRsZSA6IFRoaXMg ZmlsZSBnaXZlcyB0aGUgdG90YWwgbnVtYmVyIG9mIHRpbWVzIHRoZSBtYXgKKwkJZnJlcXVlbmN5 IGlzIHVudGhyb3R0bGVkIGFmdGVyIGJlaW5nIHRocm90dGxlZC4KKworCQktIHBvd2VyY2FwIDog VGhpcyBmaWxlIGdpdmVzIHRoZSB0b3RhbCBudW1iZXIgb2YgdGltZXMgdGhlIG1heAorCQlmcmVx dWVuY3kgaXMgdGhyb3R0bGVkIGR1ZSB0byAnUG93ZXIgQ2FwcGluZycuCisKKwkJLSBvdmVydGVt cCA6IFRoaXMgZmlsZSBnaXZlcyB0aGUgdG90YWwgbnVtYmVyIG9mIHRpbWVzIHRoZSBtYXgKKwkJ ZnJlcXVlbmN5IGlzIHRocm90dGxlZCBkdWUgdG8gJ0NQVSBPdmVyIFRlbXBlcmF0dXJlJy4KKwor CQktIHN1cHBseV9mYXVsdCA6IFRoaXMgZmlsZSBnaXZlcyB0aGUgdG90YWwgbnVtYmVyIG9mIHRp bWVzIHRoZQorCQltYXggZnJlcXVlbmN5IGlzIHRocm90dGxlZCBkdWUgdG8gJ1Bvd2VyIFN1cHBs eSBGYWlsdXJlJy4KKworCQktIG92ZXJjdXJyZW50IDogVGhpcyBmaWxlIGdpdmVzIHRoZSB0b3Rh bCBudW1iZXIgb2YgdGltZXMgdGhlCisJCW1heCBmcmVxdWVuY3kgaXMgdGhyb3R0bGVkIGR1ZSB0 byAnT3ZlcmN1cnJlbnQnLgorCisJCS0gb2NjX3Jlc2V0IDogVGhpcyBmaWxlIGdpdmVzIHRoZSB0 b3RhbCBudW1iZXIgb2YgdGltZXMgdGhlIG1heAorCQlmcmVxdWVuY3kgaXMgdGhyb3R0bGVkIGR1 ZSB0byAnT0NDIFJlc2V0Jy4KKworCQlUaGUgc3lzZnMgYXR0cmlidXRlcyByZXByZXNlbnRpbmcg ZGlmZmVyZW50IHRocm90dGxlIHJlYXNvbnMgbGlrZQorCQlwb3dlcmNhcCwgb3ZlcnRlbXAsIHN1 cHBseV9mYXVsdCwgb3ZlcmN1cnJlbnQgYW5kIG9jY19yZXNldCBtYXAgdG8KKwkJdGhlIHJlYXNv bnMgcHJvdmlkZWQgYnkgT0NDIGZpcm13YXJlIGZvciB0aHJvdHRsaW5nIHRoZSBmcmVxdWVuY3ku CisKK1doYXQ6CQkvc3lzL2RldmljZXMvc3lzdGVtL2NwdS9jcHVmcmVxL3BvbGljeVgvdGhyb3R0 bGVfc3RhdHMKKwkJL3N5cy9kZXZpY2VzL3N5c3RlbS9jcHUvY3B1ZnJlcS9wb2xpY3lYL3Rocm90 dGxlX3N0YXRzL3R1cmJvX3N0YXQKKwkJL3N5cy9kZXZpY2VzL3N5c3RlbS9jcHUvY3B1ZnJlcS9w b2xpY3lYL3Rocm90dGxlX3N0YXRzL3N1Yl90dXJib19zdGF0CisJCS9zeXMvZGV2aWNlcy9zeXN0 ZW0vY3B1L2NwdWZyZXEvcG9saWN5WC90aHJvdHRsZV9zdGF0cy91bnRocm90dGxlCisJCS9zeXMv ZGV2aWNlcy9zeXN0ZW0vY3B1L2NwdWZyZXEvcG9saWN5WC90aHJvdHRsZV9zdGF0cy9wb3dlcmNh cAorCQkvc3lzL2RldmljZXMvc3lzdGVtL2NwdS9jcHVmcmVxL3BvbGljeVgvdGhyb3R0bGVfc3Rh dHMvb3ZlcnRlbXAKKwkJL3N5cy9kZXZpY2VzL3N5c3RlbS9jcHUvY3B1ZnJlcS9wb2xpY3lYL3Ro cm90dGxlX3N0YXRzL3N1cHBseV9mYXVsdAorCQkvc3lzL2RldmljZXMvc3lzdGVtL2NwdS9jcHVm cmVxL3BvbGljeVgvdGhyb3R0bGVfc3RhdHMvb3ZlcmN1cnJlbnQKKwkJL3N5cy9kZXZpY2VzL3N5 c3RlbS9jcHUvY3B1ZnJlcS9wb2xpY3lYL3Rocm90dGxlX3N0YXRzL29jY19yZXNldAorRGF0ZToJ CU1hcmNoIDIwMTYKK0NvbnRhY3Q6CUxpbnV4IGtlcm5lbCBtYWlsaW5nIGxpc3QgPGxpbnV4LWtl cm5lbEB2Z2VyLmtlcm5lbC5vcmc+CisJCUxpbnV4IGZvciBQb3dlclBDIG1haWxpbmcgbGlzdCA8 bGludXhwcGMtZGV2QG96bGFicy5vcmc+CitEZXNjcmlwdGlvbjoJUE9XRVJOViBDUFVGcmVxIGRy aXZlcidzIGZyZXF1ZW5jeSB0aHJvdHRsZSBzdGF0cyBkaXJlY3RvcnkgYW5kCisJCWF0dHJpYnV0 ZXMKKworCQkncG9saWN5WC90aHJvdHRsZV9zdGF0cycgZGlyZWN0b3J5IGFuZCBhbGwgdGhlIGF0 dHJpYnV0ZXMgYXJlIHNhbWUgYXMKKwkJdGhlIC9zeXMvZGV2aWNlcy9zeXN0ZW0vY3B1L2NwdVgv Y3B1ZnJlcS90aHJvdHRsZV9zdGF0cyBkaXJlY3RvcnkgYW5kCisJCWF0dHJpYnV0ZXMgd2hpY2gg Z2l2ZSB0aGUgZnJlcXVlbmN5IHRocm90dGxlIGluZm9ybWF0aW9uIG9mIHRoZSBjaGlwLgpkaWZm IC0tZ2l0IGEvZHJpdmVycy9jcHVmcmVxL3Bvd2VybnYtY3B1ZnJlcS5jIGIvZHJpdmVycy9jcHVm cmVxL3Bvd2VybnYtY3B1ZnJlcS5jCmluZGV4IGEwMGJjYzIuLmUxN2Q2NTQgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvY3B1ZnJlcS9wb3dlcm52LWNwdWZyZXEuYworKysgYi9kcml2ZXJzL2NwdWZyZXEv cG93ZXJudi1jcHVmcmVxLmMKQEAgLTU0LDYgKzU0LDE2IEBAIHN0YXRpYyBjb25zdCBjaGFyICog Y29uc3QgdGhyb3R0bGVfcmVhc29uW10gPSB7CiAJIk9DQyBSZXNldCIKIH07CiAKK2VudW0gdGhy b3R0bGVfcmVhc29uX3R5cGUgeworCU5PX1RIUk9UVExFID0gMCwKKwlQT1dFUkNBUCwKKwlDUFVf T1ZFUlRFTVAsCisJUE9XRVJfU1VQUExZX0ZBSUxVUkUsCisJT1ZFUkNVUlJFTlQsCisJT0NDX1JF U0VUX1RIUk9UVExFLAorCU9DQ19NQVhfUkVBU09OCit9OworCiBzdGF0aWMgc3RydWN0IGNoaXAg ewogCXVuc2lnbmVkIGludCBpZDsKIAlib29sIHRocm90dGxlZDsKQEAgLTYxLDYgKzcxLDkgQEAg c3RhdGljIHN0cnVjdCBjaGlwIHsKIAl1OCB0aHJvdHRsZV9yZWFzb247CiAJY3B1bWFza190IG1h c2s7CiAJc3RydWN0IHdvcmtfc3RydWN0IHRocm90dGxlOworCWludCB0aHJvdHRsZV90dXJibzsK KwlpbnQgdGhyb3R0bGVfc3ViX3R1cmJvOworCWludCByZWFzb25bT0NDX01BWF9SRUFTT05dOwog fSAqY2hpcHM7CiAKIHN0YXRpYyBpbnQgbnJfY2hpcHM7CkBAIC0xOTYsNiArMjA5LDQyIEBAIHN0 YXRpYyBzdHJ1Y3QgZnJlcV9hdHRyICpwb3dlcm52X2NwdV9mcmVxX2F0dHJbXSA9IHsKIAlOVUxM LAogfTsKIAorI2RlZmluZSB0aHJvdHRsZV9hdHRyKG5hbWUsIG1lbWJlcikJCQkJCVwKK3N0YXRp YyBzc2l6ZV90IG5hbWUjI19zaG93KHN0cnVjdCBjcHVmcmVxX3BvbGljeSAqcG9saWN5LCBjaGFy ICpidWYpCVwKK3sJCQkJCQkJCQlcCisJc3RydWN0IGNoaXAgKmNoaXAgPSBwZXJfY3B1KGNoaXBf aW5mbywgcG9saWN5LT5jcHUpOwkJXAorCQkJCQkJCQkJXAorCXJldHVybiBzcHJpbnRmKGJ1Ziwg IiV1XG4iLCBjaGlwLT5tZW1iZXIpOwkJCVwKK30JCQkJCQkJCQlcCisJCQkJCQkJCQlcCitzdGF0 aWMgc3RydWN0IGZyZXFfYXR0ciB0aHJvdHRsZV9hdHRyXyMjbmFtZSA9IF9fQVRUUl9STyhuYW1l KQkJXAorCit0aHJvdHRsZV9hdHRyKHVudGhyb3R0bGUsIHJlYXNvbltOT19USFJPVFRMRV0pOwor dGhyb3R0bGVfYXR0cihwb3dlcmNhcCwgcmVhc29uW1BPV0VSQ0FQXSk7Cit0aHJvdHRsZV9hdHRy KG92ZXJ0ZW1wLCByZWFzb25bQ1BVX09WRVJURU1QXSk7Cit0aHJvdHRsZV9hdHRyKHN1cHBseV9m YXVsdCwgcmVhc29uW1BPV0VSX1NVUFBMWV9GQUlMVVJFXSk7Cit0aHJvdHRsZV9hdHRyKG92ZXJj dXJyZW50LCByZWFzb25bT1ZFUkNVUlJFTlRdKTsKK3Rocm90dGxlX2F0dHIob2NjX3Jlc2V0LCBy ZWFzb25bT0NDX1JFU0VUX1RIUk9UVExFXSk7Cit0aHJvdHRsZV9hdHRyKHR1cmJvX3N0YXQsIHRo cm90dGxlX3R1cmJvKTsKK3Rocm90dGxlX2F0dHIoc3ViX3R1cmJvX3N0YXQsIHRocm90dGxlX3N1 Yl90dXJibyk7CisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICp0aHJvdHRsZV9hdHRyc1tdID0g eworCSZ0aHJvdHRsZV9hdHRyX3VudGhyb3R0bGUuYXR0ciwKKwkmdGhyb3R0bGVfYXR0cl9wb3dl cmNhcC5hdHRyLAorCSZ0aHJvdHRsZV9hdHRyX292ZXJ0ZW1wLmF0dHIsCisJJnRocm90dGxlX2F0 dHJfc3VwcGx5X2ZhdWx0LmF0dHIsCisJJnRocm90dGxlX2F0dHJfb3ZlcmN1cnJlbnQuYXR0ciwK KwkmdGhyb3R0bGVfYXR0cl9vY2NfcmVzZXQuYXR0ciwKKwkmdGhyb3R0bGVfYXR0cl90dXJib19z dGF0LmF0dHIsCisJJnRocm90dGxlX2F0dHJfc3ViX3R1cmJvX3N0YXQuYXR0ciwKKwlOVUxMLAor fTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgdGhyb3R0bGVfYXR0cl9n cnAgPSB7CisJLm5hbWUJPSAidGhyb3R0bGVfc3RhdHMiLAorCS5hdHRycwk9IHRocm90dGxlX2F0 dHJzLAorfTsKKwogLyogSGVscGVyIHJvdXRpbmVzICovCiAKIC8qIEFjY2VzcyBoZWxwZXJzIHRv IHBvd2VyIG1ndCBTUFIgKi8KQEAgLTMzOCwxMCArMzg3LDE0IEBAIHN0YXRpYyB2b2lkIHBvd2Vy bnZfY3B1ZnJlcV90aHJvdHRsZV9jaGVjayh2b2lkICpkYXRhKQogCQlpZiAoY2hpcC0+dGhyb3R0 bGVkKQogCQkJZ290byBuZXh0OwogCQljaGlwLT50aHJvdHRsZWQgPSB0cnVlOwotCQlpZiAocG1z cl9wbWF4IDwgcG93ZXJudl9wc3RhdGVfaW5mby5ub21pbmFsKQorCQlpZiAocG1zcl9wbWF4IDwg cG93ZXJudl9wc3RhdGVfaW5mby5ub21pbmFsKSB7CiAJCQlwcl93YXJuX29uY2UoIkNQVSAlZCBv biBDaGlwICV1IGhhcyBQbWF4IHJlZHVjZWQgYmVsb3cgbm9taW5hbCBmcmVxdWVuY3kgKCVkIDwg JWQpXG4iLAogCQkJCSAgICAgY3B1LCBjaGlwLT5pZCwgcG1zcl9wbWF4LAogCQkJCSAgICAgcG93 ZXJudl9wc3RhdGVfaW5mby5ub21pbmFsKTsKKwkJCWNoaXAtPnRocm90dGxlX3N1Yl90dXJibysr OworCQl9IGVsc2UgeworCQkJY2hpcC0+dGhyb3R0bGVfdHVyYm8rKzsKKwkJfQogCQl0cmFjZV9w b3dlcm52X3Rocm90dGxlKGNoaXAtPmlkLAogCQkJCSAgICAgIHRocm90dGxlX3JlYXNvbltjaGlw LT50aHJvdHRsZV9yZWFzb25dLAogCQkJCSAgICAgIHBtc3JfcG1heCk7CkBAIC00MDEsMTMgKzQ1 NCwyNiBAQCBzdGF0aWMgaW50IHBvd2VybnZfY3B1ZnJlcV90YXJnZXRfaW5kZXgoc3RydWN0IGNw dWZyZXFfcG9saWN5ICpwb2xpY3ksCiAKIHN0YXRpYyBpbnQgcG93ZXJudl9jcHVmcmVxX2NwdV9p bml0KHN0cnVjdCBjcHVmcmVxX3BvbGljeSAqcG9saWN5KQogewotCWludCBiYXNlLCBpOworCWlu dCBiYXNlLCBpLCByZXQ7CiAKIAliYXNlID0gY3B1X2ZpcnN0X3RocmVhZF9zaWJsaW5nKHBvbGlj eS0+Y3B1KTsKIAogCWZvciAoaSA9IDA7IGkgPCB0aHJlYWRzX3Blcl9jb3JlOyBpKyspCiAJCWNw dW1hc2tfc2V0X2NwdShiYXNlICsgaSwgcG9saWN5LT5jcHVzKTsKIAorCWlmICghcG9saWN5LT5k cml2ZXJfZGF0YSkgeworCQlyZXQgPSBzeXNmc19jcmVhdGVfZ3JvdXAoJnBvbGljeS0+a29iaiwg JnRocm90dGxlX2F0dHJfZ3JwKTsKKwkJaWYgKHJldCkgeworCQkJcHJfaW5mbygiRmFpbGVkIHRv IGNyZWF0ZSB0aHJvdHRsZSBzdGF0cyBkaXJlY3RvcnkgZm9yIGNwdSAlZFxuIiwKKwkJCQlwb2xp Y3ktPmNwdSk7CisJCQlyZXR1cm4gcmV0OworCQl9CisJCS8qCisJCSAqIHBvbGljeS0+ZHJpdmVy X2RhdGEgaXMgdXNlZCBhcyBhIGZsYWcgZm9yIG9uZS10aW1lCisJCSAqIGNyZWF0aW9uIG9mIHRo cm90dGxlIHN5c2ZzIGZpbGVzLgorCQkgKi8KKwkJcG9saWN5LT5kcml2ZXJfZGF0YSA9ICh2b2lk ICopcG9saWN5OworCX0KIAlyZXR1cm4gY3B1ZnJlcV90YWJsZV92YWxpZGF0ZV9hbmRfc2hvdyhw b2xpY3ksIHBvd2VybnZfZnJlcXMpOwogfQogCkBAIC01MTQsOCArNTgwLDEwIEBAIHN0YXRpYyBp bnQgcG93ZXJudl9jcHVmcmVxX29jY19tc2coc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuYiwKIAkJ CQlicmVhazsKIAogCQlpZiAob21zZy50aHJvdHRsZV9zdGF0dXMgPj0gMCAmJgotCQkgICAgb21z Zy50aHJvdHRsZV9zdGF0dXMgPD0gT0NDX01BWF9USFJPVFRMRV9TVEFUVVMpCisJCSAgICBvbXNn LnRocm90dGxlX3N0YXR1cyA8PSBPQ0NfTUFYX1RIUk9UVExFX1NUQVRVUykgewogCQkJY2hpcHNb aV0udGhyb3R0bGVfcmVhc29uID0gb21zZy50aHJvdHRsZV9zdGF0dXM7CisJCQljaGlwc1tpXS5y ZWFzb25bb21zZy50aHJvdHRsZV9zdGF0dXNdKys7CisJCX0KIAogCQlpZiAoIW9tc2cudGhyb3R0 bGVfc3RhdHVzKQogCQkJY2hpcHNbaV0ucmVzdG9yZSA9IHRydWU7Ci0tIAoxLjkuMwoKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXhwcGMtZGV2IG1h aWxpbmcgbGlzdApMaW51eHBwYy1kZXZAbGlzdHMub3psYWJzLm9yZwpodHRwczovL2xpc3RzLm96 bGFicy5vcmcvbGlzdGluZm8vbGludXhwcGMtZGV2