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 1kl8Ed-0006lC-F1 for pgsql-hackers@arkaria.postgresql.org; Fri, 04 Dec 2020 10:22:43 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1kl8Ec-0006Kj-Cl for pgsql-hackers@arkaria.postgresql.org; Fri, 04 Dec 2020 10:22:42 +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 1kl8Ec-0006Kb-1T for pgsql-hackers@lists.postgresql.org; Fri, 04 Dec 2020 10:22:42 +0000 Received: from smtp-fw-4101.amazon.com ([72.21.198.25]) by magus.postgresql.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1kl8EY-0000Fi-P8 for pgsql-hackers@postgresql.org; Fri, 04 Dec 2020 10:22:41 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amazon.com; i=@amazon.com; q=dns/txt; s=amazon201209; t=1607077359; x=1638613359; h=to:cc:references:from:message-id:date:mime-version: in-reply-to:subject; bh=z+deFOgn+IbBvns1DfmYkaqCBRij8AGXrJQt9TO8Nhg=; b=LTVN9TJC6iOUu33WuRej7gEFFCBnZ9CAfkqAFwX+EPdPIT7TTO9BO99T HE7NSSx2Y1xvWu+fNcHqBAY0/o69VoBl5vjADV2HqwhSasGOyNu531g9T C3cqF5yO06jqW+/9GmD3xm9lGJ+Vm+ZwQu4kMrhR/EtZNzRbSMbZS1tJ3 I=; X-Amazon-filename: v10-0002-Log-the-standby-recovery-conflict-waits.patch X-IronPort-AV: E=Sophos;i="5.78,392,1599523200"; d="scan'208";a="67578773" Subject: Re: Add Information during standby recovery conflicts Received: from iad12-co-svc-p1-lb1-vlan2.amazon.com (HELO email-inbound-relay-2a-f14f4a47.us-west-2.amazon.com) ([10.43.8.2]) by smtp-border-fw-out-4101.iad4.amazon.com with ESMTP; 04 Dec 2020 10:22:29 +0000 Received: from EX13D03EUC003.ant.amazon.com (pdx1-ws-svc-p6-lb9-vlan2.pdx.amazon.com [10.236.137.194]) by email-inbound-relay-2a-f14f4a47.us-west-2.amazon.com (Postfix) with ESMTPS id 00E31A06A4; Fri, 4 Dec 2020 10:22:25 +0000 (UTC) Received: from 38f9d36c4abb.ant.amazon.com (10.43.161.237) by EX13D03EUC003.ant.amazon.com (10.43.164.192) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 4 Dec 2020 10:22:21 +0000 To: Fujii Masao , Masahiko Sawada 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> From: "Drouvot, Bertrand" Message-ID: <73037867-b688-c5cc-5f6d-ad73db6ab94d@amazon.com> Date: Fri, 4 Dec 2020 11:22:17 +0100 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:78.0) Gecko/20100101 Thunderbird/78.5.1 MIME-Version: 1.0 In-Reply-To: <627f702d-a04c-b72b-b94f-214f448e2935@oss.nttdata.com> Content-Type: multipart/mixed; boundary="------------293EC7674B35D395833E9894" Content-Language: en-US X-Originating-IP: [10.43.161.237] X-ClientProxiedBy: EX13d09UWA001.ant.amazon.com (10.43.160.247) To EX13D03EUC003.ant.amazon.com (10.43.164.192) List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Precedence: bulk --------------293EC7674B35D395833E9894 Content-Type: text/plain; charset="utf-8"; format=flowed Content-Transfer-Encoding: 8bit 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? 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?) I've attached a new version that makes use of it (that's the only change compare to Masao's updates). Thanks Bertrand --------------293EC7674B35D395833E9894 Content-Type: text/plain; charset="UTF-8"; x-mac-type=0; x-mac-creator=0; name="v10-0002-Log-the-standby-recovery-conflict-waits.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="v10-0002-Log-the-standby-recovery-conflict-waits.patch" IGRvYy9zcmMvc2dtbC9jb25maWcuc2dtbCAgICAgICAgICAgICAgICAgICAgICB8ICAyMiAr KysKIGRvYy9zcmMvc2dtbC9oaWdoLWF2YWlsYWJpbGl0eS5zZ21sICAgICAgICAgICB8ICAg NiArCiBzcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYyAgICAgICAgICAgfCAg MzAgKysrKwogc3JjL2JhY2tlbmQvc3RvcmFnZS9pcGMvc3RhbmRieS5jICAgICAgICAgICAg IHwgMjMyICsrKysrKysrKysrKysrKysrKysrKy0tLS0tCiBzcmMvYmFja2VuZC9zdG9yYWdl L2xtZ3IvcHJvYy5jICAgICAgICAgICAgICAgfCAgNTUgKysrKystCiBzcmMvYmFja2VuZC91 dGlscy9taXNjL2d1Yy5jICAgICAgICAgICAgICAgICAgfCAgMTAgKy0KIHNyYy9iYWNrZW5k L3V0aWxzL21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZSB8ICAgMiArCiBzcmMvaW5jbHVk ZS9zdG9yYWdlL3N0YW5kYnkuaCAgICAgICAgICAgICAgICAgfCAgIDUgKy0KIDggZmlsZXMg Y2hhbmdlZCwgMzE3IGluc2VydGlvbnMoKyksIDQ1IGRlbGV0aW9ucygtKQpkaWZmIC0tZ2l0 IGEvZG9jL3NyYy9zZ21sL2NvbmZpZy5zZ21sIGIvZG9jL3NyYy9zZ21sL2NvbmZpZy5zZ21s CmluZGV4IGVlOTE0NzQwY2MuLjNhYTg5MmMwZjMgMTAwNjQ0Ci0tLSBhL2RvYy9zcmMvc2dt bC9jb25maWcuc2dtbAorKysgYi9kb2Mvc3JjL3NnbWwvY29uZmlnLnNnbWwKQEAgLTY4Mzks NiArNjgzOSwyOCBAQCBsb2dfbGluZV9wcmVmaXggPSAnJW0gWyVwXSAlcSV1QCVkLyVhICcK ICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgIDwvdmFybGlzdGVudHJ5PgogCisgICAgIDx2YXJs aXN0ZW50cnkgaWQ9Imd1Yy1sb2ctcmVjb3ZlcnktY29uZmxpY3Qtd2FpdHMiIHhyZWZsYWJl bD0ibG9nX3JlY292ZXJ5X2NvbmZsaWN0X3dhaXRzIj4KKyAgICAgIDx0ZXJtPjx2YXJuYW1l PmxvZ19yZWNvdmVyeV9jb25mbGljdF93YWl0czwvdmFybmFtZT4gKDx0eXBlPmJvb2xlYW48 L3R5cGU+KQorICAgICAgPGluZGV4dGVybT4KKyAgICAgICA8cHJpbWFyeT48dmFybmFtZT5s b2dfcmVjb3ZlcnlfY29uZmxpY3Rfd2FpdHM8L3Zhcm5hbWU+IGNvbmZpZ3VyYXRpb24gcGFy YW1ldGVyPC9wcmltYXJ5PgorICAgICAgPC9pbmRleHRlcm0+CisgICAgICA8L3Rlcm0+Cisg ICAgICA8bGlzdGl0ZW0+CisgICAgICAgPHBhcmE+CisgICAgICAgIENvbnRyb2xzIHdoZXRo ZXIgYSBsb2cgbWVzc2FnZSBpcyBwcm9kdWNlZCB3aGVuIHRoZSBzdGFydHVwIHByb2Nlc3MK KyAgICAgICAgaXMgd2FpdGluZyBsb25nZXIgdGhhbiA8dmFybmFtZT5kZWFkbG9ja190aW1l b3V0PC92YXJuYW1lPgorICAgICAgICBmb3IgcmVjb3ZlcnkgY29uZmxpY3RzLiAgVGhpcyBp cyB1c2VmdWwgaW4gZGV0ZXJtaW5pbmcgaWYgcmVjb3ZlcnkKKyAgICAgICAgY29uZmxpY3Rz IHByZXZlbnQgdGhlIHJlY292ZXJ5IGZyb20gYXBwbHlpbmcgV0FMLgorICAgICAgIDwvcGFy YT4KKworICAgICAgIDxwYXJhPgorICAgICAgICBUaGUgZGVmYXVsdCBpcyA8bGl0ZXJhbD5v ZmY8L2xpdGVyYWw+LiAgVGhpcyBwYXJhbWV0ZXIgY2FuIG9ubHkgYmUgc2V0CisgICAgICAg IGluIHRoZSA8ZmlsZW5hbWU+cG9zdGdyZXNxbC5jb25mPC9maWxlbmFtZT4gZmlsZSBvciBv biB0aGUgc2VydmVyCisgICAgICAgIGNvbW1hbmQgbGluZS4KKyAgICAgICA8L3BhcmE+Cisg ICAgICA8L2xpc3RpdGVtPgorICAgICA8L3Zhcmxpc3RlbnRyeT4KKwogICAgICA8dmFybGlz dGVudHJ5IGlkPSJndWMtbG9nLXBhcmFtZXRlci1tYXgtbGVuZ3RoIiB4cmVmbGFiZWw9Imxv Z19wYXJhbWV0ZXJfbWF4X2xlbmd0aCI+CiAgICAgICA8dGVybT48dmFybmFtZT5sb2dfcGFy YW1ldGVyX21heF9sZW5ndGg8L3Zhcm5hbWU+ICg8dHlwZT5pbnRlZ2VyPC90eXBlPikKICAg ICAgIDxpbmRleHRlcm0+CmRpZmYgLS1naXQgYS9kb2Mvc3JjL3NnbWwvaGlnaC1hdmFpbGFi aWxpdHkuc2dtbCBiL2RvYy9zcmMvc2dtbC9oaWdoLWF2YWlsYWJpbGl0eS5zZ21sCmluZGV4 IDg2ZGE4NGZjZTcuLjNkY2IzNDE0M2EgMTAwNjQ0Ci0tLSBhL2RvYy9zcmMvc2dtbC9oaWdo LWF2YWlsYWJpbGl0eS5zZ21sCisrKyBiL2RvYy9zcmMvc2dtbC9oaWdoLWF2YWlsYWJpbGl0 eS5zZ21sCkBAIC0yMTA0LDYgKzIxMDQsMTIgQEAgaWYgKCF0cmlnZ2VyZWQpCiAgICAgc2Vy dmVyLiBUaGUgPHN0cnVjdG5hbWU+cGdfc3RhdF9kYXRhYmFzZTwvc3RydWN0bmFtZT4gc3lz dGVtIHZpZXcgYWxzbyBjb250YWlucwogICAgIHN1bW1hcnkgaW5mb3JtYXRpb24uCiAgICA8 L3BhcmE+CisKKyAgIDxwYXJhPgorICAgIFVzZXJzIGNhbiBjb250cm9sIHdoZXRoZXIgYSBs b2cgbWVzc2FnZSBpcyBwcm9kdWNlZCB3aGVuIFdBTCByZXBsYXkgaXMgd2FpdGluZworICAg IGxvbmdlciB0aGFuIDx2YXJuYW1lPmRlYWRsb2NrX3RpbWVvdXQ8L3Zhcm5hbWU+IGZvciBj b25mbGljdHMuIFRoaXMKKyAgICBpcyBjb250cm9sbGVkIGJ5IHRoZSA8eHJlZiBsaW5rZW5k PSJndWMtbG9nLXJlY292ZXJ5LWNvbmZsaWN0LXdhaXRzIi8+IHBhcmFtZXRlci4KKyAgIDwv cGFyYT4KICAgPC9zZWN0Mj4KIAogICA8c2VjdDIgaWQ9ImhvdC1zdGFuZGJ5LWFkbWluIj4K ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jIGIvc3Jj L2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMKaW5kZXggZTU0OWZhMWQzMC4uYmVl NjFlY2JlMiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdy LmMKKysrIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMKQEAgLTM4MDgs NiArMzgwOCw4IEBAIExvY2tCdWZmZXJGb3JDbGVhbnVwKEJ1ZmZlciBidWZmZXIpCiB7CiAJ QnVmZmVyRGVzYyAqYnVmSGRyOwogCWNoYXIJICAgKm5ld19zdGF0dXMgPSBOVUxMOworCVRp bWVzdGFtcFR6IHdhaXRTdGFydCA9IDA7CisJYm9vbAkJbG9nZ2VkX3JlY292ZXJ5X2NvbmZs aWN0ID0gZmFsc2U7CiAKIAlBc3NlcnQoQnVmZmVySXNQaW5uZWQoYnVmZmVyKSk7CiAJQXNz ZXJ0KFBpbkNvdW50V2FpdEJ1ZiA9PSBOVUxMKTsKQEAgLTM4ODEsNiArMzg4MywzNCBAQCBM b2NrQnVmZmVyRm9yQ2xlYW51cChCdWZmZXIgYnVmZmVyKQogCQkJCW5ld19zdGF0dXNbbGVu XSA9ICdcMCc7IC8qIHRydW5jYXRlIG9mZiAiIHdhaXRpbmciICovCiAJCQl9CiAKKwkJCS8q CisJCQkgKiBFbWl0IHRoZSBsb2cgbWVzc2FnZSBpZiB0aGUgc3RhcnR1cCBwcm9jZXNzIGlz IHdhaXRpbmcgbG9uZ2VyCisJCQkgKiB0aGFuIGRlYWRsb2NrX3RpbWVvdXQgZm9yIHJlY292 ZXJ5IGNvbmZsaWN0IG9uIGJ1ZmZlciBwaW4uCisJCQkgKgorCQkJICogU2tpcCB0aGlzIGlm IGZpcnN0IHRpbWUgdGhyb3VnaCBiZWNhdXNlIHRoZSBzdGFydHVwIHByb2Nlc3MgaGFzCisJ CQkgKiBub3Qgc3RhcnRlZCB3YWl0aW5nIHlldCBpbiB0aGlzIGNhc2UuIFNvLCB0aGUgd2Fp dCBzdGFydAorCQkJICogdGltZXN0YW1wIGlzIHNldCBhZnRlciB0aGlzIGxvZ2ljLgorCQkJ ICovCisJCQlpZiAod2FpdFN0YXJ0ICE9IDAgJiYgIWxvZ2dlZF9yZWNvdmVyeV9jb25mbGlj dCkKKwkJCXsKKwkJCQlUaW1lc3RhbXBUeiBub3cgPSBHZXRDdXJyZW50VGltZXN0YW1wKCk7 CisKKwkJCQlpZiAoVGltZXN0YW1wRGlmZmVyZW5jZUV4Y2VlZHMod2FpdFN0YXJ0LCBub3cs CisJCQkJCQkJCQkJCSAgIERlYWRsb2NrVGltZW91dCkpCisJCQkJeworCQkJCQlMb2dSZWNv dmVyeUNvbmZsaWN0KFBST0NTSUdfUkVDT1ZFUllfQ09ORkxJQ1RfQlVGRkVSUElOLAorCQkJ CQkJCQkJCXdhaXRTdGFydCwgbm93LCBOVUxMKTsKKwkJCQkJbG9nZ2VkX3JlY292ZXJ5X2Nv bmZsaWN0ID0gdHJ1ZTsKKwkJCQl9CisJCQl9CisKKwkJCS8qCisJCQkgKiBTZXQgdGhlIHdh aXQgc3RhcnQgdGltZXN0YW1wIGlmIGxvZ2dpbmcgaXMgZW5hYmxlZCBhbmQgZmlyc3QKKwkJ CSAqIHRpbWUgdGhyb3VnaC4KKwkJCSAqLworCQkJaWYgKGxvZ19yZWNvdmVyeV9jb25mbGlj dF93YWl0cyAmJiB3YWl0U3RhcnQgPT0gMCkKKwkJCQl3YWl0U3RhcnQgPSBHZXRDdXJyZW50 VGltZXN0YW1wKCk7CisKIAkJCS8qIFB1Ymxpc2ggdGhlIGJ1ZmlkIHRoYXQgU3RhcnR1cCBw cm9jZXNzIHdhaXRzIG9uICovCiAJCQlTZXRTdGFydHVwQnVmZmVyUGluV2FpdEJ1ZklkKGJ1 ZmZlciAtIDEpOwogCQkJLyogU2V0IGFsYXJtIGFuZCB0aGVuIHdhaXQgdG8gYmUgc2lnbmFs ZWQgYnkgVW5waW5CdWZmZXIoKSAqLwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvc3RvcmFn ZS9pcGMvc3RhbmRieS5jIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9pcGMvc3RhbmRieS5jCmlu ZGV4IDUyYjI4MDlkYWMuLmRhYjZjYTRiZDcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3N0 b3JhZ2UvaXBjL3N0YW5kYnkuYworKysgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2lwYy9zdGFu ZGJ5LmMKQEAgLTM5LDYgKzM5LDcgQEAKIGludAkJCXZhY3V1bV9kZWZlcl9jbGVhbnVwX2Fn ZTsKIGludAkJCW1heF9zdGFuZGJ5X2FyY2hpdmVfZGVsYXkgPSAzMCAqIDEwMDA7CiBpbnQJ CQltYXhfc3RhbmRieV9zdHJlYW1pbmdfZGVsYXkgPSAzMCAqIDEwMDA7Citib29sCQlsb2df cmVjb3ZlcnlfY29uZmxpY3Rfd2FpdHMgPSBmYWxzZTsKIAogc3RhdGljIEhUQUIgKlJlY292 ZXJ5TG9ja0xpc3RzOwogCkBAIC00OSw2ICs1MCw3IEBAIHN0YXRpYyB2b2lkIFJlc29sdmVS ZWNvdmVyeUNvbmZsaWN0V2l0aFZpcnR1YWxYSURzKFZpcnR1YWxUcmFuc2FjdGlvbklkICp3 YWl0bGlzCiBzdGF0aWMgdm9pZCBTZW5kUmVjb3ZlcnlDb25mbGljdFdpdGhCdWZmZXJQaW4o UHJvY1NpZ25hbFJlYXNvbiByZWFzb24pOwogc3RhdGljIFhMb2dSZWNQdHIgTG9nQ3VycmVu dFJ1bm5pbmdYYWN0cyhSdW5uaW5nVHJhbnNhY3Rpb25zIEN1cnJSdW5uaW5nWGFjdHMpOwog c3RhdGljIHZvaWQgTG9nQWNjZXNzRXhjbHVzaXZlTG9ja3MoaW50IG5sb2NrcywgeGxfc3Rh bmRieV9sb2NrICpsb2Nrcyk7CitzdGF0aWMgY29uc3QgY2hhciAqZ2V0X3JlY292ZXJ5X2Nv bmZsaWN0X2Rlc2MoUHJvY1NpZ25hbFJlYXNvbiByZWFzb24pOwogCiAvKgogICogS2VlcCB0 cmFjayBvZiBhbGwgdGhlIGxvY2tzIG93bmVkIGJ5IGEgZ2l2ZW4gdHJhbnNhY3Rpb24uCkBA IC0yMTUsMTUgKzIxNyw4MyBAQCBXYWl0RXhjZWVkc01heFN0YW5kYnlEZWxheSh1aW50MzIg d2FpdF9ldmVudF9pbmZvKQogCXJldHVybiBmYWxzZTsKIH0KIAorLyoKKyAqIExvZyB0aGUg cmVjb3ZlcnkgY29uZmxpY3QuCisgKgorICogd2FpdF9zdGFydCBpcyB0aGUgdGltZXN0YW1w IHdoZW4gdGhlIGNhbGxlciBzdGFydGVkIHRvIHdhaXQuCisgKiBub3cgaXMgdGhlIHRpbWVz dGFtcCB3aGVuIHRoaXMgZnVuY3Rpb24gaGFzIGJlZW4gY2FsbGVkLgorICogd2FpdF9saXN0 IGlzIHRoZSBsaXN0IG9mIHZpcnR1YWwgdHJhbnNhY3Rpb24gaWRzIGFzc2lnbmVkIHRvCisg KiBjb25mbGljdGluZyBwcm9jZXNzZXMuCisgKi8KK3ZvaWQKK0xvZ1JlY292ZXJ5Q29uZmxp Y3QoUHJvY1NpZ25hbFJlYXNvbiByZWFzb24sIFRpbWVzdGFtcFR6IHdhaXRfc3RhcnQsCisJ CQkJCVRpbWVzdGFtcFR6IG5vdywgVmlydHVhbFRyYW5zYWN0aW9uSWQgKndhaXRfbGlzdCkK K3sKKwlsb25nCQlzZWNzOworCWludAkJCXVzZWNzOworCWxvbmcJCW1zZWNzOworCVN0cmlu Z0luZm9EYXRhIGJ1ZjsKKwlpbnQJCQlucHJvY3MgPSAwOworCisJVGltZXN0YW1wRGlmZmVy ZW5jZSh3YWl0X3N0YXJ0LCBub3csICZzZWNzLCAmdXNlY3MpOworCW1zZWNzID0gc2VjcyAq IDEwMDAgKyB1c2VjcyAvIDEwMDA7CisJdXNlY3MgPSB1c2VjcyAlIDEwMDA7CisKKwlpZiAo d2FpdF9saXN0KQorCXsKKwkJVmlydHVhbFRyYW5zYWN0aW9uSWQgKnZ4aWRzOworCisJCS8q IENvbnN0cnVjdCBhIHN0cmluZyBvZiBsaXN0IG9mIHRoZSBjb25mbGljdGluZyBwcm9jZXNz ZXMgKi8KKwkJdnhpZHMgPSB3YWl0X2xpc3Q7CisJCXdoaWxlIChWaXJ0dWFsVHJhbnNhY3Rp b25JZElzVmFsaWQoKnZ4aWRzKSkKKwkJeworCQkJUEdQUk9DCSAgICpwcm9jID0gQmFja2Vu ZElkR2V0UHJvYyh2eGlkcy0+YmFja2VuZElkKTsKKworCQkJLyogcHJvYyBjYW4gYmUgTlVM TCBpZiB0aGUgdGFyZ2V0IGJhY2tlbmQgaXMgbm90IGFjdGl2ZSAqLworCQkJaWYgKHByb2Mp CisJCQl7CisJCQkJaWYgKG5wcm9jcyA9PSAwKQorCQkJCXsKKwkJCQkJaW5pdFN0cmluZ0lu Zm8oJmJ1Zik7CisJCQkJCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwgIiVkIiwgcHJvYy0+cGlk KTsKKwkJCQl9CisJCQkJZWxzZQorCQkJCQlhcHBlbmRTdHJpbmdJbmZvKCZidWYsICIsICVk IiwgcHJvYy0+cGlkKTsKKworCQkJCW5wcm9jcysrOworCQkJfQorCisJCQl2eGlkcysrOwor CQl9CisJfQorCisJLyoKKwkgKiBJZiB3YWl0X2xpc3QgaXMgc3BlY2lmaWVkLCByZXBvcnQg dGhlIGxpc3Qgb2YgUElEcyBvZiBhY3RpdmUKKwkgKiBjb25mbGljdGluZyBiYWNrZW5kcyBp biBhIGRldGFpbCBtZXNzYWdlLiBOb3RlIHRoYXQgaWYgYWxsIHRoZSBiYWNrZW5kcworCSAq IGluIHRoZSBsaXN0IGFyZSBub3QgYWN0aXZlLCBubyBkZXRhaWwgbWVzc2FnZSBpcyBsb2dn ZWQuCisJICovCisJZXJlcG9ydChMT0csCisJCQllcnJtc2coInJlY292ZXJ5IHN0aWxsIHdh aXRpbmcgYWZ0ZXIgJWxkLiUwM2QgbXM6ICVzIiwKKwkJCQkgICBtc2VjcywgdXNlY3MsIF8o Z2V0X3JlY292ZXJ5X2NvbmZsaWN0X2Rlc2MocmVhc29uKSkpLAorCQkJbnByb2NzID4gMCA/ IGVycmRldGFpbF9sb2dfcGx1cmFsKCJDb25mbGljdGluZyBwcm9jZXNzOiAlcy4iLAorCQkJ CQkJCQkJCQkgICJDb25mbGljdGluZyBwcm9jZXNzZXM6ICVzLiIsCisJCQkJCQkJCQkJCSAg bnByb2NzLCBidWYuZGF0YSkgOiAwKTsKKworCWlmIChucHJvY3MgPiAwKQorCQlwZnJlZShi dWYuZGF0YSk7Cit9CisKIC8qCiAgKiBUaGlzIGlzIHRoZSBtYWluIGV4ZWN1dGlvbmVyIGZv ciBhbnkgcXVlcnkgYmFja2VuZCB0aGF0IGNvbmZsaWN0cyB3aXRoCiAgKiByZWNvdmVyeSBw cm9jZXNzaW5nLiBKdWRnZW1lbnQgaGFzIGFscmVhZHkgYmVlbiBwYXNzZWQgb24gaXQgd2l0 aGluCiAgKiBhIHNwZWNpZmljIHJtZ3IuIEhlcmUgd2UganVzdCBpc3N1ZSB0aGUgb3JkZXJz IHRvIHRoZSBwcm9jcy4gVGhlIHByb2NzCiAgKiB0aGVuIHRocm93IHRoZSByZXF1aXJlZCBl cnJvciBhcyBpbnN0cnVjdGVkLgogICoKLSAqIElmIHJlcG9ydF93YWl0aW5nIGlzIHRydWUs ICJ3YWl0aW5nIiBpcyByZXBvcnRlZCBpbiBQUyBkaXNwbGF5IGlmIG5lY2Vzc2FyeS4KLSAq IElmIHRoZSBjYWxsZXIgaGFzIGFscmVhZHkgcmVwb3J0ZWQgdGhhdCwgcmVwb3J0X3dhaXRp bmcgc2hvdWxkIGJlIGZhbHNlLgotICogT3RoZXJ3aXNlLCAid2FpdGluZyIgaXMgcmVwb3J0 ZWQgdHdpY2UgdW5leHBlY3RlZGx5LgorICogSWYgcmVwb3J0X3dhaXRpbmcgaXMgdHJ1ZSwg IndhaXRpbmciIGlzIHJlcG9ydGVkIGluIFBTIGRpc3BsYXkgYW5kIHRoZQorICogd2FpdCBm b3IgcmVjb3ZlcnkgY29uZmxpY3QgaXMgcmVwb3J0ZWQgaW4gdGhlIGxvZywgaWYgbmVjZXNz YXJ5LiBJZgorICogdGhlIGNhbGxlciBpcyByZXNwb25zaWJsZSBmb3IgcmVwb3J0aW5nIHRo ZW0sIHJlcG9ydF93YWl0aW5nIHNob3VsZCBiZQorICogZmFsc2UuIE90aGVyd2lzZSwgYm90 aCB0aGUgY2FsbGVyIGFuZCB0aGlzIGZ1bmN0aW9uIHJlcG9ydCB0aGUgc2FtZQorICogdGhp bmcgdW5leHBlY3RlZGx5LgogICovCiBzdGF0aWMgdm9pZAogUmVzb2x2ZVJlY292ZXJ5Q29u ZmxpY3RXaXRoVmlydHVhbFhJRHMoVmlydHVhbFRyYW5zYWN0aW9uSWQgKndhaXRsaXN0LApA QCAtMjMxLDE1ICszMDEsMTYgQEAgUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoVmlydHVh bFhJRHMoVmlydHVhbFRyYW5zYWN0aW9uSWQgKndhaXRsaXN0LAogCQkJCQkJCQkJICAgYm9v bCByZXBvcnRfd2FpdGluZykKIHsKIAlUaW1lc3RhbXBUeiB3YWl0U3RhcnQgPSAwOwotCWNo YXIJICAgKm5ld19zdGF0dXM7CisJY2hhcgkgICAqbmV3X3N0YXR1cyA9IE5VTEw7CisJYm9v bAkJbG9nZ2VkX3JlY292ZXJ5X2NvbmZsaWN0ID0gZmFsc2U7CiAKIAkvKiBGYXN0IGV4aXQs IHRvIGF2b2lkIGEga2VybmVsIGNhbGwgaWYgdGhlcmUncyBubyB3b3JrIHRvIGJlIGRvbmUu ICovCiAJaWYgKCFWaXJ0dWFsVHJhbnNhY3Rpb25JZElzVmFsaWQoKndhaXRsaXN0KSkKIAkJ cmV0dXJuOwogCi0JaWYgKHJlcG9ydF93YWl0aW5nKQorCS8qIFNldCB0aGUgd2FpdCBzdGFy dCB0aW1lc3RhbXAgZm9yIHJlcG9ydGluZyAqLworCWlmIChyZXBvcnRfd2FpdGluZyAmJiAo bG9nX3JlY292ZXJ5X2NvbmZsaWN0X3dhaXRzIHx8IHVwZGF0ZV9wcm9jZXNzX3RpdGxlKSkK IAkJd2FpdFN0YXJ0ID0gR2V0Q3VycmVudFRpbWVzdGFtcCgpOwotCW5ld19zdGF0dXMgPSBO VUxMOwkJCS8qIHdlIGhhdmVuJ3QgY2hhbmdlZCB0aGUgcHMgZGlzcGxheSAqLwogCiAJd2hp bGUgKFZpcnR1YWxUcmFuc2FjdGlvbklkSXNWYWxpZCgqd2FpdGxpc3QpKQogCXsKQEAgLTI0 OSwyNSArMzIwLDYgQEAgUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoVmlydHVhbFhJRHMo VmlydHVhbFRyYW5zYWN0aW9uSWQgKndhaXRsaXN0LAogCQkvKiB3YWl0IHVudGlsIHRoZSB2 aXJ0dWFsIHhpZCBpcyBnb25lICovCiAJCXdoaWxlICghVmlydHVhbFhhY3RMb2NrKCp3YWl0 bGlzdCwgZmFsc2UpKQogCQl7Ci0JCQkvKgotCQkJICogUmVwb3J0IHZpYSBwcyBpZiB3ZSBo YXZlIGJlZW4gd2FpdGluZyBmb3IgbW9yZSB0aGFuIDUwMCBtc2VjCi0JCQkgKiAoc2hvdWxk IHRoYXQgYmUgY29uZmlndXJhYmxlPykKLQkJCSAqLwotCQkJaWYgKHVwZGF0ZV9wcm9jZXNz X3RpdGxlICYmIG5ld19zdGF0dXMgPT0gTlVMTCAmJiByZXBvcnRfd2FpdGluZyAmJgotCQkJ CVRpbWVzdGFtcERpZmZlcmVuY2VFeGNlZWRzKHdhaXRTdGFydCwgR2V0Q3VycmVudFRpbWVz dGFtcCgpLAotCQkJCQkJCQkJCSAgIDUwMCkpCi0JCQl7Ci0JCQkJY29uc3QgY2hhciAqb2xk X3N0YXR1czsKLQkJCQlpbnQJCQlsZW47Ci0KLQkJCQlvbGRfc3RhdHVzID0gZ2V0X3BzX2Rp c3BsYXkoJmxlbik7Ci0JCQkJbmV3X3N0YXR1cyA9IChjaGFyICopIHBhbGxvYyhsZW4gKyA4 ICsgMSk7Ci0JCQkJbWVtY3B5KG5ld19zdGF0dXMsIG9sZF9zdGF0dXMsIGxlbik7Ci0JCQkJ c3RyY3B5KG5ld19zdGF0dXMgKyBsZW4sICIgd2FpdGluZyIpOwotCQkJCXNldF9wc19kaXNw bGF5KG5ld19zdGF0dXMpOwotCQkJCW5ld19zdGF0dXNbbGVuXSA9ICdcMCc7IC8qIHRydW5j YXRlIG9mZiAiIHdhaXRpbmciICovCi0JCQl9Ci0KIAkJCS8qIElzIGl0IHRpbWUgdG8ga2ls bCBpdD8gKi8KIAkJCWlmIChXYWl0RXhjZWVkc01heFN0YW5kYnlEZWxheSh3YWl0X2V2ZW50 X2luZm8pKQogCQkJewpAQCAtMjg2LDYgKzMzOCw1MCBAQCBSZXNvbHZlUmVjb3ZlcnlDb25m bGljdFdpdGhWaXJ0dWFsWElEcyhWaXJ0dWFsVHJhbnNhY3Rpb25JZCAqd2FpdGxpc3QsCiAJ CQkJaWYgKHBpZCAhPSAwKQogCQkJCQlwZ191c2xlZXAoNTAwMEwpOwogCQkJfQorCisJCQlp ZiAod2FpdFN0YXJ0ICE9IDAgJiYgKCFsb2dnZWRfcmVjb3ZlcnlfY29uZmxpY3QgfHwgbmV3 X3N0YXR1cyA9PSBOVUxMKSkKKwkJCXsKKwkJCQlUaW1lc3RhbXBUeiBub3cgPSAwOworCQkJ CWJvb2wJCW1heWJlX2xvZ19jb25mbGljdDsKKwkJCQlib29sCQltYXliZV91cGRhdGVfdGl0 bGU7CisKKwkJCQltYXliZV9sb2dfY29uZmxpY3QgPSAobG9nX3JlY292ZXJ5X2NvbmZsaWN0 X3dhaXRzICYmICFsb2dnZWRfcmVjb3ZlcnlfY29uZmxpY3QpOworCQkJCW1heWJlX3VwZGF0 ZV90aXRsZSA9ICh1cGRhdGVfcHJvY2Vzc190aXRsZSAmJiBuZXdfc3RhdHVzID09IE5VTEwp OworCisJCQkJLyogR2V0IHRoZSBjdXJyZW50IHRpbWVzdGFtcCBpZiBub3QgcmVwb3J0IHll dCAqLworCQkJCWlmIChtYXliZV9sb2dfY29uZmxpY3QgfHwgbWF5YmVfdXBkYXRlX3RpdGxl KQorCQkJCQlub3cgPSBHZXRDdXJyZW50VGltZXN0YW1wKCk7CisKKwkJCQkvKgorCQkJCSAq IFJlcG9ydCB2aWEgcHMgaWYgd2UgaGF2ZSBiZWVuIHdhaXRpbmcgZm9yIG1vcmUgdGhhbiA1 MDAKKwkJCQkgKiBtc2VjIChzaG91bGQgdGhhdCBiZSBjb25maWd1cmFibGU/KQorCQkJCSAq LworCQkJCWlmIChtYXliZV91cGRhdGVfdGl0bGUgJiYKKwkJCQkJVGltZXN0YW1wRGlmZmVy ZW5jZUV4Y2VlZHMod2FpdFN0YXJ0LCBub3csIDUwMCkpCisJCQkJeworCQkJCQljb25zdCBj aGFyICpvbGRfc3RhdHVzOworCQkJCQlpbnQJCQlsZW47CisKKwkJCQkJb2xkX3N0YXR1cyA9 IGdldF9wc19kaXNwbGF5KCZsZW4pOworCQkJCQluZXdfc3RhdHVzID0gKGNoYXIgKikgcGFs bG9jKGxlbiArIDggKyAxKTsKKwkJCQkJbWVtY3B5KG5ld19zdGF0dXMsIG9sZF9zdGF0dXMs IGxlbik7CisJCQkJCXN0cmNweShuZXdfc3RhdHVzICsgbGVuLCAiIHdhaXRpbmciKTsKKwkJ CQkJc2V0X3BzX2Rpc3BsYXkobmV3X3N0YXR1cyk7CisJCQkJCW5ld19zdGF0dXNbbGVuXSA9 ICdcMCc7IC8qIHRydW5jYXRlIG9mZiAiIHdhaXRpbmciICovCisJCQkJfQorCisJCQkJLyoK KwkJCQkgKiBFbWl0IHRoZSBsb2cgbWVzc2FnZSBpZiB0aGUgc3RhcnR1cCBwcm9jZXNzIGlz IHdhaXRpbmcKKwkJCQkgKiBsb25nZXIgdGhhbiBkZWFkbG9ja190aW1lb3V0IGZvciByZWNv dmVyeSBjb25mbGljdCBvbgorCQkJCSAqIGJ1ZmZlciBwaW4uCisJCQkJICovCisJCQkJaWYg KG1heWJlX2xvZ19jb25mbGljdCAmJgorCQkJCQlUaW1lc3RhbXBEaWZmZXJlbmNlRXhjZWVk cyh3YWl0U3RhcnQsIG5vdywgRGVhZGxvY2tUaW1lb3V0KSkKKwkJCQl7CisJCQkJCUxvZ1Jl Y292ZXJ5Q29uZmxpY3QocmVhc29uLCB3YWl0U3RhcnQsIG5vdywgd2FpdGxpc3QpOworCQkJ CQlsb2dnZWRfcmVjb3ZlcnlfY29uZmxpY3QgPSB0cnVlOworCQkJCX0KKwkJCX0KIAkJfQog CiAJCS8qIFRoZSB2aXJ0dWFsIHRyYW5zYWN0aW9uIGlzIGdvbmUgbm93LCB3YWl0IGZvciB0 aGUgbmV4dCBvbmUgKi8KQEAgLTM5OCw5ICs0OTQsMTMgQEAgUmVzb2x2ZVJlY292ZXJ5Q29u ZmxpY3RXaXRoRGF0YWJhc2UoT2lkIGRiaWQpCiAgKgogICogRGVhZGxvY2tzIGludm9sdmlu ZyB0aGUgU3RhcnR1cCBwcm9jZXNzIGFuZCBhbiBvcmRpbmFyeSBiYWNrZW5kIHByb2Nlc3MK ICAqIHdpbGwgYmUgZGV0ZWN0ZWQgYnkgdGhlIGRlYWRsb2NrIGRldGVjdG9yIHdpdGhpbiB0 aGUgb3JkaW5hcnkgYmFja2VuZC4KKyAqCisgKiBFbmFibGUgdGhlIGRlYWRsb2NrIHRpbWVy IGlmIGRlYWRsb2NrX3RpbWVyIGlzIHRydWUuIFRoaXMgaXMgdXNlZCB0bworICogbG9nIHdo ZW4gdGhlIHN0YXJ0dXAgcHJvY2VzcyBpcyB3YWl0aW5nIGxvbmdlciB0aGFuIGRlYWRsb2Nr X3RpbWVvdXQKKyAqIGZvciByZWNvdmVyeSBjb25mbGljdCBvbiBsb2NrLgogICovCiB2b2lk Ci1SZXNvbHZlUmVjb3ZlcnlDb25mbGljdFdpdGhMb2NrKExPQ0tUQUcgbG9ja3RhZykKK1Jl c29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aExvY2soTE9DS1RBRyBsb2NrdGFnLCBib29sIGRl YWRsb2NrX3RpbWVyKQogewogCVRpbWVzdGFtcFR6IGx0aW1lOwogCkBAIC00MDgsNyArNTA4 LDM1IEBAIFJlc29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aExvY2soTE9DS1RBRyBsb2NrdGFn KQogCiAJbHRpbWUgPSBHZXRTdGFuZGJ5TGltaXRUaW1lKCk7CiAKLQlpZiAoR2V0Q3VycmVu dFRpbWVzdGFtcCgpID49IGx0aW1lKQorCWlmIChsdGltZSA9PSAwIHx8IEdldEN1cnJlbnRU aW1lc3RhbXAoKSA8IGx0aW1lKQorCXsKKwkJRW5hYmxlVGltZW91dFBhcmFtcyB0aW1lb3V0 c1syXTsKKwkJaW50CQkJY250ID0gMDsKKworCQkvKgorCQkgKiBXYWl0IChvciB3YWl0IGFn YWluKSB1bnRpbCBsdGltZQorCQkgKi8KKwkJaWYgKGx0aW1lICE9IDApCisJCXsKKwkJCXRp bWVvdXRzW2NudF0uaWQgPSBTVEFOREJZX0xPQ0tfVElNRU9VVDsKKwkJCXRpbWVvdXRzW2Nu dF0udHlwZSA9IFRNUEFSQU1fQVQ7CisJCQl0aW1lb3V0c1tjbnRdLmZpbl90aW1lID0gbHRp bWU7CisJCQljbnQrKzsKKwkJfQorCisJCS8qIEFsc28sIHNldCB0aGUgZGVhZGxvY2sgdGlt ZXIgaWYgbmVjZXNzYXJ5ICovCisJCWlmIChkZWFkbG9ja190aW1lcikKKwkJeworCQkJdGlt ZW91dHNbY250XS5pZCA9IFNUQU5EQllfTE9DS19USU1FT1VUOworCQkJdGltZW91dHNbY250 XS50eXBlID0gVE1QQVJBTV9BRlRFUjsKKwkJCXRpbWVvdXRzW2NudF0uZGVsYXlfbXMgPSBE ZWFkbG9ja1RpbWVvdXQ7CisJCQljbnQrKzsKKwkJfQorCisJCWlmIChjbnQgPiAwKQorCQkJ ZW5hYmxlX3RpbWVvdXRzKHRpbWVvdXRzLCBjbnQpOworCX0KKwllbHNlCiAJewogCQkvKgog CQkgKiBXZSdyZSBhbHJlYWR5IGJlaGluZCwgc28gY2xlYXIgYSBwYXRoIGFzIHF1aWNrbHkg YXMgcG9zc2libGUuCkBAIC00MTksMjYgKzU0NywxNSBAQCBSZXNvbHZlUmVjb3ZlcnlDb25m bGljdFdpdGhMb2NrKExPQ0tUQUcgbG9ja3RhZykKIAogCQkvKgogCQkgKiBQcmV2ZW50IFJl c29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aFZpcnR1YWxYSURzKCkgZnJvbSByZXBvcnRpbmcK LQkJICogIndhaXRpbmciIGluIFBTIGRpc3BsYXkgYnkgZGlzYWJsaW5nIGl0cyBhcmd1bWVu dCByZXBvcnRfd2FpdGluZwotCQkgKiBiZWNhdXNlIHRoZSBjYWxsZXIsIFdhaXRPbkxvY2so KSwgaGFzIGFscmVhZHkgcmVwb3J0ZWQgdGhhdC4KKwkJICogIndhaXRpbmciIGluIFBTIGRp c3BsYXkgYW5kIGxvZ2dpbmcgcmVjb3ZlcnkgY29uZmxpY3QgYnkgZGlzYWJsaW5nCisJCSAq IGl0cyBhcmd1bWVudCByZXBvcnRfd2FpdGluZyBiZWNhdXNlIHRoZSBjYWxsZXJzIG1heSBo YXZlIGFscmVhZHkKKwkJICogcmVwb3J0ZWQgdGhhdC4KIAkJICovCiAJCVJlc29sdmVSZWNv dmVyeUNvbmZsaWN0V2l0aFZpcnR1YWxYSURzKGJhY2tlbmRzLAogCQkJCQkJCQkJCQkgICBQ Uk9DU0lHX1JFQ09WRVJZX0NPTkZMSUNUX0xPQ0ssCiAJCQkJCQkJCQkJCSAgIFBHX1dBSVRf TE9DSyB8IGxvY2t0YWcubG9ja3RhZ190eXBlLAogCQkJCQkJCQkJCQkgICBmYWxzZSk7CiAJ fQotCWVsc2UKLQl7Ci0JCS8qCi0JCSAqIFdhaXQgKG9yIHdhaXQgYWdhaW4pIHVudGlsIGx0 aW1lCi0JCSAqLwotCQlFbmFibGVUaW1lb3V0UGFyYW1zIHRpbWVvdXRzWzFdOwotCi0JCXRp bWVvdXRzWzBdLmlkID0gU1RBTkRCWV9MT0NLX1RJTUVPVVQ7Ci0JCXRpbWVvdXRzWzBdLnR5 cGUgPSBUTVBBUkFNX0FUOwotCQl0aW1lb3V0c1swXS5maW5fdGltZSA9IGx0aW1lOwotCQll bmFibGVfdGltZW91dHModGltZW91dHMsIDEpOwotCX0KIAogCS8qIFdhaXQgdG8gYmUgc2ln bmFsZWQgYnkgdGhlIHJlbGVhc2Ugb2YgdGhlIFJlbGF0aW9uIExvY2sgKi8KIAlQcm9jV2Fp dEZvclNpZ25hbChQR19XQUlUX0xPQ0sgfCBsb2NrdGFnLmxvY2t0YWdfdHlwZSk7CkBAIC0x MTE2LDMgKzEyMzMsMzYgQEAgTG9nU3RhbmRieUludmFsaWRhdGlvbnMoaW50IG5tc2dzLCBT aGFyZWRJbnZhbGlkYXRpb25NZXNzYWdlICptc2dzLAogCQkJCQkgbm1zZ3MgKiBzaXplb2Yo U2hhcmVkSW52YWxpZGF0aW9uTWVzc2FnZSkpOwogCVhMb2dJbnNlcnQoUk1fU1RBTkRCWV9J RCwgWExPR19JTlZBTElEQVRJT05TKTsKIH0KKworLyogUmV0dXJuIHRoZSBkZXNjcmlwdGlv biBvZiByZWNvdmVyeSBjb25mbGljdCAqLworc3RhdGljIGNvbnN0IGNoYXIgKgorZ2V0X3Jl Y292ZXJ5X2NvbmZsaWN0X2Rlc2MoUHJvY1NpZ25hbFJlYXNvbiByZWFzb24pCit7CisJY29u c3QgY2hhciAqcmVhc29uRGVzYyA9IGdldHRleHRfbm9vcCgidW5rbm93biByZWFzb24iKTsK KworCXN3aXRjaCAocmVhc29uKQorCXsKKwkJY2FzZSBQUk9DU0lHX1JFQ09WRVJZX0NPTkZM SUNUX0JVRkZFUlBJTjoKKwkJCXJlYXNvbkRlc2MgPSBnZXR0ZXh0X25vb3AoInJlY292ZXJ5 IGNvbmZsaWN0IG9uIGJ1ZmZlciBwaW4iKTsKKwkJCWJyZWFrOworCQljYXNlIFBST0NTSUdf UkVDT1ZFUllfQ09ORkxJQ1RfTE9DSzoKKwkJCXJlYXNvbkRlc2MgPSBnZXR0ZXh0X25vb3Ao InJlY292ZXJ5IGNvbmZsaWN0IG9uIGxvY2siKTsKKwkJCWJyZWFrOworCQljYXNlIFBST0NT SUdfUkVDT1ZFUllfQ09ORkxJQ1RfVEFCTEVTUEFDRToKKwkJCXJlYXNvbkRlc2MgPSBnZXR0 ZXh0X25vb3AoInJlY292ZXJ5IGNvbmZsaWN0IG9uIHRhYmxlc3BhY2UiKTsKKwkJCWJyZWFr OworCQljYXNlIFBST0NTSUdfUkVDT1ZFUllfQ09ORkxJQ1RfU05BUFNIT1Q6CisJCQlyZWFz b25EZXNjID0gZ2V0dGV4dF9ub29wKCJyZWNvdmVyeSBjb25mbGljdCBvbiBzbmFwc2hvdCIp OworCQkJYnJlYWs7CisJCWNhc2UgUFJPQ1NJR19SRUNPVkVSWV9DT05GTElDVF9TVEFSVFVQ X0RFQURMT0NLOgorCQkJcmVhc29uRGVzYyA9IGdldHRleHRfbm9vcCgicmVjb3ZlcnkgY29u ZmxpY3Qgb24gYnVmZmVyIGRlYWRsb2NrIik7CisJCQlicmVhazsKKwkJY2FzZSBQUk9DU0lH X1JFQ09WRVJZX0NPTkZMSUNUX0RBVEFCQVNFOgorCQkJcmVhc29uRGVzYyA9IGdldHRleHRf bm9vcCgicmVjb3ZlcnkgY29uZmxpY3Qgb24gZGF0YWJhc2UiKTsKKwkJCWJyZWFrOworCQlk ZWZhdWx0OgorCQkJYnJlYWs7CisJfQorCisJcmV0dXJuIHJlYXNvbkRlc2M7Cit9CmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC9zdG9yYWdlL2xtZ3IvcHJvYy5jIGIvc3JjL2JhY2tlbmQv c3RvcmFnZS9sbWdyL3Byb2MuYwppbmRleCA4ODU2NmJkOWZhLi40Yzc1ZWZiZTA0IDEwMDY0 NAotLS0gYS9zcmMvYmFja2VuZC9zdG9yYWdlL2xtZ3IvcHJvYy5jCisrKyBiL3NyYy9iYWNr ZW5kL3N0b3JhZ2UvbG1nci9wcm9jLmMKQEAgLTEwNjMsOCArMTA2MywxMCBAQCBQcm9jU2xl ZXAoTE9DQUxMT0NLICpsb2NhbGxvY2ssIExvY2tNZXRob2QgbG9ja01ldGhvZFRhYmxlKQog CUxXTG9jawkgICAqcGFydGl0aW9uTG9jayA9IExvY2tIYXNoUGFydGl0aW9uTG9jayhoYXNo Y29kZSk7CiAJUFJPQ19RVUVVRSAqd2FpdFF1ZXVlID0gJihsb2NrLT53YWl0UHJvY3MpOwog CUxPQ0tNQVNLCW15SGVsZExvY2tzID0gTXlQcm9jLT5oZWxkTG9ja3M7CisJVGltZXN0YW1w VHogc3RhbmRieVdhaXRTdGFydCA9IDA7CiAJYm9vbAkJZWFybHlfZGVhZGxvY2sgPSBmYWxz ZTsKIAlib29sCQlhbGxvd19hdXRvdmFjdXVtX2NhbmNlbCA9IHRydWU7CisJYm9vbAkJbG9n Z2VkX3JlY292ZXJ5X2NvbmZsaWN0ID0gZmFsc2U7CiAJUHJvY1dhaXRTdGF0dXMgbXlXYWl0 U3RhdHVzOwogCVBHUFJPQwkgICAqcHJvYzsKIAlQR1BST0MJICAgKmxlYWRlciA9IE15UHJv Yy0+bG9ja0dyb3VwTGVhZGVyOwpAQCAtMTI2MCw2ICsxMjYyLDE0IEBAIFByb2NTbGVlcChM T0NBTExPQ0sgKmxvY2FsbG9jaywgTG9ja01ldGhvZCBsb2NrTWV0aG9kVGFibGUpCiAJCWVs c2UKIAkJCWVuYWJsZV90aW1lb3V0X2FmdGVyKERFQURMT0NLX1RJTUVPVVQsIERlYWRsb2Nr VGltZW91dCk7CiAJfQorCWVsc2UgaWYgKGxvZ19yZWNvdmVyeV9jb25mbGljdF93YWl0cykK Kwl7CisJCS8qCisJCSAqIFNldCB0aGUgd2FpdCBzdGFydCB0aW1lc3RhbXAgaWYgbG9nZ2lu ZyBpcyBlbmFibGVkIGFuZCBpbiBob3QKKwkJICogc3RhbmRieS4KKwkJICovCisJCXN0YW5k YnlXYWl0U3RhcnQgPSBHZXRDdXJyZW50VGltZXN0YW1wKCk7CisJfQogCiAJLyoKIAkgKiBJ ZiBzb21lYm9keSB3YWtlcyB1cyBiZXR3ZWVuIExXTG9ja1JlbGVhc2UgYW5kIFdhaXRMYXRj aCwgdGhlIGxhdGNoCkBAIC0xMjc5LDggKzEyODksNDkgQEAgUHJvY1NsZWVwKExPQ0FMTE9D SyAqbG9jYWxsb2NrLCBMb2NrTWV0aG9kIGxvY2tNZXRob2RUYWJsZSkKIAl7CiAJCWlmIChJ bkhvdFN0YW5kYnkpCiAJCXsKLQkJCS8qIFNldCBhIHRpbWVyIGFuZCB3YWl0IGZvciB0aGF0 IG9yIGZvciB0aGUgTG9jayB0byBiZSBncmFudGVkICovCi0JCQlSZXNvbHZlUmVjb3ZlcnlD b25mbGljdFdpdGhMb2NrKGxvY2FsbG9jay0+dGFnLmxvY2spOworCQkJYm9vbAkJbWF5YmVf bG9nX2NvbmZsaWN0ID0KKwkJCShzdGFuZGJ5V2FpdFN0YXJ0ICE9IDAgJiYgIWxvZ2dlZF9y ZWNvdmVyeV9jb25mbGljdCk7CisKKwkJCS8qCisJCQkgKiBTZXQgYSB0aW1lciBhbmQgd2Fp dCBmb3IgdGhhdCBvciBmb3IgdGhlIGxvY2sgdG8gYmUgZ3JhbnRlZC4KKwkJCSAqCisJCQkg KiBJZiB0aGUgcmVjb3ZlcnkgY29uZmxpY3QgaGFzIG5vdCBiZWVuIGxvZ2dlZCB5ZXQgZXZl biB0aG91Z2gKKwkJCSAqIGxvZ2dpbmcgaXMgZW5hYmxlZCwgc2V0IGEgZGVhZGxvY2sgdGlt ZXIgc28gdGhhdCB3ZSBjYW4gbG9nCisJCQkgKiB3aGVuIHdlIGFyZSB3YWl0aW5nIGxvbmdl ciB0aGFuIGRlYWRsb2NrX3RpbWVvdXQgZm9yIHRoZQorCQkJICogY29uZmxpY3QuCisJCQkg Ki8KKwkJCVJlc29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aExvY2sobG9jYWxsb2NrLT50YWcu bG9jaywKKwkJCQkJCQkJCQkJbWF5YmVfbG9nX2NvbmZsaWN0KTsKKworCQkJLyoKKwkJCSAq IEVtaXQgdGhlIGxvZyBtZXNzYWdlIGlmIHRoZSBzdGFydHVwIHByb2Nlc3MgaXMgd2FpdGlu ZyBsb25nZXIKKwkJCSAqIHRoYW4gZGVhZGxvY2tfdGltZW91dCBmb3IgcmVjb3ZlcnkgY29u ZmxpY3Qgb24gbG9jay4KKwkJCSAqLworCQkJaWYgKG1heWJlX2xvZ19jb25mbGljdCkKKwkJ CXsKKwkJCQlUaW1lc3RhbXBUeiBub3cgPSBHZXRDdXJyZW50VGltZXN0YW1wKCk7CisKKwkJ CQlpZiAoVGltZXN0YW1wRGlmZmVyZW5jZUV4Y2VlZHMoc3RhbmRieVdhaXRTdGFydCwgbm93 LAorCQkJCQkJCQkJCQkgICBEZWFkbG9ja1RpbWVvdXQpKQorCQkJCXsKKwkJCQkJVmlydHVh bFRyYW5zYWN0aW9uSWQgKnZ4aWRzOworCQkJCQlpbnQJCQljbnQ7CisKKwkJCQkJdnhpZHMg PSBHZXRMb2NrQ29uZmxpY3RzKCZsb2NhbGxvY2stPnRhZy5sb2NrLAorCQkJCQkJCQkJCQkg QWNjZXNzRXhjbHVzaXZlTG9jaywgJmNudCk7CisKKwkJCQkJLyoKKwkJCQkJICogTG9nIHRo ZSByZWNvdmVyeSBjb25mbGljdCBhbmQgdGhlIGxpc3Qgb2YgUElEcyBvZgorCQkJCQkgKiBi YWNrZW5kcyBob2xkaW5nIHRoZSBjb25mbGljdGluZyBsb2NrLiBOb3RlIHRoYXQgd2UgZG8K KwkJCQkJICogbG9nZ2luZyBldmVuIGlmIHRoZXJlIGFyZSBubyBzdWNoIGJhY2tlbmRzIHJp Z2h0IG5vdworCQkJCQkgKiBiZWNhdXNlIHRoZSBzdGFydHVwIHByb2Nlc3MgaGVyZSBoYXMg YWxyZWFkeSB3YWl0ZWQKKwkJCQkJICogbG9uZ2VyIHRoYW4gZGVhZGxvY2tfdGltZW91dC4K KwkJCQkJICovCisJCQkJCUxvZ1JlY292ZXJ5Q29uZmxpY3QoUFJPQ1NJR19SRUNPVkVSWV9D T05GTElDVF9MT0NLLAorCQkJCQkJCQkJCXN0YW5kYnlXYWl0U3RhcnQsIG5vdywgY250ID4g MCA/IHZ4aWRzIDogTlVMTCk7CisJCQkJCWxvZ2dlZF9yZWNvdmVyeV9jb25mbGljdCA9IHRy dWU7CisJCQkJfQorCQkJfQogCQl9CiAJCWVsc2UKIAkJewpkaWZmIC0tZ2l0IGEvc3JjL2Jh Y2tlbmQvdXRpbHMvbWlzYy9ndWMuYyBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjLmMK aW5kZXggNTk2YmNiN2I4NC4uZTU1YTI4YjFjZCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQv dXRpbHMvbWlzYy9ndWMuYworKysgYi9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Yy5jCkBA IC0xNTcwLDcgKzE1NzAsMTUgQEAgc3RhdGljIHN0cnVjdCBjb25maWdfYm9vbCBDb25maWd1 cmVOYW1lc0Jvb2xbXSA9CiAJCWZhbHNlLAogCQlOVUxMLCBOVUxMLCBOVUxMCiAJfSwKLQor CXsKKwkJeyJsb2dfcmVjb3ZlcnlfY29uZmxpY3Rfd2FpdHMiLCBQR0NfU0lHSFVQLCBMT0dH SU5HX1dIQVQsCisJCQlnZXR0ZXh0X25vb3AoIkxvZ3Mgc3RhbmRieSByZWNvdmVyeSBjb25m bGljdCB3YWl0cy4iKSwKKwkJCU5VTEwKKwkJfSwKKwkJJmxvZ19yZWNvdmVyeV9jb25mbGlj dF93YWl0cywKKwkJZmFsc2UsCisJCU5VTEwsIE5VTEwsIE5VTEwKKwl9LAogCXsKIAkJeyJs b2dfaG9zdG5hbWUiLCBQR0NfU0lHSFVQLCBMT0dHSU5HX1dIQVQsCiAJCQlnZXR0ZXh0X25v b3AoIkxvZ3MgdGhlIGhvc3QgbmFtZSBpbiB0aGUgY29ubmVjdGlvbiBsb2dzLiIpLApkaWZm IC0tZ2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxl IGIvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlCmluZGV4 IDljYjU3MWY3Y2MuLjU2MjU2ODFlOGEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxz L21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZQorKysgYi9zcmMvYmFja2VuZC91dGlscy9t aXNjL3Bvc3RncmVzcWwuY29uZi5zYW1wbGUKQEAgLTU1Myw2ICs1NTMsOCBAQAogCQkJCQkj ICAgJSUgPSAnJScKIAkJCQkJIyBlLmcuICc8JXUlJSVkPiAnCiAjbG9nX2xvY2tfd2FpdHMg PSBvZmYJCQkjIGxvZyBsb2NrIHdhaXRzID49IGRlYWRsb2NrX3RpbWVvdXQKKyNsb2dfcmVj b3ZlcnlfY29uZmxpY3Rfd2FpdHMgPSBvZmYJIyBsb2cgc3RhbmRieSByZWNvdmVyeSBjb25m bGljdCB3YWl0cworCQkJCQkjID49IGRlYWRsb2NrX3RpbWVvdXQKICNsb2dfcGFyYW1ldGVy X21heF9sZW5ndGggPSAtMQkJIyB3aGVuIGxvZ2dpbmcgc3RhdGVtZW50cywgbGltaXQgbG9n Z2VkCiAJCQkJCSMgYmluZC1wYXJhbWV0ZXIgdmFsdWVzIHRvIE4gYnl0ZXM7CiAJCQkJCSMg LTEgbWVhbnMgcHJpbnQgaW4gZnVsbCwgMCBkaXNhYmxlcwpkaWZmIC0tZ2l0IGEvc3JjL2lu Y2x1ZGUvc3RvcmFnZS9zdGFuZGJ5LmggYi9zcmMvaW5jbHVkZS9zdG9yYWdlL3N0YW5kYnku aAppbmRleCBmYWFmMWQzODE3Li5lZTg3ZTFiZmJjIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVk ZS9zdG9yYWdlL3N0YW5kYnkuaAorKysgYi9zcmMvaW5jbHVkZS9zdG9yYWdlL3N0YW5kYnku aApAQCAtMjMsNiArMjMsNyBAQAogZXh0ZXJuIGludAl2YWN1dW1fZGVmZXJfY2xlYW51cF9h Z2U7CiBleHRlcm4gaW50CW1heF9zdGFuZGJ5X2FyY2hpdmVfZGVsYXk7CiBleHRlcm4gaW50 CW1heF9zdGFuZGJ5X3N0cmVhbWluZ19kZWxheTsKK2V4dGVybiBib29sIGxvZ19yZWNvdmVy eV9jb25mbGljdF93YWl0czsKIAogZXh0ZXJuIHZvaWQgSW5pdFJlY292ZXJ5VHJhbnNhY3Rp b25FbnZpcm9ubWVudCh2b2lkKTsKIGV4dGVybiB2b2lkIFNodXRkb3duUmVjb3ZlcnlUcmFu c2FjdGlvbkVudmlyb25tZW50KHZvaWQpOwpAQCAtMzIsMTIgKzMzLDE0IEBAIGV4dGVybiB2 b2lkIFJlc29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aFNuYXBzaG90KFRyYW5zYWN0aW9uSWQg bGF0ZXN0UmVtb3ZlZFhpZCwKIGV4dGVybiB2b2lkIFJlc29sdmVSZWNvdmVyeUNvbmZsaWN0 V2l0aFRhYmxlc3BhY2UoT2lkIHRzaWQpOwogZXh0ZXJuIHZvaWQgUmVzb2x2ZVJlY292ZXJ5 Q29uZmxpY3RXaXRoRGF0YWJhc2UoT2lkIGRiaWQpOwogCi1leHRlcm4gdm9pZCBSZXNvbHZl UmVjb3ZlcnlDb25mbGljdFdpdGhMb2NrKExPQ0tUQUcgbG9ja3RhZyk7CitleHRlcm4gdm9p ZCBSZXNvbHZlUmVjb3ZlcnlDb25mbGljdFdpdGhMb2NrKExPQ0tUQUcgbG9ja3RhZywgYm9v bCBhbHJlYWR5X2xvZ2dlZCk7CiBleHRlcm4gdm9pZCBSZXNvbHZlUmVjb3ZlcnlDb25mbGlj dFdpdGhCdWZmZXJQaW4odm9pZCk7CiBleHRlcm4gdm9pZCBDaGVja1JlY292ZXJ5Q29uZmxp Y3REZWFkbG9jayh2b2lkKTsKIGV4dGVybiB2b2lkIFN0YW5kYnlEZWFkTG9ja0hhbmRsZXIo dm9pZCk7CiBleHRlcm4gdm9pZCBTdGFuZGJ5VGltZW91dEhhbmRsZXIodm9pZCk7CiBleHRl cm4gdm9pZCBTdGFuZGJ5TG9ja1RpbWVvdXRIYW5kbGVyKHZvaWQpOworZXh0ZXJuIHZvaWQg TG9nUmVjb3ZlcnlDb25mbGljdChQcm9jU2lnbmFsUmVhc29uIHJlYXNvbiwgVGltZXN0YW1w VHogd2FpdF9zdGFydCwKKwkJCQkJCQkJVGltZXN0YW1wVHogY3VyX3RzLCBWaXJ0dWFsVHJh bnNhY3Rpb25JZCAqd2FpdF9saXN0KTsKIAogLyoKICAqIFN0YW5kYnkgUm1nciAoUk1fU1RB TkRCWV9JRCkK --------------293EC7674B35D395833E9894--