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.94.2) (envelope-from ) id 1slO2c-007HYk-5r for pgsql-hackers@arkaria.postgresql.org; Tue, 03 Sep 2024 07:33:31 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.94.2) (envelope-from ) id 1slO2a-008MY8-DG for pgsql-hackers@arkaria.postgresql.org; Tue, 03 Sep 2024 07:33:28 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1slO2Z-008MXz-SS for pgsql-hackers@lists.postgresql.org; Tue, 03 Sep 2024 07:33:28 +0000 Received: from mail.postgrespro.ru ([93.174.131.139]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1slO2W-000Q6j-Uh for pgsql-hackers@lists.postgresql.org; Tue, 03 Sep 2024 07:33:27 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=postgrespro.ru; s=mx2023; t=1725348804; bh=nPJSFt/smT0c8/q2BK7u3wAXFfDeuxha33LdFhMy5fg=; h=Date:From:To:Cc:Subject:In-Reply-To:References:User-Agent: Message-ID:From; b=vtqquP5SyzYrr9/PuyzEod43Z59jaGx9FLy/5Qz2EM9fDpy50S3G7RY3Y8x0XGCEJ LwBayCz9+QFkTrjez1E9LkgXVh1lx9fLN3HucL2kzEUZvAM5GtXWrC/9zG7sqK+i/Y pCGH+kx+yqLngO2eyEnPR3GxAsEZ9M9CaVNX97M0uxrY47ZObNi4q3WJwiiwI3wOkv WDMbtchTc1irlz2cuc7TGbiJl9+E4o/KPc1BQ59Kg/j1JXvEOo01LhoY2jFDS7P6/s 4wjYfjFtakC/MnB1RZc5bNAL76zgAIpeiPZOwmwMN6NPE1jz4aZg8oHUmleZXgOn2l DSd69VAi1QbFw== Received: from mail.postgrespro.ru (unknown [192.168.2.28]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (Client did not present a certificate) (Authenticated sender: a.pyhalov@postgrespro.ru) by mail.postgrespro.ru (Postfix/587) with ESMTPSA id D9A7960349; Tue, 3 Sep 2024 10:33:23 +0300 (MSK) MIME-Version: 1.0 Date: Tue, 03 Sep 2024 10:33:23 +0300 From: Alexander Pyhalov To: pgsql-hackers@lists.postgresql.org Cc: Ronan Dunklau , Tom Lane Subject: Re: SQLFunctionCache and generic plans In-Reply-To: <3084885.1675783797@sss.pgh.pa.us> References: <8216639.NyiUUSuA9g@aivenlaptop> <3084885.1675783797@sss.pgh.pa.us> User-Agent: Roundcube Webmail/1.6.8 Message-ID: X-Sender: a.pyhalov@postgrespro.ru Content-Type: multipart/mixed; boundary="=_979e70d20c6e330d2f68544b102680e1" X-KSMG-AntiPhishing: NotDetected X-KSMG-AntiSpam-Interceptor-Info: not scanned X-KSMG-AntiSpam-Status: not scanned, disabled by settings X-KSMG-AntiVirus: Kaspersky Secure Mail Gateway, version 2.1.0.7854, bases: 2024/09/03 06:42:00 #26513250 X-KSMG-AntiVirus-Status: NotDetected, skipped X-KSMG-LinksScanning: not scanned, disabled by settings X-KSMG-Message-Action: skipped X-KSMG-Rule-ID: 1 List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --=_979e70d20c6e330d2f68544b102680e1 Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset=UTF-8; format=flowed Tom Lane писал(а) 2023-02-07 18:29: > Ronan Dunklau writes: >> The following comment can be found in functions.c, about the >> SQLFunctionCache: > >> * Note that currently this has only the lifespan of the calling >> query. >> * Someday we should rewrite this code to use plancache.c to save >> parse/plan >> * results for longer than that. > >> I would be interested in working on this, primarily to avoid this >> problem of >> having generic query plans for SQL functions but maybe having a longer >> lived >> cache as well would be nice to have. >> Is there any reason not too, or pitfalls we would like to avoid ? > > AFAIR it's just lack of round tuits. There would probably be some > semantic side-effects, though if you pay attention you could likely > make things better while you are at it. The existing behavior of > parsing and planning all the statements at once is not very desirable > --- for instance, it doesn't work to do > CREATE TABLE foo AS ...; > SELECT * FROM foo; > I think if we're going to nuke this code and start over, we should > try to make that sort of case work. > > regards, tom lane Hi. I've tried to make SQL functions use CachedPlan machinery. The main goal was to allow SQL functions to use custom plans (the work was started from question - why sql function is so slow compared to plpgsql one). It turned out that plpgsql function used custom plan and eliminated scan of all irrelevant sections, but exec-time pruning didn't cope with pruning when ScalarArrayOpExpr, filtering data using int[] parameter. In current prototype there are two restrictions. The first one is that CachecPlan has lifetime of a query - it's not saved for future use, as we don't have something like plpgsql hashtable for long live function storage. Second - SQL language functions in sql_body form (with stored queryTree_list) are handled in the old way, as we currently lack tools to make cached plans from query trees. Currently this change solves the issue of inefficient plans for queries over partitioned tables. For example, function like CREATE OR REPLACE FUNCTION public.test_get_records(ids integer[]) RETURNS SETOF test LANGUAGE sql AS $function$ select * from test where id = any (ids) $function$; for hash-distributed table test can perform pruning in plan time and can have plan like Append (cost=0.00..51.88 rows=26 width=36) -> Seq Scan on test_0 test_1 (cost=0.00..25.88 rows=13 width=36) Filter: (id = ANY ('{1,2}'::integer[])) -> Seq Scan on test_2 (cost=0.00..25.88 rows=13 width=36) Filter: (id = ANY ('{1,2}'::integer[])) instead of Append (cost=0.00..155.54 rows=248 width=36) -> Seq Scan on test_0 test_1 (cost=0.00..38.58 rows=62 width=36) Filter: (id = ANY ($1)) -> Seq Scan on test_1 test_2 (cost=0.00..38.58 rows=62 width=36) Filter: (id = ANY ($1)) -> Seq Scan on test_2 test_3 (cost=0.00..38.58 rows=62 width=36) Filter: (id = ANY ($1)) -> Seq Scan on test_3 test_4 (cost=0.00..38.58 rows=62 width=36) Filter: (id = ANY ($1)) This patch definitely requires more work, and I share it to get some early feedback. What should we do with "pre-parsed" SQL functions (when prosrc is empty)? How should we create cached plans when we don't have raw parsetrees? Currently we can create cached plans without raw parsetrees, but this means that plan revalidation doesn't work, choose_custom_plan() always returns false and we get generic plan. Perhaps, we need some form of GetCachedPlan(), which ignores raw_parse_tree? In this case how could we possibly cache plans for session lifetime (like plpgsql language does) if we can't use cached revalidation machinery? I hope to get some hints to move further. -- Best regards, Alexander Pyhalov, Postgres Professional --=_979e70d20c6e330d2f68544b102680e1 Content-Transfer-Encoding: base64 Content-Type: text/x-diff; name=0001-Use-custom-plan-machinery-for-SQL-functions.patch Content-Disposition: attachment; filename=0001-Use-custom-plan-machinery-for-SQL-functions.patch; size=18805 RnJvbSBkN2NkZGU0NDlkYWVlZmJmZDljY2QzZTcyYWUyODJmMjFiZTBjMWM4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbGV4YW5kZXIgUHloYWxvdiA8YS5weWhhbG92QHBvc3RncmVz cHJvLnJ1PgpEYXRlOiBGcmksIDIzIEF1ZyAyMDI0IDE1OjQ4OjM4ICswMzAwClN1YmplY3Q6IFtQ QVRDSF0gVXNlIGN1c3RvbSBwbGFuIG1hY2hpbmVyeSBmb3IgU1FMIGZ1bmN0aW9ucwoKLS0tCiBj b250cmliL2NpdGV4dC9leHBlY3RlZC9jaXRleHQub3V0ICAgICAgICAgICAgfCAgIDIgKy0KIGNv bnRyaWIvY2l0ZXh0L2V4cGVjdGVkL2NpdGV4dF8xLm91dCAgICAgICAgICB8ICAgMiArLQogc3Jj L2JhY2tlbmQvZXhlY3V0b3IvZnVuY3Rpb25zLmMgICAgICAgICAgICAgIHwgMzA4ICsrKysrKysr KysrKysrLS0tLQogc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWNfdGFibGVzLmMgICAgICAgICAg IHwgIDEyICsKIHNyYy9pbmNsdWRlL2V4ZWN1dG9yL2Z1bmN0aW9ucy5oICAgICAgICAgICAgICB8 ICAgMiArCiBzcmMvdGVzdC9yZWdyZXNzL2V4cGVjdGVkL3BscGdzcWwub3V0ICAgICAgICAgfCAg IDIgKy0KIHNyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvc2VsZWN0X3BhcmFsbGVsLm91dCB8ICAg NCArLQogc3JjL3Rlc3QvcmVncmVzcy9leHBlY3RlZC9zeXN2aWV3cy5vdXQgICAgICAgIHwgICAz ICstCiA4IGZpbGVzIGNoYW5nZWQsIDI2NSBpbnNlcnRpb25zKCspLCA3MCBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9jb250cmliL2NpdGV4dC9leHBlY3RlZC9jaXRleHQub3V0IGIvY29udHJp Yi9jaXRleHQvZXhwZWN0ZWQvY2l0ZXh0Lm91dAppbmRleCA4YzBiZjU0ZjBmMy4uZjg3NjUwNTM2 NTEgMTAwNjQ0Ci0tLSBhL2NvbnRyaWIvY2l0ZXh0L2V4cGVjdGVkL2NpdGV4dC5vdXQKKysrIGIv Y29udHJpYi9jaXRleHQvZXhwZWN0ZWQvY2l0ZXh0Lm91dApAQCAtMTgxNiw3ICsxODE2LDcgQEAg U0VMRUNUIHJlZ2V4cF9tYXRjaCgnZm9vYmFyYmVxdWViYXonOjpjaXRleHQsICcoQkFSKShCRVFV RSknOjpjaXRleHQsICdjJzo6Y2l0ZXgKIFNFTEVDVCByZWdleHBfbWF0Y2goJ2Zvb2JhcmJlcXVl YmF6bW9yZWJhcmJlcXVldG9vJzo6Y2l0ZXh0LCAnKEJBUikoQkVRVUUpJzo6Y2l0ZXh0LCAnZycp IEFTICJlcnJvciI7CiBFUlJPUjogIHJlZ2V4cF9tYXRjaCgpIGRvZXMgbm90IHN1cHBvcnQgdGhl ICJnbG9iYWwiIG9wdGlvbgogSElOVDogIFVzZSB0aGUgcmVnZXhwX21hdGNoZXMgZnVuY3Rpb24g aW5zdGVhZC4KLUNPTlRFWFQ6ICBTUUwgZnVuY3Rpb24gInJlZ2V4cF9tYXRjaCIgc3RhdGVtZW50 IDEKK0NPTlRFWFQ6ICBTUUwgZnVuY3Rpb24gInJlZ2V4cF9tYXRjaCIgZHVyaW5nIHN0YXJ0dXAK IFNFTEVDVCByZWdleHBfbWF0Y2hlcygnZm9vYmFyYmVxdWViYXonOjpjaXRleHQsICcoYmFyKShi ZXF1ZSknKSA9IEFSUkFZWyAnYmFyJywgJ2JlcXVlJyBdIEFTIHQ7CiAgdCAKIC0tLQpkaWZmIC0t Z2l0IGEvY29udHJpYi9jaXRleHQvZXhwZWN0ZWQvY2l0ZXh0XzEub3V0IGIvY29udHJpYi9jaXRl eHQvZXhwZWN0ZWQvY2l0ZXh0XzEub3V0CmluZGV4IGM1ZTVmMTgwZjJiLi4zNTZkYzZiYmE0MyAx MDA2NDQKLS0tIGEvY29udHJpYi9jaXRleHQvZXhwZWN0ZWQvY2l0ZXh0XzEub3V0CisrKyBiL2Nv bnRyaWIvY2l0ZXh0L2V4cGVjdGVkL2NpdGV4dF8xLm91dApAQCAtMTgxNiw3ICsxODE2LDcgQEAg U0VMRUNUIHJlZ2V4cF9tYXRjaCgnZm9vYmFyYmVxdWViYXonOjpjaXRleHQsICcoQkFSKShCRVFV RSknOjpjaXRleHQsICdjJzo6Y2l0ZXgKIFNFTEVDVCByZWdleHBfbWF0Y2goJ2Zvb2JhcmJlcXVl YmF6bW9yZWJhcmJlcXVldG9vJzo6Y2l0ZXh0LCAnKEJBUikoQkVRVUUpJzo6Y2l0ZXh0LCAnZycp IEFTICJlcnJvciI7CiBFUlJPUjogIHJlZ2V4cF9tYXRjaCgpIGRvZXMgbm90IHN1cHBvcnQgdGhl ICJnbG9iYWwiIG9wdGlvbgogSElOVDogIFVzZSB0aGUgcmVnZXhwX21hdGNoZXMgZnVuY3Rpb24g aW5zdGVhZC4KLUNPTlRFWFQ6ICBTUUwgZnVuY3Rpb24gInJlZ2V4cF9tYXRjaCIgc3RhdGVtZW50 IDEKK0NPTlRFWFQ6ICBTUUwgZnVuY3Rpb24gInJlZ2V4cF9tYXRjaCIgZHVyaW5nIHN0YXJ0dXAK IFNFTEVDVCByZWdleHBfbWF0Y2hlcygnZm9vYmFyYmVxdWViYXonOjpjaXRleHQsICcoYmFyKShi ZXF1ZSknKSA9IEFSUkFZWyAnYmFyJywgJ2JlcXVlJyBdIEFTIHQ7CiAgdCAKIC0tLQpkaWZmIC0t Z2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZnVuY3Rpb25zLmMgYi9zcmMvYmFja2VuZC9leGVj dXRvci9mdW5jdGlvbnMuYwppbmRleCA2OTI4NTRlMmIzZS4uYTY3Y2M4ODhlYTYgMTAwNjQ0Ci0t LSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2Z1bmN0aW9ucy5jCisrKyBiL3NyYy9iYWNrZW5kL2V4 ZWN1dG9yL2Z1bmN0aW9ucy5jCkBAIC0zMyw5ICszMywxNCBAQAogI2luY2x1ZGUgInV0aWxzL2Rh dHVtLmgiCiAjaW5jbHVkZSAidXRpbHMvbHN5c2NhY2hlLmgiCiAjaW5jbHVkZSAidXRpbHMvbWVt dXRpbHMuaCIKKyNpbmNsdWRlICJ1dGlscy9wbGFuY2FjaGUuaCIKICNpbmNsdWRlICJ1dGlscy9z bmFwbWdyLmgiCiAjaW5jbHVkZSAidXRpbHMvc3lzY2FjaGUuaCIKIAorLyoKKyAqIEdVQyB2YXJp YWJsZXMKKyAqLworYm9vbAkJZW5hYmxlX3NxbF9mdW5jX2N1c3RvbV9wbGFucyA9IHRydWU7CiAK IC8qCiAgKiBTcGVjaWFsaXplZCBEZXN0UmVjZWl2ZXIgZm9yIGNvbGxlY3RpbmcgcXVlcnkgb3V0 cHV0IGluIGEgU1FMIGZ1bmN0aW9uCkBAIC0xMTIsNiArMTE3LDExIEBAIHR5cGVkZWYgc3RydWN0 CiAKIAlKdW5rRmlsdGVyICpqdW5rRmlsdGVyOwkJLyogd2lsbCBiZSBOVUxMIGlmIGZ1bmN0aW9u IHJldHVybnMgVk9JRCAqLwogCisJLyogQ2FjaGVkIHBsYW5zIHN1cHBvcnQgKi8KKwlMaXN0CSAg ICpxdWVyeVRyZWVfbGlzdDsgLyogbGlzdCBvZiBxdWVyeSBsaXN0cyAqLworCUxpc3QJICAgKnBs YW5zb3VyY2VfbGlzdDsJLyogbGlzdCBvZiBwbGFuc291cmNlICovCisJTGlzdAkgICAqY3BsYW5f bGlzdDsJCS8qIGxpc3Qgb2YgY2FjaGVkIHBsYW5zICovCisKIAkvKgogCSAqIGZ1bmNfc3RhdGUg aXMgYSBMaXN0IG9mIGV4ZWN1dGlvbl9zdGF0ZSByZWNvcmRzLCBlYWNoIG9mIHdoaWNoIGlzIHRo ZQogCSAqIGZpcnN0IGZvciBpdHMgb3JpZ2luYWwgcGFyc2V0cmVlLCB3aXRoIGFueSBhZGRpdGlv bmFsIHJlY29yZHMgY2hhaW5lZApAQCAtNDU0LDYgKzQ2NCw0MCBAQCBzcWxfZm5fcmVzb2x2ZV9w YXJhbV9uYW1lKFNRTEZ1bmN0aW9uUGFyc2VJbmZvUHRyIHBpbmZvLAogCXJldHVybiBOVUxMOwog fQogCisvKiBQcmVjaGVjayBjb21tYW5kIGZvciB2YWxpZGl0eSBpbiBhIGZ1bmN0aW9uICovCitz dGF0aWMgdm9pZAorY2hlY2tfcGxhbm5lZF9zdG10KFBsYW5uZWRTdG10ICpzdG10LCBTUUxGdW5j dGlvbkNhY2hlUHRyIGZjYWNoZSkKK3sKKworCS8qCisJICogUHJlY2hlY2sgYWxsIGNvbW1hbmRz IGZvciB2YWxpZGl0eSBpbiBhIGZ1bmN0aW9uLiAgVGhpcyBzaG91bGQKKwkgKiBnZW5lcmFsbHkg bWF0Y2ggdGhlIHJlc3RyaWN0aW9ucyBzcGkuYyBhcHBsaWVzLgorCSAqLworCWlmIChzdG10LT5j b21tYW5kVHlwZSA9PSBDTURfVVRJTElUWSkKKwl7CisJCWlmIChJc0Eoc3RtdC0+dXRpbGl0eVN0 bXQsIENvcHlTdG10KSAmJgorCQkJKChDb3B5U3RtdCAqKSBzdG10LT51dGlsaXR5U3RtdCktPmZp bGVuYW1lID09IE5VTEwpCisJCQllcmVwb3J0KEVSUk9SLAorCQkJCQkoZXJyY29kZShFUlJDT0RF X0ZFQVRVUkVfTk9UX1NVUFBPUlRFRCksCisJCQkJCSBlcnJtc2coImNhbm5vdCBDT1BZIHRvL2Zy b20gY2xpZW50IGluIGFuIFNRTCBmdW5jdGlvbiIpKSk7CisKKwkJaWYgKElzQShzdG10LT51dGls aXR5U3RtdCwgVHJhbnNhY3Rpb25TdG10KSkKKwkJCWVyZXBvcnQoRVJST1IsCisJCQkJCShlcnJj b2RlKEVSUkNPREVfRkVBVFVSRV9OT1RfU1VQUE9SVEVEKSwKKwkJCS8qIHRyYW5zbGF0b3I6ICVz IGlzIGEgU1FMIHN0YXRlbWVudCBuYW1lICovCisJCQkJCSBlcnJtc2coIiVzIGlzIG5vdCBhbGxv d2VkIGluIGFuIFNRTCBmdW5jdGlvbiIsCisJCQkJCQkJQ3JlYXRlQ29tbWFuZE5hbWUoc3RtdC0+ dXRpbGl0eVN0bXQpKSkpOworCX0KKworCWlmIChmY2FjaGUtPnJlYWRvbmx5X2Z1bmMgJiYgIUNv bW1hbmRJc1JlYWRPbmx5KHN0bXQpKQorCQllcmVwb3J0KEVSUk9SLAorCQkJCShlcnJjb2RlKEVS UkNPREVfRkVBVFVSRV9OT1RfU1VQUE9SVEVEKSwKKwkJLyogdHJhbnNsYXRvcjogJXMgaXMgYSBT UUwgc3RhdGVtZW50IG5hbWUgKi8KKwkJCQkgZXJybXNnKCIlcyBpcyBub3QgYWxsb3dlZCBpbiBh IG5vbi12b2xhdGlsZSBmdW5jdGlvbiIsCisJCQkJCQlDcmVhdGVDb21tYW5kTmFtZSgoTm9kZSAq KSBzdG10KSkpKTsKKworfQorCiAvKgogICogU2V0IHVwIHRoZSBwZXItcXVlcnkgZXhlY3V0aW9u X3N0YXRlIHJlY29yZHMgZm9yIGEgU1FMIGZ1bmN0aW9uLgogICoKQEAgLTQ2Niw4NSArNTEwLDEx NyBAQCBpbml0X2V4ZWN1dGlvbl9zdGF0ZShMaXN0ICpxdWVyeVRyZWVfbGlzdCwKIAkJCQkJIGJv b2wgbGF6eUV2YWxPSykKIHsKIAlMaXN0CSAgICplc2xpc3QgPSBOSUw7CisJTGlzdAkgICAqY3Bs YW5fbGlzdCA9IE5JTDsKIAlleGVjdXRpb25fc3RhdGUgKmxhc3R0YWdlcyA9IE5VTEw7CiAJTGlz dENlbGwgICAqbGMxOwogCiAJZm9yZWFjaChsYzEsIHF1ZXJ5VHJlZV9saXN0KQogCXsKLQkJTGlz dAkgICAqcXRsaXN0ID0gbGZpcnN0X25vZGUoTGlzdCwgbGMxKTsKKwkJTGlzdAkgICAqcXRsaXN0 OwogCQlleGVjdXRpb25fc3RhdGUgKmZpcnN0ZXMgPSBOVUxMOwogCQlleGVjdXRpb25fc3RhdGUg KnByZXZlcyA9IE5VTEw7CiAJCUxpc3RDZWxsICAgKmxjMjsKIAotCQlmb3JlYWNoKGxjMiwgcXRs aXN0KQorCQlpZiAoZmNhY2hlLT5wbGFuc291cmNlX2xpc3QpCiAJCXsKLQkJCVF1ZXJ5CSAgICpx dWVyeVRyZWUgPSBsZmlyc3Rfbm9kZShRdWVyeSwgbGMyKTsKLQkJCVBsYW5uZWRTdG10ICpzdG10 OwotCQkJZXhlY3V0aW9uX3N0YXRlICpuZXdlczsKKwkJCUNhY2hlZFBsYW4gKmNwbGFuOworCQkJ Q2FjaGVkUGxhblNvdXJjZSAqcGxhbnNvdXJjZTsKKwkJCWludAkJCWN1cl9pZHg7CiAKLQkJCS8q IFBsYW4gdGhlIHF1ZXJ5IGlmIG5lZWRlZCAqLwotCQkJaWYgKHF1ZXJ5VHJlZS0+Y29tbWFuZFR5 cGUgPT0gQ01EX1VUSUxJVFkpCi0JCQl7Ci0JCQkJLyogVXRpbGl0eSBjb21tYW5kcyByZXF1aXJl IG5vIHBsYW5uaW5nLiAqLwotCQkJCXN0bXQgPSBtYWtlTm9kZShQbGFubmVkU3RtdCk7Ci0JCQkJ c3RtdC0+Y29tbWFuZFR5cGUgPSBDTURfVVRJTElUWTsKLQkJCQlzdG10LT5jYW5TZXRUYWcgPSBx dWVyeVRyZWUtPmNhblNldFRhZzsKLQkJCQlzdG10LT51dGlsaXR5U3RtdCA9IHF1ZXJ5VHJlZS0+ dXRpbGl0eVN0bXQ7Ci0JCQkJc3RtdC0+c3RtdF9sb2NhdGlvbiA9IHF1ZXJ5VHJlZS0+c3RtdF9s b2NhdGlvbjsKLQkJCQlzdG10LT5zdG10X2xlbiA9IHF1ZXJ5VHJlZS0+c3RtdF9sZW47Ci0JCQkJ c3RtdC0+cXVlcnlJZCA9IHF1ZXJ5VHJlZS0+cXVlcnlJZDsKLQkJCX0KLQkJCWVsc2UKLQkJCQlz dG10ID0gcGdfcGxhbl9xdWVyeShxdWVyeVRyZWUsCi0JCQkJCQkJCQkgZmNhY2hlLT5zcmMsCi0J CQkJCQkJCQkgQ1VSU09SX09QVF9QQVJBTExFTF9PSywKLQkJCQkJCQkJCSBOVUxMKTsKKwkJCS8q IEZpbmQgcGxhbiBzb3VyY2UsIGNvcnJlc3BvbmRpbmcgdG8gdGhpcyBxdWVyeSBsaXN0ICovCisJ CQljdXJfaWR4ID0gZm9yZWFjaF9jdXJyZW50X2luZGV4KGxjMSk7CisJCQlwbGFuc291cmNlID0g bGlzdF9udGgoZmNhY2hlLT5wbGFuc291cmNlX2xpc3QsIGN1cl9pZHgpOwogCiAJCQkvKgotCQkJ ICogUHJlY2hlY2sgYWxsIGNvbW1hbmRzIGZvciB2YWxpZGl0eSBpbiBhIGZ1bmN0aW9uLiAgVGhp cyBzaG91bGQKLQkJCSAqIGdlbmVyYWxseSBtYXRjaCB0aGUgcmVzdHJpY3Rpb25zIHNwaS5jIGFw cGxpZXMuCisJCQkgKiBHZXQgcGxhbiBmb3IgdGhlIHF1ZXJ5LiBJZiBwYXJhbUxJIGlzIHNldCwg d2UgY2FuIGdldCBjdXN0b20KKwkJCSAqIHBsYW4KIAkJCSAqLwotCQkJaWYgKHN0bXQtPmNvbW1h bmRUeXBlID09IENNRF9VVElMSVRZKQorCQkJY3BsYW4gPSBHZXRDYWNoZWRQbGFuKHBsYW5zb3Vy Y2UsIGZjYWNoZS0+cGFyYW1MSSwgTlVMTCwgTlVMTCk7CisKKwkJCS8qIFJlY29yZCBjcGxhbiBp biBwbGFuIGxpc3QgdG8gYmUgcmVsZWFzZWQgb24gcmVwbGFubmluZyAqLworCQkJY3BsYW5fbGlz dCA9IGxhcHBlbmQoY3BsYW5fbGlzdCwgY3BsYW4pOworCisJCQkvKiBGb3IgZWFjaCBwbGFubmVk IHN0YXRlbWVudCBjcmVhdGUgZXhlY3V0aW9uIHN0YXRlICovCisJCQlmb3JlYWNoKGxjMiwgY3Bs YW4tPnN0bXRfbGlzdCkKIAkJCXsKLQkJCQlpZiAoSXNBKHN0bXQtPnV0aWxpdHlTdG10LCBDb3B5 U3RtdCkgJiYKLQkJCQkJKChDb3B5U3RtdCAqKSBzdG10LT51dGlsaXR5U3RtdCktPmZpbGVuYW1l ID09IE5VTEwpCi0JCQkJCWVyZXBvcnQoRVJST1IsCi0JCQkJCQkJKGVycmNvZGUoRVJSQ09ERV9G RUFUVVJFX05PVF9TVVBQT1JURUQpLAotCQkJCQkJCSBlcnJtc2coImNhbm5vdCBDT1BZIHRvL2Zy b20gY2xpZW50IGluIGFuIFNRTCBmdW5jdGlvbiIpKSk7CisJCQkJUGxhbm5lZFN0bXQgKnN0bXQg PSBsZmlyc3QobGMyKTsKKwkJCQlleGVjdXRpb25fc3RhdGUgKm5ld2VzOwogCi0JCQkJaWYgKElz QShzdG10LT51dGlsaXR5U3RtdCwgVHJhbnNhY3Rpb25TdG10KSkKLQkJCQkJZXJlcG9ydChFUlJP UiwKLQkJCQkJCQkoZXJyY29kZShFUlJDT0RFX0ZFQVRVUkVfTk9UX1NVUFBPUlRFRCksCi0JCQkJ CS8qIHRyYW5zbGF0b3I6ICVzIGlzIGEgU1FMIHN0YXRlbWVudCBuYW1lICovCi0JCQkJCQkJIGVy cm1zZygiJXMgaXMgbm90IGFsbG93ZWQgaW4gYW4gU1FMIGZ1bmN0aW9uIiwKLQkJCQkJCQkJCUNy ZWF0ZUNvbW1hbmROYW1lKHN0bXQtPnV0aWxpdHlTdG10KSkpKTsKKwkJCQkvKiBDaGVjayB0aGF0 IHN0bXQgaXMgdmFsaWQgZm9yIFNRTCBmdW5jdGlvbiAqLworCQkJCWNoZWNrX3BsYW5uZWRfc3Rt dChzdG10LCBmY2FjaGUpOworCisJCQkJbmV3ZXMgPSAoZXhlY3V0aW9uX3N0YXRlICopIHBhbGxv YyhzaXplb2YoZXhlY3V0aW9uX3N0YXRlKSk7CisKKwkJCQlpZiAocHJldmVzKQorCQkJCQlwcmV2 ZXMtPm5leHQgPSBuZXdlczsKKwkJCQllbHNlCisJCQkJCWZpcnN0ZXMgPSBuZXdlczsKKworCQkJ CW5ld2VzLT5uZXh0ID0gTlVMTDsKKwkJCQluZXdlcy0+c3RhdHVzID0gRl9FWEVDX1NUQVJUOwor CQkJCW5ld2VzLT5zZXRzUmVzdWx0ID0gZmFsc2U7CS8qIG1pZ2h0IGNoYW5nZSBiZWxvdyAqLwor CQkJCW5ld2VzLT5sYXp5RXZhbCA9IGZhbHNlOwkvKiBtaWdodCBjaGFuZ2UgYmVsb3cgKi8KKwkJ CQluZXdlcy0+c3RtdCA9IHN0bXQ7CisJCQkJbmV3ZXMtPnFkID0gTlVMTDsKKworCQkJCWlmIChz dG10LT5jYW5TZXRUYWcpCisJCQkJCWxhc3R0YWdlcyA9IG5ld2VzOworCisJCQkJcHJldmVzID0g bmV3ZXM7CiAJCQl9CisJCX0KKwkJZWxzZQorCQl7CisJCQlxdGxpc3QgPSBsZmlyc3Rfbm9kZShM aXN0LCBsYzEpOwogCi0JCQlpZiAoZmNhY2hlLT5yZWFkb25seV9mdW5jICYmICFDb21tYW5kSXNS ZWFkT25seShzdG10KSkKLQkJCQllcmVwb3J0KEVSUk9SLAotCQkJCQkJKGVycmNvZGUoRVJSQ09E RV9GRUFUVVJFX05PVF9TVVBQT1JURUQpLAotCQkJCS8qIHRyYW5zbGF0b3I6ICVzIGlzIGEgU1FM IHN0YXRlbWVudCBuYW1lICovCi0JCQkJCQkgZXJybXNnKCIlcyBpcyBub3QgYWxsb3dlZCBpbiBh IG5vbi12b2xhdGlsZSBmdW5jdGlvbiIsCi0JCQkJCQkJCUNyZWF0ZUNvbW1hbmROYW1lKChOb2Rl ICopIHN0bXQpKSkpOwotCi0JCQkvKiBPSywgYnVpbGQgdGhlIGV4ZWN1dGlvbl9zdGF0ZSBmb3Ig dGhpcyBxdWVyeSAqLwotCQkJbmV3ZXMgPSAoZXhlY3V0aW9uX3N0YXRlICopIHBhbGxvYyhzaXpl b2YoZXhlY3V0aW9uX3N0YXRlKSk7Ci0JCQlpZiAocHJldmVzKQotCQkJCXByZXZlcy0+bmV4dCA9 IG5ld2VzOwotCQkJZWxzZQotCQkJCWZpcnN0ZXMgPSBuZXdlczsKKwkJCWZvcmVhY2gobGMyLCBx dGxpc3QpCisJCQl7CisJCQkJUXVlcnkJICAgKnF1ZXJ5VHJlZSA9IGxmaXJzdF9ub2RlKFF1ZXJ5 LCBsYzIpOworCQkJCVBsYW5uZWRTdG10ICpzdG10OworCQkJCWV4ZWN1dGlvbl9zdGF0ZSAqbmV3 ZXM7CisKKwkJCQkvKiBQbGFuIHRoZSBxdWVyeSBpZiBuZWVkZWQgKi8KKwkJCQlpZiAocXVlcnlU cmVlLT5jb21tYW5kVHlwZSA9PSBDTURfVVRJTElUWSkKKwkJCQl7CisJCQkJCS8qIFV0aWxpdHkg Y29tbWFuZHMgcmVxdWlyZSBubyBwbGFubmluZy4gKi8KKwkJCQkJc3RtdCA9IG1ha2VOb2RlKFBs YW5uZWRTdG10KTsKKwkJCQkJc3RtdC0+Y29tbWFuZFR5cGUgPSBDTURfVVRJTElUWTsKKwkJCQkJ c3RtdC0+Y2FuU2V0VGFnID0gcXVlcnlUcmVlLT5jYW5TZXRUYWc7CisJCQkJCXN0bXQtPnV0aWxp dHlTdG10ID0gcXVlcnlUcmVlLT51dGlsaXR5U3RtdDsKKwkJCQkJc3RtdC0+c3RtdF9sb2NhdGlv biA9IHF1ZXJ5VHJlZS0+c3RtdF9sb2NhdGlvbjsKKwkJCQkJc3RtdC0+c3RtdF9sZW4gPSBxdWVy eVRyZWUtPnN0bXRfbGVuOworCQkJCQlzdG10LT5xdWVyeUlkID0gcXVlcnlUcmVlLT5xdWVyeUlk OworCQkJCX0KKwkJCQllbHNlCisJCQkJeworCQkJCQkvKiBHZXQgZ2VuZXJpYyBwbGFuIGZvciB0 aGUgcXVlcnkgKi8KKwkJCQkJc3RtdCA9IHBnX3BsYW5fcXVlcnkocXVlcnlUcmVlLAorCQkJCQkJ CQkJCSBmY2FjaGUtPnNyYywKKwkJCQkJCQkJCQkgQ1VSU09SX09QVF9QQVJBTExFTF9PSywKKwkJ CQkJCQkJCQkgTlVMTCk7CisJCQkJfQorCisJCQkJLyogQ2hlY2sgdGhhdCBzdG10IGlzIHZhbGlk IGZvciBTUUwgZnVuY3Rpb24gKi8KKwkJCQljaGVja19wbGFubmVkX3N0bXQoc3RtdCwgZmNhY2hl KTsKIAotCQkJbmV3ZXMtPm5leHQgPSBOVUxMOwotCQkJbmV3ZXMtPnN0YXR1cyA9IEZfRVhFQ19T VEFSVDsKLQkJCW5ld2VzLT5zZXRzUmVzdWx0ID0gZmFsc2U7CS8qIG1pZ2h0IGNoYW5nZSBiZWxv dyAqLwotCQkJbmV3ZXMtPmxhenlFdmFsID0gZmFsc2U7CS8qIG1pZ2h0IGNoYW5nZSBiZWxvdyAq LwotCQkJbmV3ZXMtPnN0bXQgPSBzdG10OwotCQkJbmV3ZXMtPnFkID0gTlVMTDsKKwkJCQluZXdl cyA9IChleGVjdXRpb25fc3RhdGUgKikgcGFsbG9jKHNpemVvZihleGVjdXRpb25fc3RhdGUpKTsK KwkJCQlpZiAocHJldmVzKQorCQkJCQlwcmV2ZXMtPm5leHQgPSBuZXdlczsKKwkJCQllbHNlCisJ CQkJCWZpcnN0ZXMgPSBuZXdlczsKKworCQkJCW5ld2VzLT5uZXh0ID0gTlVMTDsKKwkJCQluZXdl cy0+c3RhdHVzID0gRl9FWEVDX1NUQVJUOworCQkJCW5ld2VzLT5zZXRzUmVzdWx0ID0gZmFsc2U7 CS8qIG1pZ2h0IGNoYW5nZSBiZWxvdyAqLworCQkJCW5ld2VzLT5sYXp5RXZhbCA9IGZhbHNlOwkv KiBtaWdodCBjaGFuZ2UgYmVsb3cgKi8KKwkJCQluZXdlcy0+c3RtdCA9IHN0bXQ7CisJCQkJbmV3 ZXMtPnFkID0gTlVMTDsKIAotCQkJaWYgKHF1ZXJ5VHJlZS0+Y2FuU2V0VGFnKQotCQkJCWxhc3R0 YWdlcyA9IG5ld2VzOworCQkJCWlmIChxdWVyeVRyZWUtPmNhblNldFRhZykKKwkJCQkJbGFzdHRh Z2VzID0gbmV3ZXM7CiAKLQkJCXByZXZlcyA9IG5ld2VzOworCQkJCXByZXZlcyA9IG5ld2VzOwor CQkJfQogCQl9CiAKIAkJZXNsaXN0ID0gbGFwcGVuZChlc2xpc3QsIGZpcnN0ZXMpOwpAQCAtNTcz LDYgKzY0OSw3IEBAIGluaXRfZXhlY3V0aW9uX3N0YXRlKExpc3QgKnF1ZXJ5VHJlZV9saXN0LAog CQkJZmNhY2hlLT5sYXp5RXZhbCA9IGxhc3R0YWdlcy0+bGF6eUV2YWwgPSB0cnVlOwogCX0KIAor CWZjYWNoZS0+Y3BsYW5fbGlzdCA9IGNwbGFuX2xpc3Q7CiAJcmV0dXJuIGVzbGlzdDsKIH0KIApA QCAtNTk2LDYgKzY3Myw3IEBAIGluaXRfc3FsX2ZjYWNoZShGdW5jdGlvbkNhbGxJbmZvIGZjaW5m bywgT2lkIGNvbGxhdGlvbiwgYm9vbCBsYXp5RXZhbE9LKQogCUxpc3RDZWxsICAgKmxjOwogCURh dHVtCQl0bXA7CiAJYm9vbAkJaXNOdWxsOworCUxpc3QJICAgKnBsYW5zb3VyY2VfbGlzdDsKIAog CS8qCiAJICogQ3JlYXRlIG1lbW9yeSBjb250ZXh0IHRoYXQgaG9sZHMgYWxsIHRoZSBTUUxGdW5j dGlvbkNhY2hlIGRhdGEuICBJdApAQCAtNjgwLDYgKzc1OCw3IEBAIGluaXRfc3FsX2ZjYWNoZShG dW5jdGlvbkNhbGxJbmZvIGZjaW5mbywgT2lkIGNvbGxhdGlvbiwgYm9vbCBsYXp5RXZhbE9LKQog CSAqIHBsYW5jYWNoZS5jLgogCSAqLwogCXF1ZXJ5VHJlZV9saXN0ID0gTklMOworCXBsYW5zb3Vy Y2VfbGlzdCA9IE5JTDsKIAlpZiAoIWlzTnVsbCkKIAl7CiAJCU5vZGUJICAgKm47CkBAIC03MTEs NiArNzkwLDE0IEBAIGluaXRfc3FsX2ZjYWNoZShGdW5jdGlvbkNhbGxJbmZvIGZjaW5mbywgT2lk IGNvbGxhdGlvbiwgYm9vbCBsYXp5RXZhbE9LKQogCQl7CiAJCQlSYXdTdG10ICAgICpwYXJzZXRy ZWUgPSBsZmlyc3Rfbm9kZShSYXdTdG10LCBsYyk7CiAJCQlMaXN0CSAgICpxdWVyeVRyZWVfc3Vi bGlzdDsKKwkJCUNhY2hlZFBsYW5Tb3VyY2UgKnBsYW5zb3VyY2U7CisKKwkJCS8qIEFsYXMsIHdl IGNhbiBjcmVhdGUgY3VzdG9tIHBsYW5zIG9ubHkgZm9yIFJhd1N0bXQgKi8KKwkJCWlmIChlbmFi bGVfc3FsX2Z1bmNfY3VzdG9tX3BsYW5zKQorCQkJeworCQkJCXBsYW5zb3VyY2UgPSBDcmVhdGVD YWNoZWRQbGFuKHBhcnNldHJlZSwgZmNhY2hlLT5zcmMsIENyZWF0ZUNvbW1hbmRUYWcocGFyc2V0 cmVlLT5zdG10KSk7CisJCQkJcGxhbnNvdXJjZV9saXN0ID0gbGFwcGVuZChwbGFuc291cmNlX2xp c3QsIHBsYW5zb3VyY2UpOworCQkJfQogCiAJCQlxdWVyeVRyZWVfc3VibGlzdCA9IHBnX2FuYWx5 emVfYW5kX3Jld3JpdGVfd2l0aGNiKHBhcnNldHJlZSwKIAkJCQkJCQkJCQkJCQkJCSAgZmNhY2hl LT5zcmMsCkBAIC03NTEsNiArODM4LDM0IEBAIGluaXRfc3FsX2ZjYWNoZShGdW5jdGlvbkNhbGxJ bmZvIGZjaW5mbywgT2lkIGNvbGxhdGlvbiwgYm9vbCBsYXp5RXZhbE9LKQogCQkJCQkJCQkJCQkg ICBmYWxzZSwKIAkJCQkJCQkJCQkJICAgJnJlc3VsdHRsaXN0KTsKIAorCS8qCisJICogUXVlcmll cyBjb3VsZCBiZSByZXdyaXR0ZW4gYnkgY2hlY2tfc3FsX2ZuX3JldHZhbCgpLiBOb3cgd2hlbiB0 aGV5IGhhdmUKKwkgKiB0aGVpciBmaW5hbCBmb3JtLCB3ZSBjYW4gY29tcGxldGUgcGxhbiBjYWNo ZSBlbnRyeSBjcmVhdGlvbi4KKwkgKi8KKwlpZiAocGxhbnNvdXJjZV9saXN0ICE9IE5JTCkKKwl7 CisJCUxpc3RDZWxsICAgKnFsYzsKKwkJTGlzdENlbGwgICAqcGxjOworCisJCWZvcmJvdGgocWxj LCBxdWVyeVRyZWVfbGlzdCwgcGxjLCBwbGFuc291cmNlX2xpc3QpCisJCXsKKwkJCUxpc3QJICAg KnF1ZXJ5VHJlZV9zdWJsaXN0ID0gbGZpcnN0KHFsYyk7CisJCQlDYWNoZWRQbGFuU291cmNlICpw bGFuc291cmNlID0gbGZpcnN0KHBsYyk7CisKKworCQkJLyogRmluaXNoIGZpbGxpbmcgaW4gdGhl IENhY2hlZFBsYW5Tb3VyY2UgKi8KKwkJCUNvbXBsZXRlQ2FjaGVkUGxhbihwbGFuc291cmNlLAor CQkJCQkJCSAgIHF1ZXJ5VHJlZV9zdWJsaXN0LAorCQkJCQkJCSAgIE5VTEwsCisJCQkJCQkJICAg TlVMTCwKKwkJCQkJCQkgICAwLAorCQkJCQkJCSAgIChQYXJzZXJTZXR1cEhvb2spIHNxbF9mbl9w YXJzZXJfc2V0dXAsCisJCQkJCQkJICAgZmNhY2hlLT5waW5mbywKKwkJCQkJCQkgICBDVVJTT1Jf T1BUX1BBUkFMTEVMX09LIHwgQ1VSU09SX09QVF9OT19TQ1JPTEwsCisJCQkJCQkJICAgZmFsc2Up OworCQl9CisJfQorCiAJLyoKIAkgKiBDb25zdHJ1Y3QgYSBKdW5rRmlsdGVyIHdlIGNhbiB1c2Ug dG8gY29lcmNlIHRoZSByZXR1cm5lZCByb3d0eXBlIHRvIHRoZQogCSAqIGRlc2lyZWQgZm9ybSwg dW5sZXNzIHRoZSByZXN1bHQgdHlwZSBpcyBWT0lELCBpbiB3aGljaCBjYXNlIHRoZXJlJ3MKQEAg LTc5NSwxMCArOTEwLDE4IEBAIGluaXRfc3FsX2ZjYWNoZShGdW5jdGlvbkNhbGxJbmZvIGZjaW5m bywgT2lkIGNvbGxhdGlvbiwgYm9vbCBsYXp5RXZhbE9LKQogCQlsYXp5RXZhbE9LID0gdHJ1ZTsK IAl9CiAKLQkvKiBGaW5hbGx5LCBwbGFuIHRoZSBxdWVyaWVzICovCi0JZmNhY2hlLT5mdW5jX3N0 YXRlID0gaW5pdF9leGVjdXRpb25fc3RhdGUocXVlcnlUcmVlX2xpc3QsCi0JCQkJCQkJCQkJCSAg ZmNhY2hlLAotCQkJCQkJCQkJCQkgIGxhenlFdmFsT0spOworCWZjYWNoZS0+cXVlcnlUcmVlX2xp c3QgPSBxdWVyeVRyZWVfbGlzdDsKKwlmY2FjaGUtPnBsYW5zb3VyY2VfbGlzdCA9IHBsYW5zb3Vy Y2VfbGlzdDsKKworCS8qCisJICogRmluYWxseSwgcGxhbiB0aGUgcXVlcmllcy4gU2tpcCBwbGFu bmluZyBpZiB3ZSB1c2UgY2FjaGVkIHBsYW5zCisJICogbWFjaGluZXJ5IC0gYW55d2F5IHdlJ2xs IGhhdmUgdG8gcmVwbGFuIG9uIHRoZSBmaXJzdCBydW4gd2hlbgorCSAqIHBhcmFtZXRlcnMgYXJl IHN1YnN0aXR1dGVkLgorCSAqLworCWlmIChwbGFuc291cmNlX2xpc3QgPT0gTklMKQorCQlmY2Fj aGUtPmZ1bmNfc3RhdGUgPSBpbml0X2V4ZWN1dGlvbl9zdGF0ZShxdWVyeVRyZWVfbGlzdCwKKwkJ CQkJCQkJCQkJCSAgZmNhY2hlLAorCQkJCQkJCQkJCQkJICBsYXp5RXZhbE9LKTsKIAogCS8qIE1h cmsgZmNhY2hlIHdpdGggdGltZSBvZiBjcmVhdGlvbiB0byBzaG93IGl0J3MgdmFsaWQgKi8KIAlm Y2FjaGUtPmx4aWQgPSBNeVByb2MtPnZ4aWQubHhpZDsKQEAgLTk2OSw3ICsxMDkyLDEzIEBAIHBv c3RxdWVsX3N1Yl9wYXJhbXMoU1FMRnVuY3Rpb25DYWNoZVB0ciBmY2FjaGUsCiAJCQlwcm0tPnZh bHVlID0gTWFrZUV4cGFuZGVkT2JqZWN0UmVhZE9ubHkoZmNpbmZvLT5hcmdzW2ldLnZhbHVlLAog CQkJCQkJCQkJCQkJCXBybS0+aXNudWxsLAogCQkJCQkJCQkJCQkJCWdldF90eXBsZW4oYXJndHlw ZXNbaV0pKTsKLQkJCXBybS0+cGZsYWdzID0gMDsKKworCQkJLyoKKwkJCSAqIFBBUkFNX0ZMQUdf Q09OU1QgaXMgbmVjZXNzYXJ5IHRvIGJ1aWxkIGVmZmljaWVudCBjdXN0b20gcGxhbi4KKwkJCSAq LworCQkJaWYgKGZjYWNoZS0+cGxhbnNvdXJjZV9saXN0KQorCQkJCXBybS0+cGZsYWdzID0gUEFS QU1fRkxBR19DT05TVDsKKwogCQkJcHJtLT5wdHlwZSA9IGFyZ3R5cGVzW2ldOwogCQl9CiAJfQpA QCAtMTAyMiw2ICsxMTUxLDMzIEBAIHBvc3RxdWVsX2dldF9zaW5nbGVfcmVzdWx0KFR1cGxlVGFi bGVTbG90ICpzbG90LAogCXJldHVybiB2YWx1ZTsKIH0KIAorLyoKKyAqIFJlbGVhc2UgcGxhbnMu IFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIHByaW9yIHRvIHBsYW5uaW5nCisgKiBzdGF0ZW1lbnRz IHdpdGggbmV3IHBhcmFtZXRlcnMuIFdoZW4gY3VzdG9tIHBsYW5zIGFyZSBnZW5lcmF0ZWQKKyAq IGZvciBlYWNoIGZ1bmN0aW9uIGNhbGwgaW4gYSBzdGF0ZW1lbnQsIHRoZXkgY2FuIGNvbnN1bWUg dG9vIG11Y2ggbWVtb3J5LCBzbworICogcmVsZWFzZSB0aGVtLiBHZW5lcmljIHBsYW5zIHdpbGwg c3Vydml2ZSBpdCBhcyBwbGFuc291cmNlIGhvbGRzCisgKiByZWZlcmVuY2UgdG8gYSBnZW5lcmlj IHBsYW4uCisgKi8KK3N0YXRpYyB2b2lkCityZWxlYXNlX3BsYW5zKExpc3QgKmNwbGFucykKK3sK KwlMaXN0Q2VsbCAgICpsYzsKKworCS8qCisJICogV2Ugc3VwcG9ydCBzZXBhcmF0ZSBwbGFuIGxp c3QsIHNvIHRoYXQgd2UgdmlzaXQgZWFjaCBwbGFuIGhlcmUgb25seQorCSAqIG9uY2UKKwkgKi8K Kwlmb3JlYWNoKGxjLCBjcGxhbnMpCisJeworCQlDYWNoZWRQbGFuICpjcGxhbiA9IGxmaXJzdChs Yyk7CisKKwkJUmVsZWFzZUNhY2hlZFBsYW4oY3BsYW4sIE5VTEwpOworCX0KKworCS8qIENsZWFu dXAgdGhlIGxpc3QgaXRzZWxmICovCisJbGlzdF9mcmVlKGNwbGFucyk7Cit9CisKIC8qCiAgKiBm bWdyX3NxbDogZnVuY3Rpb24gY2FsbCBtYW5hZ2VyIGZvciBTUUwgZnVuY3Rpb25zCiAgKi8KQEAg LTEwNDAsNiArMTE5Niw3IEBAIGZtZ3Jfc3FsKFBHX0ZVTkNUSU9OX0FSR1MpCiAJRGF0dW0JCXJl c3VsdDsKIAlMaXN0CSAgICplc2xpc3Q7CiAJTGlzdENlbGwgICAqZXNsYzsKKwlib29sCQlidWls ZF9jYWNoZWRfcGxhbnMgPSBmYWxzZTsKIAogCS8qCiAJICogU2V0dXAgZXJyb3IgdHJhY2ViYWNr IHN1cHBvcnQgZm9yIGVyZXBvcnQoKQpAQCAtMTEyOSwxMiArMTI4NiwzNSBAQCBmbWdyX3NxbChQ R19GVU5DVElPTl9BUkdTKQogCQkJYnJlYWs7CiAJfQogCisJLyoKKwkgKiBXZSBjb3VsZCBza2lw IGFjdHVhbCBwbGFubmluZyBpZiBkZWNpZGVkIHRvIHVzZSBjYWNoZWQgcGxhbnMuIEluIHRoaXMK KwkgKiBjYXNlIHdlIGhhdmUgdG8gYnVpbGQgY2FjaGVkIHBsYW5zIG5vdy4KKwkgKi8KKwlpZiAo ZmNhY2hlLT5wbGFuc291cmNlX2xpc3QgIT0gTklMICYmIGVzbGlzdCA9PSBOSUwpCisJCWJ1aWxk X2NhY2hlZF9wbGFucyA9IHRydWU7CisKIAkvKgogCSAqIENvbnZlcnQgcGFyYW1zIHRvIGFwcHJv cHJpYXRlIGZvcm1hdCBpZiBzdGFydGluZyBhIGZyZXNoIGV4ZWN1dGlvbi4gKElmCiAJICogY29u dGludWluZyBleGVjdXRpb24sIHdlIGNhbiByZS11c2UgcHJpb3IgcGFyYW1zLikKIAkgKi8KLQlp ZiAoaXNfZmlyc3QgJiYgZXMgJiYgZXMtPnN0YXR1cyA9PSBGX0VYRUNfU1RBUlQpCisJaWYgKChp c19maXJzdCAmJiBlcyAmJiBlcy0+c3RhdHVzID09IEZfRVhFQ19TVEFSVCkgfHwgYnVpbGRfY2Fj aGVkX3BsYW5zKQorCXsKIAkJcG9zdHF1ZWxfc3ViX3BhcmFtcyhmY2FjaGUsIGZjaW5mbyk7CisJ CWlmIChmY2FjaGUtPnBsYW5zb3VyY2VfbGlzdCkKKwkJeworCQkJLyogcmVwbGFuIHRoZSBxdWVy aWVzICovCisJCQlyZWxlYXNlX3BsYW5zKGZjYWNoZS0+Y3BsYW5fbGlzdCk7CisJCQlsaXN0X2Zy ZWVfZGVlcChmY2FjaGUtPmZ1bmNfc3RhdGUpOworCisJCQlmY2FjaGUtPmZ1bmNfc3RhdGUgPSBp bml0X2V4ZWN1dGlvbl9zdGF0ZShmY2FjaGUtPnF1ZXJ5VHJlZV9saXN0LAorCQkJCQkJCQkJCQkJ CSAgZmNhY2hlLAorCQkJCQkJCQkJCQkJCSAgbGF6eUV2YWxPSyk7CisJCQkvKiByZXN0b3JlIGV4 ZWN1dGlvbiBzdGF0ZSBhbmQgZXNsaXN0LXJlbGF0ZWQgdmFyaWFibGVzICovCisJCQllc2xpc3Qg PSBmY2FjaGUtPmZ1bmNfc3RhdGU7CisJCQllc2xjID0gbGlzdF9oZWFkKGVzbGlzdCk7CisJCQll cyA9IGxpbml0aWFsKGZjYWNoZS0+ZnVuY19zdGF0ZSk7CisJCX0KKwl9CiAKIAkvKgogCSAqIEJ1 aWxkIHR1cGxlc3RvcmUgdG8gaG9sZCByZXN1bHRzLCBpZiB3ZSBkb24ndCBoYXZlIG9uZSBhbHJl YWR5LiBOb3RlCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Y190YWJsZXMu YyBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjX3RhYmxlcy5jCmluZGV4IDUyMWVjNTU5MWM4 Li44ZjY2ZDVmZjlmZSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWNfdGFi bGVzLmMKKysrIGIvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWNfdGFibGVzLmMKQEAgLTQ2LDYg KzQ2LDcgQEAKICNpbmNsdWRlICJjb21tYW5kcy92YWN1dW0uaCIKICNpbmNsdWRlICJjb21tb24v ZmlsZV91dGlscy5oIgogI2luY2x1ZGUgImNvbW1vbi9zY3JhbS1jb21tb24uaCIKKyNpbmNsdWRl ICJleGVjdXRvci9mdW5jdGlvbnMuaCIKICNpbmNsdWRlICJqaXQvaml0LmgiCiAjaW5jbHVkZSAi bGlicHEvYXV0aC5oIgogI2luY2x1ZGUgImxpYnBxL2xpYnBxLmgiCkBAIC05NzYsNiArOTc3LDE3 IEBAIHN0cnVjdCBjb25maWdfYm9vbCBDb25maWd1cmVOYW1lc0Jvb2xbXSA9CiAJCXRydWUsCiAJ CU5VTEwsIE5VTEwsIE5VTEwKIAl9LAorCXsKKwkJeyJlbmFibGVfc3FsX2Z1bmNfY3VzdG9tX3Bs YW5zIiwgUEdDX1VTRVJTRVQsIFFVRVJZX1RVTklOR19NRVRIT0QsCisJCQlnZXR0ZXh0X25vb3Ao IkVuYWJsZSBwbGFuIGNhY2hlIG1hY2hpbmVyeSBhbmQgY3VzdG9tIHBsYW5zIGZvciAiCisJCQkJ CQkgIlNRTCBsYW5ndWFnZSBmdW5jdGlvbnMuIiksCisJCQlOVUxMLAorCQkJR1VDX05PVF9JTl9T QU1QTEUgfCBHVUNfRVhQTEFJTgorCQl9LAorCQkmZW5hYmxlX3NxbF9mdW5jX2N1c3RvbV9wbGFu cywKKwkJdHJ1ZSwKKwkJTlVMTCwgTlVMTCwgTlVMTAorCX0sCiAJewogCQl7ImVuYWJsZV9hc3lu Y19hcHBlbmQiLCBQR0NfVVNFUlNFVCwgUVVFUllfVFVOSU5HX01FVEhPRCwKIAkJCWdldHRleHRf bm9vcCgiRW5hYmxlcyB0aGUgcGxhbm5lcidzIHVzZSBvZiBhc3luYyBhcHBlbmQgcGxhbnMuIiks CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9leGVjdXRvci9mdW5jdGlvbnMuaCBiL3NyYy9pbmNs dWRlL2V4ZWN1dG9yL2Z1bmN0aW9ucy5oCmluZGV4IDI3Zjk0OGM2ZjUyLi44ZjM4MDVkNzc4MiAx MDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvZXhlY3V0b3IvZnVuY3Rpb25zLmgKKysrIGIvc3JjL2lu Y2x1ZGUvZXhlY3V0b3IvZnVuY3Rpb25zLmgKQEAgLTUzLDQgKzUzLDYgQEAgZXh0ZXJuIGJvb2wg Y2hlY2tfc3FsX2ZuX3JldHZhbChMaXN0ICpxdWVyeVRyZWVMaXN0cywKIAogZXh0ZXJuIERlc3RS ZWNlaXZlciAqQ3JlYXRlU1FMRnVuY3Rpb25EZXN0UmVjZWl2ZXIodm9pZCk7CiAKK2V4dGVybiBQ R0RMTElNUE9SVCBib29sIGVuYWJsZV9zcWxfZnVuY19jdXN0b21fcGxhbnM7CisKICNlbmRpZgkJ CQkJCQkvKiBGVU5DVElPTlNfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvcmVncmVzcy9leHBl Y3RlZC9wbHBnc3FsLm91dCBiL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvcGxwZ3NxbC5vdXQK aW5kZXggMDc0YWY4ZjMzYTguLmMxYTYyOTcwNDNlIDEwMDY0NAotLS0gYS9zcmMvdGVzdC9yZWdy ZXNzL2V4cGVjdGVkL3BscGdzcWwub3V0CisrKyBiL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQv cGxwZ3NxbC5vdXQKQEAgLTQ0NzQsNyArNDQ3NCw3IEBAIGNyZWF0ZSB0YWJsZSBwdWJsaWMuc3R1 ZmZzIChzdHVmZiB0ZXh0KTsKIFNBVkVQT0lOVCBhOwogc2VsZWN0IGVycm9yMignbm9uZXhpc3Rl bnQuc3R1ZmZzJyk7CiBFUlJPUjogIHNjaGVtYSAibm9uZXhpc3RlbnQiIGRvZXMgbm90IGV4aXN0 Ci1DT05URVhUOiAgU1FMIGZ1bmN0aW9uICJlcnJvcjEiIHN0YXRlbWVudCAxCitDT05URVhUOiAg U1FMIGZ1bmN0aW9uICJlcnJvcjEiIGR1cmluZyBzdGFydHVwCiBQTC9wZ1NRTCBmdW5jdGlvbiBl cnJvcjIodGV4dCkgbGluZSAzIGF0IFJFVFVSTgogUk9MTEJBQ0sgVE8gYTsKIHNlbGVjdCBlcnJv cjIoJ3B1YmxpYy5zdHVmZnMnKTsKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0 ZWQvc2VsZWN0X3BhcmFsbGVsLm91dCBiL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvc2VsZWN0 X3BhcmFsbGVsLm91dAppbmRleCBjNTY1NDA3MDgyYy4uNGExYzJlNTNiYmEgMTAwNjQ0Ci0tLSBh L3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvc2VsZWN0X3BhcmFsbGVsLm91dAorKysgYi9zcmMv dGVzdC9yZWdyZXNzL2V4cGVjdGVkL3NlbGVjdF9wYXJhbGxlbC5vdXQKQEAgLTEzNzAsNyArMTM3 MCw3IEBAIHNlbGVjdCBzZXRfYW5kX3JlcG9ydF9yb2xlKCk7CiAKIHNlbGVjdCBzZXRfcm9sZV9h bmRfZXJyb3IoMCk7CiBFUlJPUjogIGRpdmlzaW9uIGJ5IHplcm8KLUNPTlRFWFQ6ICBTUUwgZnVu Y3Rpb24gInNldF9yb2xlX2FuZF9lcnJvciIgc3RhdGVtZW50IDEKK0NPTlRFWFQ6ICBTUUwgZnVu Y3Rpb24gInNldF9yb2xlX2FuZF9lcnJvciIgZHVyaW5nIHN0YXJ0dXAKIHNldCBkZWJ1Z19wYXJh bGxlbF9xdWVyeSA9IDE7CiBzZWxlY3Qgc2V0X2FuZF9yZXBvcnRfcm9sZSgpOwogICAgc2V0X2Fu ZF9yZXBvcnRfcm9sZSAgIApAQCAtMTM4MCw3ICsxMzgwLDcgQEAgc2VsZWN0IHNldF9hbmRfcmVw b3J0X3JvbGUoKTsKIAogc2VsZWN0IHNldF9yb2xlX2FuZF9lcnJvcigwKTsKIEVSUk9SOiAgZGl2 aXNpb24gYnkgemVybwotQ09OVEVYVDogIFNRTCBmdW5jdGlvbiAic2V0X3JvbGVfYW5kX2Vycm9y IiBzdGF0ZW1lbnQgMQorQ09OVEVYVDogIFNRTCBmdW5jdGlvbiAic2V0X3JvbGVfYW5kX2Vycm9y IiBkdXJpbmcgc3RhcnR1cAogcGFyYWxsZWwgd29ya2VyCiByZXNldCBkZWJ1Z19wYXJhbGxlbF9x dWVyeTsKIGRyb3AgZnVuY3Rpb24gc2V0X2FuZF9yZXBvcnRfcm9sZSgpOwpkaWZmIC0tZ2l0IGEv c3JjL3Rlc3QvcmVncmVzcy9leHBlY3RlZC9zeXN2aWV3cy5vdXQgYi9zcmMvdGVzdC9yZWdyZXNz L2V4cGVjdGVkL3N5c3ZpZXdzLm91dAppbmRleCBmYWQ3ZmMzYTdlMC4uNDhkZjA4OGQ1NjggMTAw NjQ0Ci0tLSBhL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvc3lzdmlld3Mub3V0CisrKyBiL3Ny Yy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvc3lzdmlld3Mub3V0CkBAIC0xNjksOCArMTY5LDkgQEAg c2VsZWN0IG5hbWUsIHNldHRpbmcgZnJvbSBwZ19zZXR0aW5ncyB3aGVyZSBuYW1lIGxpa2UgJ2Vu YWJsZSUnOwogIGVuYWJsZV9wcmVzb3J0ZWRfYWdncmVnYXRlICAgICB8IG9uCiAgZW5hYmxlX3Nl cXNjYW4gICAgICAgICAgICAgICAgIHwgb24KICBlbmFibGVfc29ydCAgICAgICAgICAgICAgICAg ICAgfCBvbgorIGVuYWJsZV9zcWxfZnVuY19jdXN0b21fcGxhbnMgICB8IG9uCiAgZW5hYmxlX3Rp ZHNjYW4gICAgICAgICAgICAgICAgIHwgb24KLSgyMiByb3dzKQorKDIzIHJvd3MpCiAKIC0tIFRo ZXJlIGFyZSBhbHdheXMgd2FpdCBldmVudCBkZXNjcmlwdGlvbnMgZm9yIHZhcmlvdXMgdHlwZXMu ICBJbmplY3Rpb25Qb2ludAogLS0gbWF5IGJlIHByZXNlbnQgb3IgYWJzZW50LCBkZXBlbmRpbmcg b24gaGlzdG9yeSBzaW5jZSBsYXN0IHBvc3RtYXN0ZXIgc3RhcnQuCi0tIAoyLjM0LjEKCg== --=_979e70d20c6e330d2f68544b102680e1--