Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1kxCeQ-0003BZ-F6 for pgsql-hackers@arkaria.postgresql.org; Wed, 06 Jan 2021 17:31:14 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1kxCeP-0000MY-Dk for pgsql-hackers@arkaria.postgresql.org; Wed, 06 Jan 2021 17:31:13 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1kxCeP-0000MR-5E for pgsql-hackers@lists.postgresql.org; Wed, 06 Jan 2021 17:31:13 +0000 Received: from oss.nttdata.com ([49.212.34.109]) by magus.postgresql.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1kxCeL-0005pK-O7 for pgsql-hackers@postgresql.org; Wed, 06 Jan 2021 17:31:12 +0000 Received: from hnk.local (p2390043-ipbf1028funabasi.chiba.ocn.ne.jp [118.7.248.43]) by oss.nttdata.com (Postfix) with ESMTPSA id B6B146233A; Thu, 7 Jan 2021 02:31:04 +0900 (JST) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.102.3 at oss.nttdata.com Subject: Re: Add Information during standby recovery conflicts From: Fujii Masao To: Masahiko Sawada , "Drouvot, Bertrand" Cc: Alvaro Herrera , Masahiko Sawada , Kyotaro Horiguchi , PostgreSQL-development References: <20201130182528.GA1854@alvherre.pgsql> <594f4419-62aa-c272-ef7d-4287e5c6b654@amazon.com> <627f702d-a04c-b72b-b94f-214f448e2935@oss.nttdata.com> <73037867-b688-c5cc-5f6d-ad73db6ab94d@amazon.com> <02b17df8-cf11-7e5a-31e3-d94c87b28775@oss.nttdata.com> Message-ID: Date: Thu, 7 Jan 2021 02:31:03 +0900 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0) Gecko/20100101 Thunderbird/78.6.0 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------EDA05675B262CC93EB8AAF7B" Content-Language: en-US List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Precedence: bulk This is a multi-part message in MIME format. --------------EDA05675B262CC93EB8AAF7B Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit On 2020/12/15 0:20, Fujii Masao wrote: > > > On 2020/12/14 21:31, Fujii Masao wrote: >> >> >> On 2020/12/05 12:38, Masahiko Sawada wrote: >>> On Fri, Dec 4, 2020 at 7:22 PM Drouvot, Bertrand wrote: >>>> >>>> Hi, >>>> >>>> On 12/4/20 2:21 AM, Fujii Masao wrote: >>>>> >>>>> On 2020/12/04 9:28, Masahiko Sawada wrote: >>>>>> On Fri, Dec 4, 2020 at 2:54 AM Fujii Masao >>>>>> wrote: >>>>>>> >>>>>>> >>>>>>> >>>>>>> On 2020/12/01 17:29, Drouvot, Bertrand wrote: >>>>>>>> Hi, >>>>>>>> >>>>>>>> On 12/1/20 12:35 AM, Masahiko Sawada wrote: >>>>>>>>> CAUTION: This email originated from outside of the organization. >>>>>>>>> Do not click links or open attachments unless you can confirm the >>>>>>>>> sender and know the content is safe. >>>>>>>>> >>>>>>>>> >>>>>>>>> >>>>>>>>> On Tue, Dec 1, 2020 at 3:25 AM Alvaro Herrera >>>>>>>>> wrote: >>>>>>>>>> On 2020-Dec-01, Fujii Masao wrote: >>>>>>>>>> >>>>>>>>>>> +                     if (proc) >>>>>>>>>>> +                     { >>>>>>>>>>> +                             if (nprocs == 0) >>>>>>>>>>> + appendStringInfo(&buf, "%d", proc->pid); >>>>>>>>>>> +                             else >>>>>>>>>>> + appendStringInfo(&buf, ", %d", proc->pid); >>>>>>>>>>> + >>>>>>>>>>> +                             nprocs++; >>>>>>>>>>> >>>>>>>>>>> What happens if all the backends in wait_list have gone? In >>>>>>>>>>> other words, >>>>>>>>>>> how should we handle the case where nprocs == 0 (i.e., nprocs >>>>>>>>>>> has not been >>>>>>>>>>> incrmented at all)? This would very rarely happen, but can happen. >>>>>>>>>>> In this case, since buf.data is empty, at least there seems no >>>>>>>>>>> need to log >>>>>>>>>>> the list of conflicting processes in detail message. >>>>>>>>>> Yes, I noticed this too; this can be simplified by changing the >>>>>>>>>> condition in the ereport() call to be "nprocs > 0" (rather than >>>>>>>>>> wait_list being null), otherwise not print the errdetail.  (You >>>>>>>>>> could >>>>>>>>>> test buf.data or buf.len instead, but that seems uglier to me.) >>>>>>>>> +1 >>>>>>>>> >>>>>>>>> Maybe we can also improve the comment of this function from: >>>>>>>>> >>>>>>>>> + * This function also reports the details about the conflicting >>>>>>>>> + * process ids if *wait_list is not NULL. >>>>>>>>> >>>>>>>>> to " This function also reports the details about the conflicting >>>>>>>>> process ids if exist" or something. >>>>>>>>> >>>>>>>> Thank you all for the review/remarks. >>>>>>>> >>>>>>>> They have been addressed in the new attached patch version. >>>>>>> >>>>>>> Thanks for updating the patch! I read through the patch again >>>>>>> and applied the following chages to it. Attached is the updated >>>>>>> version of the patch. Could you review this version? If there is >>>>>>> no issue in it, I'm thinking to commit this version. >>>>>> >>>>>> Thank you for updating the patch! I have one question. >>>>>> >>>>>>> >>>>>>> +                       timeouts[cnt].id = STANDBY_TIMEOUT; >>>>>>> +                       timeouts[cnt].type = TMPARAM_AFTER; >>>>>>> +                       timeouts[cnt].delay_ms = DeadlockTimeout; >>>>>>> >>>>>>> Maybe STANDBY_TIMEOUT should be STANDBY_DEADLOCK_TIMEOUT here? >>>>>>> I changed the code that way. >>>>>> >>>>>> As the comment of ResolveRecoveryConflictWithLock() says the >>>>>> following, a deadlock is detected by the ordinary backend process: >>>>>> >>>>>>    * Deadlocks involving the Startup process and an ordinary backend >>>>>> proces >>>>>>    * will be detected by the deadlock detector within the ordinary >>>>>> backend. >>>>>> >>>>>> If we use STANDBY_DEADLOCK_TIMEOUT, >>>>>> SendRecoveryConflictWithBufferPin() will be called after >>>>>> DeadlockTimeout passed, but I think it's not necessary for the startup >>>>>> process in this case. >>>>> >>>>> Thanks for pointing this! You are right. >>>>> >>>>> >>>>>> If we want to just wake up the startup process >>>>>> maybe we can use STANDBY_TIMEOUT here? >>>>> >>>> Thanks for the patch updates! Except what we are still discussing below, >>>> it looks good to me. >>>> >>>>> When STANDBY_TIMEOUT happens, a request to release conflicting buffer >>>>> pins is sent. Right? If so, we should not also use STANDBY_TIMEOUT there? >>>> >>>> Agree >>>> >>>>> >>>>> Or, first of all, we don't need to enable the deadlock timer at all? >>>>> Since what we'd like to do is to wake up after deadlock_timeout >>>>> passes, we can do that by changing ProcWaitForSignal() so that it can >>>>> accept the timeout and giving the deadlock_timeout to it. If we do >>>>> this, maybe we can get rid of STANDBY_LOCK_TIMEOUT from >>>>> ResolveRecoveryConflictWithLock(). Thought? >>> >>> Where do we enable deadlock timeout in hot standby case? You meant to >>> enable it in ProcWaitForSignal() or where we set a timer for not hot >>> standby case, in ProcSleep()? >> >> No, what I tried to say is to change ResolveRecoveryConflictWithLock() so that it does >> >> 1. calculate the "minimum" timeout from deadlock_timeout and max_standby_xxx_delay >> 2. give the calculated timeout value to ProcWaitForSignal() >> 3. wait for signal and timeout on ProcWaitForSignal() >> >> Since ProcWaitForSignal() calls WaitLatch(), seems it's not so difficult to make ProcWaitForSignal() handle the timeout. If we do this, I was thinking that we can get rid of enable_timeouts() from ResolveRecoveryConflictWithLock(). >> >> >>> >>>> >>>> Why not simply use (again) the STANDBY_LOCK_TIMEOUT one? (as it triggers >>>> a call to StandbyLockTimeoutHandler() which does nothing, except waking >>>> up. That's what we want, right?) >>> >>> Right, what I wanted to mean is STANDBY_LOCK_TIMEOUT. The startup >>> process can wake up and do nothing. Thank you for pointing out. >> >> Okay, understood! Firstly I was thinking that enabling the same type (i.e., STANDBY_LOCK_TIMEOUT) of lock twice doesn't work properly, but as far as I read the code, it works. In that case, only the shorter timeout would be activated in enable_timeouts(). So I agree to use STANDBY_LOCK_TIMEOUT. > > So I renamed the argument "deadlock_timer" in ResolveRecoveryConflictWithLock() > because it's not the timer for deadlock and is confusing. Attached is the > updated version of the patch. Barring any objection, I will commit this version. Since the recent commit 8900b5a9d5 changed the recovery conflict code, I updated the patch. Attached is the updated version of the patch. Regards, -- Fujii Masao Advanced Computing Technology Center Research and Development Headquarters NTT DATA CORPORATION --------------EDA05675B262CC93EB8AAF7B Content-Type: text/plain; charset=UTF-8; x-mac-type="0"; x-mac-creator="0"; name="v12-0002-Log-the-standby-recovery-conflict-waits.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="v12-0002-Log-the-standby-recovery-conflict-waits.patch" ZGlmZiAtLWdpdCBhL2RvYy9zcmMvc2dtbC9jb25maWcuc2dtbCBiL2RvYy9zcmMvc2dtbC9j b25maWcuc2dtbAppbmRleCAyYTkwZDAxMWRiLi4zZGM0ZjVjMzUyIDEwMDY0NAotLS0gYS9k b2Mvc3JjL3NnbWwvY29uZmlnLnNnbWwKKysrIGIvZG9jL3NyYy9zZ21sL2NvbmZpZy5zZ21s CkBAIC02OTUyLDYgKzY5NTIsMjggQEAgbG9nX2xpbmVfcHJlZml4ID0gJyVtIFslcF0gJXEl dUAlZC8lYSAnCiAgICAgICA8L2xpc3RpdGVtPgogICAgICA8L3Zhcmxpc3RlbnRyeT4KIAor ICAgICA8dmFybGlzdGVudHJ5IGlkPSJndWMtbG9nLXJlY292ZXJ5LWNvbmZsaWN0LXdhaXRz IiB4cmVmbGFiZWw9ImxvZ19yZWNvdmVyeV9jb25mbGljdF93YWl0cyI+CisgICAgICA8dGVy bT48dmFybmFtZT5sb2dfcmVjb3ZlcnlfY29uZmxpY3Rfd2FpdHM8L3Zhcm5hbWU+ICg8dHlw ZT5ib29sZWFuPC90eXBlPikKKyAgICAgIDxpbmRleHRlcm0+CisgICAgICAgPHByaW1hcnk+ PHZhcm5hbWU+bG9nX3JlY292ZXJ5X2NvbmZsaWN0X3dhaXRzPC92YXJuYW1lPiBjb25maWd1 cmF0aW9uIHBhcmFtZXRlcjwvcHJpbWFyeT4KKyAgICAgIDwvaW5kZXh0ZXJtPgorICAgICAg PC90ZXJtPgorICAgICAgPGxpc3RpdGVtPgorICAgICAgIDxwYXJhPgorICAgICAgICBDb250 cm9scyB3aGV0aGVyIGEgbG9nIG1lc3NhZ2UgaXMgcHJvZHVjZWQgd2hlbiB0aGUgc3RhcnR1 cCBwcm9jZXNzCisgICAgICAgIGlzIHdhaXRpbmcgbG9uZ2VyIHRoYW4gPHZhcm5hbWU+ZGVh ZGxvY2tfdGltZW91dDwvdmFybmFtZT4KKyAgICAgICAgZm9yIHJlY292ZXJ5IGNvbmZsaWN0 cy4gIFRoaXMgaXMgdXNlZnVsIGluIGRldGVybWluaW5nIGlmIHJlY292ZXJ5CisgICAgICAg IGNvbmZsaWN0cyBwcmV2ZW50IHRoZSByZWNvdmVyeSBmcm9tIGFwcGx5aW5nIFdBTC4KKyAg ICAgICA8L3BhcmE+CisKKyAgICAgICA8cGFyYT4KKyAgICAgICAgVGhlIGRlZmF1bHQgaXMg PGxpdGVyYWw+b2ZmPC9saXRlcmFsPi4gIFRoaXMgcGFyYW1ldGVyIGNhbiBvbmx5IGJlIHNl dAorICAgICAgICBpbiB0aGUgPGZpbGVuYW1lPnBvc3RncmVzcWwuY29uZjwvZmlsZW5hbWU+ IGZpbGUgb3Igb24gdGhlIHNlcnZlcgorICAgICAgICBjb21tYW5kIGxpbmUuCisgICAgICAg PC9wYXJhPgorICAgICAgPC9saXN0aXRlbT4KKyAgICAgPC92YXJsaXN0ZW50cnk+CisKICAg ICAgPHZhcmxpc3RlbnRyeSBpZD0iZ3VjLWxvZy1wYXJhbWV0ZXItbWF4LWxlbmd0aCIgeHJl ZmxhYmVsPSJsb2dfcGFyYW1ldGVyX21heF9sZW5ndGgiPgogICAgICAgPHRlcm0+PHZhcm5h bWU+bG9nX3BhcmFtZXRlcl9tYXhfbGVuZ3RoPC92YXJuYW1lPiAoPHR5cGU+aW50ZWdlcjwv dHlwZT4pCiAgICAgICA8aW5kZXh0ZXJtPgpkaWZmIC0tZ2l0IGEvZG9jL3NyYy9zZ21sL2hp Z2gtYXZhaWxhYmlsaXR5LnNnbWwgYi9kb2Mvc3JjL3NnbWwvaGlnaC1hdmFpbGFiaWxpdHku c2dtbAppbmRleCAwNGY3NTAyMGU0Li5lZmMzODJjYjhkIDEwMDY0NAotLS0gYS9kb2Mvc3Jj L3NnbWwvaGlnaC1hdmFpbGFiaWxpdHkuc2dtbAorKysgYi9kb2Mvc3JjL3NnbWwvaGlnaC1h dmFpbGFiaWxpdHkuc2dtbApAQCAtMjA3MSw2ICsyMDcxLDEyIEBAIGlmICghdHJpZ2dlcmVk KQogICAgIHNlcnZlci4gVGhlIDxzdHJ1Y3RuYW1lPnBnX3N0YXRfZGF0YWJhc2U8L3N0cnVj dG5hbWU+IHN5c3RlbSB2aWV3IGFsc28gY29udGFpbnMKICAgICBzdW1tYXJ5IGluZm9ybWF0 aW9uLgogICAgPC9wYXJhPgorCisgICA8cGFyYT4KKyAgICBVc2VycyBjYW4gY29udHJvbCB3 aGV0aGVyIGEgbG9nIG1lc3NhZ2UgaXMgcHJvZHVjZWQgd2hlbiBXQUwgcmVwbGF5IGlzIHdh aXRpbmcKKyAgICBsb25nZXIgdGhhbiA8dmFybmFtZT5kZWFkbG9ja190aW1lb3V0PC92YXJu YW1lPiBmb3IgY29uZmxpY3RzLiBUaGlzCisgICAgaXMgY29udHJvbGxlZCBieSB0aGUgPHhy ZWYgbGlua2VuZD0iZ3VjLWxvZy1yZWNvdmVyeS1jb25mbGljdC13YWl0cyIvPiBwYXJhbWV0 ZXIuCisgICA8L3BhcmE+CiAgIDwvc2VjdDI+CiAKICAgPHNlY3QyIGlkPSJob3Qtc3RhbmRi eS1hZG1pbiI+CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZt Z3IuYyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jCmluZGV4IDhmMmM0 ODJiYzguLjcxYjU4NTIyMjQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVm ZmVyL2J1Zm1nci5jCisrKyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5j CkBAIC0zODA5LDYgKzM4MDksOCBAQCBMb2NrQnVmZmVyRm9yQ2xlYW51cChCdWZmZXIgYnVm ZmVyKQogewogCUJ1ZmZlckRlc2MgKmJ1ZkhkcjsKIAljaGFyCSAgICpuZXdfc3RhdHVzID0g TlVMTDsKKwlUaW1lc3RhbXBUeiB3YWl0U3RhcnQgPSAwOworCWJvb2wJCWxvZ2dlZF9yZWNv dmVyeV9jb25mbGljdCA9IGZhbHNlOwogCiAJQXNzZXJ0KEJ1ZmZlcklzUGlubmVkKGJ1ZmZl cikpOwogCUFzc2VydChQaW5Db3VudFdhaXRCdWYgPT0gTlVMTCk7CkBAIC0zODgyLDYgKzM4 ODQsMzQgQEAgTG9ja0J1ZmZlckZvckNsZWFudXAoQnVmZmVyIGJ1ZmZlcikKIAkJCQluZXdf c3RhdHVzW2xlbl0gPSAnXDAnOyAvKiB0cnVuY2F0ZSBvZmYgIiB3YWl0aW5nIiAqLwogCQkJ fQogCisJCQkvKgorCQkJICogRW1pdCB0aGUgbG9nIG1lc3NhZ2UgaWYgdGhlIHN0YXJ0dXAg cHJvY2VzcyBpcyB3YWl0aW5nIGxvbmdlcgorCQkJICogdGhhbiBkZWFkbG9ja190aW1lb3V0 IGZvciByZWNvdmVyeSBjb25mbGljdCBvbiBidWZmZXIgcGluLgorCQkJICoKKwkJCSAqIFNr aXAgdGhpcyBpZiBmaXJzdCB0aW1lIHRocm91Z2ggYmVjYXVzZSB0aGUgc3RhcnR1cCBwcm9j ZXNzIGhhcworCQkJICogbm90IHN0YXJ0ZWQgd2FpdGluZyB5ZXQgaW4gdGhpcyBjYXNlLiBT bywgdGhlIHdhaXQgc3RhcnQKKwkJCSAqIHRpbWVzdGFtcCBpcyBzZXQgYWZ0ZXIgdGhpcyBs b2dpYy4KKwkJCSAqLworCQkJaWYgKHdhaXRTdGFydCAhPSAwICYmICFsb2dnZWRfcmVjb3Zl cnlfY29uZmxpY3QpCisJCQl7CisJCQkJVGltZXN0YW1wVHogbm93ID0gR2V0Q3VycmVudFRp bWVzdGFtcCgpOworCisJCQkJaWYgKFRpbWVzdGFtcERpZmZlcmVuY2VFeGNlZWRzKHdhaXRT dGFydCwgbm93LAorCQkJCQkJCQkJCQkgICBEZWFkbG9ja1RpbWVvdXQpKQorCQkJCXsKKwkJ CQkJTG9nUmVjb3ZlcnlDb25mbGljdChQUk9DU0lHX1JFQ09WRVJZX0NPTkZMSUNUX0JVRkZF UlBJTiwKKwkJCQkJCQkJCQl3YWl0U3RhcnQsIG5vdywgTlVMTCk7CisJCQkJCWxvZ2dlZF9y ZWNvdmVyeV9jb25mbGljdCA9IHRydWU7CisJCQkJfQorCQkJfQorCisJCQkvKgorCQkJICog U2V0IHRoZSB3YWl0IHN0YXJ0IHRpbWVzdGFtcCBpZiBsb2dnaW5nIGlzIGVuYWJsZWQgYW5k IGZpcnN0CisJCQkgKiB0aW1lIHRocm91Z2guCisJCQkgKi8KKwkJCWlmIChsb2dfcmVjb3Zl cnlfY29uZmxpY3Rfd2FpdHMgJiYgd2FpdFN0YXJ0ID09IDApCisJCQkJd2FpdFN0YXJ0ID0g R2V0Q3VycmVudFRpbWVzdGFtcCgpOworCiAJCQkvKiBQdWJsaXNoIHRoZSBidWZpZCB0aGF0 IFN0YXJ0dXAgcHJvY2VzcyB3YWl0cyBvbiAqLwogCQkJU2V0U3RhcnR1cEJ1ZmZlclBpbldh aXRCdWZJZChidWZmZXIgLSAxKTsKIAkJCS8qIFNldCBhbGFybSBhbmQgdGhlbiB3YWl0IHRv IGJlIHNpZ25hbGVkIGJ5IFVucGluQnVmZmVyKCkgKi8KZGlmZiAtLWdpdCBhL3NyYy9iYWNr ZW5kL3N0b3JhZ2UvaXBjL3N0YW5kYnkuYyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvaXBjL3N0 YW5kYnkuYwppbmRleCA3N2U4MWJkYmMwLi5kNGIwZjY1YmEyIDEwMDY0NAotLS0gYS9zcmMv YmFja2VuZC9zdG9yYWdlL2lwYy9zdGFuZGJ5LmMKKysrIGIvc3JjL2JhY2tlbmQvc3RvcmFn ZS9pcGMvc3RhbmRieS5jCkBAIC0zOSw2ICszOSw3IEBACiBpbnQJCQl2YWN1dW1fZGVmZXJf Y2xlYW51cF9hZ2U7CiBpbnQJCQltYXhfc3RhbmRieV9hcmNoaXZlX2RlbGF5ID0gMzAgKiAx MDAwOwogaW50CQkJbWF4X3N0YW5kYnlfc3RyZWFtaW5nX2RlbGF5ID0gMzAgKiAxMDAwOwor Ym9vbAkJbG9nX3JlY292ZXJ5X2NvbmZsaWN0X3dhaXRzID0gZmFsc2U7CiAKIHN0YXRpYyBI VEFCICpSZWNvdmVyeUxvY2tMaXN0czsKIApAQCAtNTMsNiArNTQsNyBAQCBzdGF0aWMgdm9p ZCBSZXNvbHZlUmVjb3ZlcnlDb25mbGljdFdpdGhWaXJ0dWFsWElEcyhWaXJ0dWFsVHJhbnNh Y3Rpb25JZCAqd2FpdGxpcwogc3RhdGljIHZvaWQgU2VuZFJlY292ZXJ5Q29uZmxpY3RXaXRo QnVmZmVyUGluKFByb2NTaWduYWxSZWFzb24gcmVhc29uKTsKIHN0YXRpYyBYTG9nUmVjUHRy IExvZ0N1cnJlbnRSdW5uaW5nWGFjdHMoUnVubmluZ1RyYW5zYWN0aW9ucyBDdXJyUnVubmlu Z1hhY3RzKTsKIHN0YXRpYyB2b2lkIExvZ0FjY2Vzc0V4Y2x1c2l2ZUxvY2tzKGludCBubG9j a3MsIHhsX3N0YW5kYnlfbG9jayAqbG9ja3MpOworc3RhdGljIGNvbnN0IGNoYXIgKmdldF9y ZWNvdmVyeV9jb25mbGljdF9kZXNjKFByb2NTaWduYWxSZWFzb24gcmVhc29uKTsKIAogLyoK ICAqIEtlZXAgdHJhY2sgb2YgYWxsIHRoZSBsb2NrcyBvd25lZCBieSBhIGdpdmVuIHRyYW5z YWN0aW9uLgpAQCAtMjE4LDE1ICsyMjAsODMgQEAgV2FpdEV4Y2VlZHNNYXhTdGFuZGJ5RGVs YXkodWludDMyIHdhaXRfZXZlbnRfaW5mbykKIAlyZXR1cm4gZmFsc2U7CiB9CiAKKy8qCisg KiBMb2cgdGhlIHJlY292ZXJ5IGNvbmZsaWN0LgorICoKKyAqIHdhaXRfc3RhcnQgaXMgdGhl IHRpbWVzdGFtcCB3aGVuIHRoZSBjYWxsZXIgc3RhcnRlZCB0byB3YWl0LgorICogbm93IGlz IHRoZSB0aW1lc3RhbXAgd2hlbiB0aGlzIGZ1bmN0aW9uIGhhcyBiZWVuIGNhbGxlZC4KKyAq IHdhaXRfbGlzdCBpcyB0aGUgbGlzdCBvZiB2aXJ0dWFsIHRyYW5zYWN0aW9uIGlkcyBhc3Np Z25lZCB0bworICogY29uZmxpY3RpbmcgcHJvY2Vzc2VzLgorICovCit2b2lkCitMb2dSZWNv dmVyeUNvbmZsaWN0KFByb2NTaWduYWxSZWFzb24gcmVhc29uLCBUaW1lc3RhbXBUeiB3YWl0 X3N0YXJ0LAorCQkJCQlUaW1lc3RhbXBUeiBub3csIFZpcnR1YWxUcmFuc2FjdGlvbklkICp3 YWl0X2xpc3QpCit7CisJbG9uZwkJc2VjczsKKwlpbnQJCQl1c2VjczsKKwlsb25nCQltc2Vj czsKKwlTdHJpbmdJbmZvRGF0YSBidWY7CisJaW50CQkJbnByb2NzID0gMDsKKworCVRpbWVz dGFtcERpZmZlcmVuY2Uod2FpdF9zdGFydCwgbm93LCAmc2VjcywgJnVzZWNzKTsKKwltc2Vj cyA9IHNlY3MgKiAxMDAwICsgdXNlY3MgLyAxMDAwOworCXVzZWNzID0gdXNlY3MgJSAxMDAw OworCisJaWYgKHdhaXRfbGlzdCkKKwl7CisJCVZpcnR1YWxUcmFuc2FjdGlvbklkICp2eGlk czsKKworCQkvKiBDb25zdHJ1Y3QgYSBzdHJpbmcgb2YgbGlzdCBvZiB0aGUgY29uZmxpY3Rp bmcgcHJvY2Vzc2VzICovCisJCXZ4aWRzID0gd2FpdF9saXN0OworCQl3aGlsZSAoVmlydHVh bFRyYW5zYWN0aW9uSWRJc1ZhbGlkKCp2eGlkcykpCisJCXsKKwkJCVBHUFJPQwkgICAqcHJv YyA9IEJhY2tlbmRJZEdldFByb2ModnhpZHMtPmJhY2tlbmRJZCk7CisKKwkJCS8qIHByb2Mg Y2FuIGJlIE5VTEwgaWYgdGhlIHRhcmdldCBiYWNrZW5kIGlzIG5vdCBhY3RpdmUgKi8KKwkJ CWlmIChwcm9jKQorCQkJeworCQkJCWlmIChucHJvY3MgPT0gMCkKKwkJCQl7CisJCQkJCWlu aXRTdHJpbmdJbmZvKCZidWYpOworCQkJCQlhcHBlbmRTdHJpbmdJbmZvKCZidWYsICIlZCIs IHByb2MtPnBpZCk7CisJCQkJfQorCQkJCWVsc2UKKwkJCQkJYXBwZW5kU3RyaW5nSW5mbygm YnVmLCAiLCAlZCIsIHByb2MtPnBpZCk7CisKKwkJCQlucHJvY3MrKzsKKwkJCX0KKworCQkJ dnhpZHMrKzsKKwkJfQorCX0KKworCS8qCisJICogSWYgd2FpdF9saXN0IGlzIHNwZWNpZmll ZCwgcmVwb3J0IHRoZSBsaXN0IG9mIFBJRHMgb2YgYWN0aXZlCisJICogY29uZmxpY3Rpbmcg YmFja2VuZHMgaW4gYSBkZXRhaWwgbWVzc2FnZS4gTm90ZSB0aGF0IGlmIGFsbCB0aGUgYmFj a2VuZHMKKwkgKiBpbiB0aGUgbGlzdCBhcmUgbm90IGFjdGl2ZSwgbm8gZGV0YWlsIG1lc3Nh Z2UgaXMgbG9nZ2VkLgorCSAqLworCWVyZXBvcnQoTE9HLAorCQkJZXJybXNnKCJyZWNvdmVy eSBzdGlsbCB3YWl0aW5nIGFmdGVyICVsZC4lMDNkIG1zOiAlcyIsCisJCQkJICAgbXNlY3Ms IHVzZWNzLCBfKGdldF9yZWNvdmVyeV9jb25mbGljdF9kZXNjKHJlYXNvbikpKSwKKwkJCW5w cm9jcyA+IDAgPyBlcnJkZXRhaWxfbG9nX3BsdXJhbCgiQ29uZmxpY3RpbmcgcHJvY2Vzczog JXMuIiwKKwkJCQkJCQkJCQkJICAiQ29uZmxpY3RpbmcgcHJvY2Vzc2VzOiAlcy4iLAorCQkJ CQkJCQkJCQkgIG5wcm9jcywgYnVmLmRhdGEpIDogMCk7CisKKwlpZiAobnByb2NzID4gMCkK KwkJcGZyZWUoYnVmLmRhdGEpOworfQorCiAvKgogICogVGhpcyBpcyB0aGUgbWFpbiBleGVj dXRpb25lciBmb3IgYW55IHF1ZXJ5IGJhY2tlbmQgdGhhdCBjb25mbGljdHMgd2l0aAogICog cmVjb3ZlcnkgcHJvY2Vzc2luZy4gSnVkZ2VtZW50IGhhcyBhbHJlYWR5IGJlZW4gcGFzc2Vk IG9uIGl0IHdpdGhpbgogICogYSBzcGVjaWZpYyBybWdyLiBIZXJlIHdlIGp1c3QgaXNzdWUg dGhlIG9yZGVycyB0byB0aGUgcHJvY3MuIFRoZSBwcm9jcwogICogdGhlbiB0aHJvdyB0aGUg cmVxdWlyZWQgZXJyb3IgYXMgaW5zdHJ1Y3RlZC4KICAqCi0gKiBJZiByZXBvcnRfd2FpdGlu ZyBpcyB0cnVlLCAid2FpdGluZyIgaXMgcmVwb3J0ZWQgaW4gUFMgZGlzcGxheSBpZiBuZWNl c3NhcnkuCi0gKiBJZiB0aGUgY2FsbGVyIGhhcyBhbHJlYWR5IHJlcG9ydGVkIHRoYXQsIHJl cG9ydF93YWl0aW5nIHNob3VsZCBiZSBmYWxzZS4KLSAqIE90aGVyd2lzZSwgIndhaXRpbmci IGlzIHJlcG9ydGVkIHR3aWNlIHVuZXhwZWN0ZWRseS4KKyAqIElmIHJlcG9ydF93YWl0aW5n IGlzIHRydWUsICJ3YWl0aW5nIiBpcyByZXBvcnRlZCBpbiBQUyBkaXNwbGF5IGFuZCB0aGUK KyAqIHdhaXQgZm9yIHJlY292ZXJ5IGNvbmZsaWN0IGlzIHJlcG9ydGVkIGluIHRoZSBsb2cs IGlmIG5lY2Vzc2FyeS4gSWYKKyAqIHRoZSBjYWxsZXIgaXMgcmVzcG9uc2libGUgZm9yIHJl cG9ydGluZyB0aGVtLCByZXBvcnRfd2FpdGluZyBzaG91bGQgYmUKKyAqIGZhbHNlLiBPdGhl cndpc2UsIGJvdGggdGhlIGNhbGxlciBhbmQgdGhpcyBmdW5jdGlvbiByZXBvcnQgdGhlIHNh bWUKKyAqIHRoaW5nIHVuZXhwZWN0ZWRseS4KICAqLwogc3RhdGljIHZvaWQKIFJlc29sdmVS ZWNvdmVyeUNvbmZsaWN0V2l0aFZpcnR1YWxYSURzKFZpcnR1YWxUcmFuc2FjdGlvbklkICp3 YWl0bGlzdCwKQEAgLTIzNCwxNSArMzA0LDE2IEBAIFJlc29sdmVSZWNvdmVyeUNvbmZsaWN0 V2l0aFZpcnR1YWxYSURzKFZpcnR1YWxUcmFuc2FjdGlvbklkICp3YWl0bGlzdCwKIAkJCQkJ CQkJCSAgIGJvb2wgcmVwb3J0X3dhaXRpbmcpCiB7CiAJVGltZXN0YW1wVHogd2FpdFN0YXJ0 ID0gMDsKLQljaGFyCSAgICpuZXdfc3RhdHVzOworCWNoYXIJICAgKm5ld19zdGF0dXMgPSBO VUxMOworCWJvb2wJCWxvZ2dlZF9yZWNvdmVyeV9jb25mbGljdCA9IGZhbHNlOwogCiAJLyog RmFzdCBleGl0LCB0byBhdm9pZCBhIGtlcm5lbCBjYWxsIGlmIHRoZXJlJ3Mgbm8gd29yayB0 byBiZSBkb25lLiAqLwogCWlmICghVmlydHVhbFRyYW5zYWN0aW9uSWRJc1ZhbGlkKCp3YWl0 bGlzdCkpCiAJCXJldHVybjsKIAotCWlmIChyZXBvcnRfd2FpdGluZykKKwkvKiBTZXQgdGhl IHdhaXQgc3RhcnQgdGltZXN0YW1wIGZvciByZXBvcnRpbmcgKi8KKwlpZiAocmVwb3J0X3dh aXRpbmcgJiYgKGxvZ19yZWNvdmVyeV9jb25mbGljdF93YWl0cyB8fCB1cGRhdGVfcHJvY2Vz c190aXRsZSkpCiAJCXdhaXRTdGFydCA9IEdldEN1cnJlbnRUaW1lc3RhbXAoKTsKLQluZXdf c3RhdHVzID0gTlVMTDsJCQkvKiB3ZSBoYXZlbid0IGNoYW5nZWQgdGhlIHBzIGRpc3BsYXkg Ki8KIAogCXdoaWxlIChWaXJ0dWFsVHJhbnNhY3Rpb25JZElzVmFsaWQoKndhaXRsaXN0KSkK IAl7CkBAIC0yNTIsMjUgKzMyMyw2IEBAIFJlc29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aFZp cnR1YWxYSURzKFZpcnR1YWxUcmFuc2FjdGlvbklkICp3YWl0bGlzdCwKIAkJLyogd2FpdCB1 bnRpbCB0aGUgdmlydHVhbCB4aWQgaXMgZ29uZSAqLwogCQl3aGlsZSAoIVZpcnR1YWxYYWN0 TG9jaygqd2FpdGxpc3QsIGZhbHNlKSkKIAkJewotCQkJLyoKLQkJCSAqIFJlcG9ydCB2aWEg cHMgaWYgd2UgaGF2ZSBiZWVuIHdhaXRpbmcgZm9yIG1vcmUgdGhhbiA1MDAgbXNlYwotCQkJ ICogKHNob3VsZCB0aGF0IGJlIGNvbmZpZ3VyYWJsZT8pCi0JCQkgKi8KLQkJCWlmICh1cGRh dGVfcHJvY2Vzc190aXRsZSAmJiBuZXdfc3RhdHVzID09IE5VTEwgJiYgcmVwb3J0X3dhaXRp bmcgJiYKLQkJCQlUaW1lc3RhbXBEaWZmZXJlbmNlRXhjZWVkcyh3YWl0U3RhcnQsIEdldEN1 cnJlbnRUaW1lc3RhbXAoKSwKLQkJCQkJCQkJCQkgICA1MDApKQotCQkJewotCQkJCWNvbnN0 IGNoYXIgKm9sZF9zdGF0dXM7Ci0JCQkJaW50CQkJbGVuOwotCi0JCQkJb2xkX3N0YXR1cyA9 IGdldF9wc19kaXNwbGF5KCZsZW4pOwotCQkJCW5ld19zdGF0dXMgPSAoY2hhciAqKSBwYWxs b2MobGVuICsgOCArIDEpOwotCQkJCW1lbWNweShuZXdfc3RhdHVzLCBvbGRfc3RhdHVzLCBs ZW4pOwotCQkJCXN0cmNweShuZXdfc3RhdHVzICsgbGVuLCAiIHdhaXRpbmciKTsKLQkJCQlz ZXRfcHNfZGlzcGxheShuZXdfc3RhdHVzKTsKLQkJCQluZXdfc3RhdHVzW2xlbl0gPSAnXDAn OyAvKiB0cnVuY2F0ZSBvZmYgIiB3YWl0aW5nIiAqLwotCQkJfQotCiAJCQkvKiBJcyBpdCB0 aW1lIHRvIGtpbGwgaXQ/ICovCiAJCQlpZiAoV2FpdEV4Y2VlZHNNYXhTdGFuZGJ5RGVsYXko d2FpdF9ldmVudF9pbmZvKSkKIAkJCXsKQEAgLTI4OSw2ICszNDEsNTAgQEAgUmVzb2x2ZVJl Y292ZXJ5Q29uZmxpY3RXaXRoVmlydHVhbFhJRHMoVmlydHVhbFRyYW5zYWN0aW9uSWQgKndh aXRsaXN0LAogCQkJCWlmIChwaWQgIT0gMCkKIAkJCQkJcGdfdXNsZWVwKDUwMDBMKTsKIAkJ CX0KKworCQkJaWYgKHdhaXRTdGFydCAhPSAwICYmICghbG9nZ2VkX3JlY292ZXJ5X2NvbmZs aWN0IHx8IG5ld19zdGF0dXMgPT0gTlVMTCkpCisJCQl7CisJCQkJVGltZXN0YW1wVHogbm93 ID0gMDsKKwkJCQlib29sCQltYXliZV9sb2dfY29uZmxpY3Q7CisJCQkJYm9vbAkJbWF5YmVf dXBkYXRlX3RpdGxlOworCisJCQkJbWF5YmVfbG9nX2NvbmZsaWN0ID0gKGxvZ19yZWNvdmVy eV9jb25mbGljdF93YWl0cyAmJiAhbG9nZ2VkX3JlY292ZXJ5X2NvbmZsaWN0KTsKKwkJCQlt YXliZV91cGRhdGVfdGl0bGUgPSAodXBkYXRlX3Byb2Nlc3NfdGl0bGUgJiYgbmV3X3N0YXR1 cyA9PSBOVUxMKTsKKworCQkJCS8qIEdldCB0aGUgY3VycmVudCB0aW1lc3RhbXAgaWYgbm90 IHJlcG9ydCB5ZXQgKi8KKwkJCQlpZiAobWF5YmVfbG9nX2NvbmZsaWN0IHx8IG1heWJlX3Vw ZGF0ZV90aXRsZSkKKwkJCQkJbm93ID0gR2V0Q3VycmVudFRpbWVzdGFtcCgpOworCisJCQkJ LyoKKwkJCQkgKiBSZXBvcnQgdmlhIHBzIGlmIHdlIGhhdmUgYmVlbiB3YWl0aW5nIGZvciBt b3JlIHRoYW4gNTAwCisJCQkJICogbXNlYyAoc2hvdWxkIHRoYXQgYmUgY29uZmlndXJhYmxl PykKKwkJCQkgKi8KKwkJCQlpZiAobWF5YmVfdXBkYXRlX3RpdGxlICYmCisJCQkJCVRpbWVz dGFtcERpZmZlcmVuY2VFeGNlZWRzKHdhaXRTdGFydCwgbm93LCA1MDApKQorCQkJCXsKKwkJ CQkJY29uc3QgY2hhciAqb2xkX3N0YXR1czsKKwkJCQkJaW50CQkJbGVuOworCisJCQkJCW9s ZF9zdGF0dXMgPSBnZXRfcHNfZGlzcGxheSgmbGVuKTsKKwkJCQkJbmV3X3N0YXR1cyA9IChj aGFyICopIHBhbGxvYyhsZW4gKyA4ICsgMSk7CisJCQkJCW1lbWNweShuZXdfc3RhdHVzLCBv bGRfc3RhdHVzLCBsZW4pOworCQkJCQlzdHJjcHkobmV3X3N0YXR1cyArIGxlbiwgIiB3YWl0 aW5nIik7CisJCQkJCXNldF9wc19kaXNwbGF5KG5ld19zdGF0dXMpOworCQkJCQluZXdfc3Rh dHVzW2xlbl0gPSAnXDAnOyAvKiB0cnVuY2F0ZSBvZmYgIiB3YWl0aW5nIiAqLworCQkJCX0K KworCQkJCS8qCisJCQkJICogRW1pdCB0aGUgbG9nIG1lc3NhZ2UgaWYgdGhlIHN0YXJ0dXAg cHJvY2VzcyBpcyB3YWl0aW5nCisJCQkJICogbG9uZ2VyIHRoYW4gZGVhZGxvY2tfdGltZW91 dCBmb3IgcmVjb3ZlcnkgY29uZmxpY3Qgb24KKwkJCQkgKiBidWZmZXIgcGluLgorCQkJCSAq LworCQkJCWlmIChtYXliZV9sb2dfY29uZmxpY3QgJiYKKwkJCQkJVGltZXN0YW1wRGlmZmVy ZW5jZUV4Y2VlZHMod2FpdFN0YXJ0LCBub3csIERlYWRsb2NrVGltZW91dCkpCisJCQkJewor CQkJCQlMb2dSZWNvdmVyeUNvbmZsaWN0KHJlYXNvbiwgd2FpdFN0YXJ0LCBub3csIHdhaXRs aXN0KTsKKwkJCQkJbG9nZ2VkX3JlY292ZXJ5X2NvbmZsaWN0ID0gdHJ1ZTsKKwkJCQl9CisJ CQl9CiAJCX0KIAogCQkvKiBUaGUgdmlydHVhbCB0cmFuc2FjdGlvbiBpcyBnb25lIG5vdywg d2FpdCBmb3IgdGhlIG5leHQgb25lICovCkBAIC00MDUsOSArNTAxLDE4IEBAIFJlc29sdmVS ZWNvdmVyeUNvbmZsaWN0V2l0aERhdGFiYXNlKE9pZCBkYmlkKQogICogaG90LXN0YW5kYnkg YmFja2VuZCBwcm9jZXNzZXMuIElmIGRlYWRsb2NrX3RpbWVvdXQgaXMgcmVhY2hlZCBpbgog ICogdGhpcyBmdW5jdGlvbiwgYWxsIHRoZSBiYWNrZW5kcyBob2xkaW5nIHRoZSBjb25mbGlj dGluZyBsb2NrcyBhcmUKICAqIHJlcXVlc3RlZCB0byBjaGVjayB0aGVtc2VsdmVzIGZvciBk ZWFkbG9ja3MuCisgKgorICogbG9nZ2luZ19jb25mbGljdCBzaG91bGQgYmUgdHJ1ZSBpZiB0 aGUgcmVjb3ZlcnkgY29uZmxpY3QgaGFzIG5vdCBiZWVuCisgKiBsb2dnZWQgeWV0IGV2ZW4g dGhvdWdoIGxvZ2dpbmcgaXMgZW5hYmxlZC4gQWZ0ZXIgZGVhZGxvY2tfdGltZW91dCBpcwor ICogcmVhY2hlZCBhbmQgdGhlIHJlcXVlc3QgZm9yIGRlYWRsb2NrIGNoZWNrIGlzIHNlbnQs IHdlIHdhaXQgYWdhaW4gdG8KKyAqIGJlIHNpZ25hbGVkIGJ5IHRoZSByZWxlYXNlIG9mIHRo ZSBsb2NrIGlmIGxvZ2dpbmdfY29uZmxpY3QgaXMgZmFsc2UuCisgKiBPdGhlcndpc2Ugd2Ug cmV0dXJuIHdpdGhvdXQgd2FpdGluZyBhZ2FpbiBzbyB0aGF0IHRoZSBjYWxsZXIgY2FuIHJl cG9ydAorICogdGhlIHJlY292ZXJ5IGNvbmZsaWN0LiBJbiB0aGlzIGNhc2UsIHRoZW4sIHRo aXMgZnVuY3Rpb24gaXMgY2FsbGVkIGFnYWluCisgKiB3aXRoIGxvZ2dpbmdfY29uZmxpY3Q9 ZmFsc2UgKGJlY2F1c2UgdGhlIHJlY292ZXJ5IGNvbmZsaWN0IGhhcyBhbHJlYWR5CisgKiBi ZWVuIGxvZ2dlZCkgYW5kIHdlIHdpbGwgd2FpdCBhZ2FpbiBmb3IgdGhlIGxvY2sgdG8gYmUg cmVsZWFzZWQuCiAgKi8KIHZvaWQKLVJlc29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aExvY2so TE9DS1RBRyBsb2NrdGFnKQorUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoTG9jayhMT0NL VEFHIGxvY2t0YWcsIGJvb2wgbG9nZ2luZ19jb25mbGljdCkKIHsKIAlUaW1lc3RhbXBUeiBs dGltZTsKIApAQCAtNDk0LDYgKzU5OSwxNSBAQCBSZXNvbHZlUmVjb3ZlcnlDb25mbGljdFdp dGhMb2NrKExPQ0tUQUcgbG9ja3RhZykKIAkJCWJhY2tlbmRzKys7CiAJCX0KIAorCQkvKgor CQkgKiBFeGl0IGlmIHRoZSByZWNvdmVyeSBjb25mbGljdCBoYXMgbm90IGJlZW4gbG9nZ2Vk IHlldCBldmVuIHRob3VnaAorCQkgKiBsb2dnaW5nIGlzIGVuYWJsZWQsIHNvIHRoYXQgdGhl IGNhbGxlciBjYW4gbG9nIHRoYXQuIFRoZW4KKwkJICogUmVjb3ZlcnlDb25mbGljdFdpdGhM b2NrKCkgaXMgY2FsbGVkIGFnYWluIGFuZCB3ZSB3aWxsIHdhaXQgYWdhaW4KKwkJICogZm9y IHRoZSBsb2NrIHRvIGJlIHJlbGVhc2VkLgorCQkgKi8KKwkJaWYgKGxvZ2dpbmdfY29uZmxp Y3QpCisJCQlnb3RvIGNsZWFudXA7CisKIAkJLyoKIAkJICogV2FpdCBhZ2FpbiBoZXJlIHRv IGJlIHNpZ25hbGVkIGJ5IHRoZSByZWxlYXNlIG9mIHRoZSBSZWxhdGlvbiBMb2NrLAogCQkg KiB0byBwcmV2ZW50IHRoZSBzdWJzZXF1ZW50IFJlY292ZXJ5Q29uZmxpY3RXaXRoTG9jaygp IGZyb20gY2F1c2luZwpAQCAtMTIwOSwzICsxMzIzLDM2IEBAIExvZ1N0YW5kYnlJbnZhbGlk YXRpb25zKGludCBubXNncywgU2hhcmVkSW52YWxpZGF0aW9uTWVzc2FnZSAqbXNncywKIAkJ CQkJIG5tc2dzICogc2l6ZW9mKFNoYXJlZEludmFsaWRhdGlvbk1lc3NhZ2UpKTsKIAlYTG9n SW5zZXJ0KFJNX1NUQU5EQllfSUQsIFhMT0dfSU5WQUxJREFUSU9OUyk7CiB9CisKKy8qIFJl dHVybiB0aGUgZGVzY3JpcHRpb24gb2YgcmVjb3ZlcnkgY29uZmxpY3QgKi8KK3N0YXRpYyBj b25zdCBjaGFyICoKK2dldF9yZWNvdmVyeV9jb25mbGljdF9kZXNjKFByb2NTaWduYWxSZWFz b24gcmVhc29uKQoreworCWNvbnN0IGNoYXIgKnJlYXNvbkRlc2MgPSBnZXR0ZXh0X25vb3Ao InVua25vd24gcmVhc29uIik7CisKKwlzd2l0Y2ggKHJlYXNvbikKKwl7CisJCWNhc2UgUFJP Q1NJR19SRUNPVkVSWV9DT05GTElDVF9CVUZGRVJQSU46CisJCQlyZWFzb25EZXNjID0gZ2V0 dGV4dF9ub29wKCJyZWNvdmVyeSBjb25mbGljdCBvbiBidWZmZXIgcGluIik7CisJCQlicmVh azsKKwkJY2FzZSBQUk9DU0lHX1JFQ09WRVJZX0NPTkZMSUNUX0xPQ0s6CisJCQlyZWFzb25E ZXNjID0gZ2V0dGV4dF9ub29wKCJyZWNvdmVyeSBjb25mbGljdCBvbiBsb2NrIik7CisJCQli cmVhazsKKwkJY2FzZSBQUk9DU0lHX1JFQ09WRVJZX0NPTkZMSUNUX1RBQkxFU1BBQ0U6CisJ CQlyZWFzb25EZXNjID0gZ2V0dGV4dF9ub29wKCJyZWNvdmVyeSBjb25mbGljdCBvbiB0YWJs ZXNwYWNlIik7CisJCQlicmVhazsKKwkJY2FzZSBQUk9DU0lHX1JFQ09WRVJZX0NPTkZMSUNU X1NOQVBTSE9UOgorCQkJcmVhc29uRGVzYyA9IGdldHRleHRfbm9vcCgicmVjb3ZlcnkgY29u ZmxpY3Qgb24gc25hcHNob3QiKTsKKwkJCWJyZWFrOworCQljYXNlIFBST0NTSUdfUkVDT1ZF UllfQ09ORkxJQ1RfU1RBUlRVUF9ERUFETE9DSzoKKwkJCXJlYXNvbkRlc2MgPSBnZXR0ZXh0 X25vb3AoInJlY292ZXJ5IGNvbmZsaWN0IG9uIGJ1ZmZlciBkZWFkbG9jayIpOworCQkJYnJl YWs7CisJCWNhc2UgUFJPQ1NJR19SRUNPVkVSWV9DT05GTElDVF9EQVRBQkFTRToKKwkJCXJl YXNvbkRlc2MgPSBnZXR0ZXh0X25vb3AoInJlY292ZXJ5IGNvbmZsaWN0IG9uIGRhdGFiYXNl Iik7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCWJyZWFrOworCX0KKworCXJldHVybiBy ZWFzb25EZXNjOworfQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9sbWdyL3By b2MuYyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvbG1nci9wcm9jLmMKaW5kZXggOWI2YWEyZmUw ZC4uYTE3NGMyYzE3OSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9sbWdyL3By b2MuYworKysgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2xtZ3IvcHJvYy5jCkBAIC0xMDYzLDgg KzEwNjMsMTAgQEAgUHJvY1NsZWVwKExPQ0FMTE9DSyAqbG9jYWxsb2NrLCBMb2NrTWV0aG9k IGxvY2tNZXRob2RUYWJsZSkKIAlMV0xvY2sJICAgKnBhcnRpdGlvbkxvY2sgPSBMb2NrSGFz aFBhcnRpdGlvbkxvY2soaGFzaGNvZGUpOwogCVBST0NfUVVFVUUgKndhaXRRdWV1ZSA9ICYo bG9jay0+d2FpdFByb2NzKTsKIAlMT0NLTUFTSwlteUhlbGRMb2NrcyA9IE15UHJvYy0+aGVs ZExvY2tzOworCVRpbWVzdGFtcFR6IHN0YW5kYnlXYWl0U3RhcnQgPSAwOwogCWJvb2wJCWVh cmx5X2RlYWRsb2NrID0gZmFsc2U7CiAJYm9vbAkJYWxsb3dfYXV0b3ZhY3V1bV9jYW5jZWwg PSB0cnVlOworCWJvb2wJCWxvZ2dlZF9yZWNvdmVyeV9jb25mbGljdCA9IGZhbHNlOwogCVBy b2NXYWl0U3RhdHVzIG15V2FpdFN0YXR1czsKIAlQR1BST0MJICAgKnByb2M7CiAJUEdQUk9D CSAgICpsZWFkZXIgPSBNeVByb2MtPmxvY2tHcm91cExlYWRlcjsKQEAgLTEyNjAsNiArMTI2 MiwxNCBAQCBQcm9jU2xlZXAoTE9DQUxMT0NLICpsb2NhbGxvY2ssIExvY2tNZXRob2QgbG9j a01ldGhvZFRhYmxlKQogCQllbHNlCiAJCQllbmFibGVfdGltZW91dF9hZnRlcihERUFETE9D S19USU1FT1VULCBEZWFkbG9ja1RpbWVvdXQpOwogCX0KKwllbHNlIGlmIChsb2dfcmVjb3Zl cnlfY29uZmxpY3Rfd2FpdHMpCisJeworCQkvKgorCQkgKiBTZXQgdGhlIHdhaXQgc3RhcnQg dGltZXN0YW1wIGlmIGxvZ2dpbmcgaXMgZW5hYmxlZCBhbmQgaW4gaG90CisJCSAqIHN0YW5k YnkuCisJCSAqLworCQlzdGFuZGJ5V2FpdFN0YXJ0ID0gR2V0Q3VycmVudFRpbWVzdGFtcCgp OworCX0KIAogCS8qCiAJICogSWYgc29tZWJvZHkgd2FrZXMgdXMgYmV0d2VlbiBMV0xvY2tS ZWxlYXNlIGFuZCBXYWl0TGF0Y2gsIHRoZSBsYXRjaApAQCAtMTI3OSw4ICsxMjg5LDQyIEBA IFByb2NTbGVlcChMT0NBTExPQ0sgKmxvY2FsbG9jaywgTG9ja01ldGhvZCBsb2NrTWV0aG9k VGFibGUpCiAJewogCQlpZiAoSW5Ib3RTdGFuZGJ5KQogCQl7Ci0JCQkvKiBTZXQgYSB0aW1l ciBhbmQgd2FpdCBmb3IgdGhhdCBvciBmb3IgdGhlIExvY2sgdG8gYmUgZ3JhbnRlZCAqLwot CQkJUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoTG9jayhsb2NhbGxvY2stPnRhZy5sb2Nr KTsKKwkJCWJvb2wJCW1heWJlX2xvZ19jb25mbGljdCA9CisJCQkoc3RhbmRieVdhaXRTdGFy dCAhPSAwICYmICFsb2dnZWRfcmVjb3ZlcnlfY29uZmxpY3QpOworCisJCQkvKiBTZXQgYSB0 aW1lciBhbmQgd2FpdCBmb3IgdGhhdCBvciBmb3IgdGhlIGxvY2sgdG8gYmUgZ3JhbnRlZCAq LworCQkJUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoTG9jayhsb2NhbGxvY2stPnRhZy5s b2NrLAorCQkJCQkJCQkJCQltYXliZV9sb2dfY29uZmxpY3QpOworCisJCQkvKgorCQkJICog RW1pdCB0aGUgbG9nIG1lc3NhZ2UgaWYgdGhlIHN0YXJ0dXAgcHJvY2VzcyBpcyB3YWl0aW5n IGxvbmdlcgorCQkJICogdGhhbiBkZWFkbG9ja190aW1lb3V0IGZvciByZWNvdmVyeSBjb25m bGljdCBvbiBsb2NrLgorCQkJICovCisJCQlpZiAobWF5YmVfbG9nX2NvbmZsaWN0KQorCQkJ eworCQkJCVRpbWVzdGFtcFR6IG5vdyA9IEdldEN1cnJlbnRUaW1lc3RhbXAoKTsKKworCQkJ CWlmIChUaW1lc3RhbXBEaWZmZXJlbmNlRXhjZWVkcyhzdGFuZGJ5V2FpdFN0YXJ0LCBub3cs CisJCQkJCQkJCQkJCSAgIERlYWRsb2NrVGltZW91dCkpCisJCQkJeworCQkJCQlWaXJ0dWFs VHJhbnNhY3Rpb25JZCAqdnhpZHM7CisJCQkJCWludAkJCWNudDsKKworCQkJCQl2eGlkcyA9 IEdldExvY2tDb25mbGljdHMoJmxvY2FsbG9jay0+dGFnLmxvY2ssCisJCQkJCQkJCQkJCSBB Y2Nlc3NFeGNsdXNpdmVMb2NrLCAmY250KTsKKworCQkJCQkvKgorCQkJCQkgKiBMb2cgdGhl IHJlY292ZXJ5IGNvbmZsaWN0IGFuZCB0aGUgbGlzdCBvZiBQSURzIG9mCisJCQkJCSAqIGJh Y2tlbmRzIGhvbGRpbmcgdGhlIGNvbmZsaWN0aW5nIGxvY2suIE5vdGUgdGhhdCB3ZSBkbwor CQkJCQkgKiBsb2dnaW5nIGV2ZW4gaWYgdGhlcmUgYXJlIG5vIHN1Y2ggYmFja2VuZHMgcmln aHQgbm93CisJCQkJCSAqIGJlY2F1c2UgdGhlIHN0YXJ0dXAgcHJvY2VzcyBoZXJlIGhhcyBh bHJlYWR5IHdhaXRlZAorCQkJCQkgKiBsb25nZXIgdGhhbiBkZWFkbG9ja190aW1lb3V0Lgor CQkJCQkgKi8KKwkJCQkJTG9nUmVjb3ZlcnlDb25mbGljdChQUk9DU0lHX1JFQ09WRVJZX0NP TkZMSUNUX0xPQ0ssCisJCQkJCQkJCQkJc3RhbmRieVdhaXRTdGFydCwgbm93LCBjbnQgPiAw ID8gdnhpZHMgOiBOVUxMKTsKKwkJCQkJbG9nZ2VkX3JlY292ZXJ5X2NvbmZsaWN0ID0gdHJ1 ZTsKKwkJCQl9CisJCQl9CiAJCX0KIAkJZWxzZQogCQl7CmRpZmYgLS1naXQgYS9zcmMvYmFj a2VuZC91dGlscy9taXNjL2d1Yy5jIGIvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWMuYwpp bmRleCAzODNiN2QwZDcxLi5jNjI1NzY4ZjE4IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC91 dGlscy9taXNjL2d1Yy5jCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjLmMKQEAg LTE1NzIsNyArMTU3MiwxNSBAQCBzdGF0aWMgc3RydWN0IGNvbmZpZ19ib29sIENvbmZpZ3Vy ZU5hbWVzQm9vbFtdID0KIAkJZmFsc2UsCiAJCU5VTEwsIE5VTEwsIE5VTEwKIAl9LAotCisJ eworCQl7ImxvZ19yZWNvdmVyeV9jb25mbGljdF93YWl0cyIsIFBHQ19TSUdIVVAsIExPR0dJ TkdfV0hBVCwKKwkJCWdldHRleHRfbm9vcCgiTG9ncyBzdGFuZGJ5IHJlY292ZXJ5IGNvbmZs aWN0IHdhaXRzLiIpLAorCQkJTlVMTAorCQl9LAorCQkmbG9nX3JlY292ZXJ5X2NvbmZsaWN0 X3dhaXRzLAorCQlmYWxzZSwKKwkJTlVMTCwgTlVMTCwgTlVMTAorCX0sCiAJewogCQl7Imxv Z19ob3N0bmFtZSIsIFBHQ19TSUdIVVAsIExPR0dJTkdfV0hBVCwKIAkJCWdldHRleHRfbm9v cCgiTG9ncyB0aGUgaG9zdCBuYW1lIGluIHRoZSBjb25uZWN0aW9uIGxvZ3MuIiksCmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9taXNjL3Bvc3RncmVzcWwuY29uZi5zYW1wbGUg Yi9zcmMvYmFja2VuZC91dGlscy9taXNjL3Bvc3RncmVzcWwuY29uZi5zYW1wbGUKaW5kZXgg NTI5OGUxOGVjZC4uNWEyNDMwMDk1ZCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMv bWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL21p c2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZQpAQCAtNTUyLDYgKzU1Miw4IEBACiAJCQkJCSMg ICAlJSA9ICclJwogCQkJCQkjIGUuZy4gJzwldSUlJWQ+ICcKICNsb2dfbG9ja193YWl0cyA9 IG9mZgkJCSMgbG9nIGxvY2sgd2FpdHMgPj0gZGVhZGxvY2tfdGltZW91dAorI2xvZ19yZWNv dmVyeV9jb25mbGljdF93YWl0cyA9IG9mZgkjIGxvZyBzdGFuZGJ5IHJlY292ZXJ5IGNvbmZs aWN0IHdhaXRzCisJCQkJCSMgPj0gZGVhZGxvY2tfdGltZW91dAogI2xvZ19wYXJhbWV0ZXJf bWF4X2xlbmd0aCA9IC0xCQkjIHdoZW4gbG9nZ2luZyBzdGF0ZW1lbnRzLCBsaW1pdCBsb2dn ZWQKIAkJCQkJIyBiaW5kLXBhcmFtZXRlciB2YWx1ZXMgdG8gTiBieXRlczsKIAkJCQkJIyAt MSBtZWFucyBwcmludCBpbiBmdWxsLCAwIGRpc2FibGVzCmRpZmYgLS1naXQgYS9zcmMvaW5j bHVkZS9zdG9yYWdlL3N0YW5kYnkuaCBiL3NyYy9pbmNsdWRlL3N0b3JhZ2Uvc3RhbmRieS5o CmluZGV4IDliNWNjMDFjOTcuLmEwZjNlMGJkZjAgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRl L3N0b3JhZ2Uvc3RhbmRieS5oCisrKyBiL3NyYy9pbmNsdWRlL3N0b3JhZ2Uvc3RhbmRieS5o CkBAIC0yMyw2ICsyMyw3IEBACiBleHRlcm4gaW50CXZhY3V1bV9kZWZlcl9jbGVhbnVwX2Fn ZTsKIGV4dGVybiBpbnQJbWF4X3N0YW5kYnlfYXJjaGl2ZV9kZWxheTsKIGV4dGVybiBpbnQJ bWF4X3N0YW5kYnlfc3RyZWFtaW5nX2RlbGF5OworZXh0ZXJuIGJvb2wgbG9nX3JlY292ZXJ5 X2NvbmZsaWN0X3dhaXRzOwogCiBleHRlcm4gdm9pZCBJbml0UmVjb3ZlcnlUcmFuc2FjdGlv bkVudmlyb25tZW50KHZvaWQpOwogZXh0ZXJuIHZvaWQgU2h1dGRvd25SZWNvdmVyeVRyYW5z YWN0aW9uRW52aXJvbm1lbnQodm9pZCk7CkBAIC0zMiwxMiArMzMsMTQgQEAgZXh0ZXJuIHZv aWQgUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoU25hcHNob3QoVHJhbnNhY3Rpb25JZCBs YXRlc3RSZW1vdmVkWGlkLAogZXh0ZXJuIHZvaWQgUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RX aXRoVGFibGVzcGFjZShPaWQgdHNpZCk7CiBleHRlcm4gdm9pZCBSZXNvbHZlUmVjb3ZlcnlD b25mbGljdFdpdGhEYXRhYmFzZShPaWQgZGJpZCk7CiAKLWV4dGVybiB2b2lkIFJlc29sdmVS ZWNvdmVyeUNvbmZsaWN0V2l0aExvY2soTE9DS1RBRyBsb2NrdGFnKTsKK2V4dGVybiB2b2lk IFJlc29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aExvY2soTE9DS1RBRyBsb2NrdGFnLCBib29s IGxvZ2dpbmdfY29uZmxpY3QpOwogZXh0ZXJuIHZvaWQgUmVzb2x2ZVJlY292ZXJ5Q29uZmxp Y3RXaXRoQnVmZmVyUGluKHZvaWQpOwogZXh0ZXJuIHZvaWQgQ2hlY2tSZWNvdmVyeUNvbmZs aWN0RGVhZGxvY2sodm9pZCk7CiBleHRlcm4gdm9pZCBTdGFuZGJ5RGVhZExvY2tIYW5kbGVy KHZvaWQpOwogZXh0ZXJuIHZvaWQgU3RhbmRieVRpbWVvdXRIYW5kbGVyKHZvaWQpOwogZXh0 ZXJuIHZvaWQgU3RhbmRieUxvY2tUaW1lb3V0SGFuZGxlcih2b2lkKTsKK2V4dGVybiB2b2lk IExvZ1JlY292ZXJ5Q29uZmxpY3QoUHJvY1NpZ25hbFJlYXNvbiByZWFzb24sIFRpbWVzdGFt cFR6IHdhaXRfc3RhcnQsCisJCQkJCQkJCVRpbWVzdGFtcFR6IGN1cl90cywgVmlydHVhbFRy YW5zYWN0aW9uSWQgKndhaXRfbGlzdCk7CiAKIC8qCiAgKiBTdGFuZGJ5IFJtZ3IgKFJNX1NU QU5EQllfSUQpCg== --------------EDA05675B262CC93EB8AAF7B--