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 1khx3O-0002cU-Dj for pgsql-hackers@arkaria.postgresql.org; Wed, 25 Nov 2020 15:49:58 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1khx3M-0005Ar-4n for pgsql-hackers@arkaria.postgresql.org; Wed, 25 Nov 2020 15:49:56 +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 1khx3L-0005Ak-PU for pgsql-hackers@lists.postgresql.org; Wed, 25 Nov 2020 15:49:55 +0000 Received: from smtp-fw-2101.amazon.com ([72.21.196.25]) by magus.postgresql.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1khx3E-0007u6-Hz for pgsql-hackers@postgresql.org; Wed, 25 Nov 2020 15:49:55 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amazon.com; i=@amazon.com; q=dns/txt; s=amazon201209; t=1606319389; x=1637855389; h=to:cc:references:from:message-id:date:mime-version: in-reply-to:subject; bh=PpUz2Nittjh1YGS0YeaMN2/6KoBlAHF7eiCUKeBz4Hw=; b=bIbnv2cM0d0Zw1jJxwBxTrOSYnpoVSPA6NwGcI3U8WmM39AT2B4rfOBC 1qwGBZFR1ds4unt95NomisZ8+W4sAuXstLifP1dyywLZzOcBjuuK6/ZoL VW5UtEMwb0jrp+1Hr8N51CMZBwUHTImR0ydKlB47gYlopc48j2OpoQVBe 8=; X-Amazon-filename: v9-0003-Log-the-standby-recovery-conflict-waits.patch X-IronPort-AV: E=Sophos;i="5.78,369,1599523200"; d="scan'208";a="65775755" Subject: Re: Add Information during standby recovery conflicts Received: from iad12-co-svc-p1-lb1-vlan3.amazon.com (HELO email-inbound-relay-2a-90c42d1d.us-west-2.amazon.com) ([10.43.8.6]) by smtp-border-fw-out-2101.iad2.amazon.com with ESMTP; 25 Nov 2020 15:49:39 +0000 Received: from EX13D03EUC003.ant.amazon.com (pdx1-ws-svc-p6-lb9-vlan3.pdx.amazon.com [10.236.137.198]) by email-inbound-relay-2a-90c42d1d.us-west-2.amazon.com (Postfix) with ESMTPS id AEC7AA1878; Wed, 25 Nov 2020 15:47:52 +0000 (UTC) Received: from 38f9d36c4abb.ant.amazon.com (10.43.162.231) by EX13D03EUC003.ant.amazon.com (10.43.164.192) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 25 Nov 2020 15:47:48 +0000 To: Masahiko Sawada CC: Fujii Masao , Masahiko Sawada , Kyotaro Horiguchi , Alvaro Herrera , PostgreSQL-development References: <9493cda6-ac77-6aff-28ea-4ff7774ba78c@oss.nttdata.com> <6416172a-8c7d-84da-2600-f5f41c61db18@amazon.com> <9682a167-af46-2e58-7f77-c87edaf80fde@amazon.com> <0c8a89ae-27bf-2c31-e74a-cf04033d7daf@oss.nttdata.com> <9e66cab4-dda4-50c8-6c0a-d41468338fa5@amazon.com> From: "Drouvot, Bertrand" Message-ID: <48a1c817-cbde-33c4-2672-13ef37e1d946@amazon.com> Date: Wed, 25 Nov 2020 16:47:44 +0100 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:78.0) Gecko/20100101 Thunderbird/78.5.0 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------B3A56158E6C6B1DFB23F37AE" Content-Language: en-US X-Originating-IP: [10.43.162.231] X-ClientProxiedBy: EX13D35UWB004.ant.amazon.com (10.43.161.230) To EX13D03EUC003.ant.amazon.com (10.43.164.192) List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Precedence: bulk --------------B3A56158E6C6B1DFB23F37AE Content-Type: text/plain; charset="utf-8"; format=flowed Content-Transfer-Encoding: 7bit Hi, On 11/25/20 2:20 PM, 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 Fri, Nov 20, 2020 at 6:18 PM Drouvot, Bertrand wrote: >> Hi, >> >> On 11/17/20 4:44 PM, Fujii Masao wrote: >>> Thanks for updating the patch! Here are review comments. >>> >>> + Controls whether a log message is produced when the startup >>> process >>> + is waiting longer than deadlock_timeout >>> + for recovery conflicts. >>> >>> But a log message can be produced also when the backend is waiting >>> for recovery conflict. Right? If yes, this description needs to be >>> corrected. >> Thanks for looking at it! >> >> I don't think so, only the startup process should write those new log >> messages. >> >> What makes you think that would not be the case? >> >>> >>> + for recovery conflicts. This is useful in determining if >>> recovery >>> + conflicts prevents the recovery from applying WAL. >>> >>> "prevents" should be "prevent"? >> Indeed: fixed in the new attached patch. >> >>> >>> + TimestampDifference(waitStart, GetCurrentTimestamp(), &secs, >>> &usecs); >>> + msecs = secs * 1000 + usecs / 1000; >>> >>> GetCurrentTimestamp() is basically called before LogRecoveryConflict() >>> is called. So isn't it better to avoid calling GetCurrentTimestamp() >>> newly in >>> LogRecoveryConflict() and to reuse the timestamp that we got? >>> It's helpful to avoid the waste of cycles. >>> >> good catch! fixed in the new attached patch. >> >>> + while (VirtualTransactionIdIsValid(*vxids)) >>> + { >>> + PGPROC *proc = >>> BackendIdGetProc(vxids->backendId); >>> >>> BackendIdGetProc() can return NULL if the backend is not active >>> at that moment. This case should be handled. >>> >> handled in the new attached patch. >>> + case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN: >>> + reasonDesc = gettext_noop("recovery is still >>> waiting recovery conflict on buffer pin"); >>> >>> It's natural to use "waiting for recovery" rather than "waiting >>> recovery"? >>> >> I would be tempted to say so, the new patch makes use of "waiting for". >>> + /* Also, set deadlock timeout for logging purpose if >>> necessary */ >>> + if (log_recovery_conflict_waits) >>> + { >>> + timeouts[cnt].id = STANDBY_TIMEOUT; >>> + timeouts[cnt].type = TMPARAM_AFTER; >>> + timeouts[cnt].delay_ms = DeadlockTimeout; >>> + cnt++; >>> + } >>> >>> This needs to be executed only when the message has not been logged yet. >>> Right? >>> >> good catch: fixed in the new attached patch. >> > Thank you for updating the patch! Here are review comments on the > latest version patch. > > + while (VirtualTransactionIdIsValid(*vxids)) > + { > + PGPROC *proc = BackendIdGetProc(vxids->backendId); > + > + if (proc) > + { > + if (nprocs == 0) > + appendStringInfo(&buf, "%d", proc->pid); > + else > + appendStringInfo(&buf, ", %d", proc->pid); > + > + nprocs++; > + vxids++; > + } > + } > > We need to increment vxids even if *proc is null. Otherwise, the loop won't end. My bad, that's fixed. > > --- > + TimestampTz cur_ts = GetCurrentTimestamp();; Fixed > > There is an extra semi-colon. > > --- > int max_standby_streaming_delay = 30 * 1000; > +bool log_recovery_conflict_waits = false; > +bool logged_lock_conflict = false; > > > + if (log_recovery_conflict_waits && !logged_lock_conflict) > + { > + timeouts[cnt].id = STANDBY_TIMEOUT; > + timeouts[cnt].type = TMPARAM_AFTER; > + timeouts[cnt].delay_ms = DeadlockTimeout; > + cnt++; > + } > > Can we pass a bool indicating if a timeout may be needed for recovery > conflict logging from ProcSleep() to ResolveRecoveryConflictWithLock() > instead of using a static variable? Yeah that makes more sense, specially as we already have logged_recovery_conflict at our disposal. New patch version attached. Thanks! Bertrand --------------B3A56158E6C6B1DFB23F37AE Content-Type: text/plain; charset="UTF-8"; x-mac-type=0; x-mac-creator=0; name="v9-0003-Log-the-standby-recovery-conflict-waits.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="v9-0003-Log-the-standby-recovery-conflict-waits.patch" IGRvYy9zcmMvc2dtbC9jb25maWcuc2dtbCAgICAgICAgICAgICAgICAgICAgICB8ICAyMiAr KysKIGRvYy9zcmMvc2dtbC9oaWdoLWF2YWlsYWJpbGl0eS5zZ21sICAgICAgICAgICB8ICAg NiArCiBzcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYyAgICAgICAgICAgfCAg MTggKysrCiBzcmMvYmFja2VuZC9zdG9yYWdlL2lwYy9zdGFuZGJ5LmMgICAgICAgICAgICAg fCAyMTYgKysrKysrKysrKysrKysrKysrKysrLS0tLS0KIHNyYy9iYWNrZW5kL3N0b3JhZ2Uv bG1nci9wcm9jLmMgICAgICAgICAgICAgICB8ICAzNSArKysrLQogc3JjL2JhY2tlbmQvdXRp bHMvbWlzYy9ndWMuYyAgICAgICAgICAgICAgICAgIHwgIDEwICstCiBzcmMvYmFja2VuZC91 dGlscy9taXNjL3Bvc3RncmVzcWwuY29uZi5zYW1wbGUgfCAgIDIgKwogc3JjL2luY2x1ZGUv c3RvcmFnZS9zdGFuZGJ5LmggICAgICAgICAgICAgICAgIHwgICA2ICstCiA4IGZpbGVzIGNo YW5nZWQsIDI3NiBpbnNlcnRpb25zKCspLCAzOSBkZWxldGlvbnMoLSkKZGlmZiAtLWdpdCBh L2RvYy9zcmMvc2dtbC9jb25maWcuc2dtbCBiL2RvYy9zcmMvc2dtbC9jb25maWcuc2dtbApp bmRleCBlZTkxNDc0MGNjLi4zYWE4OTJjMGYzIDEwMDY0NAotLS0gYS9kb2Mvc3JjL3NnbWwv Y29uZmlnLnNnbWwKKysrIGIvZG9jL3NyYy9zZ21sL2NvbmZpZy5zZ21sCkBAIC02ODM5LDYg KzY4MzksMjggQEAgbG9nX2xpbmVfcHJlZml4ID0gJyVtIFslcF0gJXEldUAlZC8lYSAnCiAg ICAgICA8L2xpc3RpdGVtPgogICAgICA8L3Zhcmxpc3RlbnRyeT4KIAorICAgICA8dmFybGlz dGVudHJ5IGlkPSJndWMtbG9nLXJlY292ZXJ5LWNvbmZsaWN0LXdhaXRzIiB4cmVmbGFiZWw9 ImxvZ19yZWNvdmVyeV9jb25mbGljdF93YWl0cyI+CisgICAgICA8dGVybT48dmFybmFtZT5s b2dfcmVjb3ZlcnlfY29uZmxpY3Rfd2FpdHM8L3Zhcm5hbWU+ICg8dHlwZT5ib29sZWFuPC90 eXBlPikKKyAgICAgIDxpbmRleHRlcm0+CisgICAgICAgPHByaW1hcnk+PHZhcm5hbWU+bG9n X3JlY292ZXJ5X2NvbmZsaWN0X3dhaXRzPC92YXJuYW1lPiBjb25maWd1cmF0aW9uIHBhcmFt ZXRlcjwvcHJpbWFyeT4KKyAgICAgIDwvaW5kZXh0ZXJtPgorICAgICAgPC90ZXJtPgorICAg ICAgPGxpc3RpdGVtPgorICAgICAgIDxwYXJhPgorICAgICAgICBDb250cm9scyB3aGV0aGVy IGEgbG9nIG1lc3NhZ2UgaXMgcHJvZHVjZWQgd2hlbiB0aGUgc3RhcnR1cCBwcm9jZXNzCisg ICAgICAgIGlzIHdhaXRpbmcgbG9uZ2VyIHRoYW4gPHZhcm5hbWU+ZGVhZGxvY2tfdGltZW91 dDwvdmFybmFtZT4KKyAgICAgICAgZm9yIHJlY292ZXJ5IGNvbmZsaWN0cy4gIFRoaXMgaXMg dXNlZnVsIGluIGRldGVybWluaW5nIGlmIHJlY292ZXJ5CisgICAgICAgIGNvbmZsaWN0cyBw cmV2ZW50IHRoZSByZWNvdmVyeSBmcm9tIGFwcGx5aW5nIFdBTC4KKyAgICAgICA8L3BhcmE+ CisKKyAgICAgICA8cGFyYT4KKyAgICAgICAgVGhlIGRlZmF1bHQgaXMgPGxpdGVyYWw+b2Zm PC9saXRlcmFsPi4gIFRoaXMgcGFyYW1ldGVyIGNhbiBvbmx5IGJlIHNldAorICAgICAgICBp biB0aGUgPGZpbGVuYW1lPnBvc3RncmVzcWwuY29uZjwvZmlsZW5hbWU+IGZpbGUgb3Igb24g dGhlIHNlcnZlcgorICAgICAgICBjb21tYW5kIGxpbmUuCisgICAgICAgPC9wYXJhPgorICAg ICAgPC9saXN0aXRlbT4KKyAgICAgPC92YXJsaXN0ZW50cnk+CisKICAgICAgPHZhcmxpc3Rl bnRyeSBpZD0iZ3VjLWxvZy1wYXJhbWV0ZXItbWF4LWxlbmd0aCIgeHJlZmxhYmVsPSJsb2df cGFyYW1ldGVyX21heF9sZW5ndGgiPgogICAgICAgPHRlcm0+PHZhcm5hbWU+bG9nX3BhcmFt ZXRlcl9tYXhfbGVuZ3RoPC92YXJuYW1lPiAoPHR5cGU+aW50ZWdlcjwvdHlwZT4pCiAgICAg ICA8aW5kZXh0ZXJtPgpkaWZmIC0tZ2l0IGEvZG9jL3NyYy9zZ21sL2hpZ2gtYXZhaWxhYmls aXR5LnNnbWwgYi9kb2Mvc3JjL3NnbWwvaGlnaC1hdmFpbGFiaWxpdHkuc2dtbAppbmRleCA4 NmRhODRmY2U3Li4zZGNiMzQxNDNhIDEwMDY0NAotLS0gYS9kb2Mvc3JjL3NnbWwvaGlnaC1h dmFpbGFiaWxpdHkuc2dtbAorKysgYi9kb2Mvc3JjL3NnbWwvaGlnaC1hdmFpbGFiaWxpdHku c2dtbApAQCAtMjEwNCw2ICsyMTA0LDEyIEBAIGlmICghdHJpZ2dlcmVkKQogICAgIHNlcnZl ci4gVGhlIDxzdHJ1Y3RuYW1lPnBnX3N0YXRfZGF0YWJhc2U8L3N0cnVjdG5hbWU+IHN5c3Rl bSB2aWV3IGFsc28gY29udGFpbnMKICAgICBzdW1tYXJ5IGluZm9ybWF0aW9uLgogICAgPC9w YXJhPgorCisgICA8cGFyYT4KKyAgICBVc2VycyBjYW4gY29udHJvbCB3aGV0aGVyIGEgbG9n IG1lc3NhZ2UgaXMgcHJvZHVjZWQgd2hlbiBXQUwgcmVwbGF5IGlzIHdhaXRpbmcKKyAgICBs b25nZXIgdGhhbiA8dmFybmFtZT5kZWFkbG9ja190aW1lb3V0PC92YXJuYW1lPiBmb3IgY29u ZmxpY3RzLiBUaGlzCisgICAgaXMgY29udHJvbGxlZCBieSB0aGUgPHhyZWYgbGlua2VuZD0i Z3VjLWxvZy1yZWNvdmVyeS1jb25mbGljdC13YWl0cyIvPiBwYXJhbWV0ZXIuCisgICA8L3Bh cmE+CiAgIDwvc2VjdDI+CiAKICAgPHNlY3QyIGlkPSJob3Qtc3RhbmRieS1hZG1pbiI+CmRp ZmYgLS1naXQgYS9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYyBiL3NyYy9i YWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jCmluZGV4IGU1NDlmYTFkMzAuLjVhOTc0 MGFiNmYgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5j CisrKyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jCkBAIC0zODA4LDYg KzM4MDgsOCBAQCBMb2NrQnVmZmVyRm9yQ2xlYW51cChCdWZmZXIgYnVmZmVyKQogewogCUJ1 ZmZlckRlc2MgKmJ1ZkhkcjsKIAljaGFyCSAgICpuZXdfc3RhdHVzID0gTlVMTDsKKwlUaW1l c3RhbXBUeiB3YWl0U3RhcnQgPSAwOworCWJvb2wgICAgICAgIGxvZ2dlZF9yZWNvdmVyeV9j b25mbGljdCA9IGZhbHNlOwogCiAJQXNzZXJ0KEJ1ZmZlcklzUGlubmVkKGJ1ZmZlcikpOwog CUFzc2VydChQaW5Db3VudFdhaXRCdWYgPT0gTlVMTCk7CkBAIC0zODI5LDYgKzM4MzEsMTAg QEAgTG9ja0J1ZmZlckZvckNsZWFudXAoQnVmZmVyIGJ1ZmZlcikKIAogCWJ1ZkhkciA9IEdl dEJ1ZmZlckRlc2NyaXB0b3IoYnVmZmVyIC0gMSk7CiAKKwkvKiBTZXQgd2FpdCBzdGFydCB0 aW1lc3RhbXAgaWYgbG9nZ2luZyBpcyBlbmFibGVkICovCisJaWYgKGxvZ19yZWNvdmVyeV9j b25mbGljdF93YWl0cykKKwkJd2FpdFN0YXJ0ID0gR2V0Q3VycmVudFRpbWVzdGFtcCgpOwor CiAJZm9yICg7OykKIAl7CiAJCXVpbnQzMgkJYnVmX3N0YXRlOwpAQCAtMzg4MSw2ICszODg3 LDE4IEBAIExvY2tCdWZmZXJGb3JDbGVhbnVwKEJ1ZmZlciBidWZmZXIpCiAJCQkJbmV3X3N0 YXR1c1tsZW5dID0gJ1wwJzsgLyogdHJ1bmNhdGUgb2ZmICIgd2FpdGluZyIgKi8KIAkJCX0K IAorCQkJaWYgKHdhaXRTdGFydCA+IDAgJiYgIWxvZ2dlZF9yZWNvdmVyeV9jb25mbGljdCkK KwkJCXsKKwkJCQlUaW1lc3RhbXBUeiBjdXJfdHMgPSBHZXRDdXJyZW50VGltZXN0YW1wKCk7 CisJCQkJaWYgKFRpbWVzdGFtcERpZmZlcmVuY2VFeGNlZWRzKHdhaXRTdGFydCwgY3VyX3Rz LAorCQkJCQkJCQkJCSAgIERlYWRsb2NrVGltZW91dCkpCisJCQkJeworCQkJCQlBc3NlcnQo bG9nX3JlY292ZXJ5X2NvbmZsaWN0X3dhaXRzKTsKKwkJCQkJTG9nUmVjb3ZlcnlDb25mbGlj dChQUk9DU0lHX1JFQ09WRVJZX0NPTkZMSUNUX0JVRkZFUlBJTiwKKwkJCQkJCQkJCQl3YWl0 U3RhcnQsIGN1cl90cywgTlVMTCk7CisJCQkJCWxvZ2dlZF9yZWNvdmVyeV9jb25mbGljdCA9 IHRydWU7CisJCQkJfQorCQkJfQogCQkJLyogUHVibGlzaCB0aGUgYnVmaWQgdGhhdCBTdGFy dHVwIHByb2Nlc3Mgd2FpdHMgb24gKi8KIAkJCVNldFN0YXJ0dXBCdWZmZXJQaW5XYWl0QnVm SWQoYnVmZmVyIC0gMSk7CiAJCQkvKiBTZXQgYWxhcm0gYW5kIHRoZW4gd2FpdCB0byBiZSBz aWduYWxlZCBieSBVbnBpbkJ1ZmZlcigpICovCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9z dG9yYWdlL2lwYy9zdGFuZGJ5LmMgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2lwYy9zdGFuZGJ5 LmMKaW5kZXggNTJiMjgwOWRhYy4uMDk4ZmUzNTgwMiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tl bmQvc3RvcmFnZS9pcGMvc3RhbmRieS5jCisrKyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvaXBj L3N0YW5kYnkuYwpAQCAtMzksNiArMzksNyBAQAogaW50CQkJdmFjdXVtX2RlZmVyX2NsZWFu dXBfYWdlOwogaW50CQkJbWF4X3N0YW5kYnlfYXJjaGl2ZV9kZWxheSA9IDMwICogMTAwMDsK IGludAkJCW1heF9zdGFuZGJ5X3N0cmVhbWluZ19kZWxheSA9IDMwICogMTAwMDsKK2Jvb2wJ CWxvZ19yZWNvdmVyeV9jb25mbGljdF93YWl0cyA9IGZhbHNlOwogCiBzdGF0aWMgSFRBQiAq UmVjb3ZlcnlMb2NrTGlzdHM7CiAKQEAgLTQ5LDYgKzUwLDcgQEAgc3RhdGljIHZvaWQgUmVz b2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoVmlydHVhbFhJRHMoVmlydHVhbFRyYW5zYWN0aW9u SWQgKndhaXRsaXMKIHN0YXRpYyB2b2lkIFNlbmRSZWNvdmVyeUNvbmZsaWN0V2l0aEJ1ZmZl clBpbihQcm9jU2lnbmFsUmVhc29uIHJlYXNvbik7CiBzdGF0aWMgWExvZ1JlY1B0ciBMb2dD dXJyZW50UnVubmluZ1hhY3RzKFJ1bm5pbmdUcmFuc2FjdGlvbnMgQ3VyclJ1bm5pbmdYYWN0 cyk7CiBzdGF0aWMgdm9pZCBMb2dBY2Nlc3NFeGNsdXNpdmVMb2NrcyhpbnQgbmxvY2tzLCB4 bF9zdGFuZGJ5X2xvY2sgKmxvY2tzKTsKK3N0YXRpYyBjb25zdCBjaGFyICpnZXRfcmVjb3Zl cnlfY29uZmxpY3RfZGVzYyhQcm9jU2lnbmFsUmVhc29uIHJlYXNvbik7CiAKIC8qCiAgKiBL ZWVwIHRyYWNrIG9mIGFsbCB0aGUgbG9ja3Mgb3duZWQgYnkgYSBnaXZlbiB0cmFuc2FjdGlv bi4KQEAgLTIxNSwxNSArMjE3LDg1IEBAIFdhaXRFeGNlZWRzTWF4U3RhbmRieURlbGF5KHVp bnQzMiB3YWl0X2V2ZW50X2luZm8pCiAJcmV0dXJuIGZhbHNlOwogfQogCisvKgorICogTG9n IHRoZSByZWNvdmVyeSBjb25mbGljdC4KKyAqCisgKiB3YWl0U3RhcnQgaXMgdGhlIHRpbWVz dGFtcCB3aGVuIHRoZSBjYWxsZXIgc3RhcnRlZCB0byB3YWl0LiBUaGlzIGZ1bmN0aW9uIGFs c28KKyAqIHJlcG9ydHMgdGhlIGRldGFpbHMgYWJvdXQgdGhlIGNvbmZsaWN0aW5nIHByb2Nl c3MgaWRzIGlmICp3YWl0bGlzdCBpcyBub3QgTlVMTC4KKyAqLwordm9pZAorTG9nUmVjb3Zl cnlDb25mbGljdChQcm9jU2lnbmFsUmVhc29uIHJlYXNvbiwgVGltZXN0YW1wVHogd2FpdFN0 YXJ0LAorCQkJCQlUaW1lc3RhbXBUeiBjdXJfdHMsIFZpcnR1YWxUcmFuc2FjdGlvbklkICp3 YWl0bGlzdCkKK3sKKwlsb25nCQlzZWNzOworCWludAkJCXVzZWNzOworCWxvbmcJCW1zZWNz OworCisJVGltZXN0YW1wRGlmZmVyZW5jZSh3YWl0U3RhcnQsIGN1cl90cywgJnNlY3MsICZ1 c2Vjcyk7CisJbXNlY3MgPSBzZWNzICogMTAwMCArIHVzZWNzIC8gMTAwMDsKKwl1c2VjcyA9 IHVzZWNzICUgMTAwMDsKKworCWlmICh3YWl0bGlzdCkKKwl7CisJCVZpcnR1YWxUcmFuc2Fj dGlvbklkICp2eGlkczsKKwkJU3RyaW5nSW5mb0RhdGEgYnVmOworCQlpbnQJbnByb2NzID0g MDsKKworCQlpbml0U3RyaW5nSW5mbygmYnVmKTsKKworCQkvKiBjb25zdHJ1Y3QgYSBzdHJp bmcgb2YgbGlzdCBvZiB0aGUgY29uZmxpY3RlZCBwcm9jZXNzZXMgKi8KKwkJdnhpZHMgPSB3 YWl0bGlzdDsKKwkJd2hpbGUgKFZpcnR1YWxUcmFuc2FjdGlvbklkSXNWYWxpZCgqdnhpZHMp KQorCQl7CisJCQlQR1BST0MgKnByb2MgPSBCYWNrZW5kSWRHZXRQcm9jKHZ4aWRzLT5iYWNr ZW5kSWQpOworCisJCQlpZiAocHJvYykKKwkJCXsKKwkJCQlpZiAobnByb2NzID09IDApCisJ CQkJCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwgIiVkIiwgcHJvYy0+cGlkKTsKKwkJCQllbHNl CisJCQkJCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwgIiwgJWQiLCBwcm9jLT5waWQpOworCisJ CQkJbnByb2NzKys7CisJCQl9CisKKwkJCXZ4aWRzKys7CisJCX0KKworCQlpZiAobnByb2Nz ID4gMCkKKwkJeworCQkJZXJlcG9ydChMT0csCisJCQkJCShlcnJtc2coIiVzIGFmdGVyICVs ZC4lMDNkIG1zIiwKKwkJCQkJCQlnZXRfcmVjb3ZlcnlfY29uZmxpY3RfZGVzYyhyZWFzb24p LCBtc2VjcywgdXNlY3MpLAorCQkJCQkgKGVycmRldGFpbF9sb2dfcGx1cmFsKCJDb25mbGlj dGluZyBwcm9jZXNzOiAlcy4iLAorCQkJCQkJCQkJCSAgICJDb25mbGljdGluZyBwcm9jZXNz ZXM6ICVzLiIsCisJCQkJCQkJCQkJICAgbnByb2NzLCBidWYuZGF0YSkpKSk7CisJCX0KKwkJ ZWxzZQorCQl7CisJCQllcmVwb3J0KExPRywKKwkJCQkJKGVycm1zZygiJXMgYWZ0ZXIgJWxk LiUwM2QgbXMiLAorCQkJCQkJCWdldF9yZWNvdmVyeV9jb25mbGljdF9kZXNjKHJlYXNvbiks IG1zZWNzLCB1c2VjcykpKTsKKwkJfQorCisJCXBmcmVlKGJ1Zi5kYXRhKTsKKwl9CisJZWxz ZQorCQllcmVwb3J0KExPRywKKwkJCQkoZXJybXNnKCIlcyBhZnRlciAlbGQuJTAzZCBtcyIs CisJCQkJCQlnZXRfcmVjb3ZlcnlfY29uZmxpY3RfZGVzYyhyZWFzb24pLCBtc2VjcywgdXNl Y3MpKSk7Cit9CisKIC8qCiAgKiBUaGlzIGlzIHRoZSBtYWluIGV4ZWN1dGlvbmVyIGZvciBh bnkgcXVlcnkgYmFja2VuZCB0aGF0IGNvbmZsaWN0cyB3aXRoCiAgKiByZWNvdmVyeSBwcm9j ZXNzaW5nLiBKdWRnZW1lbnQgaGFzIGFscmVhZHkgYmVlbiBwYXNzZWQgb24gaXQgd2l0aGlu CiAgKiBhIHNwZWNpZmljIHJtZ3IuIEhlcmUgd2UganVzdCBpc3N1ZSB0aGUgb3JkZXJzIHRv IHRoZSBwcm9jcy4gVGhlIHByb2NzCiAgKiB0aGVuIHRocm93IHRoZSByZXF1aXJlZCBlcnJv ciBhcyBpbnN0cnVjdGVkLgogICoKLSAqIElmIHJlcG9ydF93YWl0aW5nIGlzIHRydWUsICJ3 YWl0aW5nIiBpcyByZXBvcnRlZCBpbiBQUyBkaXNwbGF5IGlmIG5lY2Vzc2FyeS4KLSAqIElm IHRoZSBjYWxsZXIgaGFzIGFscmVhZHkgcmVwb3J0ZWQgdGhhdCwgcmVwb3J0X3dhaXRpbmcg c2hvdWxkIGJlIGZhbHNlLgotICogT3RoZXJ3aXNlLCAid2FpdGluZyIgaXMgcmVwb3J0ZWQg dHdpY2UgdW5leHBlY3RlZGx5LgorICogSWYgcmVwb3J0X3dhaXRpbmcgaXMgdHJ1ZSwgIndh aXRpbmciIGlzIHJlcG9ydGVkIGluIFBTIGRpc3BsYXkgYW5kIGxvZworICogdGhlIHdhaXRz IGZvciB0aGUgcmVjb3ZlcnkgY29uZmxpY3QgaWYgbmVjZXNzYXJ5LiAgSWYgdGhlIGNhbGxl ciBoYXMgYWxyZWFkeQorICogcmVwb3J0ZWQgdGhhdCwgcmVwb3J0X3dhaXRpbmcgc2hvdWxk IGJlIGZhbHNlLiAgT3RoZXJ3aXNlLCBib3RoIGFyZSByZXBvcnRlZAorICogdHdpY2UgdW5l eHBlY3RlZGx5LgogICovCiBzdGF0aWMgdm9pZAogUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RX aXRoVmlydHVhbFhJRHMoVmlydHVhbFRyYW5zYWN0aW9uSWQgKndhaXRsaXN0LApAQCAtMjMy LDEyICszMDQsMTQgQEAgUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoVmlydHVhbFhJRHMo VmlydHVhbFRyYW5zYWN0aW9uSWQgKndhaXRsaXN0LAogewogCVRpbWVzdGFtcFR6IHdhaXRT dGFydCA9IDA7CiAJY2hhcgkgICAqbmV3X3N0YXR1czsKKwlib29sIGxvZ2dlZF9yZWNvdmVy eV9jb25mbGljdCA9IGZhbHNlOwogCiAJLyogRmFzdCBleGl0LCB0byBhdm9pZCBhIGtlcm5l bCBjYWxsIGlmIHRoZXJlJ3Mgbm8gd29yayB0byBiZSBkb25lLiAqLwogCWlmICghVmlydHVh bFRyYW5zYWN0aW9uSWRJc1ZhbGlkKCp3YWl0bGlzdCkpCiAJCXJldHVybjsKIAotCWlmIChy ZXBvcnRfd2FpdGluZykKKwkvKiBTZXQgdGhlIHdhaXQgc3RhcnQgdGltZXN0YW1wIGZvciBy ZXBvcnRpbmcgKi8KKwlpZiAocmVwb3J0X3dhaXRpbmcgJiYgKGxvZ2dlZF9yZWNvdmVyeV9j b25mbGljdCB8fCB1cGRhdGVfcHJvY2Vzc190aXRsZSkpCiAJCXdhaXRTdGFydCA9IEdldEN1 cnJlbnRUaW1lc3RhbXAoKTsKIAluZXdfc3RhdHVzID0gTlVMTDsJCQkvKiB3ZSBoYXZlbid0 IGNoYW5nZWQgdGhlIHBzIGRpc3BsYXkgKi8KIApAQCAtMjQ5LDIzICszMjMsNDMgQEAgUmVz b2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoVmlydHVhbFhJRHMoVmlydHVhbFRyYW5zYWN0aW9u SWQgKndhaXRsaXN0LAogCQkvKiB3YWl0IHVudGlsIHRoZSB2aXJ0dWFsIHhpZCBpcyBnb25l ICovCiAJCXdoaWxlICghVmlydHVhbFhhY3RMb2NrKCp3YWl0bGlzdCwgZmFsc2UpKQogCQl7 Ci0JCQkvKgotCQkJICogUmVwb3J0IHZpYSBwcyBpZiB3ZSBoYXZlIGJlZW4gd2FpdGluZyBm b3IgbW9yZSB0aGFuIDUwMCBtc2VjCi0JCQkgKiAoc2hvdWxkIHRoYXQgYmUgY29uZmlndXJh YmxlPykKLQkJCSAqLwotCQkJaWYgKHVwZGF0ZV9wcm9jZXNzX3RpdGxlICYmIG5ld19zdGF0 dXMgPT0gTlVMTCAmJiByZXBvcnRfd2FpdGluZyAmJgotCQkJCVRpbWVzdGFtcERpZmZlcmVu Y2VFeGNlZWRzKHdhaXRTdGFydCwgR2V0Q3VycmVudFRpbWVzdGFtcCgpLAotCQkJCQkJCQkJ CSAgIDUwMCkpCisJCQlpZiAod2FpdFN0YXJ0ID4gMCkKIAkJCXsKLQkJCQljb25zdCBjaGFy ICpvbGRfc3RhdHVzOwotCQkJCWludAkJCWxlbjsKLQotCQkJCW9sZF9zdGF0dXMgPSBnZXRf cHNfZGlzcGxheSgmbGVuKTsKLQkJCQluZXdfc3RhdHVzID0gKGNoYXIgKikgcGFsbG9jKGxl biArIDggKyAxKTsKLQkJCQltZW1jcHkobmV3X3N0YXR1cywgb2xkX3N0YXR1cywgbGVuKTsK LQkJCQlzdHJjcHkobmV3X3N0YXR1cyArIGxlbiwgIiB3YWl0aW5nIik7Ci0JCQkJc2V0X3Bz X2Rpc3BsYXkobmV3X3N0YXR1cyk7Ci0JCQkJbmV3X3N0YXR1c1tsZW5dID0gJ1wwJzsgLyog dHJ1bmNhdGUgb2ZmICIgd2FpdGluZyIgKi8KKwkJCQlUaW1lc3RhbXBUeiBjdXJfdHMgPSAw OworCQkJCWJvb2wgbWF5YmVfbG9nX2NvbmZsaWN0ID0KKwkJCQkJKGxvZ19yZWNvdmVyeV9j b25mbGljdF93YWl0cyAmJiAhbG9nZ2VkX3JlY292ZXJ5X2NvbmZsaWN0KTsKKwkJCQlib29s IG1heWJlX3VwZGF0ZV9wc3RpdGxlID0KKwkJCQkJKHVwZGF0ZV9wcm9jZXNzX3RpdGxlICYm IG5ld19zdGF0dXMgPT0gTlVMTCk7CisKKwkJCQkvKiBHZXQgdGhlIGN1cnJlbnQgdGltZXN0 YW1wIGlmIG5vdCByZXBvcnQgeWV0ICovCisJCQkJaWYgKG1heWJlX2xvZ19jb25mbGljdCB8 fCBtYXliZV91cGRhdGVfcHN0aXRsZSkKKwkJCQkJY3VyX3RzID0gR2V0Q3VycmVudFRpbWVz dGFtcCgpOworCisJCQkJLyogTG9nIHRoZSByZWNvdmVyeSBjb25mbGljdCBpZiBuZWNlc3Nh cnkgKi8KKwkJCQlpZiAobWF5YmVfbG9nX2NvbmZsaWN0ICYmCisJCQkJCVRpbWVzdGFtcERp ZmZlcmVuY2VFeGNlZWRzKHdhaXRTdGFydCwgY3VyX3RzLCBEZWFkbG9ja1RpbWVvdXQpKQor CQkJCXsKKwkJCQkJTG9nUmVjb3ZlcnlDb25mbGljdChyZWFzb24sIHdhaXRTdGFydCwgY3Vy X3RzLCB3YWl0bGlzdCk7CisJCQkJCWxvZ2dlZF9yZWNvdmVyeV9jb25mbGljdCA9IHRydWU7 CisJCQkJfQorCisJCQkJLyoKKwkJCQkgKiBSZXBvcnQgdmlhIHBzIGlmIHdlIGhhdmUgYmVl biB3YWl0aW5nIGZvciBtb3JlIHRoYW4gNTAwIG1zZWMKKwkJCQkgKiAoc2hvdWxkIHRoYXQg YmUgY29uZmlndXJhYmxlPykKKwkJCQkgKi8KKwkJCQlpZiAobWF5YmVfdXBkYXRlX3BzdGl0 bGUgJiYKKwkJCQkJVGltZXN0YW1wRGlmZmVyZW5jZUV4Y2VlZHMod2FpdFN0YXJ0LCBjdXJf dHMsIDUwMCkpCisJCQkJeworCQkJCQljb25zdCBjaGFyICpvbGRfc3RhdHVzOworCQkJCQlp bnQJCQlsZW47CisKKwkJCQkJb2xkX3N0YXR1cyA9IGdldF9wc19kaXNwbGF5KCZsZW4pOwor CQkJCQluZXdfc3RhdHVzID0gKGNoYXIgKikgcGFsbG9jKGxlbiArIDggKyAxKTsKKwkJCQkJ bWVtY3B5KG5ld19zdGF0dXMsIG9sZF9zdGF0dXMsIGxlbik7CisJCQkJCXN0cmNweShuZXdf c3RhdHVzICsgbGVuLCAiIHdhaXRpbmciKTsKKwkJCQkJc2V0X3BzX2Rpc3BsYXkobmV3X3N0 YXR1cyk7CisJCQkJCW5ld19zdGF0dXNbbGVuXSA9ICdcMCc7IC8qIHRydW5jYXRlIG9mZiAi IHdhaXRpbmciICovCisJCQkJfQogCQkJfQogCiAJCQkvKiBJcyBpdCB0aW1lIHRvIGtpbGwg aXQ/ICovCkBAIC00MDAsNyArNDk0LDcgQEAgUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRo RGF0YWJhc2UoT2lkIGRiaWQpCiAgKiB3aWxsIGJlIGRldGVjdGVkIGJ5IHRoZSBkZWFkbG9j ayBkZXRlY3RvciB3aXRoaW4gdGhlIG9yZGluYXJ5IGJhY2tlbmQuCiAgKi8KIHZvaWQKLVJl c29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aExvY2soTE9DS1RBRyBsb2NrdGFnKQorUmVzb2x2 ZVJlY292ZXJ5Q29uZmxpY3RXaXRoTG9jayhMT0NLVEFHIGxvY2t0YWcsIGJvb2wgbG9nZ2Vk X3JlY292ZXJ5X2NvbmZsaWN0KQogewogCVRpbWVzdGFtcFR6IGx0aW1lOwogCkBAIC00MDgs NyArNTAyLDM1IEBAIFJlc29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aExvY2soTE9DS1RBRyBs b2NrdGFnKQogCiAJbHRpbWUgPSBHZXRTdGFuZGJ5TGltaXRUaW1lKCk7CiAKLQlpZiAoR2V0 Q3VycmVudFRpbWVzdGFtcCgpID49IGx0aW1lKQorCWlmIChsdGltZSA9PSAwIHx8IEdldEN1 cnJlbnRUaW1lc3RhbXAoKSA8IGx0aW1lKQorCXsKKwkJRW5hYmxlVGltZW91dFBhcmFtcyB0 aW1lb3V0c1syXTsKKwkJaW50IGNudCA9IDA7CisKKwkJLyoKKwkJICogV2FpdCAob3Igd2Fp dCBhZ2FpbikgdW50aWwgbHRpbWUKKwkJICovCisJCWlmIChsdGltZSAhPSAwKQorCQl7CisJ CQl0aW1lb3V0c1tjbnRdLmlkID0gU1RBTkRCWV9MT0NLX1RJTUVPVVQ7CisJCQl0aW1lb3V0 c1tjbnRdLnR5cGUgPSBUTVBBUkFNX0FUOworCQkJdGltZW91dHNbY250XS5maW5fdGltZSA9 IGx0aW1lOworCQkJY250Kys7CisJCX0KKworCQkvKiBBbHNvLCBzZXQgZGVhZGxvY2sgdGlt ZW91dCBmb3IgbG9nZ2luZyBwdXJwb3NlIGlmIG5lY2Vzc2FyeSAqLworCQlpZiAobG9nX3Jl Y292ZXJ5X2NvbmZsaWN0X3dhaXRzICYmICFsb2dnZWRfcmVjb3ZlcnlfY29uZmxpY3QpCisJ CXsKKwkJCXRpbWVvdXRzW2NudF0uaWQgPSBTVEFOREJZX1RJTUVPVVQ7CisJCQl0aW1lb3V0 c1tjbnRdLnR5cGUgPSBUTVBBUkFNX0FGVEVSOworCQkJdGltZW91dHNbY250XS5kZWxheV9t cyA9IERlYWRsb2NrVGltZW91dDsKKwkJCWNudCsrOworCQl9CisKKwkJaWYgKGNudCA+IDAp CisJCQllbmFibGVfdGltZW91dHModGltZW91dHMsIGNudCk7CisJfQorCWVsc2UKIAl7CiAJ CS8qCiAJCSAqIFdlJ3JlIGFscmVhZHkgYmVoaW5kLCBzbyBjbGVhciBhIHBhdGggYXMgcXVp Y2tseSBhcyBwb3NzaWJsZS4KQEAgLTQxOSwyNiArNTQxLDE1IEBAIFJlc29sdmVSZWNvdmVy eUNvbmZsaWN0V2l0aExvY2soTE9DS1RBRyBsb2NrdGFnKQogCiAJCS8qCiAJCSAqIFByZXZl bnQgUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoVmlydHVhbFhJRHMoKSBmcm9tIHJlcG9y dGluZwotCQkgKiAid2FpdGluZyIgaW4gUFMgZGlzcGxheSBieSBkaXNhYmxpbmcgaXRzIGFy Z3VtZW50IHJlcG9ydF93YWl0aW5nCi0JCSAqIGJlY2F1c2UgdGhlIGNhbGxlciwgV2FpdE9u TG9jaygpLCBoYXMgYWxyZWFkeSByZXBvcnRlZCB0aGF0LgorCQkgKiAid2FpdGluZyIgaW4g UFMgZGlzcGxheSBhbmQgbG9nZ2luZyByZWNvdmVyeSBjb25mbGljdCBieSBkaXNhYmxpbmcK KwkJICogaXRzIGFyZ3VtZW50IHJlcG9ydF93YWl0aW5nIGJlY2F1c2UgdGhlIGNhbGxlcnMg bWF5IGhhdmUgYWxyZWFkeQorCQkgKiByZXBvcnRlZCB0aGF0LgogCQkgKi8KIAkJUmVzb2x2 ZVJlY292ZXJ5Q29uZmxpY3RXaXRoVmlydHVhbFhJRHMoYmFja2VuZHMsCiAJCQkJCQkJCQkJ CSAgIFBST0NTSUdfUkVDT1ZFUllfQ09ORkxJQ1RfTE9DSywKIAkJCQkJCQkJCQkJICAgUEdf V0FJVF9MT0NLIHwgbG9ja3RhZy5sb2NrdGFnX3R5cGUsCiAJCQkJCQkJCQkJCSAgIGZhbHNl KTsKIAl9Ci0JZWxzZQotCXsKLQkJLyoKLQkJICogV2FpdCAob3Igd2FpdCBhZ2FpbikgdW50 aWwgbHRpbWUKLQkJICovCi0JCUVuYWJsZVRpbWVvdXRQYXJhbXMgdGltZW91dHNbMV07Ci0K LQkJdGltZW91dHNbMF0uaWQgPSBTVEFOREJZX0xPQ0tfVElNRU9VVDsKLQkJdGltZW91dHNb MF0udHlwZSA9IFRNUEFSQU1fQVQ7Ci0JCXRpbWVvdXRzWzBdLmZpbl90aW1lID0gbHRpbWU7 Ci0JCWVuYWJsZV90aW1lb3V0cyh0aW1lb3V0cywgMSk7Ci0JfQogCiAJLyogV2FpdCB0byBi ZSBzaWduYWxlZCBieSB0aGUgcmVsZWFzZSBvZiB0aGUgUmVsYXRpb24gTG9jayAqLwogCVBy b2NXYWl0Rm9yU2lnbmFsKFBHX1dBSVRfTE9DSyB8IGxvY2t0YWcubG9ja3RhZ190eXBlKTsK QEAgLTExMTYsMyArMTIyNywzNiBAQCBMb2dTdGFuZGJ5SW52YWxpZGF0aW9ucyhpbnQgbm1z Z3MsIFNoYXJlZEludmFsaWRhdGlvbk1lc3NhZ2UgKm1zZ3MsCiAJCQkJCSBubXNncyAqIHNp emVvZihTaGFyZWRJbnZhbGlkYXRpb25NZXNzYWdlKSk7CiAJWExvZ0luc2VydChSTV9TVEFO REJZX0lELCBYTE9HX0lOVkFMSURBVElPTlMpOwogfQorCisvKiBSZXR1cm4gdGhlIGRlc2Ny aXB0aW9uIG9mIHJlY292ZXJ5IGNvbmZsaWN0ICovCitzdGF0aWMgY29uc3QgY2hhciAqCitn ZXRfcmVjb3ZlcnlfY29uZmxpY3RfZGVzYyhQcm9jU2lnbmFsUmVhc29uIHJlYXNvbikKK3sK Kwljb25zdCBjaGFyICpyZWFzb25EZXNjID0gZ2V0dGV4dF9ub29wKCJ1bmtub3duIHJlYXNv biIpOworCisJc3dpdGNoIChyZWFzb24pCisJeworCQljYXNlIFBST0NTSUdfUkVDT1ZFUllf Q09ORkxJQ1RfQlVGRkVSUElOOgorCQkJcmVhc29uRGVzYyA9IGdldHRleHRfbm9vcCgicmVj b3ZlcnkgaXMgc3RpbGwgd2FpdGluZyBmb3IgcmVjb3ZlcnkgY29uZmxpY3Qgb24gYnVmZmVy IHBpbiIpOworCQkJYnJlYWs7CisJCWNhc2UgUFJPQ1NJR19SRUNPVkVSWV9DT05GTElDVF9M T0NLOgorCQkJcmVhc29uRGVzYyA9IGdldHRleHRfbm9vcCgicmVjb3ZlcnkgaXMgc3RpbGwg d2FpdGluZyBmb3IgcmVjb3ZlcnkgY29uZmxpY3Qgb24gbG9jayIpOworCQkJYnJlYWs7CisJ CWNhc2UgUFJPQ1NJR19SRUNPVkVSWV9DT05GTElDVF9UQUJMRVNQQUNFOgorCQkJcmVhc29u RGVzYyA9IGdldHRleHRfbm9vcCgicmVjb3ZlcnkgaXMgc3RpbGwgd2FpdGluZyBmb3IgcmVj b3ZlcnkgY29uZmxpY3Qgb24gdGFibGVzcGFjZSIpOworCQkJYnJlYWs7CisJCWNhc2UgUFJP Q1NJR19SRUNPVkVSWV9DT05GTElDVF9TTkFQU0hPVDoKKwkJCXJlYXNvbkRlc2MgPSBnZXR0 ZXh0X25vb3AoInJlY292ZXJ5IGlzIHN0aWxsIHdhaXRpbmcgZm9yIHJlY292ZXJ5IGNvbmZs aWN0IG9uIHNuYXBzaG90Iik7CisJCQlicmVhazsKKwkJY2FzZSBQUk9DU0lHX1JFQ09WRVJZ X0NPTkZMSUNUX1NUQVJUVVBfREVBRExPQ0s6CisJCQlyZWFzb25EZXNjID0gZ2V0dGV4dF9u b29wKCJyZWNvdmVyeSBpcyBzdGlsbCB3YWl0aW5nIGZvciByZWNvdmVyeSBjb25mbGljdCBv biBidWZmZXIgZGVhZGxvY2siKTsKKwkJCWJyZWFrOworCQljYXNlIFBST0NTSUdfUkVDT1ZF UllfQ09ORkxJQ1RfREFUQUJBU0U6CisJCQlyZWFzb25EZXNjID0gZ2V0dGV4dF9ub29wKCJy ZWNvdmVyeSBpcyBzdGlsbCB3YWl0aW5nIGZvciByZWNvdmVyeSBjb25mbGljdCBvbiBkYXRh YmFzZSIpOworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisJCQlicmVhazsKKwl9CisKKwlyZXR1 cm4gcmVhc29uRGVzYzsKK30KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvbG1n ci9wcm9jLmMgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2xtZ3IvcHJvYy5jCmluZGV4IDg4NTY2 YmQ5ZmEuLjZkMDg3MjZiZTkgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvbG1n ci9wcm9jLmMKKysrIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9sbWdyL3Byb2MuYwpAQCAtMTA2 Myw4ICsxMDYzLDEwIEBAIFByb2NTbGVlcChMT0NBTExPQ0sgKmxvY2FsbG9jaywgTG9ja01l dGhvZCBsb2NrTWV0aG9kVGFibGUpCiAJTFdMb2NrCSAgICpwYXJ0aXRpb25Mb2NrID0gTG9j a0hhc2hQYXJ0aXRpb25Mb2NrKGhhc2hjb2RlKTsKIAlQUk9DX1FVRVVFICp3YWl0UXVldWUg PSAmKGxvY2stPndhaXRQcm9jcyk7CiAJTE9DS01BU0sJbXlIZWxkTG9ja3MgPSBNeVByb2Mt PmhlbGRMb2NrczsKKwlUaW1lc3RhbXBUeiBzdGFuZGJ5V2FpdFN0YXJ0ID0gMDsKIAlib29s CQllYXJseV9kZWFkbG9jayA9IGZhbHNlOwogCWJvb2wJCWFsbG93X2F1dG92YWN1dW1fY2Fu Y2VsID0gdHJ1ZTsKKwlib29sICAgICAgICBsb2dnZWRfcmVjb3ZlcnlfY29uZmxpY3QgPSBm YWxzZTsKIAlQcm9jV2FpdFN0YXR1cyBteVdhaXRTdGF0dXM7CiAJUEdQUk9DCSAgICpwcm9j OwogCVBHUFJPQwkgICAqbGVhZGVyID0gTXlQcm9jLT5sb2NrR3JvdXBMZWFkZXI7CkBAIC0x MjYwLDYgKzEyNjIsMTEgQEAgUHJvY1NsZWVwKExPQ0FMTE9DSyAqbG9jYWxsb2NrLCBMb2Nr TWV0aG9kIGxvY2tNZXRob2RUYWJsZSkKIAkJZWxzZQogCQkJZW5hYmxlX3RpbWVvdXRfYWZ0 ZXIoREVBRExPQ0tfVElNRU9VVCwgRGVhZGxvY2tUaW1lb3V0KTsKIAl9CisJZWxzZSBpZiAo bG9nX3JlY292ZXJ5X2NvbmZsaWN0X3dhaXRzKQorCXsKKwkJLyogU2V0IHdhaXQgc3RhcnQg dGltZXN0YW1wIGlmIGxvZ2dpbmcgaXMgZW5hYmxlZCAqLworCQlzdGFuZGJ5V2FpdFN0YXJ0 ID0gR2V0Q3VycmVudFRpbWVzdGFtcCgpOworCX0KIAogCS8qCiAJICogSWYgc29tZWJvZHkg d2FrZXMgdXMgYmV0d2VlbiBMV0xvY2tSZWxlYXNlIGFuZCBXYWl0TGF0Y2gsIHRoZSBsYXRj aApAQCAtMTI4MCw3ICsxMjg3LDMzIEBAIFByb2NTbGVlcChMT0NBTExPQ0sgKmxvY2FsbG9j aywgTG9ja01ldGhvZCBsb2NrTWV0aG9kVGFibGUpCiAJCWlmIChJbkhvdFN0YW5kYnkpCiAJ CXsKIAkJCS8qIFNldCBhIHRpbWVyIGFuZCB3YWl0IGZvciB0aGF0IG9yIGZvciB0aGUgTG9j ayB0byBiZSBncmFudGVkICovCi0JCQlSZXNvbHZlUmVjb3ZlcnlDb25mbGljdFdpdGhMb2Nr KGxvY2FsbG9jay0+dGFnLmxvY2spOworCQkJUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRo TG9jayhsb2NhbGxvY2stPnRhZy5sb2NrLCBsb2dnZWRfcmVjb3ZlcnlfY29uZmxpY3QpOwor CisJCQlpZiAoc3RhbmRieVdhaXRTdGFydCA+IDAgJiYgIWxvZ2dlZF9yZWNvdmVyeV9jb25m bGljdCkKKwkJCXsKKwkJCQlUaW1lc3RhbXBUeiBjdXJfdHMgPSBHZXRDdXJyZW50VGltZXN0 YW1wKCk7CisJCQkJaWYgKFRpbWVzdGFtcERpZmZlcmVuY2VFeGNlZWRzKHN0YW5kYnlXYWl0 U3RhcnQsIGN1cl90cywKKwkJCQkJCQkJCQkgICBEZWFkbG9ja1RpbWVvdXQpKQorCQkJCXsK KwkJCQkJVmlydHVhbFRyYW5zYWN0aW9uSWQgKnZ4aWRzOworCQkJCQlpbnQJY250OworCisJ CQkJCUFzc2VydChsb2dfcmVjb3ZlcnlfY29uZmxpY3Rfd2FpdHMpOworCQkJCQl2eGlkcyA9 CUdldExvY2tDb25mbGljdHMoJmxvY2FsbG9jay0+dGFnLmxvY2ssCisJCQkJCQkJCQkJCSBB Y2Nlc3NFeGNsdXNpdmVMb2NrLCAmY250KTsKKworCQkJCQkvKgorCQkJCQkgKiBMb2cgdGhl IHJlY292ZXJ5IGNvbmZsaWN0IGlmIHRoZXJlIGlzIHN0aWxsIHZpcnR1YWwgdHJhbnNhY3Rp b24KKwkJCQkJICogY29uZmxpY3Rpbmcgd2l0aCB0aGUgbG9jay4KKwkJCQkJICovCisJCQkJ CWlmIChjbnQgPiAwKQorCQkJCQl7CisJCQkJCQlMb2dSZWNvdmVyeUNvbmZsaWN0KFBST0NT SUdfUkVDT1ZFUllfQ09ORkxJQ1RfTE9DSywKKwkJCQkJCQkJCQkJc3RhbmRieVdhaXRTdGFy dCwgY3VyX3RzLCB2eGlkcyk7CisJCQkJCQlsb2dnZWRfcmVjb3ZlcnlfY29uZmxpY3QgPSB0 cnVlOworCQkJCQl9CisJCQkJfQorCQkJfQogCQl9CiAJCWVsc2UKIAkJewpkaWZmIC0tZ2l0 IGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWMuYyBiL3NyYy9iYWNrZW5kL3V0aWxzL21p c2MvZ3VjLmMKaW5kZXggNTk2YmNiN2I4NC4uZTU1YTI4YjFjZCAxMDA2NDQKLS0tIGEvc3Jj L2JhY2tlbmQvdXRpbHMvbWlzYy9ndWMuYworKysgYi9zcmMvYmFja2VuZC91dGlscy9taXNj L2d1Yy5jCkBAIC0xNTcwLDcgKzE1NzAsMTUgQEAgc3RhdGljIHN0cnVjdCBjb25maWdfYm9v bCBDb25maWd1cmVOYW1lc0Jvb2xbXSA9CiAJCWZhbHNlLAogCQlOVUxMLCBOVUxMLCBOVUxM CiAJfSwKLQorCXsKKwkJeyJsb2dfcmVjb3ZlcnlfY29uZmxpY3Rfd2FpdHMiLCBQR0NfU0lH SFVQLCBMT0dHSU5HX1dIQVQsCisJCQlnZXR0ZXh0X25vb3AoIkxvZ3Mgc3RhbmRieSByZWNv dmVyeSBjb25mbGljdCB3YWl0cy4iKSwKKwkJCU5VTEwKKwkJfSwKKwkJJmxvZ19yZWNvdmVy eV9jb25mbGljdF93YWl0cywKKwkJZmFsc2UsCisJCU5VTEwsIE5VTEwsIE5VTEwKKwl9LAog CXsKIAkJeyJsb2dfaG9zdG5hbWUiLCBQR0NfU0lHSFVQLCBMT0dHSU5HX1dIQVQsCiAJCQln ZXR0ZXh0X25vb3AoIkxvZ3MgdGhlIGhvc3QgbmFtZSBpbiB0aGUgY29ubmVjdGlvbiBsb2dz LiIpLApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNv bmYuc2FtcGxlIGIvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2Ft cGxlCmluZGV4IDljYjU3MWY3Y2MuLjU2MjU2ODFlOGEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNr ZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZQorKysgYi9zcmMvYmFja2Vu ZC91dGlscy9taXNjL3Bvc3RncmVzcWwuY29uZi5zYW1wbGUKQEAgLTU1Myw2ICs1NTMsOCBA QAogCQkJCQkjICAgJSUgPSAnJScKIAkJCQkJIyBlLmcuICc8JXUlJSVkPiAnCiAjbG9nX2xv Y2tfd2FpdHMgPSBvZmYJCQkjIGxvZyBsb2NrIHdhaXRzID49IGRlYWRsb2NrX3RpbWVvdXQK KyNsb2dfcmVjb3ZlcnlfY29uZmxpY3Rfd2FpdHMgPSBvZmYJIyBsb2cgc3RhbmRieSByZWNv dmVyeSBjb25mbGljdCB3YWl0cworCQkJCQkjID49IGRlYWRsb2NrX3RpbWVvdXQKICNsb2df cGFyYW1ldGVyX21heF9sZW5ndGggPSAtMQkJIyB3aGVuIGxvZ2dpbmcgc3RhdGVtZW50cywg bGltaXQgbG9nZ2VkCiAJCQkJCSMgYmluZC1wYXJhbWV0ZXIgdmFsdWVzIHRvIE4gYnl0ZXM7 CiAJCQkJCSMgLTEgbWVhbnMgcHJpbnQgaW4gZnVsbCwgMCBkaXNhYmxlcwpkaWZmIC0tZ2l0 IGEvc3JjL2luY2x1ZGUvc3RvcmFnZS9zdGFuZGJ5LmggYi9zcmMvaW5jbHVkZS9zdG9yYWdl L3N0YW5kYnkuaAppbmRleCBmYWFmMWQzODE3Li5jNGZiNDJiMWU0IDEwMDY0NAotLS0gYS9z cmMvaW5jbHVkZS9zdG9yYWdlL3N0YW5kYnkuaAorKysgYi9zcmMvaW5jbHVkZS9zdG9yYWdl L3N0YW5kYnkuaApAQCAtMjMsNiArMjMsNyBAQAogZXh0ZXJuIGludAl2YWN1dW1fZGVmZXJf Y2xlYW51cF9hZ2U7CiBleHRlcm4gaW50CW1heF9zdGFuZGJ5X2FyY2hpdmVfZGVsYXk7CiBl eHRlcm4gaW50CW1heF9zdGFuZGJ5X3N0cmVhbWluZ19kZWxheTsKK2V4dGVybiBib29sCWxv Z19yZWNvdmVyeV9jb25mbGljdF93YWl0czsKIAogZXh0ZXJuIHZvaWQgSW5pdFJlY292ZXJ5 VHJhbnNhY3Rpb25FbnZpcm9ubWVudCh2b2lkKTsKIGV4dGVybiB2b2lkIFNodXRkb3duUmVj b3ZlcnlUcmFuc2FjdGlvbkVudmlyb25tZW50KHZvaWQpOwpAQCAtMzIsMTIgKzMzLDE1IEBA IGV4dGVybiB2b2lkIFJlc29sdmVSZWNvdmVyeUNvbmZsaWN0V2l0aFNuYXBzaG90KFRyYW5z YWN0aW9uSWQgbGF0ZXN0UmVtb3ZlZFhpZCwKIGV4dGVybiB2b2lkIFJlc29sdmVSZWNvdmVy eUNvbmZsaWN0V2l0aFRhYmxlc3BhY2UoT2lkIHRzaWQpOwogZXh0ZXJuIHZvaWQgUmVzb2x2 ZVJlY292ZXJ5Q29uZmxpY3RXaXRoRGF0YWJhc2UoT2lkIGRiaWQpOwogCi1leHRlcm4gdm9p ZCBSZXNvbHZlUmVjb3ZlcnlDb25mbGljdFdpdGhMb2NrKExPQ0tUQUcgbG9ja3RhZyk7Citl eHRlcm4gdm9pZCBSZXNvbHZlUmVjb3ZlcnlDb25mbGljdFdpdGhMb2NrKExPQ0tUQUcgbG9j a3RhZywKKwkJCQkJCQkJCQkJYm9vbCBsb2dnZWRfcmVjb3ZlcnlfY29uZmxpY3QpOwogZXh0 ZXJuIHZvaWQgUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoQnVmZmVyUGluKHZvaWQpOwog ZXh0ZXJuIHZvaWQgQ2hlY2tSZWNvdmVyeUNvbmZsaWN0RGVhZGxvY2sodm9pZCk7CiBleHRl cm4gdm9pZCBTdGFuZGJ5RGVhZExvY2tIYW5kbGVyKHZvaWQpOwogZXh0ZXJuIHZvaWQgU3Rh bmRieVRpbWVvdXRIYW5kbGVyKHZvaWQpOwogZXh0ZXJuIHZvaWQgU3RhbmRieUxvY2tUaW1l b3V0SGFuZGxlcih2b2lkKTsKK2V4dGVybiB2b2lkIExvZ1JlY292ZXJ5Q29uZmxpY3QoUHJv Y1NpZ25hbFJlYXNvbiByZWFzb24sIFRpbWVzdGFtcFR6IHdhaXRTdGFydCwKKwkJCQkJCQkJ VGltZXN0YW1wVHogY3VyX3RzLCBWaXJ0dWFsVHJhbnNhY3Rpb25JZCAqd2FpdGxpc3QpOwog CiAvKgogICogU3RhbmRieSBSbWdyIChSTV9TVEFOREJZX0lEKQo= --------------B3A56158E6C6B1DFB23F37AE--