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 1kopeZ-00086m-Fk for pgsql-hackers@arkaria.postgresql.org; Mon, 14 Dec 2020 15:20:47 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1kopeX-0005xC-JC for pgsql-hackers@arkaria.postgresql.org; Mon, 14 Dec 2020 15:20:45 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1kopeX-0005x4-3l for pgsql-hackers@lists.postgresql.org; Mon, 14 Dec 2020 15:20:45 +0000 Received: from oss.nttdata.com ([49.212.34.109]) by makus.postgresql.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1kopeO-0004AP-Pl for pgsql-hackers@postgresql.org; Mon, 14 Dec 2020 15:20:43 +0000 Received: from hnk.local (p1295030-ipngn4902funabasi.chiba.ocn.ne.jp [153.166.85.30]) by oss.nttdata.com (Postfix) with ESMTPSA id C335C625B3; Tue, 15 Dec 2020 00:20:32 +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: Tue, 15 Dec 2020 00:20:32 +0900 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0) Gecko/20100101 Thunderbird/78.5.1 MIME-Version: 1.0 In-Reply-To: <02b17df8-cf11-7e5a-31e3-d94c87b28775@oss.nttdata.com> Content-Type: multipart/mixed; boundary="------------3A2BF430AA503888EFBDB858" 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. --------------3A2BF430AA503888EFBDB858 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit 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. Regards, -- Fujii Masao Advanced Computing Technology Center Research and Development Headquarters NTT DATA CORPORATION --------------3A2BF430AA503888EFBDB858 Content-Type: text/plain; charset=UTF-8; x-mac-type="0"; x-mac-creator="0"; name="v11-0002-Log-the-standby-recovery-conflict-waits.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="v11-0002-Log-the-standby-recovery-conflict-waits.patch" ZGlmZiAtLWdpdCBhL2RvYy9zcmMvc2dtbC9jb25maWcuc2dtbCBiL2RvYy9zcmMvc2dtbC9j b25maWcuc2dtbAppbmRleCA0YjYwMzgyNzc4Li5lMDVmNmViNzMyIDEwMDY0NAotLS0gYS9k b2Mvc3JjL3NnbWwvY29uZmlnLnNnbWwKKysrIGIvZG9jL3NyYy9zZ21sL2NvbmZpZy5zZ21s CkBAIC02OTQ2LDYgKzY5NDYsMjggQEAgbG9nX2xpbmVfcHJlZml4ID0gJyVtIFslcF0gJXEl 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 c2dtbAppbmRleCAxOWQ3YmQyYjI4Li4yZDMyZTE0MWMyIDEwMDY0NAotLS0gYS9kb2Mvc3Jj L3NnbWwvaGlnaC1hdmFpbGFiaWxpdHkuc2dtbAorKysgYi9kb2Mvc3JjL3NnbWwvaGlnaC1h dmFpbGFiaWxpdHkuc2dtbApAQCAtMjA2OCw2ICsyMDY4LDEyIEBAIGlmICghdHJpZ2dlcmVk KQogICAgIHNlcnZlci4gVGhlIDxzdHJ1Y3RuYW1lPnBnX3N0YXRfZGF0YWJhc2U8L3N0cnVj dG5hbWU+IHN5c3RlbSB2aWV3IGFsc28gY29udGFpbnMKICAgICBzdW1tYXJ5IGluZm9ybWF0 aW9uLgogICAgPC9wYXJhPgorCisgICA8cGFyYT4KKyAgICBVc2VycyBjYW4gY29udHJvbCB3 aGV0aGVyIGEgbG9nIG1lc3NhZ2UgaXMgcHJvZHVjZWQgd2hlbiBXQUwgcmVwbGF5IGlzIHdh aXRpbmcKKyAgICBsb25nZXIgdGhhbiA8dmFybmFtZT5kZWFkbG9ja190aW1lb3V0PC92YXJu YW1lPiBmb3IgY29uZmxpY3RzLiBUaGlzCisgICAgaXMgY29udHJvbGxlZCBieSB0aGUgPHhy ZWYgbGlua2VuZD0iZ3VjLWxvZy1yZWNvdmVyeS1jb25mbGljdC13YWl0cyIvPiBwYXJhbWV0 ZXIuCisgICA8L3BhcmE+CiAgIDwvc2VjdDI+CiAKICAgPHNlY3QyIGlkPSJob3Qtc3RhbmRi eS1hZG1pbiI+CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZt Z3IuYyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jCmluZGV4IGFkMGQx YTlhYmMuLjg0OTllYTU0ZjUgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVm ZmVyL2J1Zm1nci5jCisrKyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5j CkBAIC0zODEwLDYgKzM4MTAsOCBAQCBMb2NrQnVmZmVyRm9yQ2xlYW51cChCdWZmZXIgYnVm ZmVyKQogewogCUJ1ZmZlckRlc2MgKmJ1ZkhkcjsKIAljaGFyCSAgICpuZXdfc3RhdHVzID0g TlVMTDsKKwlUaW1lc3RhbXBUeiB3YWl0U3RhcnQgPSAwOworCWJvb2wJCWxvZ2dlZF9yZWNv dmVyeV9jb25mbGljdCA9IGZhbHNlOwogCiAJQXNzZXJ0KEJ1ZmZlcklzUGlubmVkKGJ1ZmZl cikpOwogCUFzc2VydChQaW5Db3VudFdhaXRCdWYgPT0gTlVMTCk7CkBAIC0zODgzLDYgKzM4 ODUsMzQgQEAgTG9ja0J1ZmZlckZvckNsZWFudXAoQnVmZmVyIGJ1ZmZlcikKIAkJCQluZXdf c3RhdHVzW2xlbl0gPSAnXDAnOyAvKiB0cnVuY2F0ZSBvZmYgIiB3YWl0aW5nIiAqLwogCQkJ fQogCisJCQkvKgorCQkJICogRW1pdCB0aGUgbG9nIG1lc3NhZ2UgaWYgdGhlIHN0YXJ0dXAg cHJvY2VzcyBpcyB3YWl0aW5nIGxvbmdlcgorCQkJICogdGhhbiBkZWFkbG9ja190aW1lb3V0 IGZvciByZWNvdmVyeSBjb25mbGljdCBvbiBidWZmZXIgcGluLgorCQkJICoKKwkJCSAqIFNr aXAgdGhpcyBpZiBmaXJzdCB0aW1lIHRocm91Z2ggYmVjYXVzZSB0aGUgc3RhcnR1cCBwcm9j ZXNzIGhhcworCQkJICogbm90IHN0YXJ0ZWQgd2FpdGluZyB5ZXQgaW4gdGhpcyBjYXNlLiBT bywgdGhlIHdhaXQgc3RhcnQKKwkJCSAqIHRpbWVzdGFtcCBpcyBzZXQgYWZ0ZXIgdGhpcyBs b2dpYy4KKwkJCSAqLworCQkJaWYgKHdhaXRTdGFydCAhPSAwICYmICFsb2dnZWRfcmVjb3Zl cnlfY29uZmxpY3QpCisJCQl7CisJCQkJVGltZXN0YW1wVHogbm93ID0gR2V0Q3VycmVudFRp bWVzdGFtcCgpOworCisJCQkJaWYgKFRpbWVzdGFtcERpZmZlcmVuY2VFeGNlZWRzKHdhaXRT dGFydCwgbm93LAorCQkJCQkJCQkJCQkgICBEZWFkbG9ja1RpbWVvdXQpKQorCQkJCXsKKwkJ CQkJTG9nUmVjb3ZlcnlDb25mbGljdChQUk9DU0lHX1JFQ09WRVJZX0NPTkZMSUNUX0JVRkZF UlBJTiwKKwkJCQkJCQkJCQl3YWl0U3RhcnQsIG5vdywgTlVMTCk7CisJCQkJCWxvZ2dlZF9y ZWNvdmVyeV9jb25mbGljdCA9IHRydWU7CisJCQkJfQorCQkJfQorCisJCQkvKgorCQkJICog U2V0IHRoZSB3YWl0IHN0YXJ0IHRpbWVzdGFtcCBpZiBsb2dnaW5nIGlzIGVuYWJsZWQgYW5k IGZpcnN0CisJCQkgKiB0aW1lIHRocm91Z2guCisJCQkgKi8KKwkJCWlmIChsb2dfcmVjb3Zl cnlfY29uZmxpY3Rfd2FpdHMgJiYgd2FpdFN0YXJ0ID09IDApCisJCQkJd2FpdFN0YXJ0ID0g R2V0Q3VycmVudFRpbWVzdGFtcCgpOworCiAJCQkvKiBQdWJsaXNoIHRoZSBidWZpZCB0aGF0 IFN0YXJ0dXAgcHJvY2VzcyB3YWl0cyBvbiAqLwogCQkJU2V0U3RhcnR1cEJ1ZmZlclBpbldh aXRCdWZJZChidWZmZXIgLSAxKTsKIAkJCS8qIFNldCBhbGFybSBhbmQgdGhlbiB3YWl0IHRv IGJlIHNpZ25hbGVkIGJ5IFVucGluQnVmZmVyKCkgKi8KZGlmZiAtLWdpdCBhL3NyYy9iYWNr ZW5kL3N0b3JhZ2UvaXBjL3N0YW5kYnkuYyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvaXBjL3N0 YW5kYnkuYwppbmRleCA1MmIyODA5ZGFjLi5jZjRlNjMwYWEyIDEwMDY0NAotLS0gYS9zcmMv YmFja2VuZC9zdG9yYWdlL2lwYy9zdGFuZGJ5LmMKKysrIGIvc3JjL2JhY2tlbmQvc3RvcmFn ZS9pcGMvc3RhbmRieS5jCkBAIC0zOSw2ICszOSw3IEBACiBpbnQJCQl2YWN1dW1fZGVmZXJf Y2xlYW51cF9hZ2U7CiBpbnQJCQltYXhfc3RhbmRieV9hcmNoaXZlX2RlbGF5ID0gMzAgKiAx MDAwOwogaW50CQkJbWF4X3N0YW5kYnlfc3RyZWFtaW5nX2RlbGF5ID0gMzAgKiAxMDAwOwor Ym9vbAkJbG9nX3JlY292ZXJ5X2NvbmZsaWN0X3dhaXRzID0gZmFsc2U7CiAKIHN0YXRpYyBI VEFCICpSZWNvdmVyeUxvY2tMaXN0czsKIApAQCAtNDksNiArNTAsNyBAQCBzdGF0aWMgdm9p ZCBSZXNvbHZlUmVjb3ZlcnlDb25mbGljdFdpdGhWaXJ0dWFsWElEcyhWaXJ0dWFsVHJhbnNh Y3Rpb25JZCAqd2FpdGxpcwogc3RhdGljIHZvaWQgU2VuZFJlY292ZXJ5Q29uZmxpY3RXaXRo QnVmZmVyUGluKFByb2NTaWduYWxSZWFzb24gcmVhc29uKTsKIHN0YXRpYyBYTG9nUmVjUHRy IExvZ0N1cnJlbnRSdW5uaW5nWGFjdHMoUnVubmluZ1RyYW5zYWN0aW9ucyBDdXJyUnVubmlu Z1hhY3RzKTsKIHN0YXRpYyB2b2lkIExvZ0FjY2Vzc0V4Y2x1c2l2ZUxvY2tzKGludCBubG9j a3MsIHhsX3N0YW5kYnlfbG9jayAqbG9ja3MpOworc3RhdGljIGNvbnN0IGNoYXIgKmdldF9y ZWNvdmVyeV9jb25mbGljdF9kZXNjKFByb2NTaWduYWxSZWFzb24gcmVhc29uKTsKIAogLyoK ICAqIEtlZXAgdHJhY2sgb2YgYWxsIHRoZSBsb2NrcyBvd25lZCBieSBhIGdpdmVuIHRyYW5z YWN0aW9uLgpAQCAtMjE1LDE1ICsyMTcsODMgQEAgV2FpdEV4Y2VlZHNNYXhTdGFuZGJ5RGVs 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 YWl0bGlzdCwKQEAgLTIzMSwxNSArMzAxLDE2IEBAIFJlc29sdmVSZWNvdmVyeUNvbmZsaWN0 V2l0aFZpcnR1YWxYSURzKFZpcnR1YWxUcmFuc2FjdGlvbklkICp3YWl0bGlzdCwKIAkJCQkJ CQkJCSAgIGJvb2wgcmVwb3J0X3dhaXRpbmcpCiB7CiAJVGltZXN0YW1wVHogd2FpdFN0YXJ0 ID0gMDsKLQljaGFyCSAgICpuZXdfc3RhdHVzOworCWNoYXIJICAgKm5ld19zdGF0dXMgPSBO VUxMOworCWJvb2wJCWxvZ2dlZF9yZWNvdmVyeV9jb25mbGljdCA9IGZhbHNlOwogCiAJLyog RmFzdCBleGl0LCB0byBhdm9pZCBhIGtlcm5lbCBjYWxsIGlmIHRoZXJlJ3Mgbm8gd29yayB0 byBiZSBkb25lLiAqLwogCWlmICghVmlydHVhbFRyYW5zYWN0aW9uSWRJc1ZhbGlkKCp3YWl0 bGlzdCkpCiAJCXJldHVybjsKIAotCWlmIChyZXBvcnRfd2FpdGluZykKKwkvKiBTZXQgdGhl IHdhaXQgc3RhcnQgdGltZXN0YW1wIGZvciByZXBvcnRpbmcgKi8KKwlpZiAocmVwb3J0X3dh aXRpbmcgJiYgKGxvZ19yZWNvdmVyeV9jb25mbGljdF93YWl0cyB8fCB1cGRhdGVfcHJvY2Vz c190aXRsZSkpCiAJCXdhaXRTdGFydCA9IEdldEN1cnJlbnRUaW1lc3RhbXAoKTsKLQluZXdf c3RhdHVzID0gTlVMTDsJCQkvKiB3ZSBoYXZlbid0IGNoYW5nZWQgdGhlIHBzIGRpc3BsYXkg Ki8KIAogCXdoaWxlIChWaXJ0dWFsVHJhbnNhY3Rpb25JZElzVmFsaWQoKndhaXRsaXN0KSkK IAl7CkBAIC0yNDksMjUgKzMyMCw2IEBAIFJlc29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aFZp cnR1YWxYSURzKFZpcnR1YWxUcmFuc2FjdGlvbklkICp3YWl0bGlzdCwKIAkJLyogd2FpdCB1 bnRpbCB0aGUgdmlydHVhbCB4aWQgaXMgZ29uZSAqLwogCQl3aGlsZSAoIVZpcnR1YWxYYWN0 TG9jaygqd2FpdGxpc3QsIGZhbHNlKSkKIAkJewotCQkJLyoKLQkJCSAqIFJlcG9ydCB2aWEg cHMgaWYgd2UgaGF2ZSBiZWVuIHdhaXRpbmcgZm9yIG1vcmUgdGhhbiA1MDAgbXNlYwotCQkJ ICogKHNob3VsZCB0aGF0IGJlIGNvbmZpZ3VyYWJsZT8pCi0JCQkgKi8KLQkJCWlmICh1cGRh dGVfcHJvY2Vzc190aXRsZSAmJiBuZXdfc3RhdHVzID09IE5VTEwgJiYgcmVwb3J0X3dhaXRp bmcgJiYKLQkJCQlUaW1lc3RhbXBEaWZmZXJlbmNlRXhjZWVkcyh3YWl0U3RhcnQsIEdldEN1 cnJlbnRUaW1lc3RhbXAoKSwKLQkJCQkJCQkJCQkgICA1MDApKQotCQkJewotCQkJCWNvbnN0 IGNoYXIgKm9sZF9zdGF0dXM7Ci0JCQkJaW50CQkJbGVuOwotCi0JCQkJb2xkX3N0YXR1cyA9 IGdldF9wc19kaXNwbGF5KCZsZW4pOwotCQkJCW5ld19zdGF0dXMgPSAoY2hhciAqKSBwYWxs b2MobGVuICsgOCArIDEpOwotCQkJCW1lbWNweShuZXdfc3RhdHVzLCBvbGRfc3RhdHVzLCBs ZW4pOwotCQkJCXN0cmNweShuZXdfc3RhdHVzICsgbGVuLCAiIHdhaXRpbmciKTsKLQkJCQlz ZXRfcHNfZGlzcGxheShuZXdfc3RhdHVzKTsKLQkJCQluZXdfc3RhdHVzW2xlbl0gPSAnXDAn OyAvKiB0cnVuY2F0ZSBvZmYgIiB3YWl0aW5nIiAqLwotCQkJfQotCiAJCQkvKiBJcyBpdCB0 aW1lIHRvIGtpbGwgaXQ/ICovCiAJCQlpZiAoV2FpdEV4Y2VlZHNNYXhTdGFuZGJ5RGVsYXko d2FpdF9ldmVudF9pbmZvKSkKIAkJCXsKQEAgLTI4Niw2ICszMzgsNTAgQEAgUmVzb2x2ZVJl 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 d2FpdCBmb3IgdGhlIG5leHQgb25lICovCkBAIC0zOTgsOSArNDk0LDEzIEBAIFJlc29sdmVS ZWNvdmVyeUNvbmZsaWN0V2l0aERhdGFiYXNlKE9pZCBkYmlkKQogICoKICAqIERlYWRsb2Nr cyBpbnZvbHZpbmcgdGhlIFN0YXJ0dXAgcHJvY2VzcyBhbmQgYW4gb3JkaW5hcnkgYmFja2Vu ZCBwcm9jZXNzCiAgKiB3aWxsIGJlIGRldGVjdGVkIGJ5IHRoZSBkZWFkbG9jayBkZXRlY3Rv ciB3aXRoaW4gdGhlIG9yZGluYXJ5IGJhY2tlbmQuCisgKgorICogRW5hYmxlIHRoZSB0aW1l ciBzbyB0aGF0IHdlIGNhbiB3YWtlIHVwIGFmdGVyIGRlYWRsb2NrX3RpbWVvdXQKKyAqIGlm IGxvZ2dpbmdfdGltZXIgaXMgdHJ1ZS4gVGhpcyBpcyB1c2VkIHRvIGxvZyB3aGVuIHRoZSBz dGFydHVwIHByb2Nlc3MKKyAqIGlzIHdhaXRpbmcgbG9uZ2VyIHRoYW4gZGVhZGxvY2tfdGlt ZW91dCBmb3IgcmVjb3ZlcnkgY29uZmxpY3Qgb24gbG9jay4KICAqLwogdm9pZAotUmVzb2x2 ZVJlY292ZXJ5Q29uZmxpY3RXaXRoTG9jayhMT0NLVEFHIGxvY2t0YWcpCitSZXNvbHZlUmVj b3ZlcnlDb25mbGljdFdpdGhMb2NrKExPQ0tUQUcgbG9ja3RhZywgYm9vbCBsb2dnaW5nX3Rp bWVyKQogewogCVRpbWVzdGFtcFR6IGx0aW1lOwogCkBAIC00MDgsNyArNTA4LDM1IEBAIFJl c29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aExvY2soTE9DS1RBRyBsb2NrdGFnKQogCiAJbHRp bWUgPSBHZXRTdGFuZGJ5TGltaXRUaW1lKCk7CiAKLQlpZiAoR2V0Q3VycmVudFRpbWVzdGFt cCgpID49IGx0aW1lKQorCWlmIChsdGltZSA9PSAwIHx8IEdldEN1cnJlbnRUaW1lc3RhbXAo KSA8IGx0aW1lKQorCXsKKwkJRW5hYmxlVGltZW91dFBhcmFtcyB0aW1lb3V0c1syXTsKKwkJ aW50CQkJY250ID0gMDsKKworCQkvKgorCQkgKiBXYWl0IChvciB3YWl0IGFnYWluKSB1bnRp bCBsdGltZQorCQkgKi8KKwkJaWYgKGx0aW1lICE9IDApCisJCXsKKwkJCXRpbWVvdXRzW2Nu dF0uaWQgPSBTVEFOREJZX0xPQ0tfVElNRU9VVDsKKwkJCXRpbWVvdXRzW2NudF0udHlwZSA9 IFRNUEFSQU1fQVQ7CisJCQl0aW1lb3V0c1tjbnRdLmZpbl90aW1lID0gbHRpbWU7CisJCQlj bnQrKzsKKwkJfQorCisJCS8qIEFsc28sIHNldCB0aGUgdGltZXIgaWYgbmVjZXNzYXJ5ICov CisJCWlmIChsb2dnaW5nX3RpbWVyKQorCQl7CisJCQl0aW1lb3V0c1tjbnRdLmlkID0gU1RB TkRCWV9MT0NLX1RJTUVPVVQ7CisJCQl0aW1lb3V0c1tjbnRdLnR5cGUgPSBUTVBBUkFNX0FG VEVSOworCQkJdGltZW91dHNbY250XS5kZWxheV9tcyA9IERlYWRsb2NrVGltZW91dDsKKwkJ CWNudCsrOworCQl9CisKKwkJaWYgKGNudCA+IDApCisJCQllbmFibGVfdGltZW91dHModGlt ZW91dHMsIGNudCk7CisJfQorCWVsc2UKIAl7CiAJCS8qCiAJCSAqIFdlJ3JlIGFscmVhZHkg YmVoaW5kLCBzbyBjbGVhciBhIHBhdGggYXMgcXVpY2tseSBhcyBwb3NzaWJsZS4KQEAgLTQx OSwyNiArNTQ3LDE1IEBAIFJlc29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aExvY2soTE9DS1RB RyBsb2NrdGFnKQogCiAJCS8qCiAJCSAqIFByZXZlbnQgUmVzb2x2ZVJlY292ZXJ5Q29uZmxp Y3RXaXRoVmlydHVhbFhJRHMoKSBmcm9tIHJlcG9ydGluZwotCQkgKiAid2FpdGluZyIgaW4g UFMgZGlzcGxheSBieSBkaXNhYmxpbmcgaXRzIGFyZ3VtZW50IHJlcG9ydF93YWl0aW5nCi0J CSAqIGJlY2F1c2UgdGhlIGNhbGxlciwgV2FpdE9uTG9jaygpLCBoYXMgYWxyZWFkeSByZXBv cnRlZCB0aGF0LgorCQkgKiAid2FpdGluZyIgaW4gUFMgZGlzcGxheSBhbmQgbG9nZ2luZyBy ZWNvdmVyeSBjb25mbGljdCBieSBkaXNhYmxpbmcKKwkJICogaXRzIGFyZ3VtZW50IHJlcG9y dF93YWl0aW5nIGJlY2F1c2UgdGhlIGNhbGxlcnMgbWF5IGhhdmUgYWxyZWFkeQorCQkgKiBy ZXBvcnRlZCB0aGF0LgogCQkgKi8KIAkJUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoVmly dHVhbFhJRHMoYmFja2VuZHMsCiAJCQkJCQkJCQkJCSAgIFBST0NTSUdfUkVDT1ZFUllfQ09O RkxJQ1RfTE9DSywKIAkJCQkJCQkJCQkJICAgUEdfV0FJVF9MT0NLIHwgbG9ja3RhZy5sb2Nr dGFnX3R5cGUsCiAJCQkJCQkJCQkJCSAgIGZhbHNlKTsKIAl9Ci0JZWxzZQotCXsKLQkJLyoK LQkJICogV2FpdCAob3Igd2FpdCBhZ2FpbikgdW50aWwgbHRpbWUKLQkJICovCi0JCUVuYWJs ZVRpbWVvdXRQYXJhbXMgdGltZW91dHNbMV07Ci0KLQkJdGltZW91dHNbMF0uaWQgPSBTVEFO REJZX0xPQ0tfVElNRU9VVDsKLQkJdGltZW91dHNbMF0udHlwZSA9IFRNUEFSQU1fQVQ7Ci0J CXRpbWVvdXRzWzBdLmZpbl90aW1lID0gbHRpbWU7Ci0JCWVuYWJsZV90aW1lb3V0cyh0aW1l b3V0cywgMSk7Ci0JfQogCiAJLyogV2FpdCB0byBiZSBzaWduYWxlZCBieSB0aGUgcmVsZWFz ZSBvZiB0aGUgUmVsYXRpb24gTG9jayAqLwogCVByb2NXYWl0Rm9yU2lnbmFsKFBHX1dBSVRf TE9DSyB8IGxvY2t0YWcubG9ja3RhZ190eXBlKTsKQEAgLTExMTYsMyArMTIzMywzNiBAQCBM b2dTdGFuZGJ5SW52YWxpZGF0aW9ucyhpbnQgbm1zZ3MsIFNoYXJlZEludmFsaWRhdGlvbk1l c3NhZ2UgKm1zZ3MsCiAJCQkJCSBubXNncyAqIHNpemVvZihTaGFyZWRJbnZhbGlkYXRpb25N ZXNzYWdlKSk7CiAJWExvZ0luc2VydChSTV9TVEFOREJZX0lELCBYTE9HX0lOVkFMSURBVElP TlMpOwogfQorCisvKiBSZXR1cm4gdGhlIGRlc2NyaXB0aW9uIG9mIHJlY292ZXJ5IGNvbmZs aWN0ICovCitzdGF0aWMgY29uc3QgY2hhciAqCitnZXRfcmVjb3ZlcnlfY29uZmxpY3RfZGVz YyhQcm9jU2lnbmFsUmVhc29uIHJlYXNvbikKK3sKKwljb25zdCBjaGFyICpyZWFzb25EZXNj ID0gZ2V0dGV4dF9ub29wKCJ1bmtub3duIHJlYXNvbiIpOworCisJc3dpdGNoIChyZWFzb24p CisJeworCQljYXNlIFBST0NTSUdfUkVDT1ZFUllfQ09ORkxJQ1RfQlVGRkVSUElOOgorCQkJ cmVhc29uRGVzYyA9IGdldHRleHRfbm9vcCgicmVjb3ZlcnkgY29uZmxpY3Qgb24gYnVmZmVy IHBpbiIpOworCQkJYnJlYWs7CisJCWNhc2UgUFJPQ1NJR19SRUNPVkVSWV9DT05GTElDVF9M T0NLOgorCQkJcmVhc29uRGVzYyA9IGdldHRleHRfbm9vcCgicmVjb3ZlcnkgY29uZmxpY3Qg b24gbG9jayIpOworCQkJYnJlYWs7CisJCWNhc2UgUFJPQ1NJR19SRUNPVkVSWV9DT05GTElD VF9UQUJMRVNQQUNFOgorCQkJcmVhc29uRGVzYyA9IGdldHRleHRfbm9vcCgicmVjb3Zlcnkg Y29uZmxpY3Qgb24gdGFibGVzcGFjZSIpOworCQkJYnJlYWs7CisJCWNhc2UgUFJPQ1NJR19S RUNPVkVSWV9DT05GTElDVF9TTkFQU0hPVDoKKwkJCXJlYXNvbkRlc2MgPSBnZXR0ZXh0X25v b3AoInJlY292ZXJ5IGNvbmZsaWN0IG9uIHNuYXBzaG90Iik7CisJCQlicmVhazsKKwkJY2Fz ZSBQUk9DU0lHX1JFQ09WRVJZX0NPTkZMSUNUX1NUQVJUVVBfREVBRExPQ0s6CisJCQlyZWFz b25EZXNjID0gZ2V0dGV4dF9ub29wKCJyZWNvdmVyeSBjb25mbGljdCBvbiBidWZmZXIgZGVh ZGxvY2siKTsKKwkJCWJyZWFrOworCQljYXNlIFBST0NTSUdfUkVDT1ZFUllfQ09ORkxJQ1Rf REFUQUJBU0U6CisJCQlyZWFzb25EZXNjID0gZ2V0dGV4dF9ub29wKCJyZWNvdmVyeSBjb25m bGljdCBvbiBkYXRhYmFzZSIpOworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisJCQlicmVhazsK Kwl9CisKKwlyZXR1cm4gcmVhc29uRGVzYzsKK30KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5k L3N0b3JhZ2UvbG1nci9wcm9jLmMgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2xtZ3IvcHJvYy5j CmluZGV4IDdkYzM5MTE1OTAuLjUyN2UzOGM5NzQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5k L3N0b3JhZ2UvbG1nci9wcm9jLmMKKysrIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9sbWdyL3By b2MuYwpAQCAtMTA2Myw4ICsxMDYzLDEwIEBAIFByb2NTbGVlcChMT0NBTExPQ0sgKmxvY2Fs bG9jaywgTG9ja01ldGhvZCBsb2NrTWV0aG9kVGFibGUpCiAJTFdMb2NrCSAgICpwYXJ0aXRp b25Mb2NrID0gTG9ja0hhc2hQYXJ0aXRpb25Mb2NrKGhhc2hjb2RlKTsKIAlQUk9DX1FVRVVF ICp3YWl0UXVldWUgPSAmKGxvY2stPndhaXRQcm9jcyk7CiAJTE9DS01BU0sJbXlIZWxkTG9j a3MgPSBNeVByb2MtPmhlbGRMb2NrczsKKwlUaW1lc3RhbXBUeiBzdGFuZGJ5V2FpdFN0YXJ0 ID0gMDsKIAlib29sCQllYXJseV9kZWFkbG9jayA9IGZhbHNlOwogCWJvb2wJCWFsbG93X2F1 dG92YWN1dW1fY2FuY2VsID0gdHJ1ZTsKKwlib29sCQlsb2dnZWRfcmVjb3ZlcnlfY29uZmxp Y3QgPSBmYWxzZTsKIAlQcm9jV2FpdFN0YXR1cyBteVdhaXRTdGF0dXM7CiAJUEdQUk9DCSAg ICpwcm9jOwogCVBHUFJPQwkgICAqbGVhZGVyID0gTXlQcm9jLT5sb2NrR3JvdXBMZWFkZXI7 CkBAIC0xMjYwLDYgKzEyNjIsMTQgQEAgUHJvY1NsZWVwKExPQ0FMTE9DSyAqbG9jYWxsb2Nr LCBMb2NrTWV0aG9kIGxvY2tNZXRob2RUYWJsZSkKIAkJZWxzZQogCQkJZW5hYmxlX3RpbWVv dXRfYWZ0ZXIoREVBRExPQ0tfVElNRU9VVCwgRGVhZGxvY2tUaW1lb3V0KTsKIAl9CisJZWxz ZSBpZiAobG9nX3JlY292ZXJ5X2NvbmZsaWN0X3dhaXRzKQorCXsKKwkJLyoKKwkJICogU2V0 IHRoZSB3YWl0IHN0YXJ0IHRpbWVzdGFtcCBpZiBsb2dnaW5nIGlzIGVuYWJsZWQgYW5kIGlu IGhvdAorCQkgKiBzdGFuZGJ5LgorCQkgKi8KKwkJc3RhbmRieVdhaXRTdGFydCA9IEdldEN1 cnJlbnRUaW1lc3RhbXAoKTsKKwl9CiAKIAkvKgogCSAqIElmIHNvbWVib2R5IHdha2VzIHVz IGJldHdlZW4gTFdMb2NrUmVsZWFzZSBhbmQgV2FpdExhdGNoLCB0aGUgbGF0Y2gKQEAgLTEy NzksOCArMTI4OSw0OCBAQCBQcm9jU2xlZXAoTE9DQUxMT0NLICpsb2NhbGxvY2ssIExvY2tN ZXRob2QgbG9ja01ldGhvZFRhYmxlKQogCXsKIAkJaWYgKEluSG90U3RhbmRieSkKIAkJewot CQkJLyogU2V0IGEgdGltZXIgYW5kIHdhaXQgZm9yIHRoYXQgb3IgZm9yIHRoZSBMb2NrIHRv IGJlIGdyYW50ZWQgKi8KLQkJCVJlc29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aExvY2sobG9j YWxsb2NrLT50YWcubG9jayk7CisJCQlib29sCQltYXliZV9sb2dfY29uZmxpY3QgPQorCQkJ KHN0YW5kYnlXYWl0U3RhcnQgIT0gMCAmJiAhbG9nZ2VkX3JlY292ZXJ5X2NvbmZsaWN0KTsK KworCQkJLyoKKwkJCSAqIFNldCBhIHRpbWVyIGFuZCB3YWl0IGZvciB0aGF0IG9yIGZvciB0 aGUgbG9jayB0byBiZSBncmFudGVkLgorCQkJICoKKwkJCSAqIElmIHRoZSByZWNvdmVyeSBj b25mbGljdCBoYXMgbm90IGJlZW4gbG9nZ2VkIHlldCBldmVuIHRob3VnaAorCQkJICogbG9n Z2luZyBpcyBlbmFibGVkLCBzZXQgYSB0aW1lciBzbyB0aGF0IHdlIGNhbiBsb2cgd2hlbiB3 ZSBhcmUKKwkJCSAqIHdhaXRpbmcgbG9uZ2VyIHRoYW4gZGVhZGxvY2tfdGltZW91dCBmb3Ig dGhlIGNvbmZsaWN0LgorCQkJICovCisJCQlSZXNvbHZlUmVjb3ZlcnlDb25mbGljdFdpdGhM b2NrKGxvY2FsbG9jay0+dGFnLmxvY2ssCisJCQkJCQkJCQkJCW1heWJlX2xvZ19jb25mbGlj dCk7CisKKwkJCS8qCisJCQkgKiBFbWl0IHRoZSBsb2cgbWVzc2FnZSBpZiB0aGUgc3RhcnR1 cCBwcm9jZXNzIGlzIHdhaXRpbmcgbG9uZ2VyCisJCQkgKiB0aGFuIGRlYWRsb2NrX3RpbWVv dXQgZm9yIHJlY292ZXJ5IGNvbmZsaWN0IG9uIGxvY2suCisJCQkgKi8KKwkJCWlmIChtYXli ZV9sb2dfY29uZmxpY3QpCisJCQl7CisJCQkJVGltZXN0YW1wVHogbm93ID0gR2V0Q3VycmVu dFRpbWVzdGFtcCgpOworCisJCQkJaWYgKFRpbWVzdGFtcERpZmZlcmVuY2VFeGNlZWRzKHN0 YW5kYnlXYWl0U3RhcnQsIG5vdywKKwkJCQkJCQkJCQkJICAgRGVhZGxvY2tUaW1lb3V0KSkK KwkJCQl7CisJCQkJCVZpcnR1YWxUcmFuc2FjdGlvbklkICp2eGlkczsKKwkJCQkJaW50CQkJ Y250OworCisJCQkJCXZ4aWRzID0gR2V0TG9ja0NvbmZsaWN0cygmbG9jYWxsb2NrLT50YWcu bG9jaywKKwkJCQkJCQkJCQkJIEFjY2Vzc0V4Y2x1c2l2ZUxvY2ssICZjbnQpOworCisJCQkJ CS8qCisJCQkJCSAqIExvZyB0aGUgcmVjb3ZlcnkgY29uZmxpY3QgYW5kIHRoZSBsaXN0IG9m IFBJRHMgb2YKKwkJCQkJICogYmFja2VuZHMgaG9sZGluZyB0aGUgY29uZmxpY3RpbmcgbG9j ay4gTm90ZSB0aGF0IHdlIGRvCisJCQkJCSAqIGxvZ2dpbmcgZXZlbiBpZiB0aGVyZSBhcmUg bm8gc3VjaCBiYWNrZW5kcyByaWdodCBub3cKKwkJCQkJICogYmVjYXVzZSB0aGUgc3RhcnR1 cCBwcm9jZXNzIGhlcmUgaGFzIGFscmVhZHkgd2FpdGVkCisJCQkJCSAqIGxvbmdlciB0aGFu IGRlYWRsb2NrX3RpbWVvdXQuCisJCQkJCSAqLworCQkJCQlMb2dSZWNvdmVyeUNvbmZsaWN0 KFBST0NTSUdfUkVDT1ZFUllfQ09ORkxJQ1RfTE9DSywKKwkJCQkJCQkJCQlzdGFuZGJ5V2Fp dFN0YXJ0LCBub3csIGNudCA+IDAgPyB2eGlkcyA6IE5VTEwpOworCQkJCQlsb2dnZWRfcmVj b3ZlcnlfY29uZmxpY3QgPSB0cnVlOworCQkJCX0KKwkJCX0KIAkJfQogCQllbHNlCiAJCXsK ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjLmMgYi9zcmMvYmFja2Vu ZC91dGlscy9taXNjL2d1Yy5jCmluZGV4IGRhYmNiYjA3MzYuLjIzZWJkMDNmYjQgMTAwNjQ0 Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjLmMKKysrIGIvc3JjL2JhY2tlbmQv dXRpbHMvbWlzYy9ndWMuYwpAQCAtMTU3MCw3ICsxNTcwLDE1IEBAIHN0YXRpYyBzdHJ1Y3Qg Y29uZmlnX2Jvb2wgQ29uZmlndXJlTmFtZXNCb29sW10gPQogCQlmYWxzZSwKIAkJTlVMTCwg TlVMTCwgTlVMTAogCX0sCi0KKwl7CisJCXsibG9nX3JlY292ZXJ5X2NvbmZsaWN0X3dhaXRz IiwgUEdDX1NJR0hVUCwgTE9HR0lOR19XSEFULAorCQkJZ2V0dGV4dF9ub29wKCJMb2dzIHN0 YW5kYnkgcmVjb3ZlcnkgY29uZmxpY3Qgd2FpdHMuIiksCisJCQlOVUxMCisJCX0sCisJCSZs b2dfcmVjb3ZlcnlfY29uZmxpY3Rfd2FpdHMsCisJCWZhbHNlLAorCQlOVUxMLCBOVUxMLCBO VUxMCisJfSwKIAl7CiAJCXsibG9nX2hvc3RuYW1lIiwgUEdDX1NJR0hVUCwgTE9HR0lOR19X SEFULAogCQkJZ2V0dGV4dF9ub29wKCJMb2dzIHRoZSBob3N0IG5hbWUgaW4gdGhlIGNvbm5l Y3Rpb24gbG9ncy4iKSwKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9z dGdyZXNxbC5jb25mLnNhbXBsZSBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNx bC5jb25mLnNhbXBsZQppbmRleCBiN2ZiMmVjMWZlLi5lYmYxNjcyYmFkIDEwMDY0NAotLS0g YS9zcmMvYmFja2VuZC91dGlscy9taXNjL3Bvc3RncmVzcWwuY29uZi5zYW1wbGUKKysrIGIv c3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlCkBAIC01NTIs NiArNTUyLDggQEAKIAkJCQkJIyAgICUlID0gJyUnCiAJCQkJCSMgZS5nLiAnPCV1JSUlZD4g JwogI2xvZ19sb2NrX3dhaXRzID0gb2ZmCQkJIyBsb2cgbG9jayB3YWl0cyA+PSBkZWFkbG9j a190aW1lb3V0CisjbG9nX3JlY292ZXJ5X2NvbmZsaWN0X3dhaXRzID0gb2ZmCSMgbG9nIHN0 YW5kYnkgcmVjb3ZlcnkgY29uZmxpY3Qgd2FpdHMKKwkJCQkJIyA+PSBkZWFkbG9ja190aW1l b3V0CiAjbG9nX3BhcmFtZXRlcl9tYXhfbGVuZ3RoID0gLTEJCSMgd2hlbiBsb2dnaW5nIHN0 YXRlbWVudHMsIGxpbWl0IGxvZ2dlZAogCQkJCQkjIGJpbmQtcGFyYW1ldGVyIHZhbHVlcyB0 byBOIGJ5dGVzOwogCQkJCQkjIC0xIG1lYW5zIHByaW50IGluIGZ1bGwsIDAgZGlzYWJsZXMK ZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL3N0b3JhZ2Uvc3RhbmRieS5oIGIvc3JjL2luY2x1 ZGUvc3RvcmFnZS9zdGFuZGJ5LmgKaW5kZXggZmFhZjFkMzgxNy4uNzZjY2Q4Y2RlNCAxMDA2 NDQKLS0tIGEvc3JjL2luY2x1ZGUvc3RvcmFnZS9zdGFuZGJ5LmgKKysrIGIvc3JjL2luY2x1 ZGUvc3RvcmFnZS9zdGFuZGJ5LmgKQEAgLTIzLDYgKzIzLDcgQEAKIGV4dGVybiBpbnQJdmFj dXVtX2RlZmVyX2NsZWFudXBfYWdlOwogZXh0ZXJuIGludAltYXhfc3RhbmRieV9hcmNoaXZl X2RlbGF5OwogZXh0ZXJuIGludAltYXhfc3RhbmRieV9zdHJlYW1pbmdfZGVsYXk7CitleHRl cm4gYm9vbCBsb2dfcmVjb3ZlcnlfY29uZmxpY3Rfd2FpdHM7CiAKIGV4dGVybiB2b2lkIElu aXRSZWNvdmVyeVRyYW5zYWN0aW9uRW52aXJvbm1lbnQodm9pZCk7CiBleHRlcm4gdm9pZCBT aHV0ZG93blJlY292ZXJ5VHJhbnNhY3Rpb25FbnZpcm9ubWVudCh2b2lkKTsKQEAgLTMyLDEy ICszMywxNCBAQCBleHRlcm4gdm9pZCBSZXNvbHZlUmVjb3ZlcnlDb25mbGljdFdpdGhTbmFw c2hvdChUcmFuc2FjdGlvbklkIGxhdGVzdFJlbW92ZWRYaWQsCiBleHRlcm4gdm9pZCBSZXNv bHZlUmVjb3ZlcnlDb25mbGljdFdpdGhUYWJsZXNwYWNlKE9pZCB0c2lkKTsKIGV4dGVybiB2 b2lkIFJlc29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aERhdGFiYXNlKE9pZCBkYmlkKTsKIAot ZXh0ZXJuIHZvaWQgUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoTG9jayhMT0NLVEFHIGxv Y2t0YWcpOworZXh0ZXJuIHZvaWQgUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoTG9jayhM T0NLVEFHIGxvY2t0YWcsIGJvb2wgbG9nZ2luZ190aW1lcik7CiBleHRlcm4gdm9pZCBSZXNv bHZlUmVjb3ZlcnlDb25mbGljdFdpdGhCdWZmZXJQaW4odm9pZCk7CiBleHRlcm4gdm9pZCBD aGVja1JlY292ZXJ5Q29uZmxpY3REZWFkbG9jayh2b2lkKTsKIGV4dGVybiB2b2lkIFN0YW5k YnlEZWFkTG9ja0hhbmRsZXIodm9pZCk7CiBleHRlcm4gdm9pZCBTdGFuZGJ5VGltZW91dEhh bmRsZXIodm9pZCk7CiBleHRlcm4gdm9pZCBTdGFuZGJ5TG9ja1RpbWVvdXRIYW5kbGVyKHZv aWQpOworZXh0ZXJuIHZvaWQgTG9nUmVjb3ZlcnlDb25mbGljdChQcm9jU2lnbmFsUmVhc29u IHJlYXNvbiwgVGltZXN0YW1wVHogd2FpdF9zdGFydCwKKwkJCQkJCQkJVGltZXN0YW1wVHog Y3VyX3RzLCBWaXJ0dWFsVHJhbnNhY3Rpb25JZCAqd2FpdF9saXN0KTsKIAogLyoKICAqIFN0 YW5kYnkgUm1nciAoUk1fU1RBTkRCWV9JRCkK --------------3A2BF430AA503888EFBDB858--