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 1vC913-009YDS-Dk for pgsql-hackers@arkaria.postgresql.org; Fri, 24 Oct 2025 04:03:00 +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 1vC911-00DZ4T-HC for pgsql-hackers@arkaria.postgresql.org; Fri, 24 Oct 2025 04:02:58 +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 1vC911-00DZ4L-3Z for pgsql-hackers@lists.postgresql.org; Fri, 24 Oct 2025 04:02:58 +0000 Received: from mail-yx1-xb12d.google.com ([2607:f8b0:4864:20::b12d]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.96) (envelope-from ) id 1vC90x-003vL0-1L for pgsql-hackers@lists.postgresql.org; Fri, 24 Oct 2025 04:02:57 +0000 Received: by mail-yx1-xb12d.google.com with SMTP id 956f58d0204a3-63e1b52b452so1724526d50.1 for ; Thu, 23 Oct 2025 21:02:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1761278573; x=1761883373; darn=lists.postgresql.org; h=in-reply-to:from:content-language:references:to:subject:user-agent :mime-version:date:message-id:from:to:cc:subject:date:message-id :reply-to; bh=eaz6r9C/0+4H3QoAu4qQxGY/noY38d/fVTP1cHYw5yM=; b=SlL7wJHaaa9Gph0YBTNOEPqz2nEdobH5PS9M2Q1ZuSyrp9OdaAw9ayqnb19bxqmmXD rfG2Guuf//+5Qkm8ag99p8wkvrrbpcS0Cm2PSzHBWwv9j1DY+0GkKRUCw9lHu0PPkapH WH7ONy2VEq6bAlslM82QTy60BnzGut784NCbT3xx6YPexQ2R8ZmlEycMqXoz83+BrW3K +xNs10g5NJ7v7Cs0NRAXtJjRJZ/oDppd9QmGKxG7sq9tTUa3CgGgnQxwei8RUQSOSTiJ n97Vv9W8cDX37yaMxfJfy55m+d6gCbj/DLR9FWHSDFpKZ9Zup6KwZjeL1M0yqnbITolC VoVg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761278573; x=1761883373; h=in-reply-to:from:content-language:references:to:subject:user-agent :mime-version:date:message-id:x-gm-message-state:from:to:cc:subject :date:message-id:reply-to; bh=eaz6r9C/0+4H3QoAu4qQxGY/noY38d/fVTP1cHYw5yM=; b=AlddEHv4rXfjx0SAJOy3z7sE/6IH/Kxo5p3nQTmVu+eI/Ate9oL3OcIeLZDgQDnDL/ Ybfy/m1UobKzV7cU2D/9L0K66n+zms8HDWhgRrsDP/HKnKgJS+6YAWYtZ+JN+FftTzFl mSV4eO1GTGnGqZWwELWNnj9SbaLNwW36+YdIj1+VgboBtrVvN6In5z8XmbqeWmuTOqPt +Bo05vEIfEPKaKonwyC3s438oOJYL+NPxZlSDJNVaAAfxtFCy98KRpPemshwqL7OEJ/i 1beEfsANc6xwknlQZSyXssQh3mlvCH/1Q7Pwl4JhDKUZXEH825bnMse59thvQ4O+il2F 1fiQ== X-Gm-Message-State: AOJu0YzKmY0gSFJU4M2AK37O2HjmQgK3OUMELFjApzA5R3yTftSawKVX cx9Ye7Oc+J9C/OD9M17JDxztQ9mn6W0cHWZoy7XvT1/beVW/aWpw8xQ/ekwpFB0pCg3xKg== X-Gm-Gg: ASbGnctePegGtofR9+QlMtwdy5jIawtsfTgZK/RNX+iemONvTIwnPMNJxMJAiTR0fXM xxU7aYsc4bb4RbBZ2i09sRIhonGJwnJxE9qU8wfuBOOv2QRWjoNY6xKwv/2nbgg80JypwYBt7SJ +sQ1j7ktyZk8GcjXTjtSuwI8+EI+rw1dW/Hqqy5QcrubuNCDGfoZ0RliBD/qp6mdbX7GwGsGyYM UQEAqdwE7SON5HWYcyVv/0eu4pxHfDoyPSMmdn/2fk2GBW+lBRbYpE1Md1NkIpXm6D2Avz9KJK0 Cd3B1qSgSQrdk5lzYOU6GobT5BW+zEr9bs6SC2ElqmQMTErISLEK507dm98KVqeWYwXAepf7Jqg RGnGr6yorqESWV5iAGDnJvReoqzbQVxhIFKrQ0mtOJGktczBOhBYi/xN3DcSi9pMDx1o1DqoYB6 D7TGDZDL2RLF3Xjff2qQ/1QIThZNx1dlKnuVjsSd5fUm7e8FRiTuYonHmVPY+8Xv2B X-Google-Smtp-Source: AGHT+IEa9cnP7MtsG14b+gSmlVtDCWCPhzypqxKn8dHndXC2r14QjpondYeKYreYOleGYJeX2TM/tA== X-Received: by 2002:a05:690e:69c:b0:635:4ece:240c with SMTP id 956f58d0204a3-63e161c77b4mr17246138d50.44.1761278572717; Thu, 23 Oct 2025 21:02:52 -0700 (PDT) Received: from ?IPV6:2600:1700:8952:80:8538:d604:170e:6b1f? ([2600:1700:8952:80:8538:d604:170e:6b1f]) by smtp.gmail.com with ESMTPSA id 956f58d0204a3-63f37a06e8dsm1253044d50.14.2025.10.23.21.02.50 for (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 23 Oct 2025 21:02:50 -0700 (PDT) Content-Type: multipart/mixed; boundary="------------DGXo52hzvumP44RHaZIfxRBB" Message-ID: Date: Thu, 23 Oct 2025 23:02:50 -0500 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: pg_ctl start may return 0 even if the postmaster has been already started on Windows To: pgsql-hackers@lists.postgresql.org References: <20240713.064114.901257637518958249.kou@clear-code.com> <172113105761.344725.7570284373523963080.pgcf@coridan.postgresql.org> Content-Language: en-US From: Bryan Green In-Reply-To: List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk This is a multi-part message in MIME format. --------------DGXo52hzvumP44RHaZIfxRBB Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit On 3/26/2025 3:18 AM, vignesh C wrote: > On Sat, 20 Jul 2024 at 00:03, Robert Haas wrote: >> >> On Tue, Jul 16, 2024 at 8:04 AM Yasir wrote: >>> Please ignore the above 4 lines in my review. See my comments in blue. >> >> OK, so I think it's unclear what the next steps are for this patch. >> >> 1. On June 3rd, Michael Paquier said that Tom Lane proposed that, >> after doing what the patch currently does, we could simplify some >> other stuff. The details are unclear, and Tom hasn't commented. >> >> 2. On June 29th, Noah Misch proposed a platform-independent way of >> solving the problem. >> >> 3. On July 12th, Sutou Kouhei proposed using CreateProcess() to start >> the postmaster instead of cmd.exe. >> >> 4. On July 16th, Yasir Shah said that he tested the patch and found >> that the problem only exists in v17, not any prior release, which is >> contrary to my understanding of the situation. He also proposed a >> minor tweak to the patch itself. >> >> So, as I see it, we have three possible ways forward here. First, we >> could stick with the current patch, possibly with further work as per >> [1] or adjustments as per [4]. Second, we could abandon the current >> approach and adopt Noah's proposal in [2]. Third, we could possibly >> abandon the current approach and adopt Sutou's proposal in [3]. I say >> "possibly" because I can't personally assess whether this approach is >> feasible. > > Thank you very much, Robert, for summarizing this. If anyone has > suggestions on which approach might work best, please share them to > help move this discussion forward. > > Regards, > Vignesh > > Hello everyone, I've spent the last few days implementing Sutou-san's CreateProcess() proposal as a proof-of-concept. With all three approaches now available for comparison, I wanted to share my assessment and recommendation. The core issue, as we've established, is that cmd.exe intermediation prevents pg_ctl from getting the real postgres.exe PID, creating race conditions where we can't distinguish a newly-started postmaster from a pre-existing one. This causes pg_ctl start to incorrectly report success when attempting to start an already-running cluster. Horiguchi-san's process tree walking patch works and is ready to ship. It has real merit as a minimal-change solution. However, it keeps cmd.exe and adds process enumeration complexity to work around that decision. We're fixing symptoms rather than the root cause. Noah's token proposal is architecturally elegant and platform-independent. My concern is that it solves a Windows-specific problem by adding complexity to all platforms. Making other platforms adopt token-passing infrastructure for Windows's problems feels wrong. It also requires postmaster changes for what is fundamentally a pg_ctl issue, raising compatibility questions. The CreateProcess() approach eliminates cmd.exe entirely and gives us the actual postgres.exe PID directly. I've implemented this in the attached patch (about 250 lines of Windows-specific code). The implementation uses CreateProcessAsUser() with a restricted security token to handle the case where pg_ctl runs with elevated privileges—this drops Administrator group membership and dangerous privileges before launching the postmaster, matching the behavior of the existing CreateRestrictedProcess() function. For I/O redirection, we use Windows's native handle-based APIs. When a log file is specified, we open it with CreateFile() and pass it through STARTUPINFO. When there's no log file (interactive use and postgres -C queries), we inherit standard handles. One detail worth noting: we wait 2 seconds for no-log-file launches to distinguish postgres -C (which exits immediately) from actual server startup. This is long enough to catch quick exits even on loaded CI systems without impacting test suite performance. The implementation passes all regression tests on Windows, including CI environments with elevated privileges. It handles all the problem scenarios correctly: normal startup, detecting already-running clusters, postgres -C queries, pg_upgrade with multiple instances, and concurrent start attempts. I prefer the CreateProcess() approach. It fixes the root cause, not the symptoms. We get the real PID immediately with no process tree walking or PID verification complexity. It's a Windows-specific solution to a Windows-specific problem. If the CreateProcess() approach is deemed unacceptable, I would support Horiguchi-san's process tree walking patch as a pragmatic fallback. It fixes the bug and is tested. However, I believe we'd be choosing a workaround over a proper fix and adding maintenance burden we don't need. I'm opposed to the token approach for the reasons stated above—it's architecturally appealing but touches all platforms for a Windows-only problem. With this implementation complete, we now have all three options on the table for evaluation. I believe the CreateProcess() approach is technically sound and the right path forward, but I'm open to discussion and happy to address any concerns about the implementation. Regardless of which way we choose to go, I'll happily help review and test the solution. Best regards, BG --------------DGXo52hzvumP44RHaZIfxRBB Content-Type: text/plain; charset=UTF-8; name="0001-Fix-pg_ctl-on-Windows-to-reliably-detect-already-run.patch" Content-Disposition: attachment; filename*0="0001-Fix-pg_ctl-on-Windows-to-reliably-detect-already-run.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSAyZjQ1ZThkZmY4MTVhZDA4MTE4YjY4ZGNmNDM1OTQ4ZjFkOTJiNDE5IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBCcnlhbiBHcmVlbiA8ZGJyeWFuLmdyZWVuQGdtYWls LmNvbT4KRGF0ZTogVGh1LCAyMyBPY3QgMjAyNSAxMzo1Mjo1MSAtMDUwMApTdWJqZWN0OiBb UEFUQ0hdIEZpeCBwZ19jdGwgb24gV2luZG93cyB0byByZWxpYWJseSBkZXRlY3QgYWxyZWFk eS1ydW5uaW5nCiBwb3N0bWFzdGVyLgoKVGhlIHByZXZpb3VzIGltcGxlbWVudGF0aW9uIGlu dm9rZWQgcG9zdGdyZXMuZXhlIHZpYSBjbWQuZXhlLCB3aGljaCBtZWFudApwZ19jdGwgZ290 IHRoZSBQSUQgb2YgdGhlIHNoZWxsIHdyYXBwZXIgcmF0aGVyIHRoYW4gdGhlIGFjdHVhbCBw b3N0bWFzdGVyCnByb2Nlc3MuICBUaGlzIGNhdXNlZCBwcm9ibGVtcyBpbiB3YWl0X2Zvcl9w b3N0bWFzdGVyX3N0YXJ0KCksIHdoaWNoIHRyaWVzCnRvIHZlcmlmeSB0aGF0IHRoZSBQSUQg aW4gcG9zdG1hc3Rlci5waWQgbWF0Y2hlcyB0aGUgb25lIHdlIHN0YXJ0ZWQuICBUaGUKbWlz bWF0Y2ggbGVkIHRvIGEgdGltaW5nIHdpbmRvdyB3aGVyZSBwZ19jdGwgY291bGQgaW5jb3Jy ZWN0bHkgcmVwb3J0CnN1Y2Nlc3Mgd2hlbiBhdHRlbXB0aW5nIHRvIHN0YXJ0IGFuIGFscmVh ZHktcnVubmluZyBjbHVzdGVyLgoKRml4IGJ5IHJlcGxhY2luZyB0aGUgY21kLmV4ZSB3cmFw cGVyIHdpdGggYSBkaXJlY3QgQ3JlYXRlUHJvY2VzcygpIGNhbGwuClRoaXMgZ2l2ZXMgdXMg dGhlIHJlYWwgcG9zdGdyZXMuZXhlIFBJRCBpbW1lZGlhdGVseSwgZWxpbWluYXRpbmcgdGhl Cm5lZWQgZm9yIHByb2Nlc3MgdHJlZSB3YWxraW5nIG9yIG90aGVyIGhldXJpc3RpY3MgdG8g ZmluZCB0aGUgYWN0dWFsCnBvc3RtYXN0ZXIuICBXZSBoYW5kbGUgSS9PIHJlZGlyZWN0aW9u IHVzaW5nIFdpbmRvd3MgaGFuZGxlLWJhc2VkIEFQSXMKaW5zdGVhZCBvZiBzaGVsbCBzeW50 YXgsIHdoaWNoIGlzIG1vcmUgcmVsaWFibGUgYW55d2F5LgotLS0KIHNyYy9iaW4vcGdfY3Rs L3BnX2N0bC5jIHwgNTI4ICsrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0t LS0KIDEgZmlsZSBjaGFuZ2VkLCAzNzMgaW5zZXJ0aW9ucygrKSwgMTU1IGRlbGV0aW9ucygt KQoKZGlmZiAtLWdpdCBhL3NyYy9iaW4vcGdfY3RsL3BnX2N0bC5jIGIvc3JjL2Jpbi9wZ19j dGwvcGdfY3RsLmMKaW5kZXggOGE0MDVmZjEyMi4uNjE1OGZhM2I5OSAxMDA2NDQKLS0tIGEv c3JjL2Jpbi9wZ19jdGwvcGdfY3RsLmMKKysrIGIvc3JjL2Jpbi9wZ19jdGwvcGdfY3RsLmMK QEAgLTcyLDYgKzcyLDcgQEAgdHlwZWRlZiBlbnVtCiAKICNkZWZpbmUgV0FJVFNfUEVSX1NF QwkxMAkJLyogc2hvdWxkIGRpdmlkZSBVU0VDX1BFUl9TRUMgZXZlbmx5ICovCiAKK3N0YXRp YyBwaWRfdCBwbV9waWQgPSAwOwogc3RhdGljIGJvb2wgZG9fd2FpdCA9IHRydWU7CiBzdGF0 aWMgaW50CXdhaXRfc2Vjb25kcyA9IERFRkFVTFRfV0FJVDsKIHN0YXRpYyBib29sIHdhaXRf c2Vjb25kc19hcmcgPSBmYWxzZTsKQEAgLTk5LDcgKzEwMCw2IEBAIHN0YXRpYyBjaGFyIHZl cnNpb25fZmlsZVtNQVhQR1BBVEhdOwogc3RhdGljIGNoYXIgcGlkX2ZpbGVbTUFYUEdQQVRI XTsKIHN0YXRpYyBjaGFyIHByb21vdGVfZmlsZVtNQVhQR1BBVEhdOwogc3RhdGljIGNoYXIg bG9ncm90YXRlX2ZpbGVbTUFYUEdQQVRIXTsKLQogc3RhdGljIHZvbGF0aWxlIHBpZF90IHBv c3RtYXN0ZXJQSUQgPSAtMTsKIAogI2lmZGVmIFdJTjMyCkBAIC0xNDIsMTIgKzE0MiwxNCBA QCBzdGF0aWMgdm9pZCBXSU5BUEkgcGd3aW4zMl9TZXJ2aWNlTWFpbihEV09SRCwgTFBUU1RS ICopOwogc3RhdGljIHZvaWQgcGd3aW4zMl9kb1J1bkFzU2VydmljZSh2b2lkKTsKIHN0YXRp YyBpbnQJQ3JlYXRlUmVzdHJpY3RlZFByb2Nlc3MoY2hhciAqY21kLCBQUk9DRVNTX0lORk9S TUFUSU9OICpwcm9jZXNzSW5mbywgYm9vbCBhc19zZXJ2aWNlKTsKIHN0YXRpYyBQVE9LRU5f UFJJVklMRUdFUyBHZXRQcml2aWxlZ2VzVG9EZWxldGUoSEFORExFIGhUb2tlbik7CitzdGF0 aWMgdm9pZCBJbmhlcml0U3RkSGFuZGxlcyhTVEFSVFVQSU5GTyAqc2kpOworc3RhdGljIEhB TkRMRSBjcmVhdGVfcmVzdHJpY3RlZF90b2tlbih2b2lkKTsKICNlbmRpZgogCiBzdGF0aWMg cGlkX3QgZ2V0X3BncGlkKGJvb2wgaXNfc3RhdHVzX3JlcXVlc3QpOwogc3RhdGljIGNoYXIg KipyZWFkZmlsZShjb25zdCBjaGFyICpwYXRoLCBpbnQgKm51bWxpbmVzKTsKIHN0YXRpYyB2 b2lkIGZyZWVfcmVhZGZpbGUoY2hhciAqKm9wdGxpbmVzKTsKLXN0YXRpYyBwaWRfdCBzdGFy dF9wb3N0bWFzdGVyKHZvaWQpOworc3RhdGljIHZvaWQgc3RhcnRfcG9zdG1hc3Rlcih2b2lk KTsKIHN0YXRpYyB2b2lkIHJlYWRfcG9zdF9vcHRzKHZvaWQpOwogCiBzdGF0aWMgV2FpdFBN UmVzdWx0IHdhaXRfZm9yX3Bvc3RtYXN0ZXJfc3RhcnQocGlkX3QgcG1fcGlkLCBib29sIGRv X2NoZWNrcG9pbnQpOwpAQCAtNDIxLDU2ICs0MjMsMzIxIEBAIGZyZWVfcmVhZGZpbGUoY2hh ciAqKm9wdGxpbmVzKQogCWZyZWUob3B0bGluZXMpOwogfQogCisKIC8qCi0gKiBzdGFydC90 ZXN0L3N0b3Agcm91dGluZXMKKyAqIHN0YXJ0L3Rlc3Qvc3RvcCByb3V0aW5lcyAgCiAgKi8K KyNpZmRlZiBXSU4zMgorLyoKKyAqIEhlbHBlciBmdW5jdGlvbiB0byBkcm9wIHByaXZpbGVn ZXMgYmVmb3JlIGxhdW5jaGluZyBwb3N0Z3Jlcy4KKyAqLworc3RhdGljIEhBTkRMRQorY3Jl YXRlX3Jlc3RyaWN0ZWRfdG9rZW4odm9pZCkKK3sKKwlIQU5ETEUJCW9yaWdUb2tlbjsKKwlI QU5ETEUJCXJlc3RyaWN0ZWRUb2tlbjsKKwlTSURfSURFTlRJRklFUl9BVVRIT1JJVFkgTnRB dXRob3JpdHkgPSB7U0VDVVJJVFlfTlRfQVVUSE9SSVRZfTsKKwlTSURfQU5EX0FUVFJJQlVU RVMgZHJvcFNpZHNbMl07CisJUFRPS0VOX1BSSVZJTEVHRVMgZGVsUHJpdnM7CisJQk9PTAkJ YjsKKworCWlmICghT3BlblByb2Nlc3NUb2tlbihHZXRDdXJyZW50UHJvY2VzcygpLCBUT0tF Tl9BTExfQUNDRVNTLCAmb3JpZ1Rva2VuKSkKKwl7CisJCXdyaXRlX3N0ZGVycihfKCIlczog Y291bGQgbm90IG9wZW4gcHJvY2VzcyB0b2tlbjogZXJyb3IgY29kZSAlbHVcbiIpLAorCQkJ CQkgcHJvZ25hbWUsICh1bnNpZ25lZCBsb25nKSBHZXRMYXN0RXJyb3IoKSk7CisJCXJldHVy biBOVUxMOworCX0KKworCVplcm9NZW1vcnkoJmRyb3BTaWRzLCBzaXplb2YoZHJvcFNpZHMp KTsKKwlpZiAoIUFsbG9jYXRlQW5kSW5pdGlhbGl6ZVNpZCgmTnRBdXRob3JpdHksIDIsCisJ CQkJCQkJCSAgU0VDVVJJVFlfQlVJTFRJTl9ET01BSU5fUklELCBET01BSU5fQUxJQVNfUklE X0FETUlOUywgMCwgMCwgMCwgMCwgMCwKKwkJCQkJCQkJICAwLCAmZHJvcFNpZHNbMF0uU2lk KSkKKwl7CisJCXdyaXRlX3N0ZGVycihfKCIlczogY291bGQgbm90IGFsbG9jYXRlIFNJRHM6 IGVycm9yIGNvZGUgJWx1XG4iKSwKKwkJCQkJIHByb2duYW1lLCAodW5zaWduZWQgbG9uZykg R2V0TGFzdEVycm9yKCkpOworCQlDbG9zZUhhbmRsZShvcmlnVG9rZW4pOworCQlyZXR1cm4g TlVMTDsKKwl9CisKKwlkZWxQcml2cyA9IEdldFByaXZpbGVnZXNUb0RlbGV0ZShvcmlnVG9r ZW4pOworCWlmIChkZWxQcml2cyA9PSBOVUxMKQorCXsKKwkJRnJlZVNpZChkcm9wU2lkc1sx XS5TaWQpOworCQlGcmVlU2lkKGRyb3BTaWRzWzBdLlNpZCk7CisJCUNsb3NlSGFuZGxlKG9y aWdUb2tlbik7CisJCXJldHVybiBOVUxMOworCX0KKworCWIgPSBDcmVhdGVSZXN0cmljdGVk VG9rZW4ob3JpZ1Rva2VuLAorCQkJCQkJCSAgMCwKKwkJCQkJCQkgIHNpemVvZihkcm9wU2lk cykgLyBzaXplb2YoZHJvcFNpZHNbMF0pLAorCQkJCQkJCSAgZHJvcFNpZHMsCisJCQkJCQkJ ICBkZWxQcml2cy0+UHJpdmlsZWdlQ291bnQsIGRlbFByaXZzLT5Qcml2aWxlZ2VzLAorCQkJ CQkJCSAgMCwgTlVMTCwKKwkJCQkJCQkgICZyZXN0cmljdGVkVG9rZW4pOworCisJZnJlZShk ZWxQcml2cyk7CisJRnJlZVNpZChkcm9wU2lkc1sxXS5TaWQpOworCUZyZWVTaWQoZHJvcFNp ZHNbMF0uU2lkKTsKKwlDbG9zZUhhbmRsZShvcmlnVG9rZW4pOworCisJaWYgKCFiKQorCXsK KwkJd3JpdGVfc3RkZXJyKF8oIiVzOiBjb3VsZCBub3QgY3JlYXRlIHJlc3RyaWN0ZWQgdG9r ZW46IGVycm9yIGNvZGUgJWx1XG4iKSwKKwkJCQkJIHByb2duYW1lLCAodW5zaWduZWQgbG9u ZykgR2V0TGFzdEVycm9yKCkpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlyZXR1cm4gcmVz dHJpY3RlZFRva2VuOworfQorCisKK3N0YXRpYyBwaWRfdAorc3RhcnRfcG9zdG1hc3Rlcl93 aW4zMih2b2lkKQoreworCUhBTkRMRQkJaE91dHB1dEZpbGUgPSBJTlZBTElEX0hBTkRMRV9W QUxVRTsKKwlIQU5ETEUJCWhFcnJvckZpbGUgPSBJTlZBTElEX0hBTkRMRV9WQUxVRTsKKwlI QU5ETEUJCWhJbnB1dEZpbGUgPSBJTlZBTElEX0hBTkRMRV9WQUxVRTsKKwlIQU5ETEUJCXJl c3RyaWN0ZWRUb2tlbiA9IE5VTEw7CisJU1RBUlRVUElORk8gc2k7CisJUFJPQ0VTU19JTkZP Uk1BVElPTiBwaTsKKwljaGFyCQljbWRbTUFYUEdQQVRIICogMiArIDI1Nl07CisJU0VDVVJJ VFlfQVRUUklCVVRFUyBzYTsKKwlEV09SRAkJY3JlYXRpb25fZmxhZ3M7CisJRFdPUkQJCWNy ZWF0ZV9lcnJvcjsKKwlCT09MCQlyZXQ7CisJY2hhcgkgICAqY21kbGluZTsKKwlpbnQJCQlj bWRsZW47CisJQk9PTAkJb3duX2hhbmRsZXMgPSBGQUxTRTsKKworCWNtZGxlbiA9IHNucHJp bnRmKGNtZCwgc2l6ZW9mKGNtZCksICJcIiVzXCIlcyVzJXMlcyIsCisJCQkJCSAgZXhlY19w YXRoLAorCQkJCQkgIHBnZGF0YV9vcHQgPyAiICIgOiAiIiwKKwkJCQkJICBwZ2RhdGFfb3B0 ID8gcGdkYXRhX29wdCA6ICIiLAorCQkJCQkgIHBvc3Rfb3B0cyA/ICIgIiA6ICIiLAorCQkJ CQkgIHBvc3Rfb3B0cyA/IHBvc3Rfb3B0cyA6ICIiKTsKKworCWlmIChjbWRsZW4gPj0gc2l6 ZW9mKGNtZCkpCisJeworCQl3cml0ZV9zdGRlcnIoXygiJXM6IGNvbW1hbmQgbGluZSB0b28g bG9uZ1xuIiksIHByb2duYW1lKTsKKwkJcmV0dXJuIDA7CisJfQorCisJY21kbGluZSA9IHBn X3N0cmR1cChjbWQpOworCisJcmVzdHJpY3RlZFRva2VuID0gY3JlYXRlX3Jlc3RyaWN0ZWRf dG9rZW4oKTsKKwlpZiAocmVzdHJpY3RlZFRva2VuID09IE5VTEwpCisJeworCQlmcmVlKGNt ZGxpbmUpOworCQlleGl0KDEpOworCX0KKworCVplcm9NZW1vcnkoJnNpLCBzaXplb2Yoc2kp KTsKKwlzaS5jYiA9IHNpemVvZihzaSk7CisKKwlpZiAobG9nX2ZpbGUgIT0gTlVMTCkKKwl7 CisJCVplcm9NZW1vcnkoJnNhLCBzaXplb2Yoc2EpKTsKKwkJc2Eubkxlbmd0aCA9IHNpemVv ZihzYSk7CisJCXNhLmJJbmhlcml0SGFuZGxlID0gVFJVRTsKKwkJc2EubHBTZWN1cml0eURl c2NyaXB0b3IgPSBOVUxMOworCisJCWhJbnB1dEZpbGUgPSBDcmVhdGVGaWxlKCJOVUwiLAor CQkJCQkJCQlHRU5FUklDX1JFQUQsCisJCQkJCQkJCUZJTEVfU0hBUkVfUkVBRCB8IEZJTEVf U0hBUkVfV1JJVEUsCisJCQkJCQkJCSZzYSwKKwkJCQkJCQkJT1BFTl9FWElTVElORywKKwkJ CQkJCQkJRklMRV9BVFRSSUJVVEVfTk9STUFMLAorCQkJCQkJCQlOVUxMKTsKKworCQlpZiAo aElucHV0RmlsZSA9PSBJTlZBTElEX0hBTkRMRV9WQUxVRSkKKwkJeworCQkJd3JpdGVfc3Rk ZXJyKF8oIiVzOiBjb3VsZCBub3Qgb3BlbiBOVUwgZGV2aWNlOiBlcnJvciBjb2RlICVsdVxu IiksCisJCQkJCQkgcHJvZ25hbWUsIEdldExhc3RFcnJvcigpKTsKKwkJCUNsb3NlSGFuZGxl KHJlc3RyaWN0ZWRUb2tlbik7CisJCQlmcmVlKGNtZGxpbmUpOworCQkJcmV0dXJuIDA7CisJ CX0KKworCQloT3V0cHV0RmlsZSA9IENyZWF0ZUZpbGUobG9nX2ZpbGUsCisJCQkJCQkJCSBH RU5FUklDX1dSSVRFLAorCQkJCQkJCQkgRklMRV9TSEFSRV9SRUFEIHwgRklMRV9TSEFSRV9X UklURSwKKwkJCQkJCQkJICZzYSwKKwkJCQkJCQkJIE9QRU5fQUxXQVlTLAorCQkJCQkJCQkg RklMRV9BVFRSSUJVVEVfTk9STUFMLAorCQkJCQkJCQkgTlVMTCk7CisKKwkJaWYgKGhPdXRw dXRGaWxlID09IElOVkFMSURfSEFORExFX1ZBTFVFKQorCQl7CisJCQl3cml0ZV9zdGRlcnIo XygiJXM6IGNvdWxkIG5vdCBvcGVuIGxvZyBmaWxlIFwiJXNcIjogZXJyb3IgY29kZSAlbHVc biIpLAorCQkJCQkJIHByb2duYW1lLCBsb2dfZmlsZSwgR2V0TGFzdEVycm9yKCkpOworCQkJ Q2xvc2VIYW5kbGUoaElucHV0RmlsZSk7CisJCQlDbG9zZUhhbmRsZShyZXN0cmljdGVkVG9r ZW4pOworCQkJZnJlZShjbWRsaW5lKTsKKwkJCXJldHVybiAwOworCQl9CisKKwkJaWYgKFNl dEZpbGVQb2ludGVyKGhPdXRwdXRGaWxlLCAwLCBOVUxMLCBGSUxFX0VORCkgPT0gSU5WQUxJ RF9TRVRfRklMRV9QT0lOVEVSICYmCisJCQlHZXRMYXN0RXJyb3IoKSAhPSBOT19FUlJPUikK KwkJeworCQkJd3JpdGVfc3RkZXJyKF8oIiVzOiBjb3VsZCBub3Qgc2VlayB0byBlbmQgb2Yg bG9nIGZpbGU6IGVycm9yIGNvZGUgJWx1XG4iKSwKKwkJCQkJCSBwcm9nbmFtZSwgR2V0TGFz dEVycm9yKCkpOworCQkJQ2xvc2VIYW5kbGUoaE91dHB1dEZpbGUpOworCQkJQ2xvc2VIYW5k bGUoaElucHV0RmlsZSk7CisJCQlDbG9zZUhhbmRsZShyZXN0cmljdGVkVG9rZW4pOworCQkJ ZnJlZShjbWRsaW5lKTsKKwkJCXJldHVybiAwOworCQl9CisKKwkJaEVycm9yRmlsZSA9IGhP dXRwdXRGaWxlOworCisJCXNpLmR3RmxhZ3MgPSBTVEFSVEZfVVNFU1RESEFORExFUzsKKwkJ c2kuaFN0ZElucHV0ID0gaElucHV0RmlsZTsKKwkJc2kuaFN0ZE91dHB1dCA9IGhPdXRwdXRG aWxlOworCQlzaS5oU3RkRXJyb3IgPSBoRXJyb3JGaWxlOworCisJCWNyZWF0aW9uX2ZsYWdz ID0gQ1JFQVRFX05PX1dJTkRPVyB8IENSRUFURV9ORVdfUFJPQ0VTU19HUk9VUCB8IENSRUFU RV9TVVNQRU5ERUQ7CisKKwkJb3duX2hhbmRsZXMgPSBUUlVFOworCX0KKwllbHNlCisJewor CQlJbmhlcml0U3RkSGFuZGxlcygmc2kpOworCQljcmVhdGlvbl9mbGFncyA9IENSRUFURV9T VVNQRU5ERUQ7CisJfQorCisJWmVyb01lbW9yeSgmcGksIHNpemVvZihwaSkpOworCisJcmV0 ID0gQ3JlYXRlUHJvY2Vzc0FzVXNlcihyZXN0cmljdGVkVG9rZW4sCQkvKiByZXN0cmljdGVk IHNlY3VyaXR5IHRva2VuICovCisJCQkJCQkJICBOVUxMLAkJCQkJLyogYXBwbGljYXRpb24g bmFtZSAqLworCQkJCQkJCSAgY21kbGluZSwJCQkJLyogY29tbWFuZCBsaW5lICovCisJCQkJ CQkJICBOVUxMLAkJCQkJLyogcHJvY2VzcyBzZWN1cml0eSBhdHRyaWJ1dGVzICovCisJCQkJ CQkJICBOVUxMLAkJCQkJLyogdGhyZWFkIHNlY3VyaXR5IGF0dHJpYnV0ZXMgKi8KKwkJCQkJ CQkgIFRSVUUsCQkJCQkvKiBpbmhlcml0IGhhbmRsZXMgKi8KKwkJCQkJCQkgIGNyZWF0aW9u X2ZsYWdzLAkJLyogY3JlYXRpb24gZmxhZ3MgKi8KKwkJCQkJCQkgIE5VTEwsCQkJCQkvKiBl bnZpcm9ubWVudCAqLworCQkJCQkJCSAgcGdfZGF0YSwJCQkJLyogY3VycmVudCBkaXJlY3Rv cnkgKi8KKwkJCQkJCQkgICZzaSwJCQkJCS8qIHN0YXJ0dXAgaW5mbyAqLworCQkJCQkJCSAg JnBpKTsJCQkJCS8qIHByb2Nlc3MgaW5mbyAqLworCisJY3JlYXRlX2Vycm9yID0gR2V0TGFz dEVycm9yKCk7CisKKwlpZiAob3duX2hhbmRsZXMpCisJeworCQlpZiAoaElucHV0RmlsZSAh PSBJTlZBTElEX0hBTkRMRV9WQUxVRSkKKwkJCUNsb3NlSGFuZGxlKGhJbnB1dEZpbGUpOwor CQlpZiAoaE91dHB1dEZpbGUgIT0gSU5WQUxJRF9IQU5ETEVfVkFMVUUpCisJCQlDbG9zZUhh bmRsZShoT3V0cHV0RmlsZSk7CisJfQorCQorCUNsb3NlSGFuZGxlKHJlc3RyaWN0ZWRUb2tl bik7CisJZnJlZShjbWRsaW5lKTsKKworCWlmICghcmV0KQorCXsKKwkJd3JpdGVfc3RkZXJy KF8oIiVzOiBjb3VsZCBub3Qgc3RhcnQgc2VydmVyOiBlcnJvciBjb2RlICVsdVxuIiksCisJ CQkJCSBwcm9nbmFtZSwgY3JlYXRlX2Vycm9yKTsKKwkJcmV0dXJuIDA7CisJfQorCisJUmVz dW1lVGhyZWFkKHBpLmhUaHJlYWQpOworCUNsb3NlSGFuZGxlKHBpLmhUaHJlYWQpOworCQor CS8qCisJICogV2hlbiB0aGVyZSdzIG5vIGxvZyBmaWxlLCB3YWl0IGJyaWVmbHkgdG8gc2Vl IGlmIHRoZSBwcm9jZXNzIGV4aXRzCisJICogaW1tZWRpYXRlbHkuIFRoaXMgZGlzdGluZ3Vp c2hlcyBwb3N0Z3JlcyAtQyBxdWVyaWVzICh3aGljaCBwcmludCBhCisJICogZnJvbSBhY3R1 YWwgc2VydmVyIHN0YXJ0dXAuIFR3byBzZWNvbmRzIGlzIGxvbmcgZW5vdWdoIHRvIGNhdGNo IAorCSAqIHF1aWNrIGV4aXRzIGV2ZW4gb24gc2xvdyBDSSBzeXN0ZW1zLCBidXQgc3RpbGwg ZmFzdCBlbm91Z2ggbm90IHRvIAorCSAqIGJlIGFubm95aW5nIGZvciBub3JtYWwgc2VydmVy IHN0YXJ0dXAuCisJICovCisJaWYgKGxvZ19maWxlID09IE5VTEwpCisJeworCQlEV09SRCB3 YWl0X3Jlc3VsdDsKKwkJRFdPUkQgZXhpdF9jb2RlOworCQkKKwkJd2FpdF9yZXN1bHQgPSBX YWl0Rm9yU2luZ2xlT2JqZWN0KHBpLmhQcm9jZXNzLCAyMDAwKTsKKwkJCisJCWlmICh3YWl0 X3Jlc3VsdCA9PSBXQUlUX1RJTUVPVVQpCisJCXsKKwkJCS8qIFN0aWxsIHJ1bm5pbmcgYWZ0 ZXIgMiBzZWNvbmRzIC0gYXNzdW1lIHJlYWwgc2VydmVyIHN0YXJ0dXAgKi8KKwkJCXBvc3Rt YXN0ZXJQcm9jZXNzID0gcGkuaFByb2Nlc3M7CisJCQlyZXR1cm4gKHBpZF90KSBwaS5kd1By b2Nlc3NJZDsKKwkJfQorCQllbHNlIGlmICh3YWl0X3Jlc3VsdCA9PSBXQUlUX09CSkVDVF8w KQorCQl7CisJCQkvKiBQcm9jZXNzIGV4aXRlZCBxdWlja2x5IC0gc2VydmVyIGRpZG4ndCBz dGF5IHJ1bm5pbmcgKi8KKwkJCWV4aXRfY29kZSA9IDA7CisJCQlHZXRFeGl0Q29kZVByb2Nl c3MocGkuaFByb2Nlc3MsICZleGl0X2NvZGUpOworCQkJQ2xvc2VIYW5kbGUocGkuaFByb2Nl c3MpOworCQkJd3JpdGVfc3RkZXJyKF8oIiVzOiBjb3VsZCBub3Qgc3RhcnQgc2VydmVyXG4i KSwgcHJvZ25hbWUpOworCQkJcmV0dXJuIDA7CisJCX0KKwkJZWxzZQorCQl7CisJCQkvKiBX YWl0IGZhaWxlZCAqLworCQkJd3JpdGVfc3RkZXJyKF8oIiVzOiBlcnJvciB3YWl0aW5nIGZv ciBzZXJ2ZXI6IGVycm9yIGNvZGUgJWx1XG4iKSwKKwkJCQkJCSBwcm9nbmFtZSwgR2V0TGFz dEVycm9yKCkpOworCQkJQ2xvc2VIYW5kbGUocGkuaFByb2Nlc3MpOworCQkJcmV0dXJuIDA7 CisJCX0KKwl9CisKKwlwb3N0bWFzdGVyUHJvY2VzcyA9IHBpLmhQcm9jZXNzOworCXJldHVy biAocGlkX3QpIHBpLmR3UHJvY2Vzc0lkOworfQorI2VuZGlmCisKIAogLyoKLSAqIFN0YXJ0 IHRoZSBwb3N0bWFzdGVyIGFuZCByZXR1cm4gaXRzIFBJRC4KKyAqIHN0YXJ0X3Bvc3RtYXN0 ZXIKKyAqCisgKiBXcmFwcGVyIGFyb3VuZCB0aGUgcGxhdGZvcm0tc3BlY2lmaWMgY29kZSB0 byBsYXVuY2ggdGhlIHBvc3RtYXN0ZXIuCiAgKgotICogQ3VycmVudGx5LCBvbiBXaW5kb3dz IHdoYXQgd2UgcmV0dXJuIGlzIHRoZSBQSUQgb2YgdGhlIHNoZWxsIHByb2Nlc3MKLSAqIHRo YXQgbGF1bmNoZWQgdGhlIHBvc3RtYXN0ZXIgKGFuZCwgd2UgdHJ1c3QsIGlzIHdhaXRpbmcg Zm9yIGl0IHRvIGV4aXQpLgotICogU28gdGhlIFBJRCBpcyB1c2FibGUgZm9yICJpcyB0aGUg cG9zdG1hc3RlciBzdGlsbCBydW5uaW5nIiBjaGVja3MsCi0gKiBidXQgY2Fubm90IGJlIGNv bXBhcmVkIGRpcmVjdGx5IHRvIHBvc3RtYXN0ZXIucGlkLgorICogT24gVW5peCwgd2UgZm9y ayBhbmQgZXhlYy4gVGhlcmUncyBubyBleHRyYSBwcm9jZXNzIGxheWVyOworICogd2UgZ2V0 IHRoZSBwb3N0Z3JlcyBQSUQgZGlyZWN0bHkuCiAgKgotICogT24gV2luZG93cywgd2UgYWxz byBzYXZlIGFzaWRlIGEgaGFuZGxlIHRvIHRoZSBzaGVsbCBwcm9jZXNzIGluCi0gKiAicG9z dG1hc3RlclByb2Nlc3MiLCB3aGljaCB0aGUgY2FsbGVyIHNob3VsZCBjbG9zZSB3aGVuIGRv bmUgd2l0aCBpdC4KKyAqIE9uIFdpbmRvd3MsIHdlIHVzZSBDcmVhdGVQcm9jZXNzIHRvIGxh dW5jaCBwb3N0Z3Jlcy5leGUgZGlyZWN0bHksIHdoaWNoCisgKiBnaXZlcyB1cyBpdHMgUElE IGltbWVkaWF0ZWx5LgogICovCi1zdGF0aWMgcGlkX3QKK3N0YXRpYyB2b2lkCiBzdGFydF9w b3N0bWFzdGVyKHZvaWQpCiB7CisjaWZkZWYgV0lOMzIKKwlwbV9waWQgPSBzdGFydF9wb3N0 bWFzdGVyX3dpbjMyKCk7CisJaWYgKHBtX3BpZCA9PSAwKQorCQlleGl0KDEpOworI2Vsc2UK IAljaGFyCSAgICpjbWQ7CisJaW50CQkJY21kbGVuOworCXBpZF90CQlmb3JrX3BpZDsKIAot I2lmbmRlZiBXSU4zMgotCXBpZF90CQlwbV9waWQ7Ci0KLQkvKiBGbHVzaCBzdGRpbyBjaGFu bmVscyBqdXN0IGJlZm9yZSBmb3JrLCB0byBhdm9pZCBkb3VibGUtb3V0cHV0IHByb2JsZW1z ICovCisJLyogRmx1c2ggc3RkaW8gdG8gYXZvaWQgZG91YmxlLW91dHB1dCBwcm9ibGVtcyBh ZnRlciBmb3JrICovCiAJZmZsdXNoKE5VTEwpOwogCiAjaWZkZWYgRVhFQ19CQUNLRU5ECiAJ cGdfZGlzYWJsZV9hc2xyKCk7CiAjZW5kaWYKIAotCXBtX3BpZCA9IGZvcmsoKTsKLQlpZiAo cG1fcGlkIDwgMCkKKwlmb3JrX3BpZCA9IGZvcmsoKTsKKwlpZiAoZm9ya19waWQgPCAwKQog CXsKLQkJLyogZm9yayBmYWlsZWQgKi8KIAkJd3JpdGVfc3RkZXJyKF8oIiVzOiBjb3VsZCBu b3Qgc3RhcnQgc2VydmVyOiAlbVxuIiksCiAJCQkJCSBwcm9nbmFtZSk7CiAJCWV4aXQoMSk7 CiAJfQotCWlmIChwbV9waWQgPiAwKQorCWlmIChmb3JrX3BpZCA+IDApCiAJewotCQkvKiBm b3JrIHN1Y2NlZWRlZCwgaW4gcGFyZW50ICovCi0JCXJldHVybiBwbV9waWQ7CisJCS8qIFBh cmVudCBwcm9jZXNzICovCisJCXBtX3BpZCA9IGZvcmtfcGlkOworCQlyZXR1cm47CiAJfQog Ci0JLyogZm9yayBzdWNjZWVkZWQsIGluIGNoaWxkICovCisJLyogQ2hpbGQgcHJvY2VzcyAq LwogCiAJLyoKLQkgKiBJZiBwb3NzaWJsZSwgZGV0YWNoIHRoZSBwb3N0bWFzdGVyIHByb2Nl c3MgZnJvbSB0aGUgbGF1bmNoaW5nIHByb2Nlc3MKLQkgKiBncm91cCBhbmQgbWFrZSBpdCBh IGdyb3VwIGxlYWRlciwgc28gdGhhdCBpdCBkb2Vzbid0IGdldCBzaWduYWxlZCBhbG9uZwot CSAqIHdpdGggdGhlIGN1cnJlbnQgZ3JvdXAgdGhhdCBsYXVuY2hlZCBpdC4KKwkgKiBEZXRh Y2ggZnJvbSB0aGUgcGFyZW50J3MgcHJvY2VzcyBncm91cCBzbyB3ZSBkb24ndCBnZXQgc2ln bmFsZWQKKwkgKiBhbG9uZyB3aXRoIGl0LiAgVGhpcyBpcyB0aGUgZXF1aXZhbGVudCBvZiB3 aGF0IENSRUFURV9ORVdfUFJPQ0VTU19HUk9VUAorCSAqIGRvZXMgb24gV2luZG93cy4KIAkg Ki8KICNpZmRlZiBIQVZFX1NFVFNJRAogCWlmIChzZXRzaWQoKSA8IDApCkBAIC00ODIsMTEy ICs3NDksNzIgQEAgc3RhcnRfcG9zdG1hc3Rlcih2b2lkKQogI2VuZGlmCiAKIAkvKgotCSAq IFNpbmNlIHRoZXJlIG1pZ2h0IGJlIHF1b3RlcyB0byBoYW5kbGUgaGVyZSwgaXQgaXMgZWFz aWVyIHNpbXBseSB0byBwYXNzCi0JICogZXZlcnl0aGluZyB0byBhIHNoZWxsIHRvIHByb2Nl c3MgdGhlbS4gIFVzZSBleGVjIHNvIHRoYXQgdGhlIHBvc3RtYXN0ZXIKLQkgKiBoYXMgdGhl IHNhbWUgUElEIGFzIHRoZSBjdXJyZW50IGNoaWxkIHByb2Nlc3MuCisJICogQnVpbGQgdGhl IHNoZWxsIGNvbW1hbmQuICBXZSB1c2UgImV4ZWMiIHNvIHRoZSBzaGVsbCByZXBsYWNlcyBp dHNlbGYKKwkgKiB3aXRoIHBvc3RncmVzLCByYXRoZXIgdGhhbiBrZWVwaW5nIHRoZSBzaGVs bCBwcm9jZXNzIGFyb3VuZC4KIAkgKi8KIAlpZiAobG9nX2ZpbGUgIT0gTlVMTCkKLQkJY21k ID0gcHNwcmludGYoImV4ZWMgXCIlc1wiICVzJXMgPCBcIiVzXCIgPj4gXCIlc1wiIDI+JjEi LAotCQkJCQkgICBleGVjX3BhdGgsIHBnZGF0YV9vcHQsIHBvc3Rfb3B0cywKLQkJCQkJICAg REVWTlVMTCwgbG9nX2ZpbGUpOworCXsKKwkJY21kbGVuID0gc25wcmludGYoTlVMTCwgMCwg ImV4ZWMgXCIlc1wiICVzJXMgPCBcIiVzXCIgPj4gXCIlc1wiIDI+JjEiLAorCQkJCQkJICBl eGVjX3BhdGgsCisJCQkJCQkgIHBnZGF0YV9vcHQgPyBwZ2RhdGFfb3B0IDogIiIsCisJCQkJ CQkgIHBvc3Rfb3B0cyA/IHBvc3Rfb3B0cyA6ICIiLAorCQkJCQkJICBERVZOVUxMLCBsb2df ZmlsZSk7CisJfQogCWVsc2UKLQkJY21kID0gcHNwcmludGYoImV4ZWMgXCIlc1wiICVzJXMg PCBcIiVzXCIgMj4mMSIsCi0JCQkJCSAgIGV4ZWNfcGF0aCwgcGdkYXRhX29wdCwgcG9zdF9v cHRzLCBERVZOVUxMKTsKLQotCSh2b2lkKSBleGVjbCgiL2Jpbi9zaCIsICIvYmluL3NoIiwg Ii1jIiwgY21kLCAoY2hhciAqKSBOVUxMKTsKLQotCS8qIGV4ZWMgZmFpbGVkICovCi0Jd3Jp dGVfc3RkZXJyKF8oIiVzOiBjb3VsZCBub3Qgc3RhcnQgc2VydmVyOiAlbVxuIiksCi0JCQkJ IHByb2duYW1lKTsKLQlleGl0KDEpOwotCi0JcmV0dXJuIDA7CQkJCQkvKiBrZWVwIGR1bWIg Y29tcGlsZXJzIHF1aWV0ICovCi0KLSNlbHNlCQkJCQkJCS8qIFdJTjMyICovCi0KLQkvKgot CSAqIEFzIHdpdGggdGhlIFVuaXggY2FzZSwgaXQncyBlYXNpZXN0IHRvIHVzZSB0aGUgc2hl bGwgKENNRC5FWEUpIHRvCi0JICogaGFuZGxlIHJlZGlyZWN0aW9uIGV0Yy4gIFVuZm9ydHVu YXRlbHkgQ01ELkVYRSBsYWNrcyBhbnkgZXF1aXZhbGVudCBvZgotCSAqICJleGVjIiwgc28g d2UgZG9uJ3QgZ2V0IHRvIGZpbmQgb3V0IHRoZSBwb3N0bWFzdGVyJ3MgUElEIGltbWVkaWF0 ZWx5LgotCSAqLwotCVBST0NFU1NfSU5GT1JNQVRJT04gcGk7Ci0JY29uc3QgY2hhciAqY29t c3BlYzsKKwl7CisJCWNtZGxlbiA9IHNucHJpbnRmKE5VTEwsIDAsICJleGVjIFwiJXNcIiAl cyVzIDwgXCIlc1wiIDI+JjEiLAorCQkJCQkJICBleGVjX3BhdGgsCisJCQkJCQkgIHBnZGF0 YV9vcHQgPyBwZ2RhdGFfb3B0IDogIiIsCisJCQkJCQkgIHBvc3Rfb3B0cyA/IHBvc3Rfb3B0 cyA6ICIiLAorCQkJCQkJICBERVZOVUxMKTsKKwl9CiAKLQkvKiBGaW5kIENNRC5FWEUgbG9j YXRpb24gdXNpbmcgQ09NU1BFQywgaWYgaXQncyBzZXQgKi8KLQljb21zcGVjID0gZ2V0ZW52 KCJDT01TUEVDIik7Ci0JaWYgKGNvbXNwZWMgPT0gTlVMTCkKLQkJY29tc3BlYyA9ICJDTUQi OworCWNtZCA9IHBnX21hbGxvYyhjbWRsZW4gKyAxKTsKIAogCWlmIChsb2dfZmlsZSAhPSBO VUxMKQogCXsKLQkJLyoKLQkJICogRmlyc3QsIG9wZW4gdGhlIGxvZyBmaWxlIGlmIGl0IGV4 aXN0cy4gIFRoZSBpZGVhIGlzIHRoYXQgaWYgdGhlCi0JCSAqIGZpbGUgaXMgc3RpbGwgbG9j a2VkIGJ5IGEgcHJldmlvdXMgcG9zdG1hc3RlciBydW4sIHdlJ2xsIHdhaXQgdW50aWwKLQkJ ICogaXQgY29tZXMgZnJlZSwgaW5zdGVhZCBvZiBmYWlsaW5nIHdpdGggRVJST1JfU0hBUklO R19WSU9MQVRJT04uCi0JCSAqIChJdCdkIGJlIGJldHRlciB0byBvcGVuIHRoZSBmaWxlIGlu IGEgc2hhcmluZy1mcmllbmRseSBtb2RlLCBidXQgd2UKLQkJICogY2FuJ3QgdXNlIENNRC5F WEUgdG8gZG8gdGhhdCwgc28gd29yayBhcm91bmQgaXQuICBOb3RlIHRoYXQgdGhlCi0JCSAq IHByZXZpb3VzIHBvc3RtYXN0ZXIgd2lsbCBzdGlsbCBoYXZlIHRoZSBmaWxlIG9wZW4gZm9y IGEgc2hvcnQgdGltZQotCQkgKiBhZnRlciByZW1vdmluZyBwb3N0bWFzdGVyLnBpZC4pCi0J CSAqCi0JCSAqIElmIHRoZSBsb2cgZmlsZSBkb2Vzbid0IGV4aXN0LCB3ZSAqbXVzdCBub3Qq IGNyZWF0ZSBpdCBoZXJlLiAgSWYgd2UKLQkJICogd2VyZSBsYXVuY2hlZCB3aXRoIGhpZ2hl ciBwcml2aWxlZ2VzIHRoYW4gdGhlIHJlc3RyaWN0ZWQgcHJvY2VzcwotCQkgKiB3aWxsIGhh dmUsIHRoZSBsb2cgZmlsZSBtaWdodCBlbmQgdXAgd2l0aCBwZXJtaXNzaW9ucyBzZXR0aW5n cyB0aGF0Ci0JCSAqIHByZXZlbnQgdGhlIHBvc3RtYXN0ZXIgZnJvbSB3cml0aW5nIG9uIGl0 LgotCQkgKi8KLQkJaW50CQkJZmQgPSBvcGVuKGxvZ19maWxlLCBPX1JEV1IsIDApOwotCi0J CWlmIChmZCA9PSAtMSkKLQkJewotCQkJLyoKLQkJCSAqIEVOT0VOVCBpcyBleHBlY3RhYmxl IHNpbmNlIHdlIGRpZG4ndCB1c2UgT19DUkVBVC4gIE90aGVyd2lzZQotCQkJICogY29tcGxh aW4uICBXZSBjb3VsZCBqdXN0IGZhbGwgdGhyb3VnaCBhbmQgbGV0IENNRC5FWEUgcmVwb3J0 Ci0JCQkgKiB0aGUgcHJvYmxlbSwgYnV0IGl0cyBlcnJvciByZXBvcnRpbmcgaXMgcHJldHR5 IG1pc2VyYWJsZS4KLQkJCSAqLwotCQkJaWYgKGVycm5vICE9IEVOT0VOVCkKLQkJCXsKLQkJ CQl3cml0ZV9zdGRlcnIoXygiJXM6IGNvdWxkIG5vdCBvcGVuIGxvZyBmaWxlIFwiJXNcIjog JW1cbiIpLAotCQkJCQkJCSBwcm9nbmFtZSwgbG9nX2ZpbGUpOwotCQkJCWV4aXQoMSk7Ci0J CQl9Ci0JCX0KLQkJZWxzZQotCQkJY2xvc2UoZmQpOwotCi0JCWNtZCA9IHBzcHJpbnRmKCJc IiVzXCIgL0MgXCJcIiVzXCIgJXMlcyA8IFwiJXNcIiA+PiBcIiVzXCIgMj4mMVwiIiwKLQkJ CQkJICAgY29tc3BlYywgZXhlY19wYXRoLCBwZ2RhdGFfb3B0LCBwb3N0X29wdHMsIERFVk5V TEwsIGxvZ19maWxlKTsKKwkJc25wcmludGYoY21kLCBjbWRsZW4gKyAxLCAiZXhlYyBcIiVz XCIgJXMlcyA8IFwiJXNcIiA+PiBcIiVzXCIgMj4mMSIsCisJCQkJIGV4ZWNfcGF0aCwKKwkJ CQkgcGdkYXRhX29wdCA/IHBnZGF0YV9vcHQgOiAiIiwKKwkJCQkgcG9zdF9vcHRzID8gcG9z dF9vcHRzIDogIiIsCisJCQkJIERFVk5VTEwsIGxvZ19maWxlKTsKIAl9CiAJZWxzZQotCQlj bWQgPSBwc3ByaW50ZigiXCIlc1wiIC9DIFwiXCIlc1wiICVzJXMgPCBcIiVzXCIgMj4mMVwi IiwKLQkJCQkJICAgY29tc3BlYywgZXhlY19wYXRoLCBwZ2RhdGFfb3B0LCBwb3N0X29wdHMs IERFVk5VTEwpOwotCi0JaWYgKCFDcmVhdGVSZXN0cmljdGVkUHJvY2VzcyhjbWQsICZwaSwg ZmFsc2UpKQogCXsKLQkJd3JpdGVfc3RkZXJyKF8oIiVzOiBjb3VsZCBub3Qgc3RhcnQgc2Vy dmVyOiBlcnJvciBjb2RlICVsdVxuIiksCi0JCQkJCSBwcm9nbmFtZSwgKHVuc2lnbmVkIGxv bmcpIEdldExhc3RFcnJvcigpKTsKLQkJZXhpdCgxKTsKKwkJc25wcmludGYoY21kLCBjbWRs ZW4gKyAxLCAiZXhlYyBcIiVzXCIgJXMlcyA8IFwiJXNcIiAyPiYxIiwKKwkJCQkgZXhlY19w YXRoLAorCQkJCSBwZ2RhdGFfb3B0ID8gcGdkYXRhX29wdCA6ICIiLAorCQkJCSBwb3N0X29w dHMgPyBwb3N0X29wdHMgOiAiIiwKKwkJCQkgREVWTlVMTCk7CiAJfQotCS8qIERvbid0IGNs b3NlIGNvbW1hbmQgcHJvY2VzcyBoYW5kbGUgaGVyZTsgY2FsbGVyIG11c3QgZG8gc28gKi8K LQlwb3N0bWFzdGVyUHJvY2VzcyA9IHBpLmhQcm9jZXNzOwotCUNsb3NlSGFuZGxlKHBpLmhU aHJlYWQpOwotCXJldHVybiBwaS5kd1Byb2Nlc3NJZDsJCS8qIFNoZWxsJ3MgUElELCBub3Qg cG9zdG1hc3RlcidzISAqLworCisJKHZvaWQpIGV4ZWNsKCIvYmluL3NoIiwgIi9iaW4vc2gi LCAiLWMiLCBjbWQsIChjaGFyICopIE5VTEwpOworCisJLyogZXhlYyBmYWlsZWQgKi8KKwl3 cml0ZV9zdGRlcnIoXygiJXM6IGNvdWxkIG5vdCBzdGFydCBzZXJ2ZXI6ICVtXG4iKSwKKwkJ CQkgcHJvZ25hbWUpOworCWV4aXQoMSk7CisKICNlbmRpZgkJCQkJCQkvKiBXSU4zMiAqLwog fQogCiAKLQogLyoKLSAqIFdhaXQgZm9yIHRoZSBwb3N0bWFzdGVyIHRvIGJlY29tZSByZWFk eS4KKyAqIHdhaXRfZm9yX3Bvc3RtYXN0ZXJfc3RhcnQKKyAqCisgKiBXYWl0IGZvciB0aGUg cG9zdG1hc3RlciB0byBmaW5pc2ggc3RhcnRpbmcgdXAgYW5kIGJlY29tZSByZWFkeSB0bwor ICogYWNjZXB0IGNvbm5lY3Rpb25zLgogICoKLSAqIE9uIFVuaXgsIHBtX3BpZCBpcyB0aGUg UElEIG9mIHRoZSBqdXN0LWxhdW5jaGVkIHBvc3RtYXN0ZXIuICBPbiBXaW5kb3dzLAotICog aXQgbWF5IGJlIHRoZSBQSUQgb2YgYW4gYW5jZXN0b3Igc2hlbGwgcHJvY2Vzcywgc28gd2Ug Y2FuJ3QgY2hlY2sgdGhlCi0gKiBjb250ZW50cyBvZiBwb3N0bWFzdGVyLnBpZCBxdWl0ZSBh cyBjYXJlZnVsbHkuCisgKiBPbiBlbnRyeSwgcG1fcGlkIHNob3VsZCBiZSB0aGUgUElEIG9m IHRoZSBwb3N0bWFzdGVyIHdlIGp1c3QgbGF1bmNoZWQuCisgKiBXZSBwb2xsIHBvc3RtYXN0 ZXIucGlkIHRvIHNlZSB3aGVuIGl0J3MgYmVlbiBjcmVhdGVkIGFuZCB3aGV0aGVyIHRoZQor ICogUElEIGluIGl0IG1hdGNoZXMgcG1fcGlkLiAgT25jZSB3ZSBzZWUgYSBtYXRjaGluZyBQ SUQgYW5kIHRoZSBzdGF0dXMKKyAqIGxpbmUgc2F5cyAicmVhZHkiLCB3ZSdyZSBkb25lLgog ICoKLSAqIE9uIFdpbmRvd3MsIHRoZSBzdGF0aWMgdmFyaWFibGUgcG9zdG1hc3RlclByb2Nl c3MgaXMgYW4gaW1wbGljaXQgYXJndW1lbnQKLSAqIHRvIHRoaXMgcm91dGluZTsgaXQgY29u dGFpbnMgYSBoYW5kbGUgdG8gdGhlIHBvc3RtYXN0ZXIgcHJvY2VzcyBvciBhbgotICogYW5j ZXN0b3Igc2hlbGwgcHJvY2VzcyB0aGVyZW9mLgorICogT24gV2luZG93cywgd2UgYWxzbyB1 c2UgdGhlIHBvc3RtYXN0ZXJQcm9jZXNzIGhhbmRsZSAoc2V0IGJ5CisgKiBzdGFydF9wb3N0 bWFzdGVyX3dpbjMyKSB0byBkZXRlY3QgaWYgdGhlIHByb2Nlc3MgZGllcyB1bmV4cGVjdGVk bHkuCiAgKgotICogTm90ZSB0aGF0IHRoZSBjaGVja3BvaW50IHBhcmFtZXRlciBlbmFibGVz IGEgV2luZG93cyBzZXJ2aWNlIGNvbnRyb2wKLSAqIG1hbmFnZXIgY2hlY2twb2ludCwgaXQn cyBnb3Qgbm90aGluZyB0byBkbyB3aXRoIGRhdGFiYXNlIGNoZWNrcG9pbnRzISEKKyAqIFJl dHVybnMgUE9TVE1BU1RFUl9SRUFEWSBpZiBhbGwgaXMgd2VsbCwgUE9TVE1BU1RFUl9TVElM TF9TVEFSVElORyBpZgorICogd2UgcmFuIG91dCBvZiB0aW1lLCBvciBQT1NUTUFTVEVSX0ZB SUxFRCBpZiB0aGUgcG9zdG1hc3RlciBkaWVkLgogICovCiBzdGF0aWMgV2FpdFBNUmVzdWx0 CiB3YWl0X2Zvcl9wb3N0bWFzdGVyX3N0YXJ0KHBpZF90IHBtX3BpZCwgYm9vbCBkb19jaGVj a3BvaW50KQpAQCAtNjAwLDYzICs4MjcsNDggQEAgd2FpdF9mb3JfcG9zdG1hc3Rlcl9zdGFy dChwaWRfdCBwbV9waWQsIGJvb2wgZG9fY2hlY2twb2ludCkKIAkJaW50CQkJbnVtbGluZXM7 CiAKIAkJLyoKLQkJICogVHJ5IHRvIHJlYWQgdGhlIHBvc3RtYXN0ZXIucGlkIGZpbGUuICBJ ZiBpdCdzIG5vdCB2YWxpZCwgb3IgaWYgdGhlCi0JCSAqIHN0YXR1cyBsaW5lIGlzbid0IHRo ZXJlIHlldCwganVzdCBrZWVwIHdhaXRpbmcuCisJCSAqIFRyeSB0byByZWFkIHBvc3RtYXN0 ZXIucGlkLiAgSWYgaXQncyBub3QgdGhlcmUgeWV0LCBvciBkb2Vzbid0CisJCSAqIGhhdmUg ZW5vdWdoIGxpbmVzLCBqdXN0IG1vdmUgb24gdG8gdGhlIG5leHQgaXRlcmF0aW9uLgogCQkg Ki8KIAkJaWYgKChvcHRsaW5lcyA9IHJlYWRmaWxlKHBpZF9maWxlLCAmbnVtbGluZXMpKSAh PSBOVUxMICYmCiAJCQludW1saW5lcyA+PSBMT0NLX0ZJTEVfTElORV9QTV9TVEFUVVMpCiAJ CXsKLQkJCS8qIEZpbGUgaXMgY29tcGxldGUgZW5vdWdoIGZvciB1cywgcGFyc2UgaXQgKi8K IAkJCXBpZF90CQlwbXBpZDsKIAkJCXRpbWVfdAkJcG1zdGFydDsKIAogCQkJLyoKLQkJCSAq IE1ha2Ugc2FuaXR5IGNoZWNrcy4gIElmIGl0J3MgZm9yIHRoZSB3cm9uZyBQSUQsIG9yIHRo ZSByZWNvcmRlZAotCQkJICogc3RhcnQgdGltZSBpcyBiZWZvcmUgcGdfY3RsIHN0YXJ0ZWQs IHRoZW4gZWl0aGVyIHdlIGFyZSBsb29raW5nCi0JCQkgKiBhdCB0aGUgd3JvbmcgZGF0YSBk aXJlY3RvcnksIG9yIHRoaXMgaXMgYSBwcmUtZXhpc3RpbmcgcGlkZmlsZQotCQkJICogdGhh dCBoYXNuJ3QgKHlldD8pIGJlZW4gb3ZlcndyaXR0ZW4gYnkgb3VyIGNoaWxkIHBvc3RtYXN0 ZXIuCi0JCQkgKiBBbGxvdyAyIHNlY29uZHMgc2xvcCBmb3IgcG9zc2libGUgY3Jvc3MtcHJv Y2VzcyBjbG9jayBza2V3LgorCQkJICogQ2hlY2sgdGhhdCB0aGUgUElEIGFuZCBzdGFydCB0 aW1lIGluIHRoZSBmaWxlIG1hdGNoIHdoYXQgd2UKKwkJCSAqIGV4cGVjdC4gIEEgbWlzbWF0 Y2ggbWVhbnMgZWl0aGVyIHdlJ3JlIGxvb2tpbmcgYXQgdGhlIHdyb25nCisJCQkgKiBkYXRh IGRpcmVjdG9yeSwgb3IgdGhpcyBpcyBhIHN0YWxlIHBpZGZpbGUgbGVmdCBvdmVyIGZyb20g YQorCQkJICogcHJldmlvdXMgcG9zdG1hc3Rlci4gIFdlIGFsbG93IDIgc2Vjb25kcyBzbG9w IGluIHRoZSB0aW1lc3RhbXAKKwkJCSAqIGNvbXBhcmlzb24gdG8gaGFuZGxlIGNsb2NrIHNr ZXcgYmV0d2VlbiBwcm9jZXNzZXMuCiAJCQkgKi8KIAkJCXBtcGlkID0gYXRvbChvcHRsaW5l c1tMT0NLX0ZJTEVfTElORV9QSUQgLSAxXSk7CiAJCQlwbXN0YXJ0ID0gYXRvbGwob3B0bGlu ZXNbTE9DS19GSUxFX0xJTkVfU1RBUlRfVElNRSAtIDFdKTsKLQkJCWlmIChwbXN0YXJ0ID49 IHN0YXJ0X3RpbWUgLSAyICYmCi0jaWZuZGVmIFdJTjMyCi0JCQkJcG1waWQgPT0gcG1fcGlk Ci0jZWxzZQotCQkJLyogV2luZG93cyBjYW4gb25seSByZWplY3Qgc3RhbmRhbG9uZS1iYWNr ZW5kIFBJRHMgKi8KLQkJCQlwbXBpZCA+IDAKLSNlbmRpZgotCQkJCSkKKwkJCQorCQkJaWYg KHBtc3RhcnQgPj0gc3RhcnRfdGltZSAtIDIgJiYgcG1waWQgPT0gcG1fcGlkKQogCQkJewog CQkJCS8qCi0JCQkJICogT0ssIHNlZW1zIHRvIGJlIGEgdmFsaWQgcGlkZmlsZSBmcm9tIG91 ciBjaGlsZC4gIENoZWNrIHRoZQotCQkJCSAqIHN0YXR1cyBsaW5lICh0aGlzIGFzc3VtZXMg YSB2MTAgb3IgbGF0ZXIgc2VydmVyKS4KKwkJCQkgKiBJdCdzIHRoZSByaWdodCBwaWRmaWxl LiAgQ2hlY2sgd2hldGhlciB0aGUgcG9zdG1hc3RlciBpcworCQkJCSAqIHJlYWR5IHRvIGFj Y2VwdCBjb25uZWN0aW9ucy4KIAkJCQkgKi8KIAkJCQljaGFyCSAgICpwbXN0YXR1cyA9IG9w dGxpbmVzW0xPQ0tfRklMRV9MSU5FX1BNX1NUQVRVUyAtIDFdOwogCiAJCQkJaWYgKHN0cmNt cChwbXN0YXR1cywgUE1fU1RBVFVTX1JFQURZKSA9PSAwIHx8CiAJCQkJCXN0cmNtcChwbXN0 YXR1cywgUE1fU1RBVFVTX1NUQU5EQlkpID09IDApCiAJCQkJewotCQkJCQkvKiBwb3N0bWFz dGVyIGlzIGRvbmUgc3RhcnRpbmcgdXAgKi8KIAkJCQkJZnJlZV9yZWFkZmlsZShvcHRsaW5l cyk7CiAJCQkJCXJldHVybiBQT1NUTUFTVEVSX1JFQURZOwogCQkJCX0KIAkJCX0KKwkJCWZy ZWVfcmVhZGZpbGUob3B0bGluZXMpOwogCQl9CiAKLQkJLyoKLQkJICogRnJlZSB0aGUgcmVz dWx0cyBvZiByZWFkZmlsZS4KLQkJICoKLQkJICogVGhpcyBpcyBzYWZlIHRvIGNhbGwgZXZl biBpZiBvcHRsaW5lcyBpcyBOVUxMLgotCQkgKi8KLQkJZnJlZV9yZWFkZmlsZShvcHRsaW5l cyk7CisJCQogCiAJCS8qCi0JCSAqIENoZWNrIHdoZXRoZXIgdGhlIGNoaWxkIHBvc3RtYXN0 ZXIgcHJvY2VzcyBpcyBzdGlsbCBhbGl2ZS4gIFRoaXMKLQkJICogbGV0cyB1cyBleGl0IGVh cmx5IGlmIHRoZSBwb3N0bWFzdGVyIGZhaWxzIGR1cmluZyBzdGFydHVwLgotCQkgKgotCQkg KiBPbiBXaW5kb3dzLCB3ZSBtYXkgYmUgY2hlY2tpbmcgdGhlIHBvc3RtYXN0ZXIncyBwYXJl bnQgc2hlbGwsIGJ1dAotCQkgKiB0aGF0J3MgZmluZSBmb3IgdGhpcyBwdXJwb3NlLgorCQkg KiBDaGVjayB3aGV0aGVyIHRoZSBwb3N0bWFzdGVyIHByb2Nlc3MgaXMgc3RpbGwgYWxpdmUu ICBJZiBpdCdzCisJCSAqIGdvbmUsIHRoZXJlJ3Mgbm8gcG9pbnQgaW4gd2FpdGluZyBhbnkg bG9uZ2VyLgogCQkgKi8KIAkJewogCQkJYm9vbAkJcG1fZGllZDsKQEAgLTY2OSw3ICs4ODEs MTAgQEAgd2FpdF9mb3JfcG9zdG1hc3Rlcl9zdGFydChwaWRfdCBwbV9waWQsIGJvb2wgZG9f Y2hlY2twb2ludCkKICNlbmRpZgogCQkJaWYgKHBtX2RpZWQpCiAJCQl7Ci0JCQkJLyogU2Vl IGlmIHBvc3RtYXN0ZXIgdGVybWluYXRlZCBpbnRlbnRpb25hbGx5ICovCisJCQkJLyoKKwkJ CQkgKiBQb3N0bWFzdGVyIGRpZWQuICBDaGVjayBpZiBpdCB3YXMgYW4gaW50ZW50aW9uYWwg c2h1dGRvd24KKwkJCQkgKiBkdXJpbmcgcmVjb3ZlcnkgKHdoaWNoIGlzIE9LKSBvciBhbiBh Y3R1YWwgZmFpbHVyZS4KKwkJCQkgKi8KIAkJCQlpZiAoZ2V0X2NvbnRyb2xfZGJzdGF0ZSgp ID09IERCX1NIVVRET1dORURfSU5fUkVDT1ZFUlkpCiAJCQkJCXJldHVybiBQT1NUTUFTVEVS X1NIVVRET1dOX0lOX1JFQ09WRVJZOwogCQkJCWVsc2UKQEAgLTY3NywxOSArODkyLDE4IEBA IHdhaXRfZm9yX3Bvc3RtYXN0ZXJfc3RhcnQocGlkX3QgcG1fcGlkLCBib29sIGRvX2NoZWNr cG9pbnQpCiAJCQl9CiAJCX0KIAotCQkvKiBTdGFydHVwIHN0aWxsIGluIHByb2Nlc3M7IHdh aXQsIHByaW50aW5nIGEgZG90IG9uY2UgcGVyIHNlY29uZCAqLworCQkvKiBTdGlsbCBzdGFy dGluZyB1cC4gIFByaW50IGEgZG90IG9uY2UgcGVyIHNlY29uZCBmb3IgdXNlciBmZWVkYmFj ayAqLwogCQlpZiAoaSAlIFdBSVRTX1BFUl9TRUMgPT0gMCkKIAkJewogI2lmZGVmIFdJTjMy CisJCQkvKgorCQkJICogT24gV2luZG93cywgaWYgd2UncmUgcnVubmluZyBhcyBhIHNlcnZp Y2UsIGluY3JlbWVudCB0aGUKKwkJCSAqIGNoZWNrcG9pbnQgY291bnRlciBzbyB0aGUgc2Vy dmljZSBjb250cm9sIG1hbmFnZXIgZG9lc24ndAorCQkJICogdGhpbmsgd2UndmUgaHVuZy4g IChUaGlzIGhhcyBub3RoaW5nIHRvIGRvIHdpdGggZGF0YWJhc2UKKwkJCSAqIGNoZWNrcG9p bnRzLCBpdCdzIGEgV2luZG93cyBzZXJ2aWNlIHRoaW5nLikKKwkJCSAqLwogCQkJaWYgKGRv X2NoZWNrcG9pbnQpCiAJCQl7Ci0JCQkJLyoKLQkJCQkgKiBJbmNyZW1lbnQgdGhlIHdhaXQg aGludCBieSA2IHNlY3MgKGNvbm5lY3Rpb24gdGltZW91dCArCi0JCQkJICogc2xlZXApLiAg V2UgbXVzdCBkbyB0aGlzIHRvIGluZGljYXRlIHRvIHRoZSBTQ00gdGhhdCBvdXIKLQkJCQkg KiBzdGFydHVwIHRpbWUgaXMgY2hhbmdpbmcsIG90aGVyd2lzZSBpdCdsbCB1c3VhbGx5IHNl bmQgYQotCQkJCSAqIHN0b3Agc2lnbmFsIGFmdGVyIDIwIHNlY29uZHMsIGRlc3BpdGUgaW5j cmVtZW50aW5nIHRoZQotCQkJCSAqIGNoZWNrcG9pbnQgY291bnRlci4KLQkJCQkgKi8KIAkJ CQlzdGF0dXMuZHdXYWl0SGludCArPSA2MDAwOwogCQkJCXN0YXR1cy5kd0NoZWNrUG9pbnQr KzsKIAkJCQlTZXRTZXJ2aWNlU3RhdHVzKGhTdGF0dXMsIChMUFNFUlZJQ0VfU1RBVFVTKSAm c3RhdHVzKTsKQEAgLTcwMiw3ICs5MTYsNyBAQCB3YWl0X2Zvcl9wb3N0bWFzdGVyX3N0YXJ0 KHBpZF90IHBtX3BpZCwgYm9vbCBkb19jaGVja3BvaW50KQogCQlwZ191c2xlZXAoVVNFQ19Q RVJfU0VDIC8gV0FJVFNfUEVSX1NFQyk7CiAJfQogCi0JLyogb3V0IG9mIHBhdGllbmNlOyBy ZXBvcnQgdGhhdCBwb3N0bWFzdGVyIGlzIHN0aWxsIHN0YXJ0aW5nIHVwICovCisJLyogUmFu IG91dCBvZiB0aW1lICovCiAJcmV0dXJuIFBPU1RNQVNURVJfU1RJTExfU1RBUlRJTkc7CiB9 CiAKQEAgLTkzMSw4ICsxMTQ1LDcgQEAgc3RhdGljIHZvaWQKIGRvX3N0YXJ0KHZvaWQpCiB7 CiAJcGlkX3QJCW9sZF9waWQgPSAwOwotCXBpZF90CQlwbV9waWQ7Ci0KKwkKIAlpZiAoY3Rs X2NvbW1hbmQgIT0gUkVTVEFSVF9DT01NQU5EKQogCXsKIAkJb2xkX3BpZCA9IGdldF9wZ3Bp ZChmYWxzZSk7CkBAIC05NzAsNyArMTE4MywxMiBAQCBkb19zdGFydCh2b2lkKQogCX0KICNl bmRpZgogCi0JcG1fcGlkID0gc3RhcnRfcG9zdG1hc3RlcigpOworCXN0YXJ0X3Bvc3RtYXN0 ZXIoKTsKKwlpZiAocG1fcGlkID09IDApCisJeworCQl3cml0ZV9zdGRlcnIoXygiJXM6IGNv dWxkIG5vdCBzdGFydCBzZXJ2ZXJcbiIpLCBwcm9nbmFtZSk7CisJCWV4aXQoMSk7CisJfQog CiAJaWYgKGRvX3dhaXQpCiAJewotLSAKMi40Ni4wLndpbmRvd3MuMQoK --------------DGXo52hzvumP44RHaZIfxRBB--