Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1x4Fyy-0072AA-35 for pgsql-hackers@arkaria.postgresql.org; Wed, 09 Sep 2026 10:56:49 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1x4Fyx-00Dvbj-0j for pgsql-hackers@arkaria.postgresql.org; Wed, 09 Sep 2026 10:56:47 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1x4Fyw-00Dvbb-2B for pgsql-hackers@lists.postgresql.org; Wed, 09 Sep 2026 10:56:46 +0000 Received: from email.dnscdc.tech ([194.226.250.15]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.98.2) (envelope-from ) id 1x4Fyt-00000004l22-1LnL for pgsql-hackers@lists.postgresql.org; Wed, 09 Sep 2026 10:56:45 +0000 Received: with id E137728130C; Wed, 9 Sep 2026 17:56:37 +0700 (+07) Received: with id 894AF28002C; Wed, 9 Sep 2026 17:56:37 +0700 (+07) From: Grigorev Jurij To: Michael Paquier CC: PostgreSQL Hackers Subject: Re: DSA_ALLOC_NO_OOM vs dsm_create ERROR leaving a half-initialized pgstats hash entry Thread-Topic: DSA_ALLOC_NO_OOM vs dsm_create ERROR leaving a half-initialized pgstats hash entry Thread-Index: AQHdP268ccO9PMgx5Ei0J2uuaTqIjLbE5gWAgAEact0= Date: Wed, 9 Sep 2026 10:56:34 +0000 Message-ID: References: , In-Reply-To: Accept-Language: ru-RU, en-US Content-Language: ru-RU X-MS-Has-Attach: yes X-MS-TNEF-Correlator: Content-Type: multipart/mixed; boundary="_002_a72c99d5b1e448b191a89e30ecaf3e8aftdataru_" MIME-Version: 1.0 X-KLMS-Rule-ID: 1 X-KLMS-Message-Action: clean X-KLMS-AntiSpam-Lua-Profiles: 205845 [Sep 09 2026] X-KLMS-AntiSpam-Version: 6.1.1.27 X-KLMS-AntiSpam-Envelope-From: ju.grigorev@ftdata.ru X-KLMS-AntiSpam-Rate: 0 X-KLMS-AntiSpam-Status: not_detected X-KLMS-AntiSpam-Method: none X-KLMS-AntiSpam-Auth: dkim=none X-MS-Exchange-Organization-SCL: -1 X-KLMS-AntiSpam-Interceptor-Info: scan successful X-KLMS-AntiPhishing: Clean, bases: 2026/09/09 08:55:00 X-KLMS-AntiVirus: Kaspersky Security for Linux Mail Server, version 8.0.3.30, bases: 2026/09/09 06:21:00 #28566238 X-KLMS-AntiVirus-Status: Clean, skipped List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --_002_a72c99d5b1e448b191a89e30ecaf3e8aftdataru_ Content-Type: text/plain; charset="koi8-r" Content-Transfer-Encoding: quoted-printable On Tue, Sep 08, 2026 at 11:52:33PM +0000, Michael Paquier wrote: > My question regarding (1) vs (2) would be: do we have other > sub-systems that display patterns similar to pgstats when it comes to > the DSA/DSM failing? If pgstats is the only one, (1) sounds like a > solution good enough for me. I checked all in-tree DSA_ALLOC_NO_OOM and DSHASH_INSERT_NO_OOM call sites, plus the comparable two-phase cases in typcache.c and async.c. pgstats is the only one that both publishes its surrounding object before allocating the DSA body and assumes the body is always valid. With one exception, discussed below, they all allocate before publishing. In dshash, insert_into_bucket() allocates the item before linking it into a bucket, resize() allocates the new bucket array before replacing the old one, and dshash_create() does not publish the table until its buckets exist. pgsa_set_advice_string() in contrib/pg_stash_advice allocates the advice string, then inserts with DSHASH_INSERT_NO_OOM and frees the string if that returns NULL, which is exactly the ordering the patch gives pgstats. find_or_make_matching_shared_tupledesc() in typcache.c copies the TupleDesc into DSA first, with a PG_TRY() around the insertion to free it on error. The exception, and the closest case to pgstats, is async.c: PrepareTableEntriesForListen() inserts a channel entry with listenersArray =3D=3D InvalidDsaPointer and allocates afterwards. But that incomplete state is supported by design -- numListeners stays zero, so consumers do not access any array elements, and a later call retries the allocation. pgstats has no such tolerance: the existing-entry path dereferences body unconditionally, which is why the escaped error becomes a SEGV instead of a retry. So option (1) looks sufficient for this crash. Patch attached. It allocates the DSA body before inserting the shared hash entry; pgstat_init_entry() now receives a valid chunk and no longer allocates. Both callers use dshash_find_or_insert_extended() with DSHASH_INSERT_NO_OOM and free the preallocated body if insertion returns NULL or finds an existing entry. One residual case remains: dshash insertion can itself raise ERROR from dsm_create() despite DSHASH_INSERT_NO_OOM, in which case the preallocated chunk is not reclaimed. pg_stash_advice and dshash_create() have analogous unreachable-allocation cases. No inconsistent pgstats entry is published, but closing the leak would require either exception cleanup or the lower-level NO_OOM change. I left PG_TRY/PG_CATCH out based on your comments; typcache shows how it could be used if such cleanup is preferred. 8191e0c was backpatched through 15 for the same class of corruption, so this path may deserve the same treatment. If the approach looks right, I can prepare back-branch versions and add a deterministic test using an injection point in make_new_segment() before dsm_create(). Thanks, Yuriy Grigoryev= --_002_a72c99d5b1e448b191a89e30ecaf3e8aftdataru_ Content-Type: application/octet-stream; name="0001-Allocate-pgstats-entry-body-before-shared-hash-insert.patch" Content-Description: 0001-Allocate-pgstats-entry-body-before-shared-hash-insert.patch Content-Disposition: attachment; filename="0001-Allocate-pgstats-entry-body-before-shared-hash-insert.patch"; size=10328; creation-date="Wed, 09 Sep 2026 10:43:13 GMT"; modification-date="Wed, 09 Sep 2026 10:43:13 GMT" Content-Transfer-Encoding: base64 RnJvbSBkMDY3OTIyOTdhODJmYjBhMGExZDhkYmIxZjQwNjRjMzI0Y2I0ODVhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBZdXJpeSBHcmlnb3J5ZXYgPGp1LmdyaWdvcmV2QGZ0ZGF0YS5y dT4KRGF0ZTogVHVlLCA4IFNlcCAyMDI2IDEzOjMwOjE4ICswNzAwClN1YmplY3Q6IFtQQVRDSF0g QWxsb2NhdGUgcGdzdGF0cyBlbnRyeSBib2R5IGJlZm9yZSBzaGFyZWQgaGFzaCBpbnNlcnQKCjgx OTFlMGMgbWFkZSBwZ3N0YXRfaW5pdF9lbnRyeSgpIHJldHVybiBOVUxMIG9uIERTQSBhbGxvY2F0 aW9uIGZhaWx1cmUKc28gY2FsbGVycyBjb3VsZCBkZWxldGUgYSBqdXN0LWluc2VydGVkIGhhc2gg ZW50cnkuICBUaGF0IHdvcmtzIHdoZW4KZHNhX2FsbG9jYXRlX2V4dGVuZGVkKC4uLiwgRFNBX0FM TE9DX05PX09PTSkgcmV0dXJucyBJbnZhbGlkRHNhUG9pbnRlciwKYnV0IG5vdCB3aGVuIGNyZWF0 aW5nIGEgbmV3IERTTSBzZWdtZW50IHJhaXNlcyBFUlJPUiAoZm9yIGV4YW1wbGUgRU5PU1BDCm9u IHBvc2l4IHNoYXJlZCBtZW1vcnkpLgoKcGdzdGF0X2luaXRfZW50cnkoKSBtYXJrZWQgdGhlIGhh c2ggZW50cnkgbGl2ZSBiZWZvcmUgYWxsb2NhdGluZyB0aGUKYm9keS4gIElmIGRzbV9jcmVhdGUo KSBmYWlsZWQgYWZ0ZXIgdGhlIGluc2VydCwgZXJyb3IgdW53aW5kIHJlbGVhc2VkCnRoZSBkc2hh c2ggbG9jayBidXQgbGVmdCBhIHZpc2libGUgZW50cnkgd2l0aCBib2R5ID09IEludmFsaWREc2FQ b2ludGVyLgpUaGUgbmV4dCBiYWNrZW5kIGNyYXNoZWQgaW4gcGdzdGF0X2FjcXVpcmVfZW50cnlf cmVmKCkuCgpTcGxpdCBhbGxvY2F0aW9uIGZyb20gaGFzaCBpbml0aWFsaXphdGlvbjogYWxsb2Nh dGUgdGhlIERTQSBjaHVuayBmaXJzdCwKaW5zZXJ0IHRoZSBoYXNoIGVudHJ5IG9ubHkgd2l0aCBh IHZhbGlkIGJvZHksIGFuZCBmcmVlIHRoZSBjaHVuayBpZiBhCmNvbmN1cnJlbnQgaW5zZXJ0IHdp bnMgb3IgdGhlIGluc2VydCByZXR1cm5zIE5VTEwuICBCb3RoIGNhbGxlcnMgdXNlCmRzaGFzaF9m aW5kX29yX2luc2VydF9leHRlbmRlZCgpIHdpdGggRFNIQVNIX0lOU0VSVF9OT19PT00gc28gdGhh dCBwYXRoCmNhbiBmcmVlIHRoZSBwcmVhbGxvY2F0ZWQgYm9keS4KCkRpc2N1c3Npb246IGh0dHBz Oi8vcG9zdGdyLmVzL20vZGRjM2VjZmIwMWNlNGU5Njk4YjIzY2M1OTc2N2YwMTZAbG9jYWxob3N0 LmxvY2FsZG9tYWluCi0tLQogc3JjL2JhY2tlbmQvdXRpbHMvYWN0aXZpdHkvcGdzdGF0LmMgICAg ICAgfCAgNDUgKysrKysrLS0tLQogc3JjL2JhY2tlbmQvdXRpbHMvYWN0aXZpdHkvcGdzdGF0X3No bWVtLmMgfCAxMDUgKysrKysrKysrKysrLS0tLS0tLS0tLQogc3JjL2luY2x1ZGUvdXRpbHMvcGdz dGF0X2ludGVybmFsLmggICAgICAgfCAgIDQgKy0KIDMgZmlsZXMgY2hhbmdlZCwgOTEgaW5zZXJ0 aW9ucygrKSwgNjMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMv YWN0aXZpdHkvcGdzdGF0LmMgYi9zcmMvYmFja2VuZC91dGlscy9hY3Rpdml0eS9wZ3N0YXQuYwpp bmRleCA1MTc3Zjg4Li4zZjRmZTYwIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC91dGlscy9hY3Rp dml0eS9wZ3N0YXQuYworKysgYi9zcmMvYmFja2VuZC91dGlscy9hY3Rpdml0eS9wZ3N0YXQuYwpA QCAtMjAwNyw2ICsyMDA3LDcgQEAgcGdzdGF0X3JlYWRfc3RhdHNmaWxlKHZvaWQpCiAJCQkJCVBn U3RhdFNoYXJlZF9IYXNoRW50cnkgKnA7CiAJCQkJCVBnU3RhdFNoYXJlZF9Db21tb24gKmhlYWRl cjsKIAkJCQkJY29uc3QgUGdTdGF0X0tpbmRJbmZvICpraW5kX2luZm8gPSBOVUxMOworCQkJCQlk c2FfcG9pbnRlciBjaHVuazsKIAogCQkJCQlDSEVDS19GT1JfSU5URVJSVVBUUygpOwogCkBAIC0y MDk1LDEyICsyMDk2LDM5IEBAIHBnc3RhdF9yZWFkX3N0YXRzZmlsZSh2b2lkKQogCQkJCQkgKiBU aGlzIGludGVudGlvbmFsbHkgZG9lc24ndCB1c2UgcGdzdGF0X2dldF9lbnRyeV9yZWYoKSAtCiAJ CQkJCSAqIHB1dHRpbmcgYWxsIHN0YXRzIGludG8gY2hlY2twb2ludGVyJ3MKIAkJCQkJICogcGdT dGF0RW50cnlSZWZIYXNoIHdvdWxkIGJlIHdhc3RlZCBlZmZvcnQgYW5kIG1lbW9yeS4KKwkJCQkJ ICoKKwkJCQkJICogQWxsb2NhdGUgdGhlIERTQSBib2R5IGJlZm9yZSBpbnNlcnRpbmcgdGhlIGhh c2ggZW50cnksCisJCQkJCSAqIHNvIGEgZHNtX2NyZWF0ZSBmYWlsdXJlIGNhbm5vdCBsZWF2ZSBh IGhhbGYtaW5pdGlhbGl6ZWQKKwkJCQkJICogc2hhcmVkIGVudHJ5IGJlaGluZC4KIAkJCQkJICov Ci0JCQkJCXAgPSBkc2hhc2hfZmluZF9vcl9pbnNlcnQocGdTdGF0TG9jYWwuc2hhcmVkX2hhc2gs ICZrZXksICZmb3VuZCk7CisJCQkJCWNodW5rID0gcGdzdGF0X2FsbG9jX2VudHJ5X2JvZHkoa2V5 LmtpbmQpOworCQkJCQlpZiAoY2h1bmsgPT0gSW52YWxpZERzYVBvaW50ZXIpCisJCQkJCXsKKwkJ CQkJCS8qCisJCQkJCQkgKiBJdCB3b3VsZCBiZSB0ZW1wdGluZyB0byBzd2l0Y2ggdGhpcyBFUlJP UiB0byBhCisJCQkJCQkgKiBXQVJOSU5HLCBidXQgaXQgd291bGQgbWVhbiB0aGF0IGFsbCB0aGUg c3RhdGlzdGljcworCQkJCQkJICogYXJlIGRpc2NhcmRlZCB3aGVuIHRoZSBlbnZpcm9ubWVudCBm YWlscyBvbiBPT00uCisJCQkJCQkgKi8KKwkJCQkJCWVsb2coRVJST1IsICJjb3VsZCBub3QgYWxs b2NhdGUgZW50cnkgJXUvJXUvJSIgUFJJdTY0ICIgb2YgdHlwZSAlYyIsCisJCQkJCQkJIGtleS5r aW5kLCBrZXkuZGJvaWQsCisJCQkJCQkJIGtleS5vYmppZCwgdCk7CisJCQkJCX0KKworCQkJCQlw ID0gZHNoYXNoX2ZpbmRfb3JfaW5zZXJ0X2V4dGVuZGVkKHBnU3RhdExvY2FsLnNoYXJlZF9oYXNo LAorCQkJCQkJCQkJCQkJCSAgICZrZXksICZmb3VuZCwKKwkJCQkJCQkJCQkJCQkgICBEU0hBU0hf SU5TRVJUX05PX09PTSk7CisJCQkJCWlmICghcCkKKwkJCQkJeworCQkJCQkJZHNhX2ZyZWUocGdT dGF0TG9jYWwuZHNhLCBjaHVuayk7CisJCQkJCQllbG9nKEVSUk9SLCAiY291bGQgbm90IGluc2Vy dCBlbnRyeSAldS8ldS8lIiBQUkl1NjQgIiBvZiB0eXBlICVjIiwKKwkJCQkJCQkga2V5LmtpbmQs IGtleS5kYm9pZCwKKwkJCQkJCQkga2V5Lm9iamlkLCB0KTsKKwkJCQkJfQogCiAJCQkJCS8qIGRv bid0IGFsbG93IGR1cGxpY2F0ZSBlbnRyaWVzICovCiAJCQkJCWlmIChmb3VuZCkKIAkJCQkJewor CQkJCQkJZHNhX2ZyZWUocGdTdGF0TG9jYWwuZHNhLCBjaHVuayk7CiAJCQkJCQlkc2hhc2hfcmVs ZWFzZV9sb2NrKHBnU3RhdExvY2FsLnNoYXJlZF9oYXNoLCBwKTsKIAkJCQkJCWVsb2coV0FSTklO RywgImZvdW5kIGR1cGxpY2F0ZSBzdGF0cyBlbnRyeSAldS8ldS8lIiBQUkl1NjQgIiBvZiB0eXBl ICVjIiwKIAkJCQkJCQkga2V5LmtpbmQsIGtleS5kYm9pZCwKQEAgLTIxMDgsMjAgKzIxMzYsNyBA QCBwZ3N0YXRfcmVhZF9zdGF0c2ZpbGUodm9pZCkKIAkJCQkJCWdvdG8gZXJyb3I7CiAJCQkJCX0K IAotCQkJCQloZWFkZXIgPSBwZ3N0YXRfaW5pdF9lbnRyeShrZXkua2luZCwgcCk7Ci0JCQkJCWlm IChoZWFkZXIgPT0gTlVMTCkKLQkJCQkJewotCQkJCQkJZHNoYXNoX2RlbGV0ZV9lbnRyeShwZ1N0 YXRMb2NhbC5zaGFyZWRfaGFzaCwgcCk7Ci0KLQkJCQkJCS8qCi0JCQkJCQkgKiBJdCB3b3VsZCBi ZSB0ZW1wdGluZyB0byBzd2l0Y2ggdGhpcyBFUlJPUiB0byBhCi0JCQkJCQkgKiBXQVJOSU5HLCBi dXQgaXQgd291bGQgbWVhbiB0aGF0IGFsbCB0aGUgc3RhdGlzdGljcwotCQkJCQkJICogYXJlIGRp c2NhcmRlZCB3aGVuIHRoZSBlbnZpcm9ubWVudCBmYWlscyBvbiBPT00uCi0JCQkJCQkgKi8KLQkJ CQkJCWVsb2coRVJST1IsICJjb3VsZCBub3QgYWxsb2NhdGUgZW50cnkgJXUvJXUvJSIgUFJJdTY0 ICIgb2YgdHlwZSAlYyIsCi0JCQkJCQkJIGtleS5raW5kLCBrZXkuZGJvaWQsCi0JCQkJCQkJIGtl eS5vYmppZCwgdCk7Ci0JCQkJCX0KKwkJCQkJaGVhZGVyID0gcGdzdGF0X2luaXRfZW50cnkoa2V5 LmtpbmQsIHAsIGNodW5rKTsKIAkJCQkJZHNoYXNoX3JlbGVhc2VfbG9jayhwZ1N0YXRMb2NhbC5z aGFyZWRfaGFzaCwgcCk7CiAKIAkJCQkJaWYgKCFyZWFkX2NodW5rKGZwaW4sCmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC91dGlscy9hY3Rpdml0eS9wZ3N0YXRfc2htZW0uYyBiL3NyYy9iYWNrZW5k L3V0aWxzL2FjdGl2aXR5L3Bnc3RhdF9zaG1lbS5jCmluZGV4IGQ4YWM5ZDYuLmJmODg2YjQgMTAw NjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL2FjdGl2aXR5L3Bnc3RhdF9zaG1lbS5jCisrKyBi L3NyYy9iYWNrZW5kL3V0aWxzL2FjdGl2aXR5L3Bnc3RhdF9zaG1lbS5jCkBAIC0zMDMsNTMgKzMw Myw1OCBAQCBwZ3N0YXRfZGV0YWNoX3NobWVtKHZvaWQpCiAgKi8KIAogLyoKLSAqIEluaXRpYWxp emUgZW50cnkgbmV3bHktY3JlYXRlZC4KKyAqIEFsbG9jYXRlIHRoZSBEU0EgYm9keSBmb3IgYSBu ZXcgdmFyaWFibGUtbnVtYmVyZWQgcGdzdGF0cyBlbnRyeS4KICAqCi0gKiBSZXR1cm5zIE5VTEwg aW4gdGhlIGV2ZW50IG9mIGFuIGFsbG9jYXRpb24gZmFpbHVyZSwgc28gYXMgY2FsbGVycyBjYW4K LSAqIHRha2UgY2xlYW51cCBhY3Rpb25zIGFzIHRoZSBlbnRyeSBpbml0aWFsaXplZCBpcyBhbHJl YWR5IGluc2VydGVkIGluIHRoZQotICogc2hhcmVkIGhhc2h0YWJsZS4KKyAqIFJldHVybnMgSW52 YWxpZERzYVBvaW50ZXIgaWYgdGhlIGFsbG9jYXRpb24gZmFpbHMgd2l0aG91dCB0aHJvd2luZy4g IENhbGwKKyAqIHRoaXMgYmVmb3JlIGluc2VydGluZyBhIGhhc2ggZW50cnk6IGRzYV9hbGxvY2F0 ZV9leHRlbmRlZCgpIGNhbiBzdGlsbCByYWlzZQorICogRVJST1Igd2hlbiBjcmVhdGluZyBhIG5l dyBEU00gc2VnbWVudCAoZm9yIGV4YW1wbGUgRU5PU1BDKSwgYW5kIGRvaW5nIHRoYXQKKyAqIGFm dGVyIHRoZSBpbnNlcnQgd291bGQgbGVhdmUgYSBsaXZlIGhhc2ggZW50cnkgd2l0aCBib2R5ID09 CisgKiBJbnZhbGlkRHNhUG9pbnRlci4KKyAqLworZHNhX3BvaW50ZXIKK3Bnc3RhdF9hbGxvY19l bnRyeV9ib2R5KFBnU3RhdF9LaW5kIGtpbmQpCit7CisJY29uc3QgUGdTdGF0X0tpbmRJbmZvICpr aW5kX2luZm8gPSBwZ3N0YXRfZ2V0X2tpbmRfaW5mbyhraW5kKTsKKworCXJldHVybiBkc2FfYWxs b2NhdGVfZXh0ZW5kZWQocGdTdGF0TG9jYWwuZHNhLAorCQkJCQkJCQkga2luZF9pbmZvLT5zaGFy ZWRfc2l6ZSwKKwkJCQkJCQkJIERTQV9BTExPQ19aRVJPIHwgRFNBX0FMTE9DX05PX09PTSk7Cit9 CisKKy8qCisgKiBJbml0aWFsaXplIGEgbmV3bHktaW5zZXJ0ZWQgaGFzaCBlbnRyeSBhcm91bmQg YW4gYWxyZWFkeS1hbGxvY2F0ZWQgRFNBCisgKiBib2R5LgorICoKKyAqIFRoZSBjYWxsZXIgbXVz dCBob2xkIHRoZSBkc2hhc2ggcGFydGl0aW9uIGxvY2suICBUaGUgZW50cnkgY2Fubm90IGJlIGZv dW5kCisgKiBieSBvdGhlciBiYWNrZW5kcyB1bnRpbCB0aGF0IGxvY2sgaXMgcmVsZWFzZWQsIHNv IGl0IGlzIHNhZmUgdG8gcHVibGlzaAorICogcmVmY291bnQvZHJvcHBlZC9ib2R5IGhlcmUuICBD YWxsZXIgbmVlZHMgdG8gaW5jcmVtZW50IHRoZSByZWZjb3VudCBmdXJ0aGVyCisgKiBpZiBhIGxv bmdlci1saXZlZCByZWZlcmVuY2UgaXMgbmVlZGVkLgorICoKKyAqIGNodW5rIG11c3QgYmUgYSB2 YWxpZCBwb2ludGVyIGZyb20gcGdzdGF0X2FsbG9jX2VudHJ5X2JvZHkoKS4KICAqLwogUGdTdGF0 U2hhcmVkX0NvbW1vbiAqCiBwZ3N0YXRfaW5pdF9lbnRyeShQZ1N0YXRfS2luZCBraW5kLAotCQkJ CSAgUGdTdGF0U2hhcmVkX0hhc2hFbnRyeSAqc2hoYXNoZW50KQorCQkJCSAgUGdTdGF0U2hhcmVk X0hhc2hFbnRyeSAqc2hoYXNoZW50LAorCQkJCSAgZHNhX3BvaW50ZXIgY2h1bmspCiB7Ci0JLyog Q3JlYXRlIG5ldyBzdGF0cyBlbnRyeS4gKi8KLQlkc2FfcG9pbnRlciBjaHVuazsKIAlQZ1N0YXRT aGFyZWRfQ29tbW9uICpzaGhlYWRlcjsKIAljb25zdCBQZ1N0YXRfS2luZEluZm8gKmtpbmRfaW5m byA9IHBnc3RhdF9nZXRfa2luZF9pbmZvKGtpbmQpOwogCi0JLyoKLQkgKiBJbml0aWFsaXplIHJl ZmNvdW50IHRvIDEsIG1hcmtpbmcgaXQgYXMgdmFsaWQgLyBub3QgZHJvcHBlZC4gVGhlIGVudHJ5 Ci0JICogY2FuJ3QgYmUgZnJlZWQgYmVmb3JlIHRoZSBpbml0aWFsaXphdGlvbiBiZWNhdXNlIGl0 IGNhbid0IGJlIGZvdW5kIGFzCi0JICogbG9uZyBhcyB3ZSBob2xkIHRoZSBkc2hhc2ggcGFydGl0 aW9uIGxvY2suIENhbGxlciBuZWVkcyB0byBpbmNyZWFzZQotCSAqIGZ1cnRoZXIgaWYgYSBsb25n ZXIgbGl2ZWQgcmVmZXJlbmNlIGlzIG5lZWRlZC4KLQkgKi8KLQlwZ19hdG9taWNfaW5pdF91MzIo JnNoaGFzaGVudC0+cmVmY291bnQsIDEpOwotCi0JLyoKLQkgKiBJbml0aWFsaXplICJnZW5lcmF0 aW9uIiB0byAwLCBhcyBmcmVzaGx5IGNyZWF0ZWQuCi0JICovCi0JcGdfYXRvbWljX2luaXRfdTMy KCZzaGhhc2hlbnQtPmdlbmVyYXRpb24sIDApOwotCXNoaGFzaGVudC0+ZHJvcHBlZCA9IGZhbHNl OwotCi0JY2h1bmsgPSBkc2FfYWxsb2NhdGVfZXh0ZW5kZWQocGdTdGF0TG9jYWwuZHNhLAotCQkJ CQkJCQkgIGtpbmRfaW5mby0+c2hhcmVkX3NpemUsCi0JCQkJCQkJCSAgRFNBX0FMTE9DX1pFUk8g fCBEU0FfQUxMT0NfTk9fT09NKTsKLQlpZiAoY2h1bmsgPT0gSW52YWxpZERzYVBvaW50ZXIpCi0J CXJldHVybiBOVUxMOworCUFzc2VydChEc2FQb2ludGVySXNWYWxpZChjaHVuaykpOwogCiAJc2ho ZWFkZXIgPSBkc2FfZ2V0X2FkZHJlc3MocGdTdGF0TG9jYWwuZHNhLCBjaHVuayk7CiAJc2hoZWFk ZXItPm1hZ2ljID0gMHhkZWFkYmVlZjsKKwlMV0xvY2tJbml0aWFsaXplKCZzaGhlYWRlci0+bG9j aywgTFdUUkFOQ0hFX1BHU1RBVFNfREFUQSk7CiAKLQkvKiBMaW5rIHRoZSBuZXcgZW50cnkgZnJv bSB0aGUgaGFzaCBlbnRyeS4gKi8KKwlwZ19hdG9taWNfaW5pdF91MzIoJnNoaGFzaGVudC0+cmVm Y291bnQsIDEpOworCXBnX2F0b21pY19pbml0X3UzMigmc2hoYXNoZW50LT5nZW5lcmF0aW9uLCAw KTsKKwlzaGhhc2hlbnQtPmRyb3BwZWQgPSBmYWxzZTsKIAlzaGhhc2hlbnQtPmJvZHkgPSBjaHVu azsKIAogCS8qIEluY3JlbWVudCBlbnRyeSBjb3VudCwgaWYgcmVxdWlyZWQuICovCiAJaWYgKGtp bmRfaW5mby0+dHJhY2tfZW50cnlfY291bnQpCiAJCXBnX2F0b21pY19mZXRjaF9hZGRfdTY0KCZw Z1N0YXRMb2NhbC5zaG1lbS0+ZW50cnlfY291bnRzW2tpbmQgLSAxXSwgMSk7CiAKLQlMV0xvY2tJ bml0aWFsaXplKCZzaGhlYWRlci0+bG9jaywgTFdUUkFOQ0hFX1BHU1RBVFNfREFUQSk7Ci0KIAly ZXR1cm4gc2hoZWFkZXI7CiB9CiAKQEAgLTU0NSw2ICs1NTAsMjQgQEAgcGdzdGF0X2dldF9lbnRy eV9yZWYoUGdTdGF0X0tpbmQga2luZCwgT2lkIGRib2lkLCB1aW50NjQgb2JqaWQsIGJvb2wgY3Jl YXRlLAogCWlmIChjcmVhdGUgJiYgIXNoaGFzaGVudCkKIAl7CiAJCWJvb2wJCXNoZm91bmQ7CisJ CWRzYV9wb2ludGVyIGNodW5rOworCisJCS8qCisJCSAqIEFsbG9jYXRlIHRoZSBzdGF0cyBib2R5 IGJlZm9yZSBpbnNlcnRpbmcgYSBoYXNoIGVudHJ5LiAgQ3JlYXRpbmcgYQorCQkgKiBuZXcgRFNB IHNlZ21lbnQgY2FuIHJhaXNlIEVSUk9SIChlLmcuIEVOT1NQQyBvbiBwb3NpeCBzaG0pOyBkb2lu ZworCQkgKiB0aGF0IGFmdGVyIHRoZSBpbnNlcnQgd291bGQgbGVhdmUgYSBsaXZlIGhhc2ggZW50 cnkgd2l0aCBhbgorCQkgKiBpbnZhbGlkIGJvZHkuCisJCSAqLworCQljaHVuayA9IHBnc3RhdF9h bGxvY19lbnRyeV9ib2R5KGtpbmQpOworCQlpZiAoY2h1bmsgPT0gSW52YWxpZERzYVBvaW50ZXIp CisJCXsKKwkJCXBnc3RhdF9yZWxlYXNlX2VudHJ5X3JlZihrZXksIGVudHJ5X3JlZiwgZmFsc2Up OworCQkJZXJlcG9ydChFUlJPUiwKKwkJCQkJKGVycmNvZGUoRVJSQ09ERV9PVVRfT0ZfTUVNT1JZ KSwKKwkJCQkJIGVycm1zZygib3V0IG9mIG1lbW9yeSIpLAorCQkJCQkgZXJyZGV0YWlsKCJGYWls ZWQgd2hpbGUgYWxsb2NhdGluZyBlbnRyeSAldS8ldS8lIiBQUkl1NjQgIi4iLAorCQkJCQkJCSAg IGtleS5raW5kLCBrZXkuZGJvaWQsIGtleS5vYmppZCkpKTsKKwkJfQogCiAJCS8qCiAJCSAqIEl0 J3MgcG9zc2libGUgdGhhdCBzb21lYm9keSBjcmVhdGVkIHRoZSBlbnRyeSBzaW5jZSB0aGUgYWJv dmUKQEAgLTU1Niw2ICs1NzksOCBAQCBwZ3N0YXRfZ2V0X2VudHJ5X3JlZihQZ1N0YXRfS2luZCBr aW5kLCBPaWQgZGJvaWQsIHVpbnQ2NCBvYmppZCwgYm9vbCBjcmVhdGUsCiAJCQkJCQkJCQkJCQkg ICBEU0hBU0hfSU5TRVJUX05PX09PTSk7CiAJCWlmICghc2hoYXNoZW50KQogCQl7CisJCQlkc2Ff ZnJlZShwZ1N0YXRMb2NhbC5kc2EsIGNodW5rKTsKKwogCQkJLyoKIAkJCSAqIENsZWFuIHVwIHRo ZSBsb2NhbCByZWZlcmVuY2Ugd2hlbiBmYWlsaW5nIGluc2VydCBpbnRvIHRoZQogCQkJICogc2hh cmVkIGhhc2h0YWJsZS4KQEAgLTU3MCwyNCArNTk1LDcgQEAgcGdzdGF0X2dldF9lbnRyeV9yZWYo UGdTdGF0X0tpbmQga2luZCwgT2lkIGRib2lkLCB1aW50NjQgb2JqaWQsIGJvb2wgY3JlYXRlLAog CiAJCWlmICghc2hmb3VuZCkKIAkJewotCQkJc2hoZWFkZXIgPSBwZ3N0YXRfaW5pdF9lbnRyeShr aW5kLCBzaGhhc2hlbnQpOwotCQkJaWYgKHNoaGVhZGVyID09IE5VTEwpCi0JCQl7Ci0JCQkJLyoK LQkJCQkgKiBGYWlsZWQgdGhlIGFsbG9jYXRpb24gb2YgYSBuZXcgZW50cnksIHNvIGNsZWFuIHVw IGJvdGggdGhlCi0JCQkJICogbG9jYWwgcmVmZXJlbmNlIGFuZCB0aGUgc2hhcmVkIGhhc2h0YWJs ZSBiZWZvcmUgZ2l2aW5nIHVwLgotCQkJCSAqIENsZWFuIHRoZSBsb2NhbCBzdGF0ZSBmaXJzdCwg c2luY2UgcmVsZWFzaW5nIHRoZSBkc2hhc2gKLQkJCQkgKiBsb2NrIGNhbiBwcm9jZXNzIGEgcGVu ZGluZyBpbnRlcnJ1cHQuCi0JCQkJICovCi0JCQkJcGdzdGF0X3JlbGVhc2VfZW50cnlfcmVmKGtl eSwgZW50cnlfcmVmLCBmYWxzZSk7Ci0JCQkJZHNoYXNoX2RlbGV0ZV9lbnRyeShwZ1N0YXRMb2Nh bC5zaGFyZWRfaGFzaCwgc2hoYXNoZW50KTsKLQotCQkJCWVyZXBvcnQoRVJST1IsCi0JCQkJCQko ZXJyY29kZShFUlJDT0RFX09VVF9PRl9NRU1PUlkpLAotCQkJCQkJIGVycm1zZygib3V0IG9mIG1l bW9yeSIpLAotCQkJCQkJIGVycmRldGFpbCgiRmFpbGVkIHdoaWxlIGFsbG9jYXRpbmcgZW50cnkg JXUvJXUvJSIgUFJJdTY0ICIuIiwKLQkJCQkJCQkJICAga2V5LmtpbmQsIGtleS5kYm9pZCwga2V5 Lm9iamlkKSkpOwotCQkJfQorCQkJc2hoZWFkZXIgPSBwZ3N0YXRfaW5pdF9lbnRyeShraW5kLCBz aGhhc2hlbnQsIGNodW5rKTsKIAkJCXBnc3RhdF9hY3F1aXJlX2VudHJ5X3JlZihlbnRyeV9yZWYs IHNoaGFzaGVudCwgc2hoZWFkZXIpOwogCiAJCQlpZiAoY3JlYXRlZF9lbnRyeSAhPSBOVUxMKQpA QCAtNTk1LDYgKzYwMyw5IEBAIHBnc3RhdF9nZXRfZW50cnlfcmVmKFBnU3RhdF9LaW5kIGtpbmQs IE9pZCBkYm9pZCwgdWludDY0IG9iamlkLCBib29sIGNyZWF0ZSwKIAogCQkJcmV0dXJuIGVudHJ5 X3JlZjsKIAkJfQorCisJCS8qIENvbmN1cnJlbnQgaW5zZXJ0IHdvbjsgZHJvcCB0aGUgdW51c2Vk IGJvZHkuICovCisJCWRzYV9mcmVlKHBnU3RhdExvY2FsLmRzYSwgY2h1bmspOwogCX0KIAogCWlm ICghc2hoYXNoZW50KQpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvdXRpbHMvcGdzdGF0X2ludGVy bmFsLmggYi9zcmMvaW5jbHVkZS91dGlscy9wZ3N0YXRfaW50ZXJuYWwuaAppbmRleCAxNDM2OWU1 Li4yMDFlNTcyIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS91dGlscy9wZ3N0YXRfaW50ZXJuYWwu aAorKysgYi9zcmMvaW5jbHVkZS91dGlscy9wZ3N0YXRfaW50ZXJuYWwuaApAQCAtODM5LDggKzgz OSwxMCBAQCBleHRlcm4gdm9pZCBwZ3N0YXRfcmVzZXRfbWF0Y2hpbmdfZW50cmllcyhib29sICgq ZG9fcmVzZXQpIChQZ1N0YXRTaGFyZWRfSGFzaEVudAogCQkJCQkJCQkJCSAgVGltZXN0YW1wVHog dHMpOwogCiBleHRlcm4gdm9pZCBwZ3N0YXRfcmVxdWVzdF9lbnRyeV9yZWZzX2djKHZvaWQpOwor ZXh0ZXJuIGRzYV9wb2ludGVyIHBnc3RhdF9hbGxvY19lbnRyeV9ib2R5KFBnU3RhdF9LaW5kIGtp bmQpOwogZXh0ZXJuIFBnU3RhdFNoYXJlZF9Db21tb24gKnBnc3RhdF9pbml0X2VudHJ5KFBnU3Rh dF9LaW5kIGtpbmQsCi0JCQkJCQkJCQkJCSAgUGdTdGF0U2hhcmVkX0hhc2hFbnRyeSAqc2hoYXNo ZW50KTsKKwkJCQkJCQkJCQkJICBQZ1N0YXRTaGFyZWRfSGFzaEVudHJ5ICpzaGhhc2hlbnQsCisJ CQkJCQkJCQkJCSAgZHNhX3BvaW50ZXIgY2h1bmspOwogCiAKIC8qCi0tIAoyLjUwLjEgKEFwcGxl IEdpdC0xNTUpCgo= --_002_a72c99d5b1e448b191a89e30ecaf3e8aftdataru_--