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 2A252C433EF for ; Fri, 25 Feb 2022 07:36:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237746AbiBYHh2 (ORCPT ); Fri, 25 Feb 2022 02:37:28 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58318 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231272AbiBYHh1 (ORCPT ); Fri, 25 Feb 2022 02:37:27 -0500 Received: from alexa-out-sd-02.qualcomm.com (alexa-out-sd-02.qualcomm.com [199.106.114.39]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A0411AEF0A; Thu, 24 Feb 2022 23:36:55 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=quicinc.com; i=@quicinc.com; q=dns/txt; s=qcdkim; t=1645774615; x=1677310615; h=message-id:date:mime-version:subject:to:cc:references: from:in-reply-to:content-transfer-encoding; bh=KCskv1w22hj0gLP7vINQmo/MIRAACxuvRN4z4n3BQEY=; b=SOrXuq6fK1ktnJjhigeeiOdlWTjm+2nPPJvt+oX9N+Nfn5t5PZk/qLtT IsjAq3Qs6crjjtYkmHdY0ksxUlVDzeZG3t/415FK0V6FkB0R/5xpIAL2Y IIhOj0dvvfReUh+6YKC9CFLHPdWSpg0yHc5P2iy+TiIPYhJNu1z0jzbth o=; Received: from unknown (HELO ironmsg-SD-alpha.qualcomm.com) ([10.53.140.30]) by alexa-out-sd-02.qualcomm.com with ESMTP; 24 Feb 2022 23:36:55 -0800 X-QCInternal: smtphost Received: from nasanex01c.na.qualcomm.com ([10.47.97.222]) by ironmsg-SD-alpha.qualcomm.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 24 Feb 2022 23:36:55 -0800 Received: from nalasex01a.na.qualcomm.com (10.47.209.196) by nasanex01c.na.qualcomm.com (10.47.97.222) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.15; Thu, 24 Feb 2022 23:36:54 -0800 Received: from [10.50.41.45] (10.80.80.8) by nalasex01a.na.qualcomm.com (10.47.209.196) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.15; Thu, 24 Feb 2022 23:36:51 -0800 Message-ID: <04907d26-db69-7d2d-ec05-59e7164b429e@quicinc.com> Date: Fri, 25 Feb 2022 13:06:48 +0530 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.1.2 Subject: Re: [PATCHv5] tty: hvc: dcc: Bind driver to CPU core0 for reads and writes Content-Language: en-US To: Greg Kroah-Hartman CC: Jiri Slaby , , , , "Shanker Donthineni" , Adam Wallis , Timur Tabi , Elliot Berman References: <20220214031322.7498-1-quic_saipraka@quicinc.com> From: Sai Prakash Ranjan In-Reply-To: Content-Type: text/plain; charset="UTF-8"; format=flowed Content-Transfer-Encoding: 8bit X-Originating-IP: [10.80.80.8] X-ClientProxiedBy: nasanex01a.na.qualcomm.com (10.52.223.231) To nalasex01a.na.qualcomm.com (10.47.209.196) Precedence: bulk List-ID: X-Mailing-List: linux-arm-msm@vger.kernel.org Hi, On 2/22/2022 12:05 AM, Greg Kroah-Hartman wrote: > On Mon, Feb 14, 2022 at 08:43:22AM +0530, Sai Prakash Ranjan wrote: >> From: Shanker Donthineni >> >> Some debuggers, such as Trace32 from Lauterbach GmbH, do not handle >> reads/writes from/to DCC on secondary cores. Each core has its >> own DCC device registers, so when a core reads or writes from/to DCC, >> it only accesses its own DCC device. Since kernel code can run on >> any core, every time the kernel wants to write to the console, it >> might write to a different DCC. >> >> In SMP mode, Trace32 creates multiple windows, and each window shows >> the DCC output only from that core's DCC. The result is that console >> output is either lost or scattered across windows. >> >> Selecting this option will enable code that serializes all console >> input and output to core 0. The DCC driver will create input and >> output FIFOs that all cores will use. Reads and writes from/to DCC >> are handled by a workqueue that runs only core 0. >> >> Signed-off-by: Shanker Donthineni >> Acked-by: Adam Wallis >> Signed-off-by: Timur Tabi >> Signed-off-by: Elliot Berman >> Signed-off-by: Sai Prakash Ranjan >> --- >> >> Changes in v5: >> * Use get_cpu() and put_cpu() for CPU id check in preemptible context. >> * Revert back to build time Kconfig. > Why did you do this? Why would you provide the option to not do this? > > Either it works properly or not at all. Huh? I don't understand what you mean here. This config is for the feature and not a hack around for non-working case. It is just like any other configs which are available throughout kernel for new features, what different thing are you seeing exactly? I have explained why device attribute like device tree property is not suitable in [1], if you insist then we can add Rob Herring and apparently as per your comment in previous version, we are not in 1990s to use module param :), so what other options are available to enable this feature? [1] https://lore.kernel.org/lkml/2866a87b-d1d2-7e9e-57d6-fdcfcd62e27e@quicinc.com/ > >> * Remove unnecessary hotplug locks, they result in sleeping in atomic context bugs. > Are you sure you can remove the locks? Please see below. > >> * Add a comment for the spinlock. >> >> Changes in v4: >> * Use module parameter for runtime choice of enabling this feature. >> * Use hotplug locks to avoid race between cpu online check and work schedule. >> * Remove ifdefs and move to common ops. >> * Remove unnecessary check for this configuration. >> * Use macros for buf size instead of magic numbers. >> * v3 - https://lore.kernel.org/lkml/20211213141013.21464-1-quic_saipraka@quicinc.com/ >> >> Changes in v3: >> * Handle case where core0 is not online. >> >> Changes in v2: >> * Checkpatch warning fixes. >> * Use of IS_ENABLED macros instead of ifdefs. >> >> --- >> drivers/tty/hvc/Kconfig | 20 +++++ >> drivers/tty/hvc/hvc_dcc.c | 171 +++++++++++++++++++++++++++++++++++++- >> 2 files changed, 188 insertions(+), 3 deletions(-) >> >> diff --git a/drivers/tty/hvc/Kconfig b/drivers/tty/hvc/Kconfig >> index 8d60e0ff67b4..c0754a2e3fe4 100644 >> --- a/drivers/tty/hvc/Kconfig >> +++ b/drivers/tty/hvc/Kconfig >> @@ -87,6 +87,26 @@ config HVC_DCC >> driver. This console is used through a JTAG only on ARM. If you don't have >> a JTAG then you probably don't want this option. >> >> +config HVC_DCC_SERIALIZE_SMP >> + bool "Use DCC only on core 0" >> + depends on SMP && HVC_DCC >> + help >> + Some debuggers, such as Trace32 from Lauterbach GmbH, do not handle >> + reads/writes from/to DCC on more than one core. Each core has its >> + own DCC device registers, so when a core reads or writes from/to DCC, >> + it only accesses its own DCC device. Since kernel code can run on >> + any core, every time the kernel wants to write to the console, it >> + might write to a different DCC. >> + >> + In SMP mode, Trace32 creates multiple windows, and each window shows >> + the DCC output only from that core's DCC. The result is that console >> + output is either lost or scattered across windows. >> + >> + Selecting this option will enable code that serializes all console >> + input and output to core 0. The DCC driver will create input and >> + output FIFOs that all cores will use. Reads and writes from/to DCC >> + are handled by a workqueue that runs only core 0. >> + >> config HVC_RISCV_SBI >> bool "RISC-V SBI console support" >> depends on RISCV_SBI_V01 >> diff --git a/drivers/tty/hvc/hvc_dcc.c b/drivers/tty/hvc/hvc_dcc.c >> index 8e0edb7d93fd..6144135c24ed 100644 >> --- a/drivers/tty/hvc/hvc_dcc.c >> +++ b/drivers/tty/hvc/hvc_dcc.c >> @@ -2,9 +2,13 @@ >> /* Copyright (c) 2010, 2014 The Linux Foundation. All rights reserved. */ >> >> #include >> +#include >> #include >> +#include >> #include >> #include >> +#include >> +#include >> >> #include >> #include >> @@ -15,6 +19,15 @@ >> #define DCC_STATUS_RX (1 << 30) >> #define DCC_STATUS_TX (1 << 29) >> >> +#define DCC_INBUF_SIZE 128 >> +#define DCC_OUTBUF_SIZE 1024 >> + >> +/* Lock to serialize access to DCC fifo */ >> +static DEFINE_SPINLOCK(dcc_lock); >> + >> +static DEFINE_KFIFO(inbuf, unsigned char, DCC_INBUF_SIZE); >> +static DEFINE_KFIFO(outbuf, unsigned char, DCC_OUTBUF_SIZE); >> + >> static void dcc_uart_console_putchar(struct uart_port *port, int ch) >> { >> while (__dcc_getstatus() & DCC_STATUS_TX) >> @@ -67,24 +80,176 @@ static int hvc_dcc_get_chars(uint32_t vt, char *buf, int count) >> return i; >> } >> >> +/* >> + * Check if the DCC is enabled. If CONFIG_HVC_DCC_SERIALIZE_SMP is enabled, >> + * then we assume then this function will be called first on core0. That way, >> + * dcc_core0_available will be true only if it's available on core0. >> + */ >> static bool hvc_dcc_check(void) >> { >> unsigned long time = jiffies + (HZ / 10); >> + static bool dcc_core0_available; >> + >> + /* >> + * If we're not on core 0, but we previously confirmed that DCC is >> + * active, then just return true. >> + */ >> + int cpu = get_cpu(); >> + >> + if (IS_ENABLED(CONFIG_HVC_DCC_SERIALIZE_SMP) && cpu && dcc_core0_available) { >> + put_cpu(); >> + return true; >> + } >> + >> + put_cpu(); >> >> /* Write a test character to check if it is handled */ >> __dcc_putchar('\n'); >> >> while (time_is_after_jiffies(time)) { >> - if (!(__dcc_getstatus() & DCC_STATUS_TX)) >> + if (!(__dcc_getstatus() & DCC_STATUS_TX)) { >> + dcc_core0_available = true; >> return true; >> + } >> } >> >> return false; >> } >> >> +/* >> + * Workqueue function that writes the output FIFO to the DCC on core 0. >> + */ >> +static void dcc_put_work(struct work_struct *work) >> +{ >> + unsigned char ch; >> + unsigned long irqflags; >> + >> + spin_lock_irqsave(&dcc_lock, irqflags); >> + >> + /* While there's data in the output FIFO, write it to the DCC */ >> + while (kfifo_get(&outbuf, &ch)) >> + hvc_dcc_put_chars(0, &ch, 1); >> + >> + /* While we're at it, check for any input characters */ >> + while (!kfifo_is_full(&inbuf)) { >> + if (!hvc_dcc_get_chars(0, &ch, 1)) >> + break; >> + kfifo_put(&inbuf, ch); >> + } >> + >> + spin_unlock_irqrestore(&dcc_lock, irqflags); >> +} >> + >> +static DECLARE_WORK(dcc_pwork, dcc_put_work); >> + >> +/* >> + * Workqueue function that reads characters from DCC and puts them into the >> + * input FIFO. >> + */ >> +static void dcc_get_work(struct work_struct *work) >> +{ >> + unsigned char ch; >> + unsigned long irqflags; >> + >> + /* >> + * Read characters from DCC and put them into the input FIFO, as >> + * long as there is room and we have characters to read. >> + */ >> + spin_lock_irqsave(&dcc_lock, irqflags); >> + >> + while (!kfifo_is_full(&inbuf)) { >> + if (!hvc_dcc_get_chars(0, &ch, 1)) >> + break; >> + kfifo_put(&inbuf, ch); >> + } >> + spin_unlock_irqrestore(&dcc_lock, irqflags); >> +} >> + >> +static DECLARE_WORK(dcc_gwork, dcc_get_work); >> + >> +/* >> + * Write characters directly to the DCC if we're on core 0 and the FIFO >> + * is empty, or write them to the FIFO if we're not. >> + */ >> +static int hvc_dcc0_put_chars(u32 vt, const char *buf, int count) >> +{ >> + int len; >> + unsigned long irqflags; >> + >> + if (!IS_ENABLED(CONFIG_HVC_DCC_SERIALIZE_SMP)) >> + return hvc_dcc_put_chars(vt, buf, count); >> + >> + spin_lock_irqsave(&dcc_lock, irqflags); >> + if (smp_processor_id() || (!kfifo_is_empty(&outbuf))) { >> + len = kfifo_in(&outbuf, buf, count); >> + spin_unlock_irqrestore(&dcc_lock, irqflags); >> + >> + /* >> + * We just push data to the output FIFO, so schedule the >> + * workqueue that will actually write that data to DCC. >> + * No hotplug lock required as we are in atomic context >> + * with interrupts and preemption disabled. >> + */ >> + if (cpu_online(0)) >> + schedule_work_on(0, &dcc_pwork); > Why is put_chars always called from atomic context? Where is that > documented? It is called from vprintk_emit->console_unlock() which I believe runs in atomic context, see below stack trace. [   68.804747] BUG: sleeping function called from invalid context at ./include/linux/percpu-rwsem.h:49 [   68.804752] in_atomic(): 1, irqs_disabled(): 128, non_block: 0, pid: 1, name: swapper/0 [   68.804757] preempt_count: 1, expected: 0 [   68.804794] Preemption disabled at: [   68.804796] [] vprintk_emit+0xc4/0x2e0 [   68.804802] CPU: 1 PID: 1 Comm: swapper/0 Tainted: G W         5.17.0-rc3-next-20220210-00001-g682663ac97d4-dirty #20 [   68.804810] Call trace: [   68.804812]  dump_backtrace.part.6+0xd8/0xe8 [   68.804820]  show_stack+0x14/0x60 [   68.804827]  dump_stack_lvl+0x88/0xb0 [   68.804831]  dump_stack+0x14/0x2c [   68.804836]  __might_resched+0x21c/0x268 [   68.804840]  __might_sleep+0x44/0x78 [   68.804844]  cpus_read_lock+0x20/0x168 [   68.804848]  hvc_dcc0_put_chars+0x6c/0x110 [   68.804852]  hvc_console_print+0x144/0x1d8 [   68.804857]  console_unlock+0x2d8/0x5f8 [   68.804862]  vprintk_emit+0xd0/0x2e0 [   68.804867]  vprintk_default+0x30/0x38 [   68.804871]  vprintk+0xcc/0xe8 [   68.804876]  _printk+0x64/0x84 > And that really will prevent another cpu from going offline after this > call has been checked? > I wasn't able to find any hotplug lock which can be used in atomic context, do you have any idea? >> + >> + return len; >> + } >> + >> + /* >> + * If we're already on core 0, and the FIFO is empty, then just >> + * write the data to DCC. >> + */ >> + len = hvc_dcc_put_chars(vt, buf, count); >> + spin_unlock_irqrestore(&dcc_lock, irqflags); >> + >> + return len; >> +} >> + >> +/* >> + * Read characters directly from the DCC if we're on core 0 and the FIFO >> + * is empty, or read them from the FIFO if we're not. >> + */ >> +static int hvc_dcc0_get_chars(u32 vt, char *buf, int count) >> +{ >> + int len; >> + unsigned long irqflags; >> + >> + if (!IS_ENABLED(CONFIG_HVC_DCC_SERIALIZE_SMP)) >> + return hvc_dcc_get_chars(vt, buf, count); >> + >> + spin_lock_irqsave(&dcc_lock, irqflags); >> + >> + if (smp_processor_id() || (!kfifo_is_empty(&inbuf))) { >> + len = kfifo_out(&inbuf, buf, count); >> + spin_unlock_irqrestore(&dcc_lock, irqflags); >> + >> + /* >> + * If the FIFO was empty, there may be characters in the DCC >> + * that we haven't read yet. Schedule a workqueue to fill >> + * the input FIFO, so that the next time this function is >> + * called, we'll have data. No hotplug lock required as we are >> + * in atomic context with interrupts and preemption disabled. >> + */ >> + if (!len && cpu_online(0)) >> + schedule_work_on(0, &dcc_gwork); > get_chars is in atomic context? Even from the poll_get_char() callback? > > From __hvc_poll(), see below stack trace: [   22.503594] BUG: sleeping function called from invalid context at ./include/linux/percpu-rwsem.h:49 [   22.503634] in_atomic(): 1, irqs_disabled(): 128, non_block: 0, pid: 49, name: khvcd [   22.503659] preempt_count: 1, expected: 0 [   22.503677] RCU nest depth: 0, expected: 0 [   22.503701] 2 locks held by khvcd/49: [   22.835450]  #0: ffffcbfe39f05868 (hvc_structs_mutex){+.+.}-{3:3}, at: khvcd+0x94/0x180 [   22.835513]  #1: ffff44a5026723b0 (&hp->lock){....}-{2:2}, at: __hvc_poll+0x218/0x370 [   23.477496] Preemption disabled at: [   23.477502] [] __hvc_poll+0x218/0x370 [   23.602048] CPU: 1 PID: 49 Comm: khvcd Tainted: G W         5.17.0-rc3-next-20220210-00001-ga7a30b39bb99-dirty #33 [   23.602100] Call trace: [   23.602115]  dump_backtrace.part.6+0xd8/0xe8 [   23.602140]  show_stack+0x14/0x60 [   23.602160]  dump_stack_lvl+0x98/0xd0 [   23.602181]  dump_stack+0x14/0x2c [   23.602200]  __might_resched+0x21c/0x268 [   23.602221]  __might_sleep+0x44/0x78 [   23.602240]  cpus_read_lock+0x20/0x168 [   23.602259]  hvc_dcc0_get_chars+0x70/0x128 [   23.602278]  __hvc_poll+0x104/0x370 [   23.602297]  khvcd+0xb8/0x180 [   23.602316]  kthread+0xec/0x110 [   23.602338]  ret_from_fork+0x10/0x20 Thanks, Sai 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 726F0C433EF for ; Fri, 25 Feb 2022 07:38:50 +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:In-Reply-To:From:References:CC:To:Subject: MIME-Version:Date:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=fwHVqrVi0+eVb1nFULjkCfKWoyhRSqP5PBb8PoMp+tY=; b=IBQOJ6WVlZxO0i CkWBMtoirZJUqxvopVWYh0w4Tne4d/bOL5c/Rwzm2URsDWuGieb6bI8+HWiQPRVFScaqSb6gcXcLg vxv3SNa8kidTEWfz+fpUznTtImSHOxNrPbH8NTI6PVjHaqrjBLrp9Ut8YfOSPTLxTxB6QmD3X+ova KXKnJxCACt3gfdk11VN2ewzCG14n18BmMHR9HJYug6JCi8jOf4S0902rVdB1mpz6dwQLU+jTg8FKQ jDvqud6UI/6WFkg0X7WmNDubep6I/muBWD4ihlzpmKk1Qfl7z4A97V/Lu40CwZploz/XlARrSW+xc yLLBBruSv9GA/W9i2Rxg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nNVAR-003chb-4V; Fri, 25 Feb 2022 07:37:31 +0000 Received: from alexa-out-sd-02.qualcomm.com ([199.106.114.39]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nNV9v-003cVh-EK for linux-arm-kernel@lists.infradead.org; Fri, 25 Feb 2022 07:37:02 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=quicinc.com; i=@quicinc.com; q=dns/txt; s=qcdkim; t=1645774619; x=1677310619; h=message-id:date:mime-version:subject:to:cc:references: from:in-reply-to:content-transfer-encoding; bh=KCskv1w22hj0gLP7vINQmo/MIRAACxuvRN4z4n3BQEY=; b=Ykr+GhgdtfqAF76JsHDkYip/B8V2K126/gmrqUJtCrQBW+LKVa+k+nc1 kQ1pZirCxqJAGGUbhFbDX9l3nKO4g8eJWAkiLuTDhEaisNfg7JrUswoy0 +Q6Iwk9/bmbVLeWxmQfvP8jCQSikZWH5//TAGxNAesuqefRN3nS+cfpyA M=; Received: from unknown (HELO ironmsg-SD-alpha.qualcomm.com) ([10.53.140.30]) by alexa-out-sd-02.qualcomm.com with ESMTP; 24 Feb 2022 23:36:55 -0800 X-QCInternal: smtphost Received: from nasanex01c.na.qualcomm.com ([10.47.97.222]) by ironmsg-SD-alpha.qualcomm.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 24 Feb 2022 23:36:55 -0800 Received: from nalasex01a.na.qualcomm.com (10.47.209.196) by nasanex01c.na.qualcomm.com (10.47.97.222) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.15; Thu, 24 Feb 2022 23:36:54 -0800 Received: from [10.50.41.45] (10.80.80.8) by nalasex01a.na.qualcomm.com (10.47.209.196) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.15; Thu, 24 Feb 2022 23:36:51 -0800 Message-ID: <04907d26-db69-7d2d-ec05-59e7164b429e@quicinc.com> Date: Fri, 25 Feb 2022 13:06:48 +0530 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.1.2 Subject: Re: [PATCHv5] tty: hvc: dcc: Bind driver to CPU core0 for reads and writes Content-Language: en-US To: Greg Kroah-Hartman CC: Jiri Slaby , , , , "Shanker Donthineni" , Adam Wallis , Timur Tabi , Elliot Berman References: <20220214031322.7498-1-quic_saipraka@quicinc.com> From: Sai Prakash Ranjan In-Reply-To: X-Originating-IP: [10.80.80.8] X-ClientProxiedBy: nasanex01a.na.qualcomm.com (10.52.223.231) To nalasex01a.na.qualcomm.com (10.47.209.196) X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220224_233659_612506_0B43DD4A X-CRM114-Status: GOOD ( 42.83 ) 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 SGksCgpPbiAyLzIyLzIwMjIgMTI6MDUgQU0sIEdyZWcgS3JvYWgtSGFydG1hbiB3cm90ZToKPiBP biBNb24sIEZlYiAxNCwgMjAyMiBhdCAwODo0MzoyMkFNICswNTMwLCBTYWkgUHJha2FzaCBSYW5q YW4gd3JvdGU6Cj4+IEZyb206IFNoYW5rZXIgRG9udGhpbmVuaSA8c2hhbmtlcmRAY29kZWF1cm9y YS5vcmc+Cj4+Cj4+IFNvbWUgZGVidWdnZXJzLCBzdWNoIGFzIFRyYWNlMzIgZnJvbSBMYXV0ZXJi YWNoIEdtYkgsIGRvIG5vdCBoYW5kbGUKPj4gcmVhZHMvd3JpdGVzIGZyb20vdG8gRENDIG9uIHNl Y29uZGFyeSBjb3Jlcy4gRWFjaCBjb3JlIGhhcyBpdHMKPj4gb3duIERDQyBkZXZpY2UgcmVnaXN0 ZXJzLCBzbyB3aGVuIGEgY29yZSByZWFkcyBvciB3cml0ZXMgZnJvbS90byBEQ0MsCj4+IGl0IG9u bHkgYWNjZXNzZXMgaXRzIG93biBEQ0MgZGV2aWNlLiBTaW5jZSBrZXJuZWwgY29kZSBjYW4gcnVu IG9uCj4+IGFueSBjb3JlLCBldmVyeSB0aW1lIHRoZSBrZXJuZWwgd2FudHMgdG8gd3JpdGUgdG8g dGhlIGNvbnNvbGUsIGl0Cj4+IG1pZ2h0IHdyaXRlIHRvIGEgZGlmZmVyZW50IERDQy4KPj4KPj4g SW4gU01QIG1vZGUsIFRyYWNlMzIgY3JlYXRlcyBtdWx0aXBsZSB3aW5kb3dzLCBhbmQgZWFjaCB3 aW5kb3cgc2hvd3MKPj4gdGhlIERDQyBvdXRwdXQgb25seSBmcm9tIHRoYXQgY29yZSdzIERDQy4g VGhlIHJlc3VsdCBpcyB0aGF0IGNvbnNvbGUKPj4gb3V0cHV0IGlzIGVpdGhlciBsb3N0IG9yIHNj YXR0ZXJlZCBhY3Jvc3Mgd2luZG93cy4KPj4KPj4gU2VsZWN0aW5nIHRoaXMgb3B0aW9uIHdpbGwg ZW5hYmxlIGNvZGUgdGhhdCBzZXJpYWxpemVzIGFsbCBjb25zb2xlCj4+IGlucHV0IGFuZCBvdXRw dXQgdG8gY29yZSAwLiBUaGUgRENDIGRyaXZlciB3aWxsIGNyZWF0ZSBpbnB1dCBhbmQKPj4gb3V0 cHV0IEZJRk9zIHRoYXQgYWxsIGNvcmVzIHdpbGwgdXNlLiBSZWFkcyBhbmQgd3JpdGVzIGZyb20v dG8gRENDCj4+IGFyZSBoYW5kbGVkIGJ5IGEgd29ya3F1ZXVlIHRoYXQgcnVucyBvbmx5IGNvcmUg MC4KPj4KPj4gU2lnbmVkLW9mZi1ieTogU2hhbmtlciBEb250aGluZW5pIDxzaGFua2VyZEBjb2Rl YXVyb3JhLm9yZz4KPj4gQWNrZWQtYnk6IEFkYW0gV2FsbGlzIDxhd2FsbGlzQGNvZGVhdXJvcmEu b3JnPgo+PiBTaWduZWQtb2ZmLWJ5OiBUaW11ciBUYWJpIDx0aW11ckBjb2RlYXVyb3JhLm9yZz4K Pj4gU2lnbmVkLW9mZi1ieTogRWxsaW90IEJlcm1hbiA8ZWJlcm1hbkBjb2RlYXVyb3JhLm9yZz4K Pj4gU2lnbmVkLW9mZi1ieTogU2FpIFByYWthc2ggUmFuamFuIDxxdWljX3NhaXByYWthQHF1aWNp bmMuY29tPgo+PiAtLS0KPj4KPj4gQ2hhbmdlcyBpbiB2NToKPj4gICAqIFVzZSBnZXRfY3B1KCkg YW5kIHB1dF9jcHUoKSBmb3IgQ1BVIGlkIGNoZWNrIGluIHByZWVtcHRpYmxlIGNvbnRleHQuCj4+ ICAgKiBSZXZlcnQgYmFjayB0byBidWlsZCB0aW1lIEtjb25maWcuCj4gV2h5IGRpZCB5b3UgZG8g dGhpcz8gIFdoeSB3b3VsZCB5b3UgcHJvdmlkZSB0aGUgb3B0aW9uIHRvIG5vdCBkbyB0aGlzPwo+ Cj4gRWl0aGVyIGl0IHdvcmtzIHByb3Blcmx5IG9yIG5vdCBhdCBhbGwuCgpIdWg/IEkgZG9uJ3Qg dW5kZXJzdGFuZCB3aGF0IHlvdSBtZWFuIGhlcmUuIFRoaXMgY29uZmlnIGlzIGZvciB0aGUgZmVh dHVyZSBhbmQgbm90IGEKaGFjayBhcm91bmQgZm9yIG5vbi13b3JraW5nIGNhc2UuIEl0IGlzIGp1 c3QgbGlrZSBhbnkgb3RoZXIgY29uZmlncyB3aGljaCBhcmUgYXZhaWxhYmxlCnRocm91Z2hvdXQg a2VybmVsIGZvciBuZXcgZmVhdHVyZXMsIHdoYXQgZGlmZmVyZW50IHRoaW5nIGFyZSB5b3Ugc2Vl aW5nIGV4YWN0bHk/CgpJIGhhdmUgZXhwbGFpbmVkIHdoeSBkZXZpY2UgYXR0cmlidXRlIGxpa2Ug ZGV2aWNlIHRyZWUgcHJvcGVydHkgaXMgbm90IHN1aXRhYmxlIGluIFsxXSwgaWYgeW91Cmluc2lz dCB0aGVuIHdlIGNhbiBhZGQgUm9iIEhlcnJpbmcgYW5kIGFwcGFyZW50bHkgYXMgcGVyIHlvdXIg Y29tbWVudCBpbiBwcmV2aW91cwp2ZXJzaW9uLCB3ZSBhcmUgbm90IGluIDE5OTBzIHRvIHVzZSBt b2R1bGUgcGFyYW0gOiksIHNvIHdoYXQgb3RoZXIgb3B0aW9ucyBhcmUgYXZhaWxhYmxlIHRvCmVu YWJsZSB0aGlzIGZlYXR1cmU/CgpbMV0gaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvbGttbC8yODY2 YTg3Yi1kMWQyLTdlOWUtNTdkNi1mZGNmY2Q2MmUyN2VAcXVpY2luYy5jb20vCgo+Cj4+ICAgKiBS ZW1vdmUgdW5uZWNlc3NhcnkgaG90cGx1ZyBsb2NrcywgdGhleSByZXN1bHQgaW4gc2xlZXBpbmcg aW4gYXRvbWljIGNvbnRleHQgYnVncy4KPiBBcmUgeW91IHN1cmUgeW91IGNhbiByZW1vdmUgdGhl IGxvY2tzPwoKUGxlYXNlIHNlZSBiZWxvdy4KCj4KPj4gICAqIEFkZCBhIGNvbW1lbnQgZm9yIHRo ZSBzcGlubG9jay4KPj4KPj4gQ2hhbmdlcyBpbiB2NDoKPj4gICAqIFVzZSBtb2R1bGUgcGFyYW1l dGVyIGZvciBydW50aW1lIGNob2ljZSBvZiBlbmFibGluZyB0aGlzIGZlYXR1cmUuCj4+ICAgKiBV c2UgaG90cGx1ZyBsb2NrcyB0byBhdm9pZCByYWNlIGJldHdlZW4gY3B1IG9ubGluZSBjaGVjayBh bmQgd29yayBzY2hlZHVsZS4KPj4gICAqIFJlbW92ZSBpZmRlZnMgYW5kIG1vdmUgdG8gY29tbW9u IG9wcy4KPj4gICAqIFJlbW92ZSB1bm5lY2Vzc2FyeSBjaGVjayBmb3IgdGhpcyBjb25maWd1cmF0 aW9uLgo+PiAgICogVXNlIG1hY3JvcyBmb3IgYnVmIHNpemUgaW5zdGVhZCBvZiBtYWdpYyBudW1i ZXJzLgo+PiAgICogdjMgLSBodHRwczovL2xvcmUua2VybmVsLm9yZy9sa21sLzIwMjExMjEzMTQx MDEzLjIxNDY0LTEtcXVpY19zYWlwcmFrYUBxdWljaW5jLmNvbS8KPj4KPj4gQ2hhbmdlcyBpbiB2 MzoKPj4gICAqIEhhbmRsZSBjYXNlIHdoZXJlIGNvcmUwIGlzIG5vdCBvbmxpbmUuCj4+Cj4+IENo YW5nZXMgaW4gdjI6Cj4+ICAgKiBDaGVja3BhdGNoIHdhcm5pbmcgZml4ZXMuCj4+ICAgKiBVc2Ug b2YgSVNfRU5BQkxFRCBtYWNyb3MgaW5zdGVhZCBvZiBpZmRlZnMuCj4+Cj4+IC0tLQo+PiAgIGRy aXZlcnMvdHR5L2h2Yy9LY29uZmlnICAgfCAgMjAgKysrKysKPj4gICBkcml2ZXJzL3R0eS9odmMv aHZjX2RjYy5jIHwgMTcxICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCj4+ ICAgMiBmaWxlcyBjaGFuZ2VkLCAxODggaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKPj4K Pj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L2h2Yy9LY29uZmlnIGIvZHJpdmVycy90dHkvaHZj L0tjb25maWcKPj4gaW5kZXggOGQ2MGUwZmY2N2I0Li5jMDc1NGEyZTNmZTQgMTAwNjQ0Cj4+IC0t LSBhL2RyaXZlcnMvdHR5L2h2Yy9LY29uZmlnCj4+ICsrKyBiL2RyaXZlcnMvdHR5L2h2Yy9LY29u ZmlnCj4+IEBAIC04Nyw2ICs4NywyNiBAQCBjb25maWcgSFZDX0RDQwo+PiAgIAkgIGRyaXZlci4g VGhpcyBjb25zb2xlIGlzIHVzZWQgdGhyb3VnaCBhIEpUQUcgb25seSBvbiBBUk0uIElmIHlvdSBk b24ndCBoYXZlCj4+ICAgCSAgYSBKVEFHIHRoZW4geW91IHByb2JhYmx5IGRvbid0IHdhbnQgdGhp cyBvcHRpb24uCj4+ICAgCj4+ICtjb25maWcgSFZDX0RDQ19TRVJJQUxJWkVfU01QCj4+ICsJYm9v bCAiVXNlIERDQyBvbmx5IG9uIGNvcmUgMCIKPj4gKwlkZXBlbmRzIG9uIFNNUCAmJiBIVkNfREND Cj4+ICsJaGVscAo+PiArCSAgU29tZSBkZWJ1Z2dlcnMsIHN1Y2ggYXMgVHJhY2UzMiBmcm9tIExh dXRlcmJhY2ggR21iSCwgZG8gbm90IGhhbmRsZQo+PiArCSAgcmVhZHMvd3JpdGVzIGZyb20vdG8g RENDIG9uIG1vcmUgdGhhbiBvbmUgY29yZS4gRWFjaCBjb3JlIGhhcyBpdHMKPj4gKwkgIG93biBE Q0MgZGV2aWNlIHJlZ2lzdGVycywgc28gd2hlbiBhIGNvcmUgcmVhZHMgb3Igd3JpdGVzIGZyb20v dG8gRENDLAo+PiArCSAgaXQgb25seSBhY2Nlc3NlcyBpdHMgb3duIERDQyBkZXZpY2UuIFNpbmNl IGtlcm5lbCBjb2RlIGNhbiBydW4gb24KPj4gKwkgIGFueSBjb3JlLCBldmVyeSB0aW1lIHRoZSBr ZXJuZWwgd2FudHMgdG8gd3JpdGUgdG8gdGhlIGNvbnNvbGUsIGl0Cj4+ICsJICBtaWdodCB3cml0 ZSB0byBhIGRpZmZlcmVudCBEQ0MuCj4+ICsKPj4gKwkgIEluIFNNUCBtb2RlLCBUcmFjZTMyIGNy ZWF0ZXMgbXVsdGlwbGUgd2luZG93cywgYW5kIGVhY2ggd2luZG93IHNob3dzCj4+ICsJICB0aGUg RENDIG91dHB1dCBvbmx5IGZyb20gdGhhdCBjb3JlJ3MgRENDLiBUaGUgcmVzdWx0IGlzIHRoYXQg Y29uc29sZQo+PiArCSAgb3V0cHV0IGlzIGVpdGhlciBsb3N0IG9yIHNjYXR0ZXJlZCBhY3Jvc3Mg d2luZG93cy4KPj4gKwo+PiArCSAgU2VsZWN0aW5nIHRoaXMgb3B0aW9uIHdpbGwgZW5hYmxlIGNv ZGUgdGhhdCBzZXJpYWxpemVzIGFsbCBjb25zb2xlCj4+ICsJICBpbnB1dCBhbmQgb3V0cHV0IHRv IGNvcmUgMC4gVGhlIERDQyBkcml2ZXIgd2lsbCBjcmVhdGUgaW5wdXQgYW5kCj4+ICsJICBvdXRw dXQgRklGT3MgdGhhdCBhbGwgY29yZXMgd2lsbCB1c2UuIFJlYWRzIGFuZCB3cml0ZXMgZnJvbS90 byBEQ0MKPj4gKwkgIGFyZSBoYW5kbGVkIGJ5IGEgd29ya3F1ZXVlIHRoYXQgcnVucyBvbmx5IGNv cmUgMC4KPj4gKwo+PiAgIGNvbmZpZyBIVkNfUklTQ1ZfU0JJCj4+ICAgCWJvb2wgIlJJU0MtViBT QkkgY29uc29sZSBzdXBwb3J0Igo+PiAgIAlkZXBlbmRzIG9uIFJJU0NWX1NCSV9WMDEKPj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvdHR5L2h2Yy9odmNfZGNjLmMgYi9kcml2ZXJzL3R0eS9odmMvaHZj X2RjYy5jCj4+IGluZGV4IDhlMGVkYjdkOTNmZC4uNjE0NDEzNWMyNGVkIDEwMDY0NAo+PiAtLS0g YS9kcml2ZXJzL3R0eS9odmMvaHZjX2RjYy5jCj4+ICsrKyBiL2RyaXZlcnMvdHR5L2h2Yy9odmNf ZGNjLmMKPj4gQEAgLTIsOSArMiwxMyBAQAo+PiAgIC8qIENvcHlyaWdodCAoYykgMjAxMCwgMjAx NCBUaGUgTGludXggRm91bmRhdGlvbi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gICovCj4+ICAgCj4+ ICAgI2luY2x1ZGUgPGxpbnV4L2NvbnNvbGUuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9jcHVtYXNr Lmg+Cj4+ICAgI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9rZmlm by5oPgo+PiAgICNpbmNsdWRlIDxsaW51eC9zZXJpYWwuaD4KPj4gICAjaW5jbHVkZSA8bGludXgv c2VyaWFsX2NvcmUuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9zbXAuaD4KPj4gKyNpbmNsdWRlIDxs aW51eC9zcGlubG9jay5oPgo+PiAgIAo+PiAgICNpbmNsdWRlIDxhc20vZGNjLmg+Cj4+ICAgI2lu Y2x1ZGUgPGFzbS9wcm9jZXNzb3IuaD4KPj4gQEAgLTE1LDYgKzE5LDE1IEBACj4+ICAgI2RlZmlu ZSBEQ0NfU1RBVFVTX1JYCQkoMSA8PCAzMCkKPj4gICAjZGVmaW5lIERDQ19TVEFUVVNfVFgJCSgx IDw8IDI5KQo+PiAgIAo+PiArI2RlZmluZSBEQ0NfSU5CVUZfU0laRQkJMTI4Cj4+ICsjZGVmaW5l IERDQ19PVVRCVUZfU0laRQkJMTAyNAo+PiArCj4+ICsvKiBMb2NrIHRvIHNlcmlhbGl6ZSBhY2Nl c3MgdG8gRENDIGZpZm8gKi8KPj4gK3N0YXRpYyBERUZJTkVfU1BJTkxPQ0soZGNjX2xvY2spOwo+ PiArCj4+ICtzdGF0aWMgREVGSU5FX0tGSUZPKGluYnVmLCB1bnNpZ25lZCBjaGFyLCBEQ0NfSU5C VUZfU0laRSk7Cj4+ICtzdGF0aWMgREVGSU5FX0tGSUZPKG91dGJ1ZiwgdW5zaWduZWQgY2hhciwg RENDX09VVEJVRl9TSVpFKTsKPj4gKwo+PiAgIHN0YXRpYyB2b2lkIGRjY191YXJ0X2NvbnNvbGVf cHV0Y2hhcihzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LCBpbnQgY2gpCj4+ICAgewo+PiAgIAl3aGls ZSAoX19kY2NfZ2V0c3RhdHVzKCkgJiBEQ0NfU1RBVFVTX1RYKQo+PiBAQCAtNjcsMjQgKzgwLDE3 NiBAQCBzdGF0aWMgaW50IGh2Y19kY2NfZ2V0X2NoYXJzKHVpbnQzMl90IHZ0LCBjaGFyICpidWYs IGludCBjb3VudCkKPj4gICAJcmV0dXJuIGk7Cj4+ICAgfQo+PiAgIAo+PiArLyoKPj4gKyAqIENo ZWNrIGlmIHRoZSBEQ0MgaXMgZW5hYmxlZC4gSWYgQ09ORklHX0hWQ19EQ0NfU0VSSUFMSVpFX1NN UCBpcyBlbmFibGVkLAo+PiArICogdGhlbiB3ZSBhc3N1bWUgdGhlbiB0aGlzIGZ1bmN0aW9uIHdp bGwgYmUgY2FsbGVkIGZpcnN0IG9uIGNvcmUwLiBUaGF0IHdheSwKPj4gKyAqIGRjY19jb3JlMF9h dmFpbGFibGUgd2lsbCBiZSB0cnVlIG9ubHkgaWYgaXQncyBhdmFpbGFibGUgb24gY29yZTAuCj4+ ICsgKi8KPj4gICBzdGF0aWMgYm9vbCBodmNfZGNjX2NoZWNrKHZvaWQpCj4+ICAgewo+PiAgIAl1 bnNpZ25lZCBsb25nIHRpbWUgPSBqaWZmaWVzICsgKEhaIC8gMTApOwo+PiArCXN0YXRpYyBib29s IGRjY19jb3JlMF9hdmFpbGFibGU7Cj4+ICsKPj4gKwkvKgo+PiArCSAqIElmIHdlJ3JlIG5vdCBv biBjb3JlIDAsIGJ1dCB3ZSBwcmV2aW91c2x5IGNvbmZpcm1lZCB0aGF0IERDQyBpcwo+PiArCSAq IGFjdGl2ZSwgdGhlbiBqdXN0IHJldHVybiB0cnVlLgo+PiArCSAqLwo+PiArCWludCBjcHUgPSBn ZXRfY3B1KCk7Cj4+ICsKPj4gKwlpZiAoSVNfRU5BQkxFRChDT05GSUdfSFZDX0RDQ19TRVJJQUxJ WkVfU01QKSAmJiBjcHUgJiYgZGNjX2NvcmUwX2F2YWlsYWJsZSkgewo+PiArCQlwdXRfY3B1KCk7 Cj4+ICsJCXJldHVybiB0cnVlOwo+PiArCX0KPj4gKwo+PiArCXB1dF9jcHUoKTsKPj4gICAKPj4g ICAJLyogV3JpdGUgYSB0ZXN0IGNoYXJhY3RlciB0byBjaGVjayBpZiBpdCBpcyBoYW5kbGVkICov Cj4+ICAgCV9fZGNjX3B1dGNoYXIoJ1xuJyk7Cj4+ICAgCj4+ICAgCXdoaWxlICh0aW1lX2lzX2Fm dGVyX2ppZmZpZXModGltZSkpIHsKPj4gLQkJaWYgKCEoX19kY2NfZ2V0c3RhdHVzKCkgJiBEQ0Nf U1RBVFVTX1RYKSkKPj4gKwkJaWYgKCEoX19kY2NfZ2V0c3RhdHVzKCkgJiBEQ0NfU1RBVFVTX1RY KSkgewo+PiArCQkJZGNjX2NvcmUwX2F2YWlsYWJsZSA9IHRydWU7Cj4+ICAgCQkJcmV0dXJuIHRy dWU7Cj4+ICsJCX0KPj4gICAJfQo+PiAgIAo+PiAgIAlyZXR1cm4gZmFsc2U7Cj4+ICAgfQo+PiAg IAo+PiArLyoKPj4gKyAqIFdvcmtxdWV1ZSBmdW5jdGlvbiB0aGF0IHdyaXRlcyB0aGUgb3V0cHV0 IEZJRk8gdG8gdGhlIERDQyBvbiBjb3JlIDAuCj4+ICsgKi8KPj4gK3N0YXRpYyB2b2lkIGRjY19w dXRfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCj4+ICt7Cj4+ICsJdW5zaWduZWQgY2hh ciBjaDsKPj4gKwl1bnNpZ25lZCBsb25nIGlycWZsYWdzOwo+PiArCj4+ICsJc3Bpbl9sb2NrX2ly cXNhdmUoJmRjY19sb2NrLCBpcnFmbGFncyk7Cj4+ICsKPj4gKwkvKiBXaGlsZSB0aGVyZSdzIGRh dGEgaW4gdGhlIG91dHB1dCBGSUZPLCB3cml0ZSBpdCB0byB0aGUgRENDICovCj4+ICsJd2hpbGUg KGtmaWZvX2dldCgmb3V0YnVmLCAmY2gpKQo+PiArCQlodmNfZGNjX3B1dF9jaGFycygwLCAmY2gs IDEpOwo+PiArCj4+ICsJLyogV2hpbGUgd2UncmUgYXQgaXQsIGNoZWNrIGZvciBhbnkgaW5wdXQg Y2hhcmFjdGVycyAqLwo+PiArCXdoaWxlICgha2ZpZm9faXNfZnVsbCgmaW5idWYpKSB7Cj4+ICsJ CWlmICghaHZjX2RjY19nZXRfY2hhcnMoMCwgJmNoLCAxKSkKPj4gKwkJCWJyZWFrOwo+PiArCQlr Zmlmb19wdXQoJmluYnVmLCBjaCk7Cj4+ICsJfQo+PiArCj4+ICsJc3Bpbl91bmxvY2tfaXJxcmVz dG9yZSgmZGNjX2xvY2ssIGlycWZsYWdzKTsKPj4gK30KPj4gKwo+PiArc3RhdGljIERFQ0xBUkVf V09SSyhkY2NfcHdvcmssIGRjY19wdXRfd29yayk7Cj4+ICsKPj4gKy8qCj4+ICsgKiBXb3JrcXVl dWUgZnVuY3Rpb24gdGhhdCByZWFkcyBjaGFyYWN0ZXJzIGZyb20gRENDIGFuZCBwdXRzIHRoZW0g aW50byB0aGUKPj4gKyAqIGlucHV0IEZJRk8uCj4+ICsgKi8KPj4gK3N0YXRpYyB2b2lkIGRjY19n ZXRfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCj4+ICt7Cj4+ICsJdW5zaWduZWQgY2hh ciBjaDsKPj4gKwl1bnNpZ25lZCBsb25nIGlycWZsYWdzOwo+PiArCj4+ICsJLyoKPj4gKwkgKiBS ZWFkIGNoYXJhY3RlcnMgZnJvbSBEQ0MgYW5kIHB1dCB0aGVtIGludG8gdGhlIGlucHV0IEZJRk8s IGFzCj4+ICsJICogbG9uZyBhcyB0aGVyZSBpcyByb29tIGFuZCB3ZSBoYXZlIGNoYXJhY3RlcnMg dG8gcmVhZC4KPj4gKwkgKi8KPj4gKwlzcGluX2xvY2tfaXJxc2F2ZSgmZGNjX2xvY2ssIGlycWZs YWdzKTsKPj4gKwo+PiArCXdoaWxlICgha2ZpZm9faXNfZnVsbCgmaW5idWYpKSB7Cj4+ICsJCWlm ICghaHZjX2RjY19nZXRfY2hhcnMoMCwgJmNoLCAxKSkKPj4gKwkJCWJyZWFrOwo+PiArCQlrZmlm b19wdXQoJmluYnVmLCBjaCk7Cj4+ICsJfQo+PiArCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRj Y19sb2NrLCBpcnFmbGFncyk7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBERUNMQVJFX1dPUksoZGNj X2d3b3JrLCBkY2NfZ2V0X3dvcmspOwo+PiArCj4+ICsvKgo+PiArICogV3JpdGUgY2hhcmFjdGVy cyBkaXJlY3RseSB0byB0aGUgRENDIGlmIHdlJ3JlIG9uIGNvcmUgMCBhbmQgdGhlIEZJRk8KPj4g KyAqIGlzIGVtcHR5LCBvciB3cml0ZSB0aGVtIHRvIHRoZSBGSUZPIGlmIHdlJ3JlIG5vdC4KPj4g KyAqLwo+PiArc3RhdGljIGludCBodmNfZGNjMF9wdXRfY2hhcnModTMyIHZ0LCBjb25zdCBjaGFy ICpidWYsIGludCBjb3VudCkKPj4gK3sKPj4gKwlpbnQgbGVuOwo+PiArCXVuc2lnbmVkIGxvbmcg aXJxZmxhZ3M7Cj4+ICsKPj4gKwlpZiAoIUlTX0VOQUJMRUQoQ09ORklHX0hWQ19EQ0NfU0VSSUFM SVpFX1NNUCkpCj4+ICsJCXJldHVybiBodmNfZGNjX3B1dF9jaGFycyh2dCwgYnVmLCBjb3VudCk7 Cj4+ICsKPj4gKwlzcGluX2xvY2tfaXJxc2F2ZSgmZGNjX2xvY2ssIGlycWZsYWdzKTsKPj4gKwlp ZiAoc21wX3Byb2Nlc3Nvcl9pZCgpIHx8ICgha2ZpZm9faXNfZW1wdHkoJm91dGJ1ZikpKSB7Cj4+ ICsJCWxlbiA9IGtmaWZvX2luKCZvdXRidWYsIGJ1ZiwgY291bnQpOwo+PiArCQlzcGluX3VubG9j a19pcnFyZXN0b3JlKCZkY2NfbG9jaywgaXJxZmxhZ3MpOwo+PiArCj4+ICsJCS8qCj4+ICsJCSAq IFdlIGp1c3QgcHVzaCBkYXRhIHRvIHRoZSBvdXRwdXQgRklGTywgc28gc2NoZWR1bGUgdGhlCj4+ ICsJCSAqIHdvcmtxdWV1ZSB0aGF0IHdpbGwgYWN0dWFsbHkgd3JpdGUgdGhhdCBkYXRhIHRvIERD Qy4KPj4gKwkJICogTm8gaG90cGx1ZyBsb2NrIHJlcXVpcmVkIGFzIHdlIGFyZSBpbiBhdG9taWMg Y29udGV4dAo+PiArCQkgKiB3aXRoIGludGVycnVwdHMgYW5kIHByZWVtcHRpb24gZGlzYWJsZWQu Cj4+ICsJCSAqLwo+PiArCQlpZiAoY3B1X29ubGluZSgwKSkKPj4gKwkJCXNjaGVkdWxlX3dvcmtf b24oMCwgJmRjY19wd29yayk7Cj4gV2h5IGlzIHB1dF9jaGFycyBhbHdheXMgY2FsbGVkIGZyb20g YXRvbWljIGNvbnRleHQ/ICBXaGVyZSBpcyB0aGF0Cj4gZG9jdW1lbnRlZD8KCkl0IGlzIGNhbGxl ZCBmcm9tIHZwcmludGtfZW1pdC0+Y29uc29sZV91bmxvY2soKSB3aGljaCBJIGJlbGlldmUgcnVu cyBpbiBhdG9taWMgY29udGV4dCwgc2VlIGJlbG93IHN0YWNrIHRyYWNlLgoKW8KgwqAgNjguODA0 NzQ3XSBCVUc6IHNsZWVwaW5nIGZ1bmN0aW9uIGNhbGxlZCBmcm9tIGludmFsaWQgY29udGV4dCBh dCAuL2luY2x1ZGUvbGludXgvcGVyY3B1LXJ3c2VtLmg6NDkKW8KgwqAgNjguODA0NzUyXSBpbl9h dG9taWMoKTogMSwgaXJxc19kaXNhYmxlZCgpOiAxMjgsIG5vbl9ibG9jazogMCwgcGlkOiAxLCBu YW1lOiBzd2FwcGVyLzAKW8KgwqAgNjguODA0NzU3XSBwcmVlbXB0X2NvdW50OiAxLCBleHBlY3Rl ZDogMApbwqDCoCA2OC44MDQ3OTRdIFByZWVtcHRpb24gZGlzYWJsZWQgYXQ6ClvCoMKgIDY4Ljgw NDc5Nl0gWzxmZmZmYTlkNTBlYjE5OGZjPl0gdnByaW50a19lbWl0KzB4YzQvMHgyZTAKW8KgwqAg NjguODA0ODAyXSBDUFU6IDEgUElEOiAxIENvbW06IHN3YXBwZXIvMCBUYWludGVkOiBHIFfCoMKg wqDCoMKgwqDCoMKgIDUuMTcuMC1yYzMtbmV4dC0yMDIyMDIxMC0wMDAwMS1nNjgyNjYzYWM5N2Q0 LWRpcnR5ICMyMApbwqDCoCA2OC44MDQ4MTBdIENhbGwgdHJhY2U6ClvCoMKgIDY4LjgwNDgxMl3C oCBkdW1wX2JhY2t0cmFjZS5wYXJ0LjYrMHhkOC8weGU4ClvCoMKgIDY4LjgwNDgyMF3CoCBzaG93 X3N0YWNrKzB4MTQvMHg2MApbwqDCoCA2OC44MDQ4MjddwqAgZHVtcF9zdGFja19sdmwrMHg4OC8w eGIwClvCoMKgIDY4LjgwNDgzMV3CoCBkdW1wX3N0YWNrKzB4MTQvMHgyYwpbwqDCoCA2OC44MDQ4 MzZdwqAgX19taWdodF9yZXNjaGVkKzB4MjFjLzB4MjY4ClvCoMKgIDY4LjgwNDg0MF3CoCBfX21p Z2h0X3NsZWVwKzB4NDQvMHg3OApbwqDCoCA2OC44MDQ4NDRdwqAgY3B1c19yZWFkX2xvY2srMHgy MC8weDE2OApbwqDCoCA2OC44MDQ4NDhdwqAgaHZjX2RjYzBfcHV0X2NoYXJzKzB4NmMvMHgxMTAK W8KgwqAgNjguODA0ODUyXcKgIGh2Y19jb25zb2xlX3ByaW50KzB4MTQ0LzB4MWQ4ClvCoMKgIDY4 LjgwNDg1N13CoCBjb25zb2xlX3VubG9jaysweDJkOC8weDVmOApbwqDCoCA2OC44MDQ4NjJdwqAg dnByaW50a19lbWl0KzB4ZDAvMHgyZTAKW8KgwqAgNjguODA0ODY3XcKgIHZwcmludGtfZGVmYXVs dCsweDMwLzB4MzgKW8KgwqAgNjguODA0ODcxXcKgIHZwcmludGsrMHhjYy8weGU4ClvCoMKgIDY4 LjgwNDg3Nl3CoCBfcHJpbnRrKzB4NjQvMHg4NAoKPiBBbmQgdGhhdCByZWFsbHkgd2lsbCBwcmV2 ZW50IGFub3RoZXIgY3B1IGZyb20gZ29pbmcgb2ZmbGluZSBhZnRlciB0aGlzCj4gY2FsbCBoYXMg YmVlbiBjaGVja2VkPwo+CgpJIHdhc24ndCBhYmxlIHRvIGZpbmQgYW55IGhvdHBsdWcgbG9jayB3 aGljaCBjYW4gYmUgdXNlZCBpbiBhdG9taWMgY29udGV4dCwgZG8geW91CmhhdmUgYW55IGlkZWE/ Cgo+PiArCj4+ICsJCXJldHVybiBsZW47Cj4+ICsJfQo+PiArCj4+ICsJLyoKPj4gKwkgKiBJZiB3 ZSdyZSBhbHJlYWR5IG9uIGNvcmUgMCwgYW5kIHRoZSBGSUZPIGlzIGVtcHR5LCB0aGVuIGp1c3QK Pj4gKwkgKiB3cml0ZSB0aGUgZGF0YSB0byBEQ0MuCj4+ICsJICovCj4+ICsJbGVuID0gaHZjX2Rj Y19wdXRfY2hhcnModnQsIGJ1ZiwgY291bnQpOwo+PiArCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUo JmRjY19sb2NrLCBpcnFmbGFncyk7Cj4+ICsKPj4gKwlyZXR1cm4gbGVuOwo+PiArfQo+PiArCj4+ ICsvKgo+PiArICogUmVhZCBjaGFyYWN0ZXJzIGRpcmVjdGx5IGZyb20gdGhlIERDQyBpZiB3ZSdy ZSBvbiBjb3JlIDAgYW5kIHRoZSBGSUZPCj4+ICsgKiBpcyBlbXB0eSwgb3IgcmVhZCB0aGVtIGZy b20gdGhlIEZJRk8gaWYgd2UncmUgbm90Lgo+PiArICovCj4+ICtzdGF0aWMgaW50IGh2Y19kY2Mw X2dldF9jaGFycyh1MzIgdnQsIGNoYXIgKmJ1ZiwgaW50IGNvdW50KQo+PiArewo+PiArCWludCBs ZW47Cj4+ICsJdW5zaWduZWQgbG9uZyBpcnFmbGFnczsKPj4gKwo+PiArCWlmICghSVNfRU5BQkxF RChDT05GSUdfSFZDX0RDQ19TRVJJQUxJWkVfU01QKSkKPj4gKwkJcmV0dXJuIGh2Y19kY2NfZ2V0 X2NoYXJzKHZ0LCBidWYsIGNvdW50KTsKPj4gKwo+PiArCXNwaW5fbG9ja19pcnFzYXZlKCZkY2Nf bG9jaywgaXJxZmxhZ3MpOwo+PiArCj4+ICsJaWYgKHNtcF9wcm9jZXNzb3JfaWQoKSB8fCAoIWtm aWZvX2lzX2VtcHR5KCZpbmJ1ZikpKSB7Cj4+ICsJCWxlbiA9IGtmaWZvX291dCgmaW5idWYsIGJ1 ZiwgY291bnQpOwo+PiArCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkY2NfbG9jaywgaXJxZmxh Z3MpOwo+PiArCj4+ICsJCS8qCj4+ICsJCSAqIElmIHRoZSBGSUZPIHdhcyBlbXB0eSwgdGhlcmUg bWF5IGJlIGNoYXJhY3RlcnMgaW4gdGhlIERDQwo+PiArCQkgKiB0aGF0IHdlIGhhdmVuJ3QgcmVh ZCB5ZXQuICBTY2hlZHVsZSBhIHdvcmtxdWV1ZSB0byBmaWxsCj4+ICsJCSAqIHRoZSBpbnB1dCBG SUZPLCBzbyB0aGF0IHRoZSBuZXh0IHRpbWUgdGhpcyBmdW5jdGlvbiBpcwo+PiArCQkgKiBjYWxs ZWQsIHdlJ2xsIGhhdmUgZGF0YS4gTm8gaG90cGx1ZyBsb2NrIHJlcXVpcmVkIGFzIHdlIGFyZQo+ PiArCQkgKiBpbiBhdG9taWMgY29udGV4dCB3aXRoIGludGVycnVwdHMgYW5kIHByZWVtcHRpb24g ZGlzYWJsZWQuCj4+ICsJCSAqLwo+PiArCQlpZiAoIWxlbiAmJiBjcHVfb25saW5lKDApKQo+PiAr CQkJc2NoZWR1bGVfd29ya19vbigwLCAmZGNjX2d3b3JrKTsKPiBnZXRfY2hhcnMgaXMgaW4gYXRv bWljIGNvbnRleHQ/ICBFdmVuIGZyb20gdGhlIHBvbGxfZ2V0X2NoYXIoKSBjYWxsYmFjaz8KPgo+ CgogRnJvbSBfX2h2Y19wb2xsKCksIHNlZSBiZWxvdyBzdGFjayB0cmFjZToKClvCoMKgIDIyLjUw MzU5NF0gQlVHOiBzbGVlcGluZyBmdW5jdGlvbiBjYWxsZWQgZnJvbSBpbnZhbGlkIGNvbnRleHQg YXQgLi9pbmNsdWRlL2xpbnV4L3BlcmNwdS1yd3NlbS5oOjQ5ClvCoMKgIDIyLjUwMzYzNF0gaW5f YXRvbWljKCk6IDEsIGlycXNfZGlzYWJsZWQoKTogMTI4LCBub25fYmxvY2s6IDAsIHBpZDogNDks IG5hbWU6IGtodmNkClvCoMKgIDIyLjUwMzY1OV0gcHJlZW1wdF9jb3VudDogMSwgZXhwZWN0ZWQ6 IDAKW8KgwqAgMjIuNTAzNjc3XSBSQ1UgbmVzdCBkZXB0aDogMCwgZXhwZWN0ZWQ6IDAKW8KgwqAg MjIuNTAzNzAxXSAyIGxvY2tzIGhlbGQgYnkga2h2Y2QvNDk6ClvCoMKgIDIyLjgzNTQ1MF3CoCAj MDogZmZmZmNiZmUzOWYwNTg2OCAoaHZjX3N0cnVjdHNfbXV0ZXgpeysuKy59LXszOjN9LCBhdDog a2h2Y2QrMHg5NC8weDE4MApbwqDCoCAyMi44MzU1MTNdwqAgIzE6IGZmZmY0NGE1MDI2NzIzYjAg KCZocC0+bG9jayl7Li4uLn0tezI6Mn0sIGF0OiBfX2h2Y19wb2xsKzB4MjE4LzB4MzcwClvCoMKg IDIzLjQ3NzQ5Nl0gUHJlZW1wdGlvbiBkaXNhYmxlZCBhdDoKW8KgwqAgMjMuNDc3NTAyXSBbPGZm ZmZjYmZlMzgyNjk1NDA+XSBfX2h2Y19wb2xsKzB4MjE4LzB4MzcwClvCoMKgIDIzLjYwMjA0OF0g Q1BVOiAxIFBJRDogNDkgQ29tbToga2h2Y2QgVGFpbnRlZDogRyBXwqDCoMKgwqDCoMKgwqDCoCA1 LjE3LjAtcmMzLW5leHQtMjAyMjAyMTAtMDAwMDEtZ2E3YTMwYjM5YmI5OS1kaXJ0eSAjMzMKW8Kg wqAgMjMuNjAyMTAwXSBDYWxsIHRyYWNlOgpbwqDCoCAyMy42MDIxMTVdwqAgZHVtcF9iYWNrdHJh Y2UucGFydC42KzB4ZDgvMHhlOApbwqDCoCAyMy42MDIxNDBdwqAgc2hvd19zdGFjaysweDE0LzB4 NjAKW8KgwqAgMjMuNjAyMTYwXcKgIGR1bXBfc3RhY2tfbHZsKzB4OTgvMHhkMApbwqDCoCAyMy42 MDIxODFdwqAgZHVtcF9zdGFjaysweDE0LzB4MmMKW8KgwqAgMjMuNjAyMjAwXcKgIF9fbWlnaHRf cmVzY2hlZCsweDIxYy8weDI2OApbwqDCoCAyMy42MDIyMjFdwqAgX19taWdodF9zbGVlcCsweDQ0 LzB4NzgKW8KgwqAgMjMuNjAyMjQwXcKgIGNwdXNfcmVhZF9sb2NrKzB4MjAvMHgxNjgKW8KgwqAg MjMuNjAyMjU5XcKgIGh2Y19kY2MwX2dldF9jaGFycysweDcwLzB4MTI4ClvCoMKgIDIzLjYwMjI3 OF3CoCBfX2h2Y19wb2xsKzB4MTA0LzB4MzcwClvCoMKgIDIzLjYwMjI5N13CoCBraHZjZCsweGI4 LzB4MTgwClvCoMKgIDIzLjYwMjMxNl3CoCBrdGhyZWFkKzB4ZWMvMHgxMTAKW8KgwqAgMjMuNjAy MzM4XcKgIHJldF9mcm9tX2ZvcmsrMHgxMC8weDIwCgoKVGhhbmtzLApTYWkKCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFp bGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlz dHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK