Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1ueOSi-009KXC-IW for pgsql-hackers@arkaria.postgresql.org; Wed, 23 Jul 2025 01:40:05 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.94.2) (envelope-from ) id 1ueOSh-00GvLG-MN for pgsql-hackers@arkaria.postgresql.org; Wed, 23 Jul 2025 01:40:03 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1ueOSh-00GvKw-21 for pgsql-hackers@lists.postgresql.org; Wed, 23 Jul 2025 01:40:03 +0000 Received: from fout-b3-smtp.messagingengine.com ([202.12.124.146]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1ueOSd-000KWz-1Q for pgsql-hackers@postgresql.org; Wed, 23 Jul 2025 01:40:03 +0000 Received: from phl-compute-04.internal (phl-compute-04.phl.internal [10.202.2.44]) by mailfout.stl.internal (Postfix) with ESMTP id D18D41D000D8; Tue, 22 Jul 2025 21:39:57 -0400 (EDT) Received: from phl-imap-03 ([10.202.2.93]) by phl-compute-04.internal (MEProxy); Tue, 22 Jul 2025 21:39:57 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=compiler.org; h= cc:cc:content-type:content-type:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:subject :subject:to:to; s=fm2; t=1753234797; x=1753321197; bh=bhPbUIGEAR 9CUWgwtzITD2v7+JpKZdQlm1SO6IZdbbs=; b=Hd77rEqFRKkzTIrSe+TgZ1DPFG Xl1dL93JqwhZDrTJTezWuV5JaXXSfHsZMn/x+72BxJvF7WV8AQAP/1/wVtBiKSxt 6IMgT97AMLk9L3WFTMQZPMRsyifeeu4Z9mHf66d0s1UsHJY4zHLpOvGUDW6WcDaC SNPc4X8zJjC6KdTusUBibYoQUTyovx3MIiCIHdSXNFRrOjk4Yg+aCZbgJ5emlNsS YIqjLHn2Pow75NMieR4ftTq6daKj8UwBWg+H9V1wrel/CJGwRL/xLfSoyfcLCKDZ uoGXL6YQ9pqIwsfbrQxu+r7+SaWGvP6Qn7PFCH6YHJBFnfKT8lvsVEaI3/Vw== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-type:content-type:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:subject:subject:to :to:x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s=fm2; t= 1753234797; x=1753321197; bh=bhPbUIGEAR9CUWgwtzITD2v7+JpKZdQlm1S O6IZdbbs=; b=GP4Cpg0QoW2oq/VEeOIwzpR25ZRYuc6ybMKDUQ6kW471u/dyDiq lFbqiCVeO4OxckxqzCACSHF8CZEIEDDDtmzQZb0x4ECdzLNiuj+i4mlWntmaoOGk ogcpFFLyMWG4fOwrBUi/YDcXEGIzPP7Nrj4HeG6pWwCxYe+lzFyCmqQtXHcDtD9X TR7qZztwQjwjJanHorvUI6RMAVK2CsiMDOxQQP17slcHrvMORRvOJEyfamTCBtU6 Tmt6A6NKUDDQNTbnMzJtt/wxnN/Dq5PSwGXQfktesSs8g0wP0UtY1PXcpnSma1V6 4LBGH0W/2KB6Fo9JOIGoerk4KbqfhRsT8NA== X-ME-Sender: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeeffedrtdefgdejieegkecutefuodetggdotefrod ftvfcurfhrohhfihhlvgemucfhrghsthforghilhdpuffrtefokffrpgfnqfghnecuuegr ihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenucfjug hrpefoggffhffvvefkjghfufgtsehmtderreertddtnecuhfhrohhmpedflfhovghlucfl rggtohgsshhonhdfuceojhhovghlsegtohhmphhilhgvrhdrohhrgheqnecuggftrfgrth htvghrnhepfefhueffveefudffkeektdetvddvtdevtdfhueduueejjeejgeekjeffjedu udegnecuffhomhgrihhnpehpohhsthhgrhgvshhqlhdrohhrghenucevlhhushhtvghruf hiiigvpedtnecurfgrrhgrmhepmhgrihhlfhhrohhmpehjohgvlhestghomhhpihhlvghr rdhorhhgpdhnsggprhgtphhtthhopeegpdhmohguvgepshhmthhpohhuthdprhgtphhtth hopehrihhshhhurdhpohhsthhgrhgvshesghhmrghilhdrtghomhdprhgtphhtthhopeht hhhomhgrshdrmhhunhhrohesghhmrghilhdrtghomhdprhgtphhtthhopehhlhhinhhnrg hkrgesihhkihdrfhhipdhrtghpthhtohepphhgshhqlhdqhhgrtghkvghrshesphhoshht ghhrvghsqhhlrdhorhhg X-ME-Proxy: Feedback-ID: ic6394509:Fastmail Received: by mailuser.phl.internal (Postfix, from userid 501) id 1E3B418E0063; Tue, 22 Jul 2025 21:39:57 -0400 (EDT) X-Mailer: MessagingEngine.com Webmail Interface MIME-Version: 1.0 X-ThreadId: T90889ce1c5a9472e Date: Wed, 23 Jul 2025 03:39:30 +0200 From: "Joel Jacobson" To: pgsql-hackers Cc: "Thomas Munro" , "Heikki Linnakangas" , "Rishu Bagga" Message-Id: <30c2aa7d-dd6c-4b68-a2e4-f217a1a34acf@app.fastmail.com> In-Reply-To: <96f00bf1-cc9d-4520-9d02-9e14e7767c88@app.fastmail.com> References: <6899c044-4a82-49be-8117-e6f669765f7e@app.fastmail.com> <165530.1752362320@sss.pgh.pa.us> <02a7cd37-e2fc-4212-8b19-f8c239c95fb8@app.fastmail.com> <96f00bf1-cc9d-4520-9d02-9e14e7767c88@app.fastmail.com> Subject: Re: Optimize LISTEN/NOTIFY Content-Type: multipart/mixed; boundary=0a829c0ef42747ee8d39e51fe8b6dfc1 List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --0a829c0ef42747ee8d39e51fe8b6dfc1 Content-Type: text/plain Content-Transfer-Encoding: 7bit On Thu, Jul 17, 2025, at 09:43, Joel Jacobson wrote: > On Wed, Jul 16, 2025, at 02:20, Rishu Bagga wrote: >> If we are doing this optimization, why not maintain a list of backends >> for each channel, and only wake up those channels? > > Thanks for a contributing a great idea, it actually turned out to work > really well in practice! > > The attached new v4 of the patch implements your multicast idea: Hi hackers, While my previous attempts of $subject has only focused on optimizing the multi-channel scenario, I thought it would be really nice if LISTEN/NOTIFY could be optimize in the general case, benefiting all users, including those who just listen on a single channel. To my surprise, this was not only possible, but actually quite simple. The main idea in this patch, is to introduce an atomic state machine, with three states, IDLE, SIGNALLED, and PROCESSED, so that we don't interrupt backends that are already in the process of catching up. Thanks to Thomas Munro for making me aware of his, Heikki Linnakanga's and others work in the "Interrupts vs signals" [1] thread. Maybe my patch is redundant due to their patch set, I'm not really sure? Their patch seems to refactors the underlying wakeup mechanism. It replaces the old, complex chain of events (SIGUSR1 signal -> handler -> flag -> latch) with a single, direct function call: SendInterrupt(). For async.c, this seems to be a low-level plumbing change that simplifies how a notification wakeup is delivered. My patch optimizes the high-level notification protocol. It introduces a state machine (IDLE, SIGNALLED, PROCESSING) to only signal backends when needed. In their patch, in asyn.c's SignalBackends(), they do SendInterrupt(INTERRUPT_ASYNC_NOTIFY, procno) instead of SendProcSignal(pid, PROCSIG_NOTIFY_INTERRUPT, procnos[i]). They don't seem to check if the backend is already signalled or not, but maybe SendInterrupt() has signal coalescing built-in so it would be a noop with almost no cost? I'm happy to rebase my LISTEN/NOTIFY work on top of [1], but I could also see benefits of doing the opposite. I'm also happy to help with benchmarking of your work in [1]. Note that this patch doesn't contain the hash table to keep track of listeners per backend, as proposed in earlier patches. I will propose such a patch again later, but first we need to figure out if I should rebase onto [1] or master (HEAD). --- PATCH --- Optimize NOTIFY signaling to avoid redundant backend signals Previously, a NOTIFY would send SIGUSR1 to all listening backends, which could lead to a "thundering herd" of redundant signals under high traffic. To address this inefficiency, this patch replaces the simple volatile notifyInterruptPending flag with a per-backend atomic state machine, stored in asyncQueueControl->backend[i].state. This state variable can be in one of three states: IDLE (awaiting signal), SIGNALLED (signal received, work pending), or PROCESSING (actively reading the queue). From the notifier's perspective, SignalBackends now uses an atomic compare-and-swap (CAS) to transition a listener from IDLE to SIGNALLED. Only on a successful transition is a signal sent. If the listener is already SIGNALLED or another notifier wins the race, no redundant signal is sent. If the listener is in the PROCESSING state, the notifier will also transition it to SIGNALLED to ensure the listener re-scans the queue after its current work is done. On the listener side, ProcessIncomingNotify first transitions its state from SIGNALLED to PROCESSING. After reading notifications, it attempts to transition from PROCESSING back to IDLE. If this CAS fails, it means a new notification arrived during processing and a notifier has already set the state back to SIGNALLED. The listener then simply re-latches itself to process the new notifications, avoiding a tight loop. The primary benefit is a significant reduction in syscall overhead and unnecessary kernel wakeups in high-traffic scenarios. This dramatically improves performance for workloads with many concurrent notifiers. Benchmarks show a substantial increase in NOTIFY-only transaction throughput, with gains exceeding 200% at higher concurrency levels. src/backend/commands/async.c | 209 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----------------------------- src/backend/tcop/postgres.c | 4 ++-- src/include/commands/async.h | 4 +++- 3 files changed, 185 insertions(+), 32 deletions(-) --- BENCHMARK --- The attached benchmark script does LISTEN on one connection, and then uses pgbench to send NOTIFY on a varying number of connections and jobs, to cause a high procsignal load. I've run the benchmark on my MacBook Pro M3 Max, 10 seconds per run, 3 runs. (I reused the same benchmark script as in the other thread, "Optimize ProcSignal to avoid redundant SIGUSR1 signals") Connections=Jobs | TPS (master) | TPS (patch) | Relative Diff (%) | StdDev (master) | StdDev (patch) ------------------+--------------+-------------+-------------------+-----------------+---------------- 1 | 118833 | 151510 | 27.50% | 484 | 923 2 | 156005 | 239051 | 53.23% | 3145 | 1596 4 | 177351 | 250910 | 41.48% | 4305 | 4891 8 | 116597 | 171944 | 47.47% | 1549 | 2752 16 | 40835 | 165482 | 305.25% | 2695 | 2825 32 | 37940 | 145150 | 282.58% | 2533 | 1566 64 | 35495 | 131836 | 271.42% | 1837 | 573 128 | 40193 | 121333 | 201.88% | 2254 | 874 (8 rows) /Joel https://www.postgresql.org/message-id/flat/CA%2BhUKG%2B3MkS21yK4jL4cgZywdnnGKiBg0jatoV6kzaniBmcqbQ%40mail.gmail.com --0a829c0ef42747ee8d39e51fe8b6dfc1 Content-Disposition: attachment; filename*0="0001-Optimize-NOTIFY-signaling-to-avoid-redundant-backend.pat"; filename*1="ch" Content-Type: application/octet-stream; name="=?UTF-8?Q?0001-Optimize-NOTIFY-signaling-to-avoid-redundant-backend.patc?= =?UTF-8?Q?h?=" Content-Transfer-Encoding: base64 RnJvbSBkNGYwMWNkYThiY2Q0MDQyZjBkNzUxZDczZTEzYjU2MWQ4YjFlYWFiIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBKb2VsIEphY29ic29uIDxqb2VsQGNvbXBpbGVyLm9y Zz4KRGF0ZTogVHVlLCAyMiBKdWwgMjAyNSAxMDozMjozNCArMDIwMApTdWJqZWN0OiBbUEFU Q0hdIE9wdGltaXplIE5PVElGWSBzaWduYWxpbmcgdG8gYXZvaWQgcmVkdW5kYW50IGJhY2tl bmQgc2lnbmFscwoKUHJldmlvdXNseSwgYSBOT1RJRlkgd291bGQgc2VuZCBTSUdVU1IxIHRv IGFsbCBsaXN0ZW5pbmcgYmFja2VuZHMsIHdoaWNoCmNvdWxkIGxlYWQgdG8gYSAidGh1bmRl cmluZyBoZXJkIiBvZiByZWR1bmRhbnQgc2lnbmFscyB1bmRlciBoaWdoCnRyYWZmaWMuIFRv IGFkZHJlc3MgdGhpcyBpbmVmZmljaWVuY3ksIHRoaXMgcGF0Y2ggcmVwbGFjZXMgdGhlIHNp bXBsZQp2b2xhdGlsZSBub3RpZnlJbnRlcnJ1cHRQZW5kaW5nIGZsYWcgd2l0aCBhIHBlci1i YWNrZW5kIGF0b21pYyBzdGF0ZQptYWNoaW5lLCBzdG9yZWQgaW4gYXN5bmNRdWV1ZUNvbnRy b2wtPmJhY2tlbmRbaV0uc3RhdGUuIFRoaXMgc3RhdGUKdmFyaWFibGUgY2FuIGJlIGluIG9u ZSBvZiB0aHJlZSBzdGF0ZXM6IElETEUgKGF3YWl0aW5nIHNpZ25hbCksClNJR05BTExFRCAo c2lnbmFsIHJlY2VpdmVkLCB3b3JrIHBlbmRpbmcpLCBvciBQUk9DRVNTSU5HIChhY3RpdmVs eQpyZWFkaW5nIHRoZSBxdWV1ZSkuCgpGcm9tIHRoZSBub3RpZmllcidzIHBlcnNwZWN0aXZl LCBTaWduYWxCYWNrZW5kcyBub3cgdXNlcyBhbiBhdG9taWMKY29tcGFyZS1hbmQtc3dhcCAo Q0FTKSB0byB0cmFuc2l0aW9uIGEgbGlzdGVuZXIgZnJvbSBJRExFIHRvIFNJR05BTExFRC4K T25seSBvbiBhIHN1Y2Nlc3NmdWwgdHJhbnNpdGlvbiBpcyBhIHNpZ25hbCBzZW50LiBJZiB0 aGUgbGlzdGVuZXIgaXMKYWxyZWFkeSBTSUdOQUxMRUQgb3IgYW5vdGhlciBub3RpZmllciB3 aW5zIHRoZSByYWNlLCBubyByZWR1bmRhbnQgc2lnbmFsCmlzIHNlbnQuIElmIHRoZSBsaXN0 ZW5lciBpcyBpbiB0aGUgUFJPQ0VTU0lORyBzdGF0ZSwgdGhlIG5vdGlmaWVyIHdpbGwKYWxz byB0cmFuc2l0aW9uIGl0IHRvIFNJR05BTExFRCB0byBlbnN1cmUgdGhlIGxpc3RlbmVyIHJl LXNjYW5zIHRoZQpxdWV1ZSBhZnRlciBpdHMgY3VycmVudCB3b3JrIGlzIGRvbmUuCgpPbiB0 aGUgbGlzdGVuZXIgc2lkZSwgUHJvY2Vzc0luY29taW5nTm90aWZ5IGZpcnN0IHRyYW5zaXRp b25zIGl0cyBzdGF0ZQpmcm9tIFNJR05BTExFRCB0byBQUk9DRVNTSU5HLiBBZnRlciByZWFk aW5nIG5vdGlmaWNhdGlvbnMsIGl0IGF0dGVtcHRzCnRvIHRyYW5zaXRpb24gZnJvbSBQUk9D RVNTSU5HIGJhY2sgdG8gSURMRS4gSWYgdGhpcyBDQVMgZmFpbHMsIGl0IG1lYW5zCmEgbmV3 IG5vdGlmaWNhdGlvbiBhcnJpdmVkIGR1cmluZyBwcm9jZXNzaW5nIGFuZCBhIG5vdGlmaWVy IGhhcyBhbHJlYWR5CnNldCB0aGUgc3RhdGUgYmFjayB0byBTSUdOQUxMRUQuIFRoZSBsaXN0 ZW5lciB0aGVuIHNpbXBseSByZS1sYXRjaGVzCml0c2VsZiB0byBwcm9jZXNzIHRoZSBuZXcg bm90aWZpY2F0aW9ucywgYXZvaWRpbmcgYSB0aWdodCBsb29wLgoKVGhlIHByaW1hcnkgYmVu ZWZpdCBpcyBhIHNpZ25pZmljYW50IHJlZHVjdGlvbiBpbiBzeXNjYWxsIG92ZXJoZWFkIGFu ZAp1bm5lY2Vzc2FyeSBrZXJuZWwgd2FrZXVwcyBpbiBoaWdoLXRyYWZmaWMgc2NlbmFyaW9z LiBUaGlzIGRyYW1hdGljYWxseQppbXByb3ZlcyBwZXJmb3JtYW5jZSBmb3Igd29ya2xvYWRz IHdpdGggbWFueSBjb25jdXJyZW50IG5vdGlmaWVycy4KQmVuY2htYXJrcyBzaG93IGEgc3Vi c3RhbnRpYWwgaW5jcmVhc2UgaW4gTk9USUZZLW9ubHkgdHJhbnNhY3Rpb24KdGhyb3VnaHB1 dCwgd2l0aCBnYWlucyBleGNlZWRpbmcgMjAwJSBhdCBoaWdoZXIKY29uY3VycmVuY3kgbGV2 ZWxzLgotLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL2FzeW5jLmMgfCAyMDkgKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrLS0tLS0KIHNyYy9iYWNrZW5kL3Rjb3AvcG9zdGdyZXMu YyAgfCAgIDQgKy0KIHNyYy9pbmNsdWRlL2NvbW1hbmRzL2FzeW5jLmggfCAgIDQgKy0KIDMg ZmlsZXMgY2hhbmdlZCwgMTg1IGluc2VydGlvbnMoKyksIDMyIGRlbGV0aW9ucygtKQoKZGlm ZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2FzeW5jLmMgYi9zcmMvYmFja2VuZC9j b21tYW5kcy9hc3luYy5jCmluZGV4IDRiZDM3ZDViZWI1Li5hZTIwMDE3YWY5YiAxMDA2NDQK LS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvYXN5bmMuYworKysgYi9zcmMvYmFja2VuZC9j b21tYW5kcy9hc3luYy5jCkBAIC0xNTAsOCArMTUwLDE5IEBACiAjaW5jbHVkZSAidXRpbHMv cHNfc3RhdHVzLmgiCiAjaW5jbHVkZSAidXRpbHMvc25hcG1nci5oIgogI2luY2x1ZGUgInV0 aWxzL3RpbWVzdGFtcC5oIgorI2luY2x1ZGUgInBvcnQvYXRvbWljcy5oIgogCiAKKy8qCisg KiBBc3luYyBub3RpZmljYXRpb24gc3RhdGUgbWFjaGluZSBzdGF0ZXMKKyAqLwordHlwZWRl ZiBlbnVtIEFzeW5jTGlzdGVuZXJTdGF0ZQoreworCUFTWU5DX1NUQVRFX0lETEUgPSAwLAkJ LyogQmFja2VuZCBpcyBpZGxlLCB3YWl0aW5nIGZvciBzaWduYWwgKi8KKwlBU1lOQ19TVEFU RV9TSUdOQUxMRUQgPSAxLAkvKiBCYWNrZW5kIGhhcyBiZWVuIHNpZ25hbGVkLCB3aWxsIHBy b2Nlc3Mgc29vbiAqLworCUFTWU5DX1NUQVRFX1BST0NFU1NJTkcgPSAyCS8qIEJhY2tlbmQg aXMgYWN0aXZlbHkgcHJvY2Vzc2luZyBub3RpZmljYXRpb25zICovCit9IEFzeW5jTGlzdGVu ZXJTdGF0ZTsKKwogLyoKICAqIE1heGltdW0gc2l6ZSBvZiBhIE5PVElGWSBwYXlsb2FkLCBp bmNsdWRpbmcgdGVybWluYXRpbmcgTlVMTC4gIFRoaXMKICAqIG11c3QgYmUga2VwdCBzbWFs bCBlbm91Z2ggc28gdGhhdCBhIG5vdGlmaWNhdGlvbiBtZXNzYWdlIGZpdHMgb24gb25lCkBA IC0yNDYsNiArMjU3LDcgQEAgdHlwZWRlZiBzdHJ1Y3QgUXVldWVCYWNrZW5kU3RhdHVzCiAJ T2lkCQkJZGJvaWQ7CQkJLyogYmFja2VuZCdzIGRhdGFiYXNlIE9JRCwgb3IgSW52YWxpZE9p ZCAqLwogCVByb2NOdW1iZXIJbmV4dExpc3RlbmVyOwkvKiBpZCBvZiBuZXh0IGxpc3RlbmVy LCBvciBJTlZBTElEX1BST0NfTlVNQkVSICovCiAJUXVldWVQb3NpdGlvbiBwb3M7CQkJLyog YmFja2VuZCBoYXMgcmVhZCBxdWV1ZSB1cCB0byBoZXJlICovCisJcGdfYXRvbWljX3VpbnQz MiBzdGF0ZTsJCS8qIGFzeW5jIHN0YXRlIG1hY2hpbmUgc3RhdGUgKi8KIH0gUXVldWVCYWNr ZW5kU3RhdHVzOwogCiAvKgpAQCAtMzAxLDYgKzMxMyw3IEBAIHN0YXRpYyBBc3luY1F1ZXVl Q29udHJvbCAqYXN5bmNRdWV1ZUNvbnRyb2w7CiAjZGVmaW5lIFFVRVVFX0JBQ0tFTkRfREJP SUQoaSkJCShhc3luY1F1ZXVlQ29udHJvbC0+YmFja2VuZFtpXS5kYm9pZCkKICNkZWZpbmUg UVVFVUVfTkVYVF9MSVNURU5FUihpKQkJKGFzeW5jUXVldWVDb250cm9sLT5iYWNrZW5kW2ld Lm5leHRMaXN0ZW5lcikKICNkZWZpbmUgUVVFVUVfQkFDS0VORF9QT1MoaSkJCShhc3luY1F1 ZXVlQ29udHJvbC0+YmFja2VuZFtpXS5wb3MpCisjZGVmaW5lIFFVRVVFX0JBQ0tFTkRfU1RB VEUoaSkJCShhc3luY1F1ZXVlQ29udHJvbC0+YmFja2VuZFtpXS5zdGF0ZSkKIAogLyoKICAq IFRoZSBTTFJVIGJ1ZmZlciBhcmVhIHRocm91Z2ggd2hpY2ggd2UgYWNjZXNzIHRoZSBub3Rp ZmljYXRpb24gcXVldWUKQEAgLTQwNSwxMiArNDE4LDEwIEBAIHN0YXRpYyBOb3RpZmljYXRp b25MaXN0ICpwZW5kaW5nTm90aWZpZXMgPSBOVUxMOwogCiAvKgogICogSW5ib3VuZCBub3Rp ZmljYXRpb25zIGFyZSBpbml0aWFsbHkgcHJvY2Vzc2VkIGJ5IEhhbmRsZU5vdGlmeUludGVy cnVwdCgpLAotICogY2FsbGVkIGZyb20gaW5zaWRlIGEgc2lnbmFsIGhhbmRsZXIuIFRoYXQg anVzdCBzZXRzIHRoZQotICogbm90aWZ5SW50ZXJydXB0UGVuZGluZyBmbGFnIGFuZCBzZXRz IHRoZSBwcm9jZXNzCisgKiBjYWxsZWQgZnJvbSBpbnNpZGUgYSBzaWduYWwgaGFuZGxlci4g VGhhdCBqdXN0IHNldHMgdGhlIHByb2Nlc3MKICAqIGxhdGNoLiBQcm9jZXNzTm90aWZ5SW50 ZXJydXB0KCkgd2lsbCB0aGVuIGJlIGNhbGxlZCB3aGVuZXZlciBpdCdzIHNhZmUgdG8KICAq IGFjdHVhbGx5IGRlYWwgd2l0aCB0aGUgaW50ZXJydXB0LgogICovCi12b2xhdGlsZSBzaWdf YXRvbWljX3Qgbm90aWZ5SW50ZXJydXB0UGVuZGluZyA9IGZhbHNlOwogCiAvKiBUcnVlIGlm IHdlJ3ZlIHJlZ2lzdGVyZWQgYW4gb25fc2htZW1fZXhpdCBjbGVhbnVwICovCiBzdGF0aWMg Ym9vbCB1bmxpc3RlbkV4aXRSZWdpc3RlcmVkID0gZmFsc2U7CkBAIC01MjcsNiArNTM4LDcg QEAgQXN5bmNTaG1lbUluaXQodm9pZCkKIAkJCVFVRVVFX0JBQ0tFTkRfREJPSUQoaSkgPSBJ bnZhbGlkT2lkOwogCQkJUVVFVUVfTkVYVF9MSVNURU5FUihpKSA9IElOVkFMSURfUFJPQ19O VU1CRVI7CiAJCQlTRVRfUVVFVUVfUE9TKFFVRVVFX0JBQ0tFTkRfUE9TKGkpLCAwLCAwKTsK KwkJCXBnX2F0b21pY19pbml0X3UzMigmUVVFVUVfQkFDS0VORF9TVEFURShpKSwgQVNZTkNf U1RBVEVfSURMRSk7CiAJCX0KIAl9CiAKQEAgLTEwOTksNiArMTExMSw4IEBAIEV4ZWNfTGlz dGVuUHJlQ29tbWl0KHZvaWQpCiAJUVVFVUVfQkFDS0VORF9QT1MoTXlQcm9jTnVtYmVyKSA9 IG1heDsKIAlRVUVVRV9CQUNLRU5EX1BJRChNeVByb2NOdW1iZXIpID0gTXlQcm9jUGlkOwog CVFVRVVFX0JBQ0tFTkRfREJPSUQoTXlQcm9jTnVtYmVyKSA9IE15RGF0YWJhc2VJZDsKKwkv KiBJbml0aWFsaXplIHRoZSBhdG9taWMgc3RhdGUgdG8gSURMRSAqLworCXBnX2F0b21pY193 cml0ZV91MzIoJlFVRVVFX0JBQ0tFTkRfU1RBVEUoTXlQcm9jTnVtYmVyKSwgQVNZTkNfU1RB VEVfSURMRSk7CiAJLyogSW5zZXJ0IGJhY2tlbmQgaW50byBsaXN0IG9mIGxpc3RlbmVycyBh dCBjb3JyZWN0IHBvc2l0aW9uICovCiAJaWYgKHByZXZMaXN0ZW5lciAhPSBJTlZBTElEX1BS T0NfTlVNQkVSKQogCXsKQEAgLTEyNDIsNiArMTI1Niw4IEBAIGFzeW5jUXVldWVVbnJlZ2lz dGVyKHZvaWQpCiAJLyogTWFyayBvdXIgZW50cnkgYXMgaW52YWxpZCAqLwogCVFVRVVFX0JB Q0tFTkRfUElEKE15UHJvY051bWJlcikgPSBJbnZhbGlkUGlkOwogCVFVRVVFX0JBQ0tFTkRf REJPSUQoTXlQcm9jTnVtYmVyKSA9IEludmFsaWRPaWQ7CisJLyogUmVzZXQgc3RhdGUgdG8g SURMRSB0byBwcmV2ZW50IHpvbWJpZSBsaXN0ZW5lcnMgKi8KKwlwZ19hdG9taWNfd3JpdGVf dTMyKCZRVUVVRV9CQUNLRU5EX1NUQVRFKE15UHJvY051bWJlciksIEFTWU5DX1NUQVRFX0lE TEUpOwogCS8qIGFuZCByZW1vdmUgaXQgZnJvbSB0aGUgbGlzdCAqLwogCWlmIChRVUVVRV9G SVJTVF9MSVNURU5FUiA9PSBNeVByb2NOdW1iZXIpCiAJCVFVRVVFX0ZJUlNUX0xJU1RFTkVS ID0gUVVFVUVfTkVYVF9MSVNURU5FUihNeVByb2NOdW1iZXIpOwpAQCAtMTYzNCwyNSArMTY1 MCw4NCBAQCBTaWduYWxCYWNrZW5kcyh2b2lkKQogCWZvciAoaW50IGkgPSAwOyBpIDwgY291 bnQ7IGkrKykKIAl7CiAJCWludDMyCQlwaWQgPSBwaWRzW2ldOworCQlQcm9jTnVtYmVyCXBy b2NubyA9IHByb2Nub3NbaV07CisJCXVpbnQzMgkJZXhwZWN0ZWQ7CisJCWJvb2wJCXNpZ25h bF9uZWVkZWQgPSBmYWxzZTsKIAogCQkvKgotCQkgKiBJZiB3ZSBhcmUgc2lnbmFsaW5nIG91 ciBvd24gcHJvY2Vzcywgbm8gbmVlZCB0byBpbnZvbHZlIHRoZSBrZXJuZWw7Ci0JCSAqIGp1 c3Qgc2V0IHRoZSBmbGFnIGRpcmVjdGx5LgorCQkgKiBJbXBsZW1lbnQgc3RhdGUgbWFjaGlu ZSB0cmFuc2l0aW9ucyBmb3IgdGhlIG5vdGlmaWVyLgorCQkgKiBXZSB1c2UgYSBsb29wIHRv IGhhbmRsZSByYWNlIGNvbmRpdGlvbnMgd2hlcmUgdGhlIHN0YXRlCisJCSAqIGNoYW5nZXMg YmV0d2VlbiBvdXIgcmVhZCBhbmQgdGhlIENBUyBvcGVyYXRpb24uCiAJCSAqLwotCQlpZiAo cGlkID09IE15UHJvY1BpZCkKKwkJdWludDMyCWN1cnJlbnRfc3RhdGUgPSBwZ19hdG9taWNf cmVhZF9tZW1iYXJyaWVyX3UzMigmUVVFVUVfQkFDS0VORF9TVEFURShwcm9jbm8pKTsKKwor CQlzd2l0Y2ggKGN1cnJlbnRfc3RhdGUpCiAJCXsKLQkJCW5vdGlmeUludGVycnVwdFBlbmRp bmcgPSB0cnVlOwotCQkJY29udGludWU7CisJCQljYXNlIEFTWU5DX1NUQVRFX0lETEU6CisJ CQkJLyogVHJ5IHRvIHRyYW5zaXRpb24gZnJvbSBJRExFIHRvIFNJR05BTExFRCAqLworCQkJ CWV4cGVjdGVkID0gQVNZTkNfU1RBVEVfSURMRTsKKwkJCQlpZiAocGdfYXRvbWljX2NvbXBh cmVfZXhjaGFuZ2VfdTMyKCZRVUVVRV9CQUNLRU5EX1NUQVRFKHByb2NubyksCisJCQkJCQkJ CQkJCQkJJmV4cGVjdGVkLAorCQkJCQkJCQkJCQkJCUFTWU5DX1NUQVRFX1NJR05BTExFRCkp CisJCQkJeworCQkJCQkvKiBTdWNjZXNzIC0gbmVlZCB0byBzZW5kIHNpZ25hbCAqLworCQkJ CQlzaWduYWxfbmVlZGVkID0gdHJ1ZTsKKwkJCQkJaWYgKFRyYWNlX25vdGlmeSkKKwkJCQkJ CWVsb2coREVCVUcxLCAiU2lnbmFsQmFja2VuZHM6IHRyYW5zaXRpb25lZCBiYWNrZW5kICVk IGZyb20gSURMRSB0byBTSUdOQUxMRUQiLCBwaWQpOworCQkJCX0KKwkJCQkvKiBBbm90aGVy IG5vdGlmaWVyIGFscmVhZHkgc2lnbmFsZWQgLSB3ZSdyZSBkb25lICovCisJCQkJYnJlYWs7 CisKKwkJCWNhc2UgQVNZTkNfU1RBVEVfU0lHTkFMTEVEOgorCQkJCS8qIEJhY2tlbmQgaXMg YWxyZWFkeSBzaWduYWxlZCAtIG5vdGhpbmcgdG8gZG8gKi8KKwkJCQlpZiAoVHJhY2Vfbm90 aWZ5KQorCQkJCQllbG9nKERFQlVHMSwgIlNpZ25hbEJhY2tlbmRzOiBiYWNrZW5kICVkIGFs cmVhZHkgaW4gU0lHTkFMTEVEIHN0YXRlLCBza2lwcGluZyIsIHBpZCk7CisJCQkJYnJlYWs7 CisKKwkJCWNhc2UgQVNZTkNfU1RBVEVfUFJPQ0VTU0lORzoKKwkJCQkvKiBUcnkgdG8gdHJh bnNpdGlvbiBmcm9tIFBST0NFU1NJTkcgdG8gU0lHTkFMTEVEICovCisJCQkJZXhwZWN0ZWQg PSBBU1lOQ19TVEFURV9QUk9DRVNTSU5HOworCQkJCWlmIChwZ19hdG9taWNfY29tcGFyZV9l eGNoYW5nZV91MzIoJlFVRVVFX0JBQ0tFTkRfU1RBVEUocHJvY25vKSwKKwkJCQkJCQkJCQkJ CQkmZXhwZWN0ZWQsCisJCQkJCQkJCQkJCQkJQVNZTkNfU1RBVEVfU0lHTkFMTEVEKSkKKwkJ CQl7CisJCQkJCS8qIFN1Y2Nlc3MgLSBuZWVkIHRvIHNlbmQgc2lnbmFsIGZvciByZS1zY2Fu ICovCisJCQkJCXNpZ25hbF9uZWVkZWQgPSB0cnVlOworCQkJCQlpZiAoVHJhY2Vfbm90aWZ5 KQorCQkJCQkJZWxvZyhERUJVRzEsICJTaWduYWxCYWNrZW5kczogdHJhbnNpdGlvbmVkIGJh Y2tlbmQgJWQgZnJvbSBQUk9DRVNTSU5HIHRvIFNJR05BTExFRCBmb3IgcmUtc2NhbiIsIHBp ZCk7CisJCQkJCWJyZWFrOworCQkJCX0KKwkJCQkvKiBBbm90aGVyIG5vdGlmaWVyIGFscmVh ZHkgc2lnbmFsZWQgLSB3ZSdyZSBkb25lICovCisJCQkJYnJlYWs7CisKKwkJCWRlZmF1bHQ6 CisJCQkJLyogU2hvdWxkIG5ldmVyIGhhcHBlbiAqLworCQkJCWVsb2coRVJST1IsICJ1bmV4 cGVjdGVkIGFzeW5jIHN0YXRlICV1IGZvciBiYWNrZW5kICVkIiwKKwkJCQkJCWN1cnJlbnRf c3RhdGUsIHBpZCk7CiAJCX0KIAotCQkvKgotCQkgKiBOb3RlOiBhc3N1bWluZyB0aGluZ3Mg YXJlbid0IGJyb2tlbiwgYSBzaWduYWwgZmFpbHVyZSBoZXJlIGNvdWxkCi0JCSAqIG9ubHkg b2NjdXIgaWYgdGhlIHRhcmdldCBiYWNrZW5kIGV4aXRlZCBzaW5jZSB3ZSByZWxlYXNlZAot CQkgKiBOb3RpZnlRdWV1ZUxvY2s7IHdoaWNoIGlzIHVubGlrZWx5IGJ1dCBjZXJ0YWlubHkg cG9zc2libGUuIFNvIHdlCi0JCSAqIGp1c3QgbG9nIGEgbG93LWxldmVsIGRlYnVnIG1lc3Nh Z2UgaWYgaXQgaGFwcGVucy4KLQkJICovCi0JCWlmIChTZW5kUHJvY1NpZ25hbChwaWQsIFBS T0NTSUdfTk9USUZZX0lOVEVSUlVQVCwgcHJvY25vc1tpXSkgPCAwKQotCQkJZWxvZyhERUJV RzMsICJjb3VsZCBub3Qgc2lnbmFsIGJhY2tlbmQgd2l0aCBQSUQgJWQ6ICVtIiwgcGlkKTsK KwkJLyogU2VuZCBzaWduYWwgaWYgbmVlZGVkICovCisJCWlmIChzaWduYWxfbmVlZGVkKQor CQl7CisJCQkvKgorCQkJICogRm9yIG91ciBvd24gcHJvY2Vzcywgbm8gbmVlZCB0byBpbnZv bHZlIHRoZSBrZXJuZWwKKwkJCSAqLworCQkJaWYgKHBpZCA9PSBNeVByb2NQaWQpCisJCQl7 CisJCQkJU2V0TGF0Y2goTXlMYXRjaCk7CisJCQl9CisJCQllbHNlCisJCQl7CisJCQkJLyoK KwkJCQkgKiBOb3RlOiBhc3N1bWluZyB0aGluZ3MgYXJlbid0IGJyb2tlbiwgYSBzaWduYWwg ZmFpbHVyZSBoZXJlIGNvdWxkCisJCQkJICogb25seSBvY2N1ciBpZiB0aGUgdGFyZ2V0IGJh Y2tlbmQgZXhpdGVkIHNpbmNlIHdlIHJlbGVhc2VkCisJCQkJICogTm90aWZ5UXVldWVMb2Nr OyB3aGljaCBpcyB1bmxpa2VseSBidXQgY2VydGFpbmx5IHBvc3NpYmxlLiBTbyB3ZQorCQkJ CSAqIGp1c3QgbG9nIGEgbG93LWxldmVsIGRlYnVnIG1lc3NhZ2UgaWYgaXQgaGFwcGVucy4K KwkJCQkgKi8KKwkJCQlpZiAoU2VuZFByb2NTaWduYWwocGlkLCBQUk9DU0lHX05PVElGWV9J TlRFUlJVUFQsIHByb2NubykgPCAwKQorCQkJCQllbG9nKERFQlVHMywgImNvdWxkIG5vdCBz aWduYWwgYmFja2VuZCB3aXRoIFBJRCAlZDogJW0iLCBwaWQpOworCQkJfQorCQl9CiAJfQog CiAJcGZyZWUocGlkcyk7CkBAIC0xODA1LDIwICsxODgwLDQzIEBAIEhhbmRsZU5vdGlmeUlu dGVycnVwdCh2b2lkKQogewogCS8qCiAJICogTm90ZTogdGhpcyBpcyBjYWxsZWQgYnkgYSBT SUdOQUwgSEFORExFUi4gWW91IG11c3QgYmUgdmVyeSB3YXJ5IHdoYXQKLQkgKiB5b3UgZG8g aGVyZS4KKwkgKiB5b3UgZG8gaGVyZS4gVGhlIGFjdHVhbCBzdGF0ZSB0cmFuc2l0aW9uIGhh cyBhbHJlYWR5IGJlZW4gZG9uZSBieQorCSAqIHRoZSBub3RpZmllciBiZWZvcmUgc2VuZGlu ZyB0aGUgc2lnbmFsLCBzbyB3ZSBvbmx5IG5lZWQgdG8gc2V0IHRoZQorCSAqIGxhdGNoIHRv IGVuc3VyZSB0aGUgYmFja2VuZCB3YWtlcyB1cCBhbmQgcHJvY2Vzc2VzIHRoZSBub3RpZmlj YXRpb24uCiAJICovCiAKLQkvKiBzaWduYWwgdGhhdCB3b3JrIG5lZWRzIHRvIGJlIGRvbmUg Ki8KLQlub3RpZnlJbnRlcnJ1cHRQZW5kaW5nID0gdHJ1ZTsKLQogCS8qIG1ha2Ugc3VyZSB0 aGUgZXZlbnQgaXMgcHJvY2Vzc2VkIGluIGR1ZSBjb3Vyc2UgKi8KIAlTZXRMYXRjaChNeUxh dGNoKTsKIH0KIAorLyoKKyAqIElzTm90aWZ5SW50ZXJydXB0UGVuZGluZworICoKKyAqCQlD aGVjayBpZiB0aGVyZSdzIGEgcGVuZGluZyBub3RpZnkgaW50ZXJydXB0IGZvciB0aGlzIGJh Y2tlbmQKKyAqLworYm9vbAorSXNOb3RpZnlJbnRlcnJ1cHRQZW5kaW5nKHZvaWQpCit7CisJ dWludDMyCQlzdGF0ZTsKKworCS8qIElmIG5vdCByZWdpc3RlcmVkIGFzIGEgbGlzdGVuZXIs IG5vIG5vdGlmaWNhdGlvbnMgYXJlIHBlbmRpbmcgKi8KKwlpZiAoIWFtUmVnaXN0ZXJlZExp c3RlbmVyKQorCQlyZXR1cm4gZmFsc2U7CisKKwkvKgorCSAqIFJlYWQgdGhlIGN1cnJlbnQg c3RhdGUgd2l0aCBhIG1lbW9yeSBiYXJyaWVyIHRvIGVuc3VyZSB3ZSBzZWUKKwkgKiB0aGUg bW9zdCByZWNlbnQgdmFsdWUgd3JpdHRlbiBieSBub3RpZmllcnMuCisJICovCisJc3RhdGUg PSBwZ19hdG9taWNfcmVhZF9tZW1iYXJyaWVyX3UzMigmUVVFVUVfQkFDS0VORF9TVEFURShN eVByb2NOdW1iZXIpKTsKKworCS8qIE5vdGlmaWNhdGlvbiBpcyBwZW5kaW5nIGlmIHN0YXRl IGlzIFNJR05BTExFRCAqLworCXJldHVybiAoc3RhdGUgPT0gQVNZTkNfU1RBVEVfU0lHTkFM TEVEKTsKK30KKwogLyoKICAqIFByb2Nlc3NOb3RpZnlJbnRlcnJ1cHQKICAqCi0gKgkJVGhp cyBpcyBjYWxsZWQgaWYgd2Ugc2VlIG5vdGlmeUludGVycnVwdFBlbmRpbmcgc2V0LCBqdXN0 IGJlZm9yZQorICoJCVRoaXMgaXMgY2FsbGVkIGlmIHdlIHNlZSBhIG5vdGlmaWNhdGlvbiBp bnRlcnJ1cHQgaXMgcGVuZGluZywganVzdCBiZWZvcmUKICAqCQl0cmFuc21pdHRpbmcgUmVh ZHlGb3JRdWVyeSBhdCB0aGUgZW5kIG9mIGEgZnJvbnRlbmQgY29tbWFuZCwgYW5kCiAgKgkJ YWxzbyBpZiBhIG5vdGlmeSBzaWduYWwgb2NjdXJzIHdoaWxlIHJlYWRpbmcgZnJvbSB0aGUg ZnJvbnRlbmQuCiAgKgkJSGFuZGxlTm90aWZ5SW50ZXJydXB0KCkgd2lsbCBjYXVzZSB0aGUg cmVhZCB0byBiZSBpbnRlcnJ1cHRlZApAQCAtMTgzNyw3ICsxOTM1LDcgQEAgUHJvY2Vzc05v dGlmeUludGVycnVwdChib29sIGZsdXNoKQogCQlyZXR1cm47CQkJCQkvKiBub3QgcmVhbGx5 IGlkbGUgKi8KIAogCS8qIExvb3AgaW4gY2FzZSBhbm90aGVyIHNpZ25hbCBhcnJpdmVzIHdo aWxlIHNlbmRpbmcgbWVzc2FnZXMgKi8KLQl3aGlsZSAobm90aWZ5SW50ZXJydXB0UGVuZGlu ZykKKwl3aGlsZSAoSXNOb3RpZnlJbnRlcnJ1cHRQZW5kaW5nKCkpCiAJCVByb2Nlc3NJbmNv bWluZ05vdGlmeShmbHVzaCk7CiB9CiAKQEAgLTIxODIsMjggKzIyODAsODEgQEAgYXN5bmNR dWV1ZUFkdmFuY2VUYWlsKHZvaWQpCiBzdGF0aWMgdm9pZAogUHJvY2Vzc0luY29taW5nTm90 aWZ5KGJvb2wgZmx1c2gpCiB7Ci0JLyogV2UgKm11c3QqIHJlc2V0IHRoZSBmbGFnICovCi0J bm90aWZ5SW50ZXJydXB0UGVuZGluZyA9IGZhbHNlOworCXVpbnQzMgkJZXhwZWN0ZWQ7CiAK LQkvKiBEbyBub3RoaW5nIGVsc2UgaWYgd2UgYXJlbid0IGFjdGl2ZWx5IGxpc3RlbmluZyAq LworCS8qIERvIG5vdGhpbmcgaWYgd2UgYXJlbid0IGFjdGl2ZWx5IGxpc3RlbmluZyAqLwog CWlmIChsaXN0ZW5DaGFubmVscyA9PSBOSUwpCiAJCXJldHVybjsKIAorCS8qCisJICogUGVy Zm9ybSBzdGF0ZSB0cmFuc2l0aW9uIGZyb20gU0lHTkFMTEVEIHRvIFBST0NFU1NJTkcuCisJ ICogVGhpcyBpcyB0aGUgImFjcXVpcmUgbG9jayIgb3BlcmF0aW9uIGZvciB0aGUgbGlzdGVu ZXIuCisJICovCisJZXhwZWN0ZWQgPSBBU1lOQ19TVEFURV9TSUdOQUxMRUQ7CisJaWYgKCFw Z19hdG9taWNfY29tcGFyZV9leGNoYW5nZV91MzIoJlFVRVVFX0JBQ0tFTkRfU1RBVEUoTXlQ cm9jTnVtYmVyKSwKKwkJCQkJCQkJCQkmZXhwZWN0ZWQsCisJCQkJCQkJCQkJQVNZTkNfU1RB VEVfUFJPQ0VTU0lORykpCisJeworCQkvKgorCQkgKiBDQVMgZmFpbGVkIC0gdGhlIHN0YXRl IHdhcyBub3QgU0lHTkFMTEVELiBUaGlzIHNob3VsZCBub3QgaGFwcGVuCisJCSAqIGFzIFBy b2Nlc3NOb3RpZnlJbnRlcnJ1cHQgb25seSBjYWxscyB1cyB3aGVuIHN0YXRlIGlzIFNJR05B TExFRC4KKwkJICovCisJCWVsb2coRVJST1IsICJ1bmV4cGVjdGVkIGFzeW5jIHN0YXRlICV1 IGluIFByb2Nlc3NJbmNvbWluZ05vdGlmeSwgZXhwZWN0ZWQgU0lHTkFMTEVEIiwKKwkJCSBl eHBlY3RlZCk7CisJfQorCiAJaWYgKFRyYWNlX25vdGlmeSkKLQkJZWxvZyhERUJVRzEsICJQ cm9jZXNzSW5jb21pbmdOb3RpZnkiKTsKKwkJZWxvZyhERUJVRzEsICJQcm9jZXNzSW5jb21p bmdOb3RpZnk6IHRyYW5zaXRpb25lZCB0byBQUk9DRVNTSU5HIik7CiAKIAlzZXRfcHNfZGlz cGxheSgibm90aWZ5IGludGVycnVwdCIpOwogCiAJLyoKLQkgKiBXZSBtdXN0IHJ1biBhc3lu Y1F1ZXVlUmVhZEFsbE5vdGlmaWNhdGlvbnMgaW5zaWRlIGEgdHJhbnNhY3Rpb24sIGVsc2UK LQkgKiBiYWQgdGhpbmdzIGhhcHBlbiBpZiBpdCBnZXRzIGFuIGVycm9yLgotCSAqLworCQkq IFdlIG11c3QgcnVuIGFzeW5jUXVldWVSZWFkQWxsTm90aWZpY2F0aW9ucyBpbnNpZGUgYSB0 cmFuc2FjdGlvbiwgZWxzZQorCQkqIGJhZCB0aGluZ3MgaGFwcGVuIGlmIGl0IGdldHMgYW4g ZXJyb3IuCisJCSovCiAJU3RhcnRUcmFuc2FjdGlvbkNvbW1hbmQoKTsKIAogCWFzeW5jUXVl dWVSZWFkQWxsTm90aWZpY2F0aW9ucygpOwogCiAJQ29tbWl0VHJhbnNhY3Rpb25Db21tYW5k KCk7CiAKKwkvKgorCSAqIFRyeSB0byB0cmFuc2l0aW9uIGZyb20gUFJPQ0VTU0lORyBiYWNr IHRvIElETEUuCisJICogVGhpcyBpcyB0aGUgInJlbGVhc2UgbG9jayIgb3BlcmF0aW9uIGZv ciB0aGUgbGlzdGVuZXIuCisJICovCisJZXhwZWN0ZWQgPSBBU1lOQ19TVEFURV9QUk9DRVNT SU5HOworCWlmIChwZ19hdG9taWNfY29tcGFyZV9leGNoYW5nZV91MzIoJlFVRVVFX0JBQ0tF TkRfU1RBVEUoTXlQcm9jTnVtYmVyKSwKKwkJCQkJCQkJCQkmZXhwZWN0ZWQsCisJCQkJCQkJ CQkJQVNZTkNfU1RBVEVfSURMRSkpCisJeworCQkvKiBTdWNjZXNzIC0gd2UncmUgZG9uZSwg dHJhbnNpdGlvbmVkIHRvIElETEUgKi8KKwkJaWYgKFRyYWNlX25vdGlmeSkKKwkJCWVsb2co REVCVUcxLCAiUHJvY2Vzc0luY29taW5nTm90aWZ5OiB0cmFuc2l0aW9uZWQgdG8gSURMRSIp OworCX0KKwllbHNlCisJeworCQkvKiBDQVMgZmFpbGVkIC0gY2hlY2sgd2hhdCB0aGUgbmV3 IHN0YXRlIGlzICovCisJCWlmIChleHBlY3RlZCA9PSBBU1lOQ19TVEFURV9TSUdOQUxMRUQp CisJCXsKKwkJCS8qCisJCQkJKiBBIG5vdGlmaWVyIHNldCBvdXIgc3RhdGUgdG8gU0lHTkFM TEVEIHdoaWxlIHdlIHdlcmUgcHJvY2Vzc2luZy4KKwkJCQkqIFdlIGFyZSBkb25lIHdpdGgg dGhpcyBiYXRjaCBvZiB3b3JrLCBidXQgd2Uga25vdyB0aGVyZSBpcyBtb3JlCisJCQkJKiB0 byBkby4gUmF0aGVyIHRoYW4gbG9vcCBoZXJlIGFuZCByaXNrIHN0YXJ2aW5nIG90aGVyIGJh Y2tlbmQKKwkJCQkqIGFjdGl2aXR5LCB3ZSBzZXQgb3VyIG93biBsYXRjaCB0byBlbnN1cmUg d2UgYXJlIHdva2VuIHVwIGFnYWluCisJCQkJKiB0byByZS1wcm9jZXNzLCBhbmQgdGhlbiBl eGl0LiBUaGUgc3RhdGUgaXMgbGVmdCBhcyBTSUdOQUxMRUQuCisJCQkJKi8KKwkJCWlmIChU cmFjZV9ub3RpZnkpCisJCQkJZWxvZyhERUJVRzEsICJQcm9jZXNzSW5jb21pbmdOb3RpZnk6 IHNpZ25hbGxlZCB3aGlsZSBwcm9jZXNzaW5nIik7CisJCQlTZXRMYXRjaChNeUxhdGNoKTsK KwkJfQorCQllbHNlCisJCXsKKwkJCS8qIEFueSBvdGhlciBzdGF0ZSBpcyBhbiBlcnJvciAq LworCQkJZWxvZyhFUlJPUiwgInVuZXhwZWN0ZWQgYXN5bmMgc3RhdGUgJXUgd2hlbiB0cnlp bmcgdG8gcmV0dXJuIHRvIElETEUiLAorCQkJCQlleHBlY3RlZCk7CisJCX0KKwl9CisKIAkv KgogCSAqIElmIHRoaXMgaXNuJ3QgYW4gZW5kLW9mLWNvbW1hbmQgY2FzZSwgd2UgbXVzdCBm bHVzaCB0aGUgbm90aWZ5IG1lc3NhZ2VzCiAJICogdG8gZW5zdXJlIGZyb250ZW5kIGdldHMg dGhlbSBwcm9tcHRseS4KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3Rjb3AvcG9zdGdyZXMu YyBiL3NyYy9iYWNrZW5kL3Rjb3AvcG9zdGdyZXMuYwppbmRleCAyZjhjM2Q1ZjkxOC4uMzIx NjI0N2E1OGIgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3Rjb3AvcG9zdGdyZXMuYworKysg Yi9zcmMvYmFja2VuZC90Y29wL3Bvc3RncmVzLmMKQEAgLTUxMiw3ICs1MTIsNyBAQCBQcm9j ZXNzQ2xpZW50UmVhZEludGVycnVwdChib29sIGJsb2NrZWQpCiAJCQlQcm9jZXNzQ2F0Y2h1 cEludGVycnVwdCgpOwogCiAJCS8qIFByb2Nlc3Mgbm90aWZ5IGludGVycnVwdHMsIGlmIGFu eSAqLwotCQlpZiAobm90aWZ5SW50ZXJydXB0UGVuZGluZykKKwkJaWYgKElzTm90aWZ5SW50 ZXJydXB0UGVuZGluZygpKQogCQkJUHJvY2Vzc05vdGlmeUludGVycnVwdCh0cnVlKTsKIAl9 CiAJZWxzZSBpZiAoUHJvY0RpZVBlbmRpbmcpCkBAIC00NjAzLDcgKzQ2MDMsNyBAQCBQb3N0 Z3Jlc01haW4oY29uc3QgY2hhciAqZGJuYW1lLCBjb25zdCBjaGFyICp1c2VybmFtZSkKIAkJ CQkgKiB3ZXJlIHJlY2VpdmVkIGR1cmluZyB0aGUganVzdC1maW5pc2hlZCB0cmFuc2FjdGlv biwgdGhleSdsbAogCQkJCSAqIGJlIHNlZW4gYnkgdGhlIGNsaWVudCBiZWZvcmUgUmVhZHlG b3JRdWVyeSBpcy4KIAkJCQkgKi8KLQkJCQlpZiAobm90aWZ5SW50ZXJydXB0UGVuZGluZykK KwkJCQlpZiAoSXNOb3RpZnlJbnRlcnJ1cHRQZW5kaW5nKCkpCiAJCQkJCVByb2Nlc3NOb3Rp ZnlJbnRlcnJ1cHQoZmFsc2UpOwogCiAJCQkJLyoKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRl L2NvbW1hbmRzL2FzeW5jLmggYi9zcmMvaW5jbHVkZS9jb21tYW5kcy9hc3luYy5oCmluZGV4 IGY3NWMzZGY5NTU2Li43ZjJlMGFjMGI5ZiAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvY29t bWFuZHMvYXN5bmMuaAorKysgYi9zcmMvaW5jbHVkZS9jb21tYW5kcy9hc3luYy5oCkBAIC0x Nyw3ICsxNyw2IEBACiAKIGV4dGVybiBQR0RMTElNUE9SVCBib29sIFRyYWNlX25vdGlmeTsK IGV4dGVybiBQR0RMTElNUE9SVCBpbnQgbWF4X25vdGlmeV9xdWV1ZV9wYWdlczsKLWV4dGVy biBQR0RMTElNUE9SVCB2b2xhdGlsZSBzaWdfYXRvbWljX3Qgbm90aWZ5SW50ZXJydXB0UGVu ZGluZzsKIAogZXh0ZXJuIFNpemUgQXN5bmNTaG1lbVNpemUodm9pZCk7CiBleHRlcm4gdm9p ZCBBc3luY1NobWVtSW5pdCh2b2lkKTsKQEAgLTQ2LDQgKzQ1LDcgQEAgZXh0ZXJuIHZvaWQg SGFuZGxlTm90aWZ5SW50ZXJydXB0KHZvaWQpOwogLyogcHJvY2VzcyBpbnRlcnJ1cHRzICov CiBleHRlcm4gdm9pZCBQcm9jZXNzTm90aWZ5SW50ZXJydXB0KGJvb2wgZmx1c2gpOwogCisv KiBjaGVjayBpZiBub3RpZmljYXRpb24gaW50ZXJydXB0IGlzIHBlbmRpbmcgKi8KK2V4dGVy biBib29sIElzTm90aWZ5SW50ZXJydXB0UGVuZGluZyh2b2lkKTsKKwogI2VuZGlmCQkJCQkJ CS8qIEFTWU5DX0ggKi8KLS0gCjIuNDcuMQoK --0a829c0ef42747ee8d39e51fe8b6dfc1--