From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from SN4PR2101CU001.outbound.protection.outlook.com (mail-southcentralusazon11012056.outbound.protection.outlook.com [40.93.195.56]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 793B735F179 for ; Tue, 5 May 2026 04:37:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=40.93.195.56 ARC-Seal:i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1777955871; cv=fail; b=SsJLV4TPWrK9bsCkc/j2f+1vazQG63h6ZSZNFf5RVp53XyHh/uvN6Y0xHENBOVLXBmoMg80c+lWMnlK1vVA0MEgO7r1YuPtFuve0J1u2Xeq9k6CpTXHGatwj5AawRW6qLt4CqFf2N3uBJ1L0fTQLcxS/ZCsMvkXlDr3/QTdfcAc= ARC-Message-Signature:i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1777955871; c=relaxed/simple; bh=zgXrTB/jkL0fZOa3zCkpSlicd3EOQ4sfI2zkCLadSMM=; h=Content-Type:Message-ID:Date:MIME-Version:Subject:To:CC: References:From:In-Reply-To; b=rI1MgySAPLKc014fTF15nAtlK8oXi7LWN53DT+0xP1LDrCtnnGLrBTdPMIM1uSt80i0EI33k4SDL6dGuDsVrVJGT8GlRJBC5nYJ/H9W0xj/c1hSPKLpDDNGtHVJCiZ3P5HV3ez0TAWSlX5EvqIxISc4u1+ms41wVP65OEFcDqPk= ARC-Authentication-Results:i=2; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=amd.com; spf=fail smtp.mailfrom=amd.com; dkim=pass (1024-bit key) header.d=amd.com header.i=@amd.com header.b=ghIXtMIr; arc=fail smtp.client-ip=40.93.195.56 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=amd.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=amd.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=amd.com header.i=@amd.com header.b="ghIXtMIr" ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=m2XLUOxmGGMDukpeBhNpASgMKgdD2jh/HyjATLHxFEJ+ZP0v+Xb0cuBRt5B/oKhFOpht7qubsNZtxZ8f5KI9etkfiIfcv3L0UXuZv8uYZ1SEcXkhIRJuVtwPBbAALwUlaw2RllS8Pv9Seibm6/3RJwl+d10kNbA8FVe88njmPD5+jWcWzLPXEqmjDXh8lfvGIhHj+s2O5vw8+h83/7JVRYLJUAMe645RnbFfMHTsBs9MbEwUbXqSB4BPah6mVmO7ELzy+dhnIDRL/I7lsS6WYi3uwXGEBrfWlZRlF/pk/BqR9yHALGLE/8Zgn2Tx29X/k4S6kGEaXEnTxGj07vtnxQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=DuYfTrynRbYJFqkQUR/7M9DWxMK4e+6kBXSU3OcdPms=; b=f07CqhnRaivrHGYoZvbiBMq4t4NKucFw6jcHjibwTHx7ew93ZBcMTi1P7Fi7TzauGEZfB2moM1oW00GsHzgVrWOo7G6ZsN9Lav6MslA+vgletaBk2u3py+KtP7i24ymjsYglcP7yWPLfSA7dn2D9e6JetGPoBleyy5/esd4QriKVUSPnPZqrwJ9VjMN9oclYZJmHbcVHxoY2UaJor2HPlnZaga80DO63ptrcFkORFjC5vCD/Grs0tshFSouTjwQJVgaNs/3CXia5AmoQLRtxjoOKKdKQfojQzsFQak0auPU2sjEa9ldrFKA71Mw0h1RggwBhJvTpf5f4GS5sJgIHrg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=google.com smtp.mailfrom=amd.com; dmarc=pass (p=quarantine sp=quarantine pct=100) action=none header.from=amd.com; dkim=none (message not signed); arc=none (0) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amd.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=DuYfTrynRbYJFqkQUR/7M9DWxMK4e+6kBXSU3OcdPms=; b=ghIXtMIrqGivE4sOiZYfWmMZ1kwJyOZy+sabHVDUvCe3X0dCtI1QV7FQWxW/tNXJOxJndO2kS11rqhHCML5WzcvryC93CfUIrWHDX+RzhmScz4HVPH1TxoSmETJ7ssRBDGGr8arZPT94KEL/Q97Wxoh3sMCqNlDIe8Rr793MT7w= Received: from PH7PR17CA0060.namprd17.prod.outlook.com (2603:10b6:510:325::24) by MW5PR12MB5599.namprd12.prod.outlook.com (2603:10b6:303:194::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.9870.25; Tue, 5 May 2026 04:37:44 +0000 Received: from CY4PEPF0000EDD3.namprd03.prod.outlook.com (2603:10b6:510:325:cafe::c4) by PH7PR17CA0060.outlook.office365.com (2603:10b6:510:325::24) with Microsoft SMTP Server (version=TLS1_3, cipher=TLS_AES_256_GCM_SHA384) id 15.20.9870.25 via Frontend Transport; Tue, 5 May 2026 04:37:44 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 165.204.84.17) smtp.mailfrom=amd.com; dkim=none (message not signed) header.d=none;dmarc=pass action=none header.from=amd.com; Received-SPF: Pass (protection.outlook.com: domain of amd.com designates 165.204.84.17 as permitted sender) receiver=protection.outlook.com; client-ip=165.204.84.17; helo=satlexmb07.amd.com; pr=C Received: from satlexmb07.amd.com (165.204.84.17) by CY4PEPF0000EDD3.mail.protection.outlook.com (10.167.241.199) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.9891.9 via Frontend Transport; Tue, 5 May 2026 04:37:43 +0000 Received: from SATLEXMB04.amd.com (10.181.40.145) by satlexmb07.amd.com (10.181.42.216) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.2.2562.17; Mon, 4 May 2026 23:37:43 -0500 Received: from satlexmb08.amd.com (10.181.42.217) by SATLEXMB04.amd.com (10.181.40.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.39; Mon, 4 May 2026 23:37:42 -0500 Received: from [10.136.42.25] (10.180.168.240) by satlexmb08.amd.com (10.181.42.217) with Microsoft SMTP Server id 15.2.2562.17 via Frontend Transport; Mon, 4 May 2026 23:37:35 -0500 Content-Type: multipart/mixed; boundary="------------4hJPLYDoWcQglx31oC4yQZP0" Message-ID: <7482ee30-5a50-41bb-9545-67cca5bd4cf2@amd.com> Date: Tue, 5 May 2026 10:07:34 +0530 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v2 1/2] sched: proxy-exec: Close race causing workqueue work being delayed To: John Stultz CC: Peter Zijlstra , LKML , Vineeth Pillai , "Sonam Sanju" , Sean Christopherson , "Kunwu Chan" , Tejun Heo , Joel Fernandes , Qais Yousef , Ingo Molnar , Juri Lelli , Vincent Guittot , Dietmar Eggemann , Valentin Schneider , Steven Rostedt , Will Deacon , Waiman Long , Boqun Feng , "Paul E. McKenney" , Metin Kaya , Xuewen Yan , Thomas Gleixner , "Daniel Lezcano" , Suleiman Souhlal , kuyo chang , hupu , References: <20260430215103.2978955-1-jstultz@google.com> <20260430215103.2978955-2-jstultz@google.com> <20260501132143.GC1026330@noisy.programming.kicks-ass.net> <63c830c3-fe6d-4822-81db-9fdd1597282e@amd.com> <20260501185900.GF1026330@noisy.programming.kicks-ass.net> <46ce422c-e796-4280-8165-b7c163928c68@amd.com> Content-Language: en-US From: K Prateek Nayak In-Reply-To: Received-SPF: None (SATLEXMB04.amd.com: kprateek.nayak@amd.com does not designate permitted sender hosts) X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: CY4PEPF0000EDD3:EE_|MW5PR12MB5599:EE_ X-MS-Office365-Filtering-Correlation-Id: 5c0d3fc6-a0f6-45c0-295b-08deaa600cb3 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|36860700016|6049299003|1800799024|82310400026|7416014|376014|4053099003|56012099003|18002099003|22082099003; X-Microsoft-Antispam-Message-Info: iUtl3qz+BY2gjr9HbS4Nr06y14RQYoH9Yb2aMJw7hfQI8Nw2qWAXsBrmrGXbPeYPmnYqiUXYmbRhdVrfkwTAGudQjgZVn7hbOAEIp4tBPOitTrrJfPymQL6iECzWrIXkp+oj9yikkcOqepMn3TOpT4/oG4MMvSvKfZ17YpX+ptfBgEmeBxtzkOzoVUWOW106ajpZ8R1eEbE6LD6RA+qiV3kDCwMRo2N77jJKg+cli4EZi95wFKz3BDL48UBeccxFdA+Rq9M/tqoXFv3+AXfWSViFTl+dCFgXm3YtPTAEHJKV1WXV80yK+Yw4fVmF3bCJ5EK+mvdLs+nHDhmCd49VBGQkDmCH9Nr+JAGBeWZGCXvoDPEXU/6Bz9XSQJEnmYnszRsPRx9+A13ciAyN8zyBZle4SSjyzZ7a247g89xV3yQiwTHeGDP3u1KXpbtnm5HfNezgGWWj0Y+X+1G/Vpr98eqMItRy0QrFShGTUDmxfL3NZI0fYyp7QJyOZe5b0C86VVfpnSTEbxCbtdlxGqTl3Q3BBYzAQwKo5YhRM0OMDSsSIa/OUf3Tgwwez62cwrlqhtz8dXXyW3fZbhzvtUE0cLPLVb7BitrKdZHDeFN+gPK5lFQkc17gm+5UKWpfAvnp2CCqCEiAn6ehHguTduRgG8lXh/uQIavw1Fb596LpJFBZzH9wCNrN+Y8X/ZYOlcyuVdESXT1JFLqgVHpcGAnwkl6vuro+Rt5qCqHuquvLcak= X-Forefront-Antispam-Report: CIP:165.204.84.17;CTRY:US;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:satlexmb07.amd.com;PTR:InfoDomainNonexistent;CAT:NONE;SFS:(13230040)(36860700016)(6049299003)(1800799024)(82310400026)(7416014)(376014)(4053099003)(56012099003)(18002099003)(22082099003);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: hlQLAzqOMWccwX0S3X+ZZyPiEnyvsv9jzKcOz877nc/4wYJc6e3qSVHTHa2ag16SHkxestKEZLZfzU3jthvyNHT5MbM0VHwEfxmRFn+ut8cdTzavAwipVpxoCqk0MsFPRXnsFadUDQTuXFVIjRN66RW9H4Wz7fyMdIQHITRLdFESzl48LnPUDYlmklojuJ3WH/Bql3cljGs/IOFftDbsqJYGzC0TbONQ9h69HtDZa2s2591YmO9+U9NpuzRzNo3KiXtasVZcyorwGWsfaArsRgMKjaq57a8zkJaCG710FEr4bQSCmq/wetVjdEvupQneKUzxhRt+iNl18AxXxwEkiHujvwvKwtxIHvmy0Qrt7NIgtS6J3K9XsIGnJCldKINUotKWfHg+dDOVovdYq8qLPnA3dcxx7vDHuY1msvrPUhM31aD2prT7OJVUdR6xCFi3 X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 05 May 2026 04:37:43.8957 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 5c0d3fc6-a0f6-45c0-295b-08deaa600cb3 X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=3dd8961f-e488-4e60-8e11-a82d994e183d;Ip=[165.204.84.17];Helo=[satlexmb07.amd.com] X-MS-Exchange-CrossTenant-AuthSource: CY4PEPF0000EDD3.namprd03.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: MW5PR12MB5599 --------------4hJPLYDoWcQglx31oC4yQZP0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit Hello John, On 5/5/2026 9:02 AM, John Stultz wrote: > On Sun, May 3, 2026 at 10:37 PM K Prateek Nayak wrote: >> On 5/4/2026 12:12 AM, K Prateek Nayak wrote: >>> So when looking at all of this, I realized we probably don't need >>> PROXY_WAKING anymore if we have the "is_blocked" state in task_struct. >>> The owner can simply clear the blocked_on and move along and the >>> waiter's "is_blocked" state will handle the sched bits. >>> >>> (p->is_blocked && !p->blocked_on) can then be interpreted as >>> PROXY_WAKING and that task should explore return migration in >>> find_proxy_task(). >>> >>> Would something like below be more amenable from a backport standpoint >>> instead of marking the config broken? >>> >> @@ -6535,8 +6548,10 @@ static bool try_to_block_task(struct rq *rq, struct task_struct *p, >> * blocked on a mutex, and we want to keep it on the runqueue >> * to be selectable for proxy-execution. >> */ >> - if (!should_block) >> + if (!should_block) { >> + sched_set_task_is_blocked(p); >> return false; >> + } >> > > So digging a bit more into this, it seems is_blocked in your patch is > semantically different from what Peter was proposing. > > Peter seemed to be suggesting is_blocked would be more generic then > just for proxy-exec, getting set in try_to_block_task() regardless if > we actually blocked the task or not, and then clearing it in > ttwu_do_wakeup() when we go RUNNABLE. Pretty much independent of > blocked_on. Something very similar to Peter's suggestion like that is attached towards the end if that is more favorable but it doesn't always clear "is_blocked" at ttwu_do_wakeup() currently - that would require the return bits in ttwu_runnable() before it can be moved to ttwu_do_wakeup() safely. > > Where as your patch is still having is_blocked very much tied with > blocked_on (since with yours we only set is_blocked if we avoid > blocking the task in try_to_block_task(), and clear it only from > find_proxy_task()). Ack! That is the main difference - we can clear it during ttwu too once we have proxy_needs_return() but with the set of changes we have committed, it is done selectively for blocked tasks in find_proxy_task(). > In a way I can map your approach utilizing is_blocked as conceptually > sort of separating the latch bit from my last approach, (if we also > re-worked PROXY_WAKING to be the value 1 (!blocked_on + latch) instead > of -1). So your approach seems workable (I've got it about half way > integrated with my full series - hitting a little bit of trouble with > the sleeping owner enquing at the moment), So, this new state is synchronized by task's rq_lock() when p->on_rq (even for the ttwu bits) but from what I can tell, sleeping owner really depended on the blocked_lock based synchronization so perhaps that is the difference? Would grabbing blocked_lock when setting and clearing the "is_blocked" help in case you've not already explored it? > but I'm not sure this is what Peter is looking for. Well this was just an option in case we don't want to backport super invasive changes. That said, we can easily do the following on top to fit what Peter originally suggested (although it'll probably require a bit effort to integrate with the sleeping owner bits): (Lightly tested as usual :-) diff --git a/kernel/sched/core.c b/kernel/sched/core.c index 30672390e6f99..e88f5b7a02b3e 100644 --- a/kernel/sched/core.c +++ b/kernel/sched/core.c @@ -3675,6 +3675,8 @@ ttwu_do_activate(struct rq *rq, struct task_struct *p, int wake_flags, } } +static inline void sched_clear_task_is_blocked(struct task_struct *p); + /* * Consider @p being inside a wait loop: * @@ -3709,8 +3711,19 @@ static int ttwu_runnable(struct task_struct *p, int wake_flags) rq = __task_rq_lock(p, &rf); if (task_on_rq_queued(p)) { update_rq_clock(rq); - if (p->se.sched_delayed) + if (p->se.sched_delayed) { + /* + * Task was fully blocked (not retained as proxy) and + * is runnable again. Clear "is_blocked" indicator. + * For all other cases, the task has either not set + * "is_blocked" since ttwu_runnable() won against + * schedule(), or the task was retained as proxy and + * expects find_proxy_task() to handle the clearing of + * "is_blocked" state. + */ + sched_clear_task_is_blocked(p); enqueue_task(rq, p, ENQUEUE_NOCLOCK | ENQUEUE_DELAYED); + } if (!task_on_cpu(rq, p)) { /* * When on_rq && !on_cpu the task is preempted, see if @@ -4190,6 +4203,13 @@ int try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags) */ WRITE_ONCE(p->__state, TASK_WAKING); + /* + * If ttwu_runnable() did not win, task is fully blocked (!p->on_rq) and + * requires a full wakeup. Clear task_is_blocked() before attempting + * ttwu_queue_wakelist(). + */ + sched_clear_task_is_blocked(p); + /* * If the owning (remote) CPU is still in the middle of schedule() with * this task as prev, considering queueing p on the remote CPUs wake_list @@ -6541,6 +6561,12 @@ static bool try_to_block_task(struct rq *rq, struct task_struct *p, return false; } + /* + * Task is considered fully blocked at this point and requires + * a wakeup to be runnable again including delayed task. + */ + sched_set_task_is_blocked(p); + /* * We check should_block after signal_pending because we * will want to wake the task in that case. But if @@ -6548,10 +6574,8 @@ static bool try_to_block_task(struct rq *rq, struct task_struct *p, * blocked on a mutex, and we want to keep it on the runqueue * to be selectable for proxy-execution. */ - if (!should_block) { - sched_set_task_is_blocked(p); + if (!should_block) return false; - } p->sched_contributes_to_load = (task_state & TASK_UNINTERRUPTIBLE) && @@ -6942,6 +6966,7 @@ find_proxy_task(struct rq *rq, struct task_struct *donor, struct rq_flags *rf) } #else /* SCHED_PROXY_EXEC */ static inline void sched_set_task_is_blocked(struct task_struct *p) {} +static inline void sched_clear_task_is_blocked(struct task_struct *p) {} static inline bool task_should_block(struct task_struct *p) { --- Attached is full diff as proxy.diff on top of tip:sched/core for convenience. I'll let Peter comment further if he likes this approach or not :-) -- Thanks and Regards, Prateek --------------4hJPLYDoWcQglx31oC4yQZP0 Content-Type: text/plain; charset="UTF-8"; name="proxy.diff" Content-Disposition: attachment; filename="proxy.diff" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc2NoZWQuaCBiL2luY2x1ZGUvbGludXgvc2No ZWQuaAppbmRleCA4ZWMzYjZkN2Q3MThiLi43YmU1ZTFmYWY1NmExIDEwMDY0NAotLS0gYS9p bmNsdWRlL2xpbnV4L3NjaGVkLmgKKysrIGIvaW5jbHVkZS9saW51eC9zY2hlZC5oCkBAIC04 NDYsNyArODQ2LDExIEBAIHN0cnVjdCB0YXNrX3N0cnVjdCB7CiAJc3RydWN0IGFsbG9jX3Rh ZwkJKmFsbG9jX3RhZzsKICNlbmRpZgogCi0JaW50CQkJCW9uX2NwdTsKKwl1OAkJCQlvbl9j cHU7CisJdTgJCQkJb25fcnE7CisJdTgJCQkJaXNfYmxvY2tlZDsKKwl1OAkJCQlfX3BhZDsK KwogCXN0cnVjdCBfX2NhbGxfc2luZ2xlX25vZGUJd2FrZV9lbnRyeTsKIAl1bnNpZ25lZCBp bnQJCQl3YWtlZV9mbGlwczsKIAl1bnNpZ25lZCBsb25nCQkJd2FrZWVfZmxpcF9kZWNheV90 czsKQEAgLTg2MSw3ICs4NjUsNiBAQCBzdHJ1Y3QgdGFza19zdHJ1Y3QgewogCSAqLwogCWlu dAkJCQlyZWNlbnRfdXNlZF9jcHU7CiAJaW50CQkJCXdha2VfY3B1OwotCWludAkJCQlvbl9y cTsKIAogCWludAkJCQlwcmlvOwogCWludAkJCQlzdGF0aWNfcHJpbzsKQEAgLTIxODEsMTkg KzIxODQsMTAgQEAgZXh0ZXJuIGludCBfX2NvbmRfcmVzY2hlZF9yd2xvY2tfd3JpdGUocnds b2NrX3QgKmxvY2spIF9fbXVzdF9ob2xkKGxvY2spOwogCiAjaWZuZGVmIENPTkZJR19QUkVF TVBUX1JUCiAKLS8qCi0gKiBXaXRoIHByb3h5IGV4ZWMsIGlmIGEgdGFzayBoYXMgYmVlbiBw cm94eS1taWdyYXRlZCwgaXQgbWF5IGJlIGEgZG9ub3IKLSAqIG9uIGEgY3B1IHRoYXQgaXQg Y2FuJ3QgYWN0dWFsbHkgcnVuIG9uLiBUaHVzIHdlIG5lZWQgYSBzcGVjaWFsIHN0YXRlCi0g KiB0byBkZW5vdGUgdGhhdCB0aGUgdGFzayBpcyBiZWluZyB3b2tlbiwgYnV0IHRoYXQgaXQg bmVlZHMgdG8gYmUKLSAqIGV2YWx1YXRlZCBmb3IgcmV0dXJuLW1pZ3JhdGlvbiBiZWZvcmUg aXQgaXMgcnVuLiBTbyBpZiB0aGUgdGFzayBpcwotICogYmxvY2tlZF9vbiBQUk9YWV9XQUtJ TkcsIHJldHVybiBtaWdyYXRlIGl0IGJlZm9yZSBydW5uaW5nIGl0LgotICovCi0jZGVmaW5l IFBST1hZX1dBS0lORyAoKHN0cnVjdCBtdXRleCAqKSgtMUwpKQotCiBzdGF0aWMgaW5saW5l IHN0cnVjdCBtdXRleCAqX19nZXRfdGFza19ibG9ja2VkX29uKHN0cnVjdCB0YXNrX3N0cnVj dCAqcCkKIHsKIAlsb2NrZGVwX2Fzc2VydF9oZWxkX29uY2UoJnAtPmJsb2NrZWRfbG9jayk7 Ci0JcmV0dXJuIHAtPmJsb2NrZWRfb24gPT0gUFJPWFlfV0FLSU5HID8gTlVMTCA6IHAtPmJs b2NrZWRfb247CisJcmV0dXJuIHAtPmJsb2NrZWRfb247CiB9CiAKIHN0YXRpYyBpbmxpbmUg dm9pZCBfX3NldF90YXNrX2Jsb2NrZWRfb24oc3RydWN0IHRhc2tfc3RydWN0ICpwLCBzdHJ1 Y3QgbXV0ZXggKm0pCkBAIC0yMjIxLDcgKzIyMTUsNyBAQCBzdGF0aWMgaW5saW5lIHZvaWQg X19jbGVhcl90YXNrX2Jsb2NrZWRfb24oc3RydWN0IHRhc2tfc3RydWN0ICpwLCBzdHJ1Y3Qg bXV0ZXggKgogCSAqIGJsb2NrZWRfb24gcmVsYXRpb25zaGlwcywgYnV0IG1ha2Ugc3VyZSB3 ZSBhcmUgbm90CiAJICogY2xlYXJpbmcgdGhlIHJlbGF0aW9uc2hpcCB3aXRoIGEgZGlmZmVy ZW50IGxvY2suCiAJICovCi0JV0FSTl9PTl9PTkNFKG0gJiYgcC0+YmxvY2tlZF9vbiAmJiBw LT5ibG9ja2VkX29uICE9IG0gJiYgcC0+YmxvY2tlZF9vbiAhPSBQUk9YWV9XQUtJTkcpOwor CVdBUk5fT05fT05DRShtICYmIHAtPmJsb2NrZWRfb24gJiYgcC0+YmxvY2tlZF9vbiAhPSBt KTsKIAlwLT5ibG9ja2VkX29uID0gTlVMTDsKIH0KIApAQCAtMjIzMSwzNCArMjIyNSw2IEBA IHN0YXRpYyBpbmxpbmUgdm9pZCBjbGVhcl90YXNrX2Jsb2NrZWRfb24oc3RydWN0IHRhc2tf c3RydWN0ICpwLCBzdHJ1Y3QgbXV0ZXggKm0pCiAJX19jbGVhcl90YXNrX2Jsb2NrZWRfb24o cCwgbSk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBfX3NldF90YXNrX2Jsb2NrZWRfb25f d2FraW5nKHN0cnVjdCB0YXNrX3N0cnVjdCAqcCwgc3RydWN0IG11dGV4ICptKQotewotCS8q IEN1cnJlbnRseSB3ZSBzZXJpYWxpemUgYmxvY2tlZF9vbiB1bmRlciB0aGUgdGFzazo6Ymxv Y2tlZF9sb2NrICovCi0JbG9ja2RlcF9hc3NlcnRfaGVsZF9vbmNlKCZwLT5ibG9ja2VkX2xv Y2spOwotCi0JaWYgKCFzY2hlZF9wcm94eV9leGVjKCkpIHsKLQkJX19jbGVhcl90YXNrX2Js b2NrZWRfb24ocCwgbSk7Ci0JCXJldHVybjsKLQl9Ci0KLQkvKiBEb24ndCBzZXQgUFJPWFlf V0FLSU5HIGlmIGJsb2NrZWRfb24gd2FzIGFscmVhZHkgY2xlYXJlZCAqLwotCWlmICghcC0+ YmxvY2tlZF9vbikKLQkJcmV0dXJuOwotCS8qCi0JICogVGhlcmUgbWF5IGJlIGNhc2VzIHdo ZXJlIHdlIHNldCBQUk9YWV9XQUtJTkcgb24gdGFza3MgdGhhdCB3ZXJlCi0JICogYWxyZWFk eSBzZXQgdG8gd2FraW5nLCBidXQgbWFrZSBzdXJlIHdlIGFyZSBub3QgY2hhbmdpbmcKLQkg KiB0aGUgcmVsYXRpb25zaGlwIHdpdGggYSBkaWZmZXJlbnQgbG9jay4KLQkgKi8KLQlXQVJO X09OX09OQ0UobSAmJiBwLT5ibG9ja2VkX29uICE9IG0gJiYgcC0+YmxvY2tlZF9vbiAhPSBQ Uk9YWV9XQUtJTkcpOwotCXAtPmJsb2NrZWRfb24gPSBQUk9YWV9XQUtJTkc7Ci19Ci0KLXN0 YXRpYyBpbmxpbmUgdm9pZCBzZXRfdGFza19ibG9ja2VkX29uX3dha2luZyhzdHJ1Y3QgdGFz a19zdHJ1Y3QgKnAsIHN0cnVjdCBtdXRleCAqbSkKLXsKLQlndWFyZChyYXdfc3BpbmxvY2tf aXJxc2F2ZSkoJnAtPmJsb2NrZWRfbG9jayk7Ci0JX19zZXRfdGFza19ibG9ja2VkX29uX3dh a2luZyhwLCBtKTsKLX0KLQogI2Vsc2UKIHN0YXRpYyBpbmxpbmUgdm9pZCBfX2NsZWFyX3Rh c2tfYmxvY2tlZF9vbihzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsIHN0cnVjdCBydF9tdXRleCAq bSkKIHsKQEAgLTIyNjcsMTQgKzIyMzMsNiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgX19jbGVh cl90YXNrX2Jsb2NrZWRfb24oc3RydWN0IHRhc2tfc3RydWN0ICpwLCBzdHJ1Y3QgcnRfbXV0 ZQogc3RhdGljIGlubGluZSB2b2lkIGNsZWFyX3Rhc2tfYmxvY2tlZF9vbihzdHJ1Y3QgdGFz a19zdHJ1Y3QgKnAsIHN0cnVjdCBydF9tdXRleCAqbSkKIHsKIH0KLQotc3RhdGljIGlubGlu ZSB2b2lkIF9fc2V0X3Rhc2tfYmxvY2tlZF9vbl93YWtpbmcoc3RydWN0IHRhc2tfc3RydWN0 ICpwLCBzdHJ1Y3QgcnRfbXV0ZXggKm0pCi17Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdm9pZCBz ZXRfdGFza19ibG9ja2VkX29uX3dha2luZyhzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsIHN0cnVj dCBydF9tdXRleCAqbSkKLXsKLX0KICNlbmRpZiAvKiAhQ09ORklHX1BSRUVNUFRfUlQgKi8K IAogc3RhdGljIF9fYWx3YXlzX2lubGluZSBib29sIG5lZWRfcmVzY2hlZCh2b2lkKQpkaWZm IC0tZ2l0IGEva2VybmVsL2xvY2tpbmcvbXV0ZXguYyBiL2tlcm5lbC9sb2NraW5nL211dGV4 LmMKaW5kZXggN2QzNTk2NDcxNTZkZi4uNGFhNzliY2FiMDhjNyAxMDA2NDQKLS0tIGEva2Vy bmVsL2xvY2tpbmcvbXV0ZXguYworKysgYi9rZXJuZWwvbG9ja2luZy9tdXRleC5jCkBAIC05 ODMsNyArOTgzLDcgQEAgc3RhdGljIG5vaW5saW5lIHZvaWQgX19zY2hlZCBfX211dGV4X3Vu bG9ja19zbG93cGF0aChzdHJ1Y3QgbXV0ZXggKmxvY2ssIHVuc2lnbmUKIAkJbmV4dCA9IHdh aXRlci0+dGFzazsKIAogCQlkZWJ1Z19tdXRleF93YWtlX3dhaXRlcihsb2NrLCB3YWl0ZXIp OwotCQlzZXRfdGFza19ibG9ja2VkX29uX3dha2luZyhuZXh0LCBsb2NrKTsKKwkJY2xlYXJf dGFza19ibG9ja2VkX29uKG5leHQsIGxvY2spOwogCQl3YWtlX3FfYWRkKCZ3YWtlX3EsIG5l eHQpOwogCX0KIApkaWZmIC0tZ2l0IGEva2VybmVsL2xvY2tpbmcvd3dfbXV0ZXguaCBiL2tl cm5lbC9sb2NraW5nL3d3X211dGV4LmgKaW5kZXggNWNkOWRmYTRiMzFlNi4uNTIyZmUwNDVl YjFiMiAxMDA2NDQKLS0tIGEva2VybmVsL2xvY2tpbmcvd3dfbXV0ZXguaAorKysgYi9rZXJu ZWwvbG9ja2luZy93d19tdXRleC5oCkBAIC0yODUsMTEgKzI4NSwxMSBAQCBfX3d3X211dGV4 X2RpZShzdHJ1Y3QgTVVURVggKmxvY2ssIHN0cnVjdCBNVVRFWF9XQUlURVIgKndhaXRlciwK IAkJZGVidWdfbXV0ZXhfd2FrZV93YWl0ZXIobG9jaywgd2FpdGVyKTsKICNlbmRpZgogCQkv KgotCQkgKiBXaGVuIHdha2luZyB1cCB0aGUgdGFzayB0byBkaWUsIGJlIHN1cmUgdG8gc2V0 IHRoZQotCQkgKiBibG9ja2VkX29uIHRvIFBST1hZX1dBS0lORy4gT3RoZXJ3aXNlIHdlIGNh biBzZWUKLQkJICogY2lyY3VsYXIgYmxvY2tlZF9vbiByZWxhdGlvbnNoaXBzIHRoYXQgY2Fu J3QgcmVzb2x2ZS4KKwkJICogV2hlbiB3YWtpbmcgdXAgdGhlIHRhc2sgdG8gZGllLCBiZSBz dXJlIHRvIGNsZWFyIHRoZQorCQkgKiBibG9ja2VkX29uLiBPdGhlcndpc2Ugd2UgY2FuIHNl ZSBjaXJjdWxhciBibG9ja2VkX29uCisJCSAqIHJlbGF0aW9uc2hpcHMgdGhhdCBjYW4ndCBy ZXNvbHZlLgogCQkgKi8KLQkJc2V0X3Rhc2tfYmxvY2tlZF9vbl93YWtpbmcod2FpdGVyLT50 YXNrLCBsb2NrKTsKKwkJY2xlYXJfdGFza19ibG9ja2VkX29uKHdhaXRlci0+dGFzaywgbG9j ayk7CiAJCXdha2VfcV9hZGQod2FrZV9xLCB3YWl0ZXItPnRhc2spOwogCX0KIApAQCAtMzQw LDE0ICszNDAsMTQgQEAgc3RhdGljIGJvb2wgX193d19tdXRleF93b3VuZChzdHJ1Y3QgTVVU RVggKmxvY2ssCiAJCWlmIChvd25lciAhPSBjdXJyZW50KSB7CiAJCQkvKgogCQkJICogV2hl biB3YWtpbmcgdXAgdGhlIHRhc2sgdG8gd291bmQsIGJlIHN1cmUgdG8gc2V0IHRoZQotCQkJ ICogYmxvY2tlZF9vbiB0byBQUk9YWV9XQUtJTkcuIE90aGVyd2lzZSB3ZSBjYW4gc2VlCi0J CQkgKiBjaXJjdWxhciBibG9ja2VkX29uIHJlbGF0aW9uc2hpcHMgdGhhdCBjYW4ndCByZXNv bHZlLgorCQkJICogY2xlYXIgYmxvY2tlZF9vbi4gT3RoZXJ3aXNlIHdlIGNhbiBzZWUgY2ly Y3VsYXIKKwkJCSAqIGJsb2NrZWRfb24gcmVsYXRpb25zaGlwcyB0aGF0IGNhbid0IHJlc29s dmUuCiAJCQkgKgogCQkJICogTk9URTogV2UgcGFzcyBOVUxMIGhlcmUgaW5zdGVhZCBvZiBs b2NrLCBiZWNhdXNlIHdlCiAJCQkgKiBhcmUgd2FraW5nIHRoZSBtdXRleCBvd25lciwgd2hv IG1heSBiZSBjdXJyZW50bHkKIAkJCSAqIGJsb2NrZWQgb24gYSBkaWZmZXJlbnQgbXV0ZXgu CiAJCQkgKi8KLQkJCXNldF90YXNrX2Jsb2NrZWRfb25fd2FraW5nKG93bmVyLCBOVUxMKTsK KwkJCWNsZWFyX3Rhc2tfYmxvY2tlZF9vbihvd25lciwgTlVMTCk7CiAJCQl3YWtlX3FfYWRk KHdha2VfcSwgb3duZXIpOwogCQl9CiAJCXJldHVybiB0cnVlOwpkaWZmIC0tZ2l0IGEva2Vy bmVsL3NjaGVkL2NvcmUuYyBiL2tlcm5lbC9zY2hlZC9jb3JlLmMKaW5kZXggNDljZDVkMjE3 MTYxMy4uZTg4ZjViN2EwMmIzZSAxMDA2NDQKLS0tIGEva2VybmVsL3NjaGVkL2NvcmUuYwor KysgYi9rZXJuZWwvc2NoZWQvY29yZS5jCkBAIC0zNjc1LDYgKzM2NzUsOCBAQCB0dHd1X2Rv X2FjdGl2YXRlKHN0cnVjdCBycSAqcnEsIHN0cnVjdCB0YXNrX3N0cnVjdCAqcCwgaW50IHdh a2VfZmxhZ3MsCiAJfQogfQogCitzdGF0aWMgaW5saW5lIHZvaWQgc2NoZWRfY2xlYXJfdGFz a19pc19ibG9ja2VkKHN0cnVjdCB0YXNrX3N0cnVjdCAqcCk7CisKIC8qCiAgKiBDb25zaWRl ciBAcCBiZWluZyBpbnNpZGUgYSB3YWl0IGxvb3A6CiAgKgpAQCAtMzcwOSw4ICszNzExLDE5 IEBAIHN0YXRpYyBpbnQgdHR3dV9ydW5uYWJsZShzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsIGlu dCB3YWtlX2ZsYWdzKQogCXJxID0gX190YXNrX3JxX2xvY2socCwgJnJmKTsKIAlpZiAodGFz a19vbl9ycV9xdWV1ZWQocCkpIHsKIAkJdXBkYXRlX3JxX2Nsb2NrKHJxKTsKLQkJaWYgKHAt PnNlLnNjaGVkX2RlbGF5ZWQpCisJCWlmIChwLT5zZS5zY2hlZF9kZWxheWVkKSB7CisJCQkv KgorCQkJICogVGFzayB3YXMgZnVsbHkgYmxvY2tlZCAobm90IHJldGFpbmVkIGFzIHByb3h5 KSBhbmQKKwkJCSAqIGlzIHJ1bm5hYmxlIGFnYWluLiBDbGVhciAiaXNfYmxvY2tlZCIgaW5k aWNhdG9yLgorCQkJICogRm9yIGFsbCBvdGVociBjYXNlcywgdGhlIHRhc2sgaGFzIGVpdGhl ciBub3Qgc2V0CisJCQkgKiAiaXNfYmxvY2tlZCIgc2luY2UgdHR3dV9ydW5uYWJsZSgpIHdv biBhZ2FpbnN0CisJCQkgKiBzY2hlZHVsZSgpLCBvciB0aGUgdGFzayB3YXMgcmV0YWluZWQg YXMgcHJveHkgYW5kCisJCQkgKiBleHBlY3RzIGZpbmRfcHJveHlfdGFzaygpIHRvIGhhbmRs ZSB0aGUgY2xlYXJpbmcgb2YKKwkJCSAqICJpc19ibG9ja2VkIiBzdGF0ZS4KKwkJCSAqLwor CQkJc2NoZWRfY2xlYXJfdGFza19pc19ibG9ja2VkKHApOwogCQkJZW5xdWV1ZV90YXNrKHJx LCBwLCBFTlFVRVVFX05PQ0xPQ0sgfCBFTlFVRVVFX0RFTEFZRUQpOworCQl9CiAJCWlmICgh dGFza19vbl9jcHUocnEsIHApKSB7CiAJCQkvKgogCQkJICogV2hlbiBvbl9ycSAmJiAhb25f Y3B1IHRoZSB0YXNrIGlzIHByZWVtcHRlZCwgc2VlIGlmCkBAIC00MTkwLDYgKzQyMDMsMTMg QEAgaW50IHRyeV90b193YWtlX3VwKHN0cnVjdCB0YXNrX3N0cnVjdCAqcCwgdW5zaWduZWQg aW50IHN0YXRlLCBpbnQgd2FrZV9mbGFncykKIAkJICovCiAJCVdSSVRFX09OQ0UocC0+X19z dGF0ZSwgVEFTS19XQUtJTkcpOwogCisJCS8qCisJCSAqIElmIHR0d3VfcnVubmFibGUoKSBk aWQgbm90IHdpbiwgdGFzayBpcyBmdWxseSBibG9ja2VkICghcC0+b25fcnEpIGFuZAorCQkg KiByZXF1aXJlcyBhIGZ1bGwgd2FrZXVwLiBDbGVhciB0YXNrX2lzX2Jsb2NrZWQoKSBiZWZv cmUgYXR0ZW1wdGluZworCQkgKiB0dHd1X3F1ZXVlX3dha2VsaXN0KCkuCisJCSAqLworCQlz Y2hlZF9jbGVhcl90YXNrX2lzX2Jsb2NrZWQocCk7CisKIAkJLyoKIAkJICogSWYgdGhlIG93 bmluZyAocmVtb3RlKSBDUFUgaXMgc3RpbGwgaW4gdGhlIG1pZGRsZSBvZiBzY2hlZHVsZSgp IHdpdGgKIAkJICogdGhpcyB0YXNrIGFzIHByZXYsIGNvbnNpZGVyaW5nIHF1ZXVlaW5nIHAg b24gdGhlIHJlbW90ZSBDUFVzIHdha2VfbGlzdApAQCAtNjQ5NSw2ICs2NTE1LDggQEAgcGlj a19uZXh0X3Rhc2soc3RydWN0IHJxICpycSwgc3RydWN0IHRhc2tfc3RydWN0ICpwcmV2LCBz dHJ1Y3QgcnFfZmxhZ3MgKnJmKQogCiAjZW5kaWYgLyogIUNPTkZJR19TQ0hFRF9DT1JFICov CiAKK3N0YXRpYyBpbmxpbmUgdm9pZCBzY2hlZF9zZXRfdGFza19pc19ibG9ja2VkKHN0cnVj dCB0YXNrX3N0cnVjdCAqcCk7CisKIC8qCiAgKiBDb25zdGFudHMgZm9yIHRoZSBzY2hlZF9t b2RlIGFyZ3VtZW50IG9mIF9fc2NoZWR1bGUoKS4KICAqCkBAIC02NTIzLDExICs2NTQ1LDI4 IEBAIHN0YXRpYyBib29sIHRyeV90b19ibG9ja190YXNrKHN0cnVjdCBycSAqcnEsIHN0cnVj dCB0YXNrX3N0cnVjdCAqcCwKIAlpZiAoc2lnbmFsX3BlbmRpbmdfc3RhdGUodGFza19zdGF0 ZSwgcCkpIHsKIAkJV1JJVEVfT05DRShwLT5fX3N0YXRlLCBUQVNLX1JVTk5JTkcpOwogCQkq dGFza19zdGF0ZV9wID0gVEFTS19SVU5OSU5HOwotCQlzZXRfdGFza19ibG9ja2VkX29uX3dh a2luZyhwLCBOVUxMKTsKKworCQkvKgorCQkgKiBDbGVhciBibG9ja2VkX29uIHJlbGF0aW9u IGlmIHdlIHdlcmUgcGxhbm5pbmcgdG8KKwkJICogcmV0YWluIHRoZSB0YXNrIGFzIHByb3h5 IGRvbm9yIHNpbmNlIGl0IGlzIHJ1bm5hYmxlCisJCSAqIGFnYWluIGFzIGEgcmVzdWx0IG9m IHBlbmRpbmcgc2lnbmFsLgorCQkgKgorCQkgKiBTaW5jZSBvbmx5IHRoZSBydW5uaW5nIHRh c2sgY2FuIHNldCB0aGUgYmxvY2tlZF9vbgorCQkgKiByZWxhdGlvbiBmb3IgaXRzZWxmLCBk byBub3QgdW5uZWNlc3NhcmlseSBncmFiIHRoZQorCQkgKiBibG9ja2VkX2xvY2sgaWYgYmxv Y2tlZF9vbiBpcyBub3Qgc2V0LgorCQkgKi8KKwkJaWYgKCFzaG91bGRfYmxvY2spCisJCQlj bGVhcl90YXNrX2Jsb2NrZWRfb24ocCwgTlVMTCk7CiAKIAkJcmV0dXJuIGZhbHNlOwogCX0K IAorCS8qCisJICogVGFzayBpcyBjb25zaWRlcmVkIGZ1bGx5IGJsb2NrZWQgYXQgdGhpcyBw b2ludCBhbmQgcmVxdWlyZXMKKwkgKiBhIHdha2V1cCB0byBiZSBydW5uYWJsZSBhZ2FpbiBp bmNsdWRpbmcgdGhlIGRlbGF5ZWQgdGFzay4KKwkgKi8KKwlzY2hlZF9zZXRfdGFza19pc19i bG9ja2VkKHApOworCiAJLyoKIAkgKiBXZSBjaGVjayBzaG91bGRfYmxvY2sgYWZ0ZXIgc2ln bmFsX3BlbmRpbmcgYmVjYXVzZSB3ZQogCSAqIHdpbGwgd2FudCB0byB3YWtlIHRoZSB0YXNr IGluIHRoYXQgY2FzZS4gQnV0IGlmCkBAIC02NTYyLDYgKzY2MDEsMjcgQEAgc3RhdGljIGJv b2wgdHJ5X3RvX2Jsb2NrX3Rhc2soc3RydWN0IHJxICpycSwgc3RydWN0IHRhc2tfc3RydWN0 ICpwLAogfQogCiAjaWZkZWYgQ09ORklHX1NDSEVEX1BST1hZX0VYRUMKK3N0YXRpYyBpbmxp bmUgdm9pZCBzY2hlZF9zZXRfdGFza19pc19ibG9ja2VkKHN0cnVjdCB0YXNrX3N0cnVjdCAq cCkKK3sKKwlpZiAoIXNjaGVkX3Byb3h5X2V4ZWMoKSkKKwkJcmV0dXJuOworCisJcC0+aXNf YmxvY2tlZCA9IDE7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBzY2hlZF9jbGVhcl90YXNr X2lzX2Jsb2NrZWQoc3RydWN0IHRhc2tfc3RydWN0ICpwKQoreworCXAtPmlzX2Jsb2NrZWQg PSAwOworfQorCitzdGF0aWMgaW5saW5lIGJvb2wgdGFza19zaG91bGRfYmxvY2soc3RydWN0 IHRhc2tfc3RydWN0ICpwKQoreworCWlmICghc2NoZWRfcHJveHlfZXhlYygpKQorCQlyZXR1 cm4gdHJ1ZTsKKworCXJldHVybiAhcC0+YmxvY2tlZF9vbjsKK30KKwogc3RhdGljIGlubGlu ZSB2b2lkIHByb3h5X3NldF90YXNrX2NwdShzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsIGludCBj cHUpCiB7CiAJdW5zaWduZWQgaW50IHdha2VfY3B1OwpAQCAtNjYwMiw2ICs2NjYyLDcgQEAg c3RhdGljIGJvb2wgcHJveHlfZGVhY3RpdmF0ZShzdHJ1Y3QgcnEgKnJxLCBzdHJ1Y3QgdGFz a19zdHJ1Y3QgKmRvbm9yKQogCSAqIG5lZWQgdG8gYmUgY2hhbmdlZCBmcm9tIG5leHQgKmJl Zm9yZSogd2UgZGVhY3RpdmF0ZS4KIAkgKi8KIAlwcm94eV9yZXNjaGVkX2lkbGUocnEpOwor CXNjaGVkX2NsZWFyX3Rhc2tfaXNfYmxvY2tlZChkb25vcik7CiAJcmV0dXJuIHRyeV90b19i bG9ja190YXNrKHJxLCBkb25vciwgJnN0YXRlLCB0cnVlKTsKIH0KIApAQCAtNjczMiw3ICs2 NzkzLDcgQEAgc3RhdGljIHZvaWQgcHJveHlfZm9yY2VfcmV0dXJuKHN0cnVjdCBycSAqcnEs IHN0cnVjdCBycV9mbGFncyAqcmYsCiAJCWNwdSA9IHNlbGVjdF90YXNrX3JxKHAsIHAtPndh a2VfY3B1LCAmd2FrZV9mbGFnKTsKIAkJc2V0X3Rhc2tfY3B1KHAsIGNwdSk7CiAJCXRhcmdl dF9ycSA9IGNwdV9ycShjcHUpOwotCQljbGVhcl90YXNrX2Jsb2NrZWRfb24ocCwgTlVMTCk7 CisJCXNjaGVkX2NsZWFyX3Rhc2tfaXNfYmxvY2tlZChwKTsKIAl9CiAKIAlpZiAodGFyZ2V0 X3JxKQpAQCAtNjc2NSwxNSArNjgyNiwxNiBAQCBmaW5kX3Byb3h5X3Rhc2soc3RydWN0IHJx ICpycSwgc3RydWN0IHRhc2tfc3RydWN0ICpkb25vciwgc3RydWN0IHJxX2ZsYWdzICpyZikK IAlib29sIGN1cnJfaW5fY2hhaW4gPSBmYWxzZTsKIAlpbnQgdGhpc19jcHUgPSBjcHVfb2Yo cnEpOwogCXN0cnVjdCB0YXNrX3N0cnVjdCAqcDsKLQlzdHJ1Y3QgbXV0ZXggKm11dGV4Owog CWludCBvd25lcl9jcHU7CiAKIAkvKiBGb2xsb3cgYmxvY2tlZF9vbiBjaGFpbi4gKi8KLQlm b3IgKHAgPSBkb25vcjsgKG11dGV4ID0gcC0+YmxvY2tlZF9vbik7IHAgPSBvd25lcikgewot CQkvKiBpZiBpdHMgUFJPWFlfV0FLSU5HLCBkbyByZXR1cm4gbWlncmF0aW9uIG9yIHJ1biBp ZiBjdXJyZW50ICovCi0JCWlmIChtdXRleCA9PSBQUk9YWV9XQUtJTkcpIHsKKwlmb3IgKHAg PSBkb25vcjsgdGFza19pc19ibG9ja2VkKHApOyBwID0gb3duZXIpIHsKKwkJc3RydWN0IG11 dGV4ICptdXRleCA9IHAtPmJsb2NrZWRfb247CisKKwkJLyogSWYgdGFzayBpcyBubyBsb25n ZXIgYmxvY2tlZCwgZG8gcmV0dXJuIG1pZ3JhdGlvbiBvciBydW4gaWYgY3VycmVudCAqLwor CQlpZiAoIW11dGV4KSB7CiAJCQlpZiAodGFza19jdXJyZW50KHJxLCBwKSkgewotCQkJCWNs ZWFyX3Rhc2tfYmxvY2tlZF9vbihwLCBQUk9YWV9XQUtJTkcpOworCQkJCXNjaGVkX2NsZWFy X3Rhc2tfaXNfYmxvY2tlZChwKTsKIAkJCQlyZXR1cm4gcDsKIAkJCX0KIAkJCWdvdG8gZm9y Y2VfcmV0dXJuOwpAQCAtNjgwNyw4ICs2ODY5LDkgQEAgZmluZF9wcm94eV90YXNrKHN0cnVj dCBycSAqcnEsIHN0cnVjdCB0YXNrX3N0cnVjdCAqZG9ub3IsIHN0cnVjdCBycV9mbGFncyAq cmYpCiAJCQkgKiBhbmQgcmV0dXJuIHAgKGlmIGl0IGlzIGN1cnJlbnQgYW5kIHNhZmUgdG8K IAkJCSAqIGp1c3QgcnVuIG9uIHRoaXMgcnEpLCBvciByZXR1cm4tbWlncmF0ZSB0aGUgdGFz ay4KIAkJCSAqLworCQkJX19jbGVhcl90YXNrX2Jsb2NrZWRfb24ocCwgbXV0ZXgpOwogCQkJ aWYgKHRhc2tfY3VycmVudChycSwgcCkpIHsKLQkJCQlfX2NsZWFyX3Rhc2tfYmxvY2tlZF9v bihwLCBOVUxMKTsKKwkJCQlzY2hlZF9jbGVhcl90YXNrX2lzX2Jsb2NrZWQocCk7CiAJCQkJ cmV0dXJuIHA7CiAJCQl9CiAJCQlnb3RvIGZvcmNlX3JldHVybjsKQEAgLTY5MDIsNiArNjk2 NSwxNCBAQCBmaW5kX3Byb3h5X3Rhc2soc3RydWN0IHJxICpycSwgc3RydWN0IHRhc2tfc3Ry dWN0ICpkb25vciwgc3RydWN0IHJxX2ZsYWdzICpyZikKIAlyZXR1cm4gTlVMTDsKIH0KICNl bHNlIC8qIFNDSEVEX1BST1hZX0VYRUMgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZCBzY2hlZF9z ZXRfdGFza19pc19ibG9ja2VkKHN0cnVjdCB0YXNrX3N0cnVjdCAqcCkge30KK3N0YXRpYyBp bmxpbmUgdm9pZCBzY2hlZF9jbGVhcl90YXNrX2lzX2Jsb2NrZWQoc3RydWN0IHRhc2tfc3Ry dWN0ICpwKSB7fQorCitzdGF0aWMgaW5saW5lIGJvb2wgdGFza19zaG91bGRfYmxvY2soc3Ry dWN0IHRhc2tfc3RydWN0ICpwKQoreworCXJldHVybiB0cnVlOworfQorCiBzdGF0aWMgc3Ry dWN0IHRhc2tfc3RydWN0ICoKIGZpbmRfcHJveHlfdGFzayhzdHJ1Y3QgcnEgKnJxLCBzdHJ1 Y3QgdGFza19zdHJ1Y3QgKmRvbm9yLCBzdHJ1Y3QgcnFfZmxhZ3MgKnJmKQogewpAQCAtNzAy NiwxMyArNzA5NywxMyBAQCBzdGF0aWMgdm9pZCBfX3NjaGVkIG5vdHJhY2UgX19zY2hlZHVs ZShpbnQgc2NoZWRfbW9kZSkKIAkJfQogCX0gZWxzZSBpZiAoIXByZWVtcHQgJiYgcHJldl9z dGF0ZSkgewogCQkvKgotCQkgKiBXZSBwYXNzIHRhc2tfaXNfYmxvY2tlZCgpIGFzIHRoZSBz aG91bGRfYmxvY2sgYXJnCisJCSAqIFdlIHBhc3MgdGFza19zaG91bGRfYmxvY2soKSBhcyB0 aGUgc2hvdWxkX2Jsb2NrIGFyZwogCQkgKiBpbiBvcmRlciB0byBrZWVwIG11dGV4LWJsb2Nr ZWQgdGFza3Mgb24gdGhlIHJ1bnF1ZXVlCiAJCSAqIGZvciBzbGVjdGlvbiB3aXRoIHByb3h5 LWV4ZWMgKHdpdGhvdXQgcHJveHktZXhlYwotCQkgKiB0YXNrX2lzX2Jsb2NrZWQoKSB3aWxs IGFsd2F5cyBiZSBmYWxzZSkuCisJCSAqIHRhc2tfc2hvdWxkX2Jsb2NrKCkgd2lsbCBhbHdh eXMgYmUgdHJ1ZSkuCiAJCSAqLwogCQl0cnlfdG9fYmxvY2tfdGFzayhycSwgcHJldiwgJnBy ZXZfc3RhdGUsCi0JCQkJICAhdGFza19pc19ibG9ja2VkKHByZXYpKTsKKwkJCQkgIHRhc2tf c2hvdWxkX2Jsb2NrKHByZXYpKTsKIAkJc3dpdGNoX2NvdW50ID0gJnByZXYtPm52Y3N3Owog CX0KIApAQCAtNzA0NCw3ICs3MTE1LDcgQEAgc3RhdGljIHZvaWQgX19zY2hlZCBub3RyYWNl IF9fc2NoZWR1bGUoaW50IHNjaGVkX21vZGUpCiAJCXN0cnVjdCB0YXNrX3N0cnVjdCAqcHJl dl9kb25vciA9IHJxLT5kb25vcjsKIAogCQlycV9zZXRfZG9ub3IocnEsIG5leHQpOwotCQlp ZiAodW5saWtlbHkobmV4dC0+YmxvY2tlZF9vbikpIHsKKwkJaWYgKHVubGlrZWx5KHRhc2tf aXNfYmxvY2tlZChuZXh0KSkpIHsKIAkJCW5leHQgPSBmaW5kX3Byb3h5X3Rhc2socnEsIG5l eHQsICZyZik7CiAJCQlpZiAoIW5leHQpIHsKIAkJCQl6YXBfYmFsYW5jZV9jYWxsYmFja3Mo cnEpOwpkaWZmIC0tZ2l0IGEva2VybmVsL3NjaGVkL3NjaGVkLmggYi9rZXJuZWwvc2NoZWQv c2NoZWQuaAppbmRleCBjOTU1ODQxOTFkNThmLi41YzEwODVmMjYwYWQ0IDEwMDY0NAotLS0g YS9rZXJuZWwvc2NoZWQvc2NoZWQuaAorKysgYi9rZXJuZWwvc2NoZWQvc2NoZWQuaApAQCAt MjM5MCw3ICsyMzkwLDcgQEAgc3RhdGljIGlubGluZSBib29sIHRhc2tfaXNfYmxvY2tlZChz dHJ1Y3QgdGFza19zdHJ1Y3QgKnApCiAJaWYgKCFzY2hlZF9wcm94eV9leGVjKCkpCiAJCXJl dHVybiBmYWxzZTsKIAotCXJldHVybiAhIXAtPmJsb2NrZWRfb247CisJcmV0dXJuICEhcC0+ aXNfYmxvY2tlZDsKIH0KIAogc3RhdGljIGlubGluZSBpbnQgdGFza19vbl9jcHUoc3RydWN0 IHJxICpycSwgc3RydWN0IHRhc2tfc3RydWN0ICpwKQo= --------------4hJPLYDoWcQglx31oC4yQZP0--