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 1sTg5s-001GQy-Lc for pgsql-hackers@arkaria.postgresql.org; Tue, 16 Jul 2024 11:11:40 +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 1sTg5r-00HL6w-3g for pgsql-hackers@arkaria.postgresql.org; Tue, 16 Jul 2024 11:11:39 +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 1sTg5q-00HL6n-LZ for pgsql-hackers@lists.postgresql.org; Tue, 16 Jul 2024 11:11:38 +0000 Received: from mail-pf1-x431.google.com ([2607:f8b0:4864:20::431]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.94.2) (envelope-from ) id 1sTg5n-002P1o-89 for pgsql-hackers@lists.postgresql.org; Tue, 16 Jul 2024 11:11:38 +0000 Received: by mail-pf1-x431.google.com with SMTP id d2e1a72fcca58-70af0684c2bso3494467b3a.0 for ; Tue, 16 Jul 2024 04:11:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1721128292; x=1721733092; darn=lists.postgresql.org; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=oMI80tuItiLh04Ou6q3SXFAFDSKLEVAABfbV6PvnjVk=; b=kWyKYk047xssEdQ7cNk9ddE3ZHjKJk/oWCycF7ZeUbiWQ5hrX2/dCi8GHjieAIlwQK 2p86/TNgKtVJeDtT5rGZBL/ve9+dGq11KQWQB0s9KdQCyxrmOryrXTHAQJgKAhjRkACG Rq/BxISrGJ3SDj1Dk6K/bR58VClJ5dqLkLxlT+usA6gGCb0C+bmHDIoLnFotpKLMTSMV tDek2SR/Lj1lRWc6Q2NX81Kro8gof1OxcGfNfHC4HVdNuU1LpzalV8tSRSE8KWbbKn++ zIqn8m7qtIQcjNvwLSghkZ/NXt+/zKGpb4bN2cOpDuKxEjWRONy9Onopsynn2rucpgh0 qX2w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1721128292; x=1721733092; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=oMI80tuItiLh04Ou6q3SXFAFDSKLEVAABfbV6PvnjVk=; b=SkL3GICALZW5haU4qF5Z82N9QHHLz05ywuVvf9Hx1L1J4fliJH6CSIheAvE5eaZXNE S6i1VLarVzPR4nA4EOL84Qx80kjVzZoN0Py8cJm6lApMA2u/j44QbCNmzoUvKclRo8cL ClMAkYI7YdbkEfGxZMsQpnn1UNQ2b2ZtafOXm/7MLQWyptT1Hc78vZBUhhR9cdGcH+cj uI8UqpV7Y0rB99sCFCNquLeImY+ebmXG6dIaoJBZEyWywVCYIWcDB7RogUh+J7MzByQG UwFoqrswpiHfyXt/pODUX/WjDUGQIQ6u9XP5hbNXpdj7WBmubWp7NdSNfQxRnOXf0RFi KuPQ== X-Gm-Message-State: AOJu0YynEk/f11caPr2DS0UgxyfZQYF3aWXeY8hf6A+MIc8lDJ5J0nuf XFv5D8oamDI9nOMYEFUeZNC06bJYCnXDhb8bqYX8qNzV4Jfvxl8v2RKsHozH7mUaoAyUDj8DJef nm5s3D+Y3FN3KVNrZYBAqR0qhxFs= X-Google-Smtp-Source: AGHT+IFW9qE2JTgCjtjDbLBhhvXOwfytVVqXotSH6/vIRw3jQ4aNeJRjBeoVy5gUUhKWssZfdTiRdV5bjc9xrlY0bbc= X-Received: by 2002:a05:6a20:9146:b0:1bd:2358:8c8d with SMTP id adf61e73a8af0-1c3f124154bmr2165038637.29.1721128292321; Tue, 16 Jul 2024 04:11:32 -0700 (PDT) MIME-Version: 1.0 References: <20240711235209.f6.nmisch@google.com> In-Reply-To: <20240711235209.f6.nmisch@google.com> From: Nazir Bilal Yavuz Date: Tue, 16 Jul 2024 14:11:20 +0300 Message-ID: Subject: Re: Use read streams in CREATE DATABASE command when the strategy is wal_log To: Noah Misch Cc: PostgreSQL Hackers Content-Type: multipart/mixed; boundary="0000000000007a6292061d5b68d9" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --0000000000007a6292061d5b68d9 Content-Type: text/plain; charset="UTF-8" Hi, Thank you for the review! On Fri, 12 Jul 2024 at 02:52, Noah Misch wrote: > > On Tue, Apr 16, 2024 at 02:12:19PM +0300, Nazir Bilal Yavuz wrote: > > I am working on using read streams in the CREATE DATABASE command when the > > strategy is wal_log. RelationCopyStorageUsingBuffer() function is used in > > this context. This function reads source buffers then copies them to the > > Please rebase. I applied this to 40126ac for review purposes. Rebased. > > Subject: [PATCH v1 1/3] Refactor PinBufferForBlock() to remove if checks about > > persistence > > > > There are if checks in PinBufferForBlock() function to set persistence > > of the relation and this function is called for the each block in the > > relation. Instead of that, set persistence of the relation before > > PinBufferForBlock() function. > > I tried with the following additional patch to see if PinBufferForBlock() ever > gets invalid smgr_relpersistence: > > ==== > --- a/src/backend/storage/buffer/bufmgr.c > +++ b/src/backend/storage/buffer/bufmgr.c > @@ -1098,6 +1098,11 @@ PinBufferForBlock(Relation rel, > > Assert(blockNum != P_NEW); > > + if (!(smgr_persistence == RELPERSISTENCE_TEMP || > + smgr_persistence == RELPERSISTENCE_PERMANENT || > + smgr_persistence == RELPERSISTENCE_UNLOGGED)) > + elog(WARNING, "unexpected relpersistence %d", smgr_persistence); > + > if (smgr_persistence == RELPERSISTENCE_TEMP) > { > io_context = IOCONTEXT_NORMAL; > ==== > > That still gets relpersistence==0 in various src/test/regress cases. I think > the intent was to prevent that. If not, please add a comment about when > relpersistence==0 is still allowed. I fixed it, it is caused by (mode == RBM_ZERO_AND_CLEANUP_LOCK | mode == RBM_ZERO_AND_LOCK) case in the ReadBuffer_common(). The persistence was not updated for this path before. I also added an assert check for this problem to PinBufferForBlock(). > > --- a/src/backend/storage/aio/read_stream.c > > +++ b/src/backend/storage/aio/read_stream.c > > @@ -549,7 +549,7 @@ read_stream_begin_relation(int flags, > > { > > stream->ios[i].op.rel = rel; > > stream->ios[i].op.smgr = RelationGetSmgr(rel); > > - stream->ios[i].op.smgr_persistence = 0; > > + stream->ios[i].op.smgr_persistence = rel->rd_rel->relpersistence; > > Does the following comment in ReadBuffersOperation need an update? > > /* > * The following members should be set by the caller. If only smgr is > * provided without rel, then smgr_persistence can be set to override the > * default assumption of RELPERSISTENCE_PERMANENT. > */ > I believe it does not need to be updated but I renamed 'ReadBuffersOperation.smgr_persistence' as 'ReadBuffersOperation.persistence'. So, this comment is updated as well. I think that rename suits better because persistence does not need to come from smgr, it could come from relation, too. Do you think it is a good idea? If it is, does it need a separate commit? > > --- a/src/backend/storage/buffer/bufmgr.c > > +++ b/src/backend/storage/buffer/bufmgr.c > > > +/* > > + * Helper struct for read stream object used in > > + * RelationCopyStorageUsingBuffer() function. > > + */ > > +struct copy_storage_using_buffer_read_stream_private > > +{ > > + BlockNumber blocknum; > > + int64 last_block; > > +}; > > Why is last_block an int64, not a BlockNumber? You are right, the type of last_block should be BlockNumber; done. I copied it from pg_prewarm_read_stream_private struct and I guess the same should be applied to it as well but it is not the topic of this thread, so I did not update it yet. > > @@ -4667,19 +4698,31 @@ RelationCopyStorageUsingBuffer(RelFileLocator srclocator, > > > /* Iterate over each block of the source relation file. */ > > for (blkno = 0; blkno < nblocks; blkno++) > > { > > CHECK_FOR_INTERRUPTS(); > > > > /* Read block from source relation. */ > > - srcBuf = ReadBufferWithoutRelcache(srclocator, forkNum, blkno, > > - RBM_NORMAL, bstrategy_src, > > - permanent); > > + srcBuf = read_stream_next_buffer(src_stream, NULL); > > LockBuffer(srcBuf, BUFFER_LOCK_SHARE); > > I think this should check for read_stream_next_buffer() returning > InvalidBuffer. pg_prewarm doesn't, but the other callers do, and I think the > other callers are a better model. LockBuffer() doesn't check the > InvalidBuffer case, so let's avoid the style of using a > read_stream_next_buffer() return value without checking. There is an assert in the LockBuffer which checks for the InvalidBuffer. If that is not enough, we may add an if check for InvalidBuffer but what should we do in this case? It should not happen, so erroring out may be a good idea. Updated patches are attached (without InvalidBuffer check for now). -- Regards, Nazir Bilal Yavuz Microsoft --0000000000007a6292061d5b68d9 Content-Type: text/x-patch; charset="US-ASCII"; name="v2-0001-Refactor-PinBufferForBlock-to-remove-if-checks-ab.patch" Content-Disposition: attachment; filename="v2-0001-Refactor-PinBufferForBlock-to-remove-if-checks-ab.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lyoam2lf0 RnJvbSA5NzdjZWE5NDUxZTYwMmQ4ZDNkNWU0ZjBjZjNjZDdkZmVhMTE4NzllIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOYXppciBCaWxhbCBZYXZ1eiA8YnlhdnV6ODFAZ21haWwuY29t PgpEYXRlOiBTdW4sIDcgQXByIDIwMjQgMjI6MzM6MzYgKzAzMDAKU3ViamVjdDogW1BBVENIIHYy IDEvM10gUmVmYWN0b3IgUGluQnVmZmVyRm9yQmxvY2soKSB0byByZW1vdmUgaWYgY2hlY2tzIGFi b3V0CiBwZXJzaXN0ZW5jZQoKVGhlcmUgYXJlIGlmIGNoZWNrcyBpbiBQaW5CdWZmZXJGb3JCbG9j aygpIGZ1bmN0aW9uIHRvIHNldCBwZXJzaXN0ZW5jZQpvZiB0aGUgcmVsYXRpb24gYW5kIHRoaXMg ZnVuY3Rpb24gaXMgY2FsbGVkIGZvciB0aGUgZWFjaCBibG9jayBpbiB0aGUKcmVsYXRpb24uIElu c3RlYWQgb2YgdGhhdCwgc2V0IHBlcnNpc3RlbmNlIG9mIHRoZSByZWxhdGlvbiBiZWZvcmUKUGlu QnVmZmVyRm9yQmxvY2soKSBmdW5jdGlvbi4KLS0tCiBzcmMvaW5jbHVkZS9zdG9yYWdlL2J1Zm1n ci5oICAgICAgICAgIHwgIDQgKystLQogc3JjL2JhY2tlbmQvc3RvcmFnZS9haW8vcmVhZF9zdHJl YW0uYyB8ICAyICstCiBzcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYyAgIHwgMzIg KysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tCiAzIGZpbGVzIGNoYW5nZWQsIDE4IGluc2VydGlv bnMoKyksIDIwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL3N0b3JhZ2Uv YnVmbWdyLmggYi9zcmMvaW5jbHVkZS9zdG9yYWdlL2J1Zm1nci5oCmluZGV4IGExZTcxMDEzZDMy Li5iYTlhMWEyODlhOSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvc3RvcmFnZS9idWZtZ3IuaAor KysgYi9zcmMvaW5jbHVkZS9zdG9yYWdlL2J1Zm1nci5oCkBAIC0xMTYsMTIgKzExNiwxMiBAQCBz dHJ1Y3QgUmVhZEJ1ZmZlcnNPcGVyYXRpb24KIHsKIAkvKgogCSAqIFRoZSBmb2xsb3dpbmcgbWVt YmVycyBzaG91bGQgYmUgc2V0IGJ5IHRoZSBjYWxsZXIuICBJZiBvbmx5IHNtZ3IgaXMKLQkgKiBw cm92aWRlZCB3aXRob3V0IHJlbCwgdGhlbiBzbWdyX3BlcnNpc3RlbmNlIGNhbiBiZSBzZXQgdG8g b3ZlcnJpZGUgdGhlCisJICogcHJvdmlkZWQgd2l0aG91dCByZWwsIHRoZW4gcGVyc2lzdGVuY2Ug Y2FuIGJlIHNldCB0byBvdmVycmlkZSB0aGUKIAkgKiBkZWZhdWx0IGFzc3VtcHRpb24gb2YgUkVM UEVSU0lTVEVOQ0VfUEVSTUFORU5ULgogCSAqLwogCVJlbGF0aW9uCXJlbDsKIAlzdHJ1Y3QgU01n clJlbGF0aW9uRGF0YSAqc21ncjsKLQljaGFyCQlzbWdyX3BlcnNpc3RlbmNlOworCWNoYXIJCXBl cnNpc3RlbmNlOwogCUZvcmtOdW1iZXIJZm9ya251bTsKIAlCdWZmZXJBY2Nlc3NTdHJhdGVneSBz dHJhdGVneTsKIApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9haW8vcmVhZF9zdHJl YW0uYyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYWlvL3JlYWRfc3RyZWFtLmMKaW5kZXggNzRiOWJh ZTYzMTMuLjU4MjIxNjQ5ZjI3IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9zdG9yYWdlL2Fpby9y ZWFkX3N0cmVhbS5jCisrKyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYWlvL3JlYWRfc3RyZWFtLmMK QEAgLTU1MSw3ICs1NTEsNyBAQCByZWFkX3N0cmVhbV9iZWdpbl9yZWxhdGlvbihpbnQgZmxhZ3Ms CiAJewogCQlzdHJlYW0tPmlvc1tpXS5vcC5yZWwgPSByZWw7CiAJCXN0cmVhbS0+aW9zW2ldLm9w LnNtZ3IgPSBSZWxhdGlvbkdldFNtZ3IocmVsKTsKLQkJc3RyZWFtLT5pb3NbaV0ub3Auc21ncl9w ZXJzaXN0ZW5jZSA9IDA7CisJCXN0cmVhbS0+aW9zW2ldLm9wLnBlcnNpc3RlbmNlID0gcmVsLT5y ZF9yZWwtPnJlbHBlcnNpc3RlbmNlOwogCQlzdHJlYW0tPmlvc1tpXS5vcC5mb3JrbnVtID0gZm9y a251bTsKIAkJc3RyZWFtLT5pb3NbaV0ub3Auc3RyYXRlZ3kgPSBzdHJhdGVneTsKIAl9CmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYyBiL3NyYy9iYWNrZW5k L3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jCmluZGV4IDYxODE2NzMwOTU1Li43Y2JjZGM2M2E2ZiAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMKKysrIGIvc3Jj L2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMKQEAgLTExMDQsNyArMTEwNCw3IEBAIFpl cm9BbmRMb2NrQnVmZmVyKEJ1ZmZlciBidWZmZXIsIFJlYWRCdWZmZXJNb2RlIG1vZGUsIGJvb2wg YWxyZWFkeV92YWxpZCkKIHN0YXRpYyBwZ19hdHRyaWJ1dGVfYWx3YXlzX2lubGluZSBCdWZmZXIK IFBpbkJ1ZmZlckZvckJsb2NrKFJlbGF0aW9uIHJlbCwKIAkJCQkgIFNNZ3JSZWxhdGlvbiBzbWdy LAotCQkJCSAgY2hhciBzbWdyX3BlcnNpc3RlbmNlLAorCQkJCSAgY2hhciBwZXJzaXN0ZW5jZSwK IAkJCQkgIEZvcmtOdW1iZXIgZm9ya051bSwKIAkJCQkgIEJsb2NrTnVtYmVyIGJsb2NrTnVtLAog CQkJCSAgQnVmZmVyQWNjZXNzU3RyYXRlZ3kgc3RyYXRlZ3ksCkBAIC0xMTEzLDIyICsxMTEzLDEy IEBAIFBpbkJ1ZmZlckZvckJsb2NrKFJlbGF0aW9uIHJlbCwKIAlCdWZmZXJEZXNjICpidWZIZHI7 CiAJSU9Db250ZXh0CWlvX2NvbnRleHQ7CiAJSU9PYmplY3QJaW9fb2JqZWN0OwotCWNoYXIJCXBl cnNpc3RlbmNlOwogCiAJQXNzZXJ0KGJsb2NrTnVtICE9IFBfTkVXKTsKIAotCS8qCi0JICogSWYg dGhlcmUgaXMgbm8gUmVsYXRpb24gaXQgdXN1YWxseSBpbXBsaWVzIHJlY292ZXJ5IGFuZCB0aHVz IHBlcm1hbmVudCwKLQkgKiBidXQgd2UgdGFrZSBhbiBhcmd1bWVudCBiZWNhdXNlIENyZWF0ZUFu ZENvcHlSZWxhdGlvbkRhdGEgY2FuIHJlYWNoIHVzCi0JICogd2l0aCBvbmx5IGFuIFNNZ3JSZWxh dGlvbiBmb3IgYW4gdW5sb2dnZWQgcmVsYXRpb24gdGhhdCB3ZSBkb24ndCB3YW50Ci0JICogdG8g ZmxhZyB3aXRoIEJNX1BFUk1BTkVOVC4KLQkgKi8KLQlpZiAocmVsKQotCQlwZXJzaXN0ZW5jZSA9 IHJlbC0+cmRfcmVsLT5yZWxwZXJzaXN0ZW5jZTsKLQllbHNlIGlmIChzbWdyX3BlcnNpc3RlbmNl ID09IDApCi0JCXBlcnNpc3RlbmNlID0gUkVMUEVSU0lTVEVOQ0VfUEVSTUFORU5UOwotCWVsc2UK LQkJcGVyc2lzdGVuY2UgPSBzbWdyX3BlcnNpc3RlbmNlOworCUFzc2VydCgocGVyc2lzdGVuY2Ug PT0gUkVMUEVSU0lTVEVOQ0VfVEVNUCB8fAorCQkJcGVyc2lzdGVuY2UgPT0gUkVMUEVSU0lTVEVO Q0VfUEVSTUFORU5UIHx8CisJCQlwZXJzaXN0ZW5jZSA9PSBSRUxQRVJTSVNURU5DRV9VTkxPR0dF RCkpOwogCiAJaWYgKHBlcnNpc3RlbmNlID09IFJFTFBFUlNJU1RFTkNFX1RFTVApCiAJewpAQCAt MTIwMyw2ICsxMTkzLDcgQEAgUmVhZEJ1ZmZlcl9jb21tb24oUmVsYXRpb24gcmVsLCBTTWdyUmVs YXRpb24gc21nciwgY2hhciBzbWdyX3BlcnNpc3RlbmNlLAogCVJlYWRCdWZmZXJzT3BlcmF0aW9u IG9wZXJhdGlvbjsKIAlCdWZmZXIJCWJ1ZmZlcjsKIAlpbnQJCQlmbGFnczsKKwljaGFyCQlwZXJz aXN0ZW5jZTsKIAogCS8qCiAJICogQmFja3dhcmQgY29tcGF0aWJpbGl0eSBwYXRoLCBtb3N0IGNv ZGUgc2hvdWxkIHVzZSBFeHRlbmRCdWZmZXJlZFJlbCgpCkBAIC0xMjI0LDEyICsxMjE1LDE5IEBA IFJlYWRCdWZmZXJfY29tbW9uKFJlbGF0aW9uIHJlbCwgU01nclJlbGF0aW9uIHNtZ3IsIGNoYXIg c21ncl9wZXJzaXN0ZW5jZSwKIAkJcmV0dXJuIEV4dGVuZEJ1ZmZlcmVkUmVsKEJNUl9SRUwocmVs KSwgZm9ya051bSwgc3RyYXRlZ3ksIGZsYWdzKTsKIAl9CiAKKwlpZiAocmVsKQorCQlwZXJzaXN0 ZW5jZSA9IHJlbC0+cmRfcmVsLT5yZWxwZXJzaXN0ZW5jZTsKKwllbHNlIGlmIChzbWdyX3BlcnNp c3RlbmNlID09IDApCisJCXBlcnNpc3RlbmNlID0gUkVMUEVSU0lTVEVOQ0VfUEVSTUFORU5UOwor CWVsc2UKKwkJcGVyc2lzdGVuY2UgPSBzbWdyX3BlcnNpc3RlbmNlOworCiAJaWYgKHVubGlrZWx5 KG1vZGUgPT0gUkJNX1pFUk9fQU5EX0NMRUFOVVBfTE9DSyB8fAogCQkJCSBtb2RlID09IFJCTV9a RVJPX0FORF9MT0NLKSkKIAl7CiAJCWJvb2wJCWZvdW5kOwogCi0JCWJ1ZmZlciA9IFBpbkJ1ZmZl ckZvckJsb2NrKHJlbCwgc21nciwgc21ncl9wZXJzaXN0ZW5jZSwKKwkJYnVmZmVyID0gUGluQnVm ZmVyRm9yQmxvY2socmVsLCBzbWdyLCBwZXJzaXN0ZW5jZSwKIAkJCQkJCQkJICAgZm9ya051bSwg YmxvY2tOdW0sIHN0cmF0ZWd5LCAmZm91bmQpOwogCQlaZXJvQW5kTG9ja0J1ZmZlcihidWZmZXIs IG1vZGUsIGZvdW5kKTsKIAkJcmV0dXJuIGJ1ZmZlcjsKQEAgLTEyNDEsNyArMTIzOSw3IEBAIFJl YWRCdWZmZXJfY29tbW9uKFJlbGF0aW9uIHJlbCwgU01nclJlbGF0aW9uIHNtZ3IsIGNoYXIgc21n cl9wZXJzaXN0ZW5jZSwKIAkJZmxhZ3MgPSAwOwogCW9wZXJhdGlvbi5zbWdyID0gc21ncjsKIAlv cGVyYXRpb24ucmVsID0gcmVsOwotCW9wZXJhdGlvbi5zbWdyX3BlcnNpc3RlbmNlID0gc21ncl9w ZXJzaXN0ZW5jZTsKKwlvcGVyYXRpb24ucGVyc2lzdGVuY2UgPSBwZXJzaXN0ZW5jZTsKIAlvcGVy YXRpb24uZm9ya251bSA9IGZvcmtOdW07CiAJb3BlcmF0aW9uLnN0cmF0ZWd5ID0gc3RyYXRlZ3k7 CiAJaWYgKFN0YXJ0UmVhZEJ1ZmZlcigmb3BlcmF0aW9uLApAQCAtMTI3Miw3ICsxMjcwLDcgQEAg U3RhcnRSZWFkQnVmZmVyc0ltcGwoUmVhZEJ1ZmZlcnNPcGVyYXRpb24gKm9wZXJhdGlvbiwKIAog CQlidWZmZXJzW2ldID0gUGluQnVmZmVyRm9yQmxvY2sob3BlcmF0aW9uLT5yZWwsCiAJCQkJCQkJ CQkgICBvcGVyYXRpb24tPnNtZ3IsCi0JCQkJCQkJCQkgICBvcGVyYXRpb24tPnNtZ3JfcGVyc2lz dGVuY2UsCisJCQkJCQkJCQkgICBvcGVyYXRpb24tPnBlcnNpc3RlbmNlLAogCQkJCQkJCQkJICAg b3BlcmF0aW9uLT5mb3JrbnVtLAogCQkJCQkJCQkJICAgYmxvY2tOdW0gKyBpLAogCQkJCQkJCQkJ ICAgb3BlcmF0aW9uLT5zdHJhdGVneSwKLS0gCjIuNDUuMgoK --0000000000007a6292061d5b68d9 Content-Type: text/x-patch; charset="US-ASCII"; name="v2-0002-Add-a-way-to-create-read-stream-object-by-using-S.patch" Content-Disposition: attachment; filename="v2-0002-Add-a-way-to-create-read-stream-object-by-using-S.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lyoam5oy1 RnJvbSA1M2MyYmQxMmQ3MWU1MjFkOTc1MDAyZmIwM2VmNTNiNzQzODljY2I3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOYXppciBCaWxhbCBZYXZ1eiA8YnlhdnV6ODFAZ21haWwuY29t PgpEYXRlOiBNb24sIDggQXByIDIwMjQgMDA6MTQ6NTIgKzAzMDAKU3ViamVjdDogW1BBVENIIHYy IDIvM10gQWRkIGEgd2F5IHRvIGNyZWF0ZSByZWFkIHN0cmVhbSBvYmplY3QgYnkgdXNpbmcKIFNN Z3JSZWxhdGlvbgoKQ3VycmVudGx5IHJlYWQgc3RyZWFtIG9iamVjdCBjYW4gYmUgY3JlYXRlZCBv bmx5IGJ5IHVzaW5nIFJlbGF0aW9uLAp0aGVyZSBpcyBubyB3YXkgdG8gY3JlYXRlIGl0IGJ5IHVz aW5nIFNNZ3JSZWxhdGlvbi4KClRvIGFjaGlldmUgdGhhdCwgcmVhZF9zdHJlYW1fYmVnaW5faW1w bCgpIGZ1bmN0aW9uIGlzIGNyZWF0ZWQgYW5kCmNvbnRlbnRzIG9mIHRoZSByZWFkX3N0cmVhbV9i ZWdpbl9yZWxhdGlvbigpIGlzIG1vdmVkIGludG8gdGhpcwpmdW5jdGlvbi4KCkJvdGggcmVhZF9z dHJlYW1fYmVnaW5fcmVsYXRpb24oKSBhbmQgcmVhZF9zdHJlYW1fYmVnaW5fc21ncl9yZWxhdGlv bigpCmNhbGxzIHJlYWRfc3RyZWFtX2JlZ2luX2ltcGwoKSBieSBSZWxhdGlvbiBhbmQgU01nclJl bGF0aW9uCnJlc3BlY3RpdmVseS4KLS0tCiBzcmMvaW5jbHVkZS9zdG9yYWdlL3JlYWRfc3RyZWFt LmggICAgIHwgMTAgKysrKwogc3JjL2JhY2tlbmQvc3RvcmFnZS9haW8vcmVhZF9zdHJlYW0uYyB8 IDgzICsrKysrKysrKysrKysrKysrKysrKystLS0tLQogMiBmaWxlcyBjaGFuZ2VkLCA3OSBpbnNl cnRpb25zKCspLCAxNCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9zdG9y YWdlL3JlYWRfc3RyZWFtLmggYi9zcmMvaW5jbHVkZS9zdG9yYWdlL3JlYWRfc3RyZWFtLmgKaW5k ZXggZjY3NmQyY2MyMGEuLjRlNTk5OTA0ZjI2IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9zdG9y YWdlL3JlYWRfc3RyZWFtLmgKKysrIGIvc3JjL2luY2x1ZGUvc3RvcmFnZS9yZWFkX3N0cmVhbS5o CkBAIC0xNSw2ICsxNSw3IEBACiAjZGVmaW5lIFJFQURfU1RSRUFNX0gKIAogI2luY2x1ZGUgInN0 b3JhZ2UvYnVmbWdyLmgiCisjaW5jbHVkZSAic3RvcmFnZS9zbWdyLmgiCiAKIC8qIERlZmF1bHQg dHVuaW5nLCByZWFzb25hYmxlIGZvciBtYW55IHVzZXJzLiAqLwogI2RlZmluZSBSRUFEX1NUUkVB TV9ERUZBVUxUIDB4MDAKQEAgLTU3LDYgKzU4LDE1IEBAIGV4dGVybiBSZWFkU3RyZWFtICpyZWFk X3N0cmVhbV9iZWdpbl9yZWxhdGlvbihpbnQgZmxhZ3MsCiAJCQkJCQkJCQkJCSAgdm9pZCAqY2Fs bGJhY2tfcHJpdmF0ZV9kYXRhLAogCQkJCQkJCQkJCQkgIHNpemVfdCBwZXJfYnVmZmVyX2RhdGFf c2l6ZSk7CiBleHRlcm4gQnVmZmVyIHJlYWRfc3RyZWFtX25leHRfYnVmZmVyKFJlYWRTdHJlYW0g KnN0cmVhbSwgdm9pZCAqKnBlcl9idWZmZXJfZGF0YSk7CitleHRlcm4gUmVhZFN0cmVhbSAqcmVh ZF9zdHJlYW1fYmVnaW5fc21ncl9yZWxhdGlvbihpbnQgZmxhZ3MsCisJCQkJCQkJCQkJCQkgICBC dWZmZXJBY2Nlc3NTdHJhdGVneSBzdHJhdGVneSwKKwkJCQkJCQkJCQkJCSAgIFNNZ3JSZWxhdGlv biBzbWdyLAorCQkJCQkJCQkJCQkJICAgY2hhciBzbWdyX3BlcnNpc3RlbmNlLAorCQkJCQkJCQkJ CQkJICAgRm9ya051bWJlciBmb3JrbnVtLAorCQkJCQkJCQkJCQkJICAgUmVhZFN0cmVhbUJsb2Nr TnVtYmVyQ0IgY2FsbGJhY2ssCisJCQkJCQkJCQkJCQkgICB2b2lkICpjYWxsYmFja19wcml2YXRl X2RhdGEsCisJCQkJCQkJCQkJCQkgICBzaXplX3QgcGVyX2J1ZmZlcl9kYXRhX3NpemUpOworZXh0 ZXJuIEJ1ZmZlciByZWFkX3N0cmVhbV9uZXh0X2J1ZmZlcihSZWFkU3RyZWFtICpzdHJlYW0sIHZv aWQgKipwZXJfYnVmZmVyX3ByaXZhdGUpOwogZXh0ZXJuIHZvaWQgcmVhZF9zdHJlYW1fcmVzZXQo UmVhZFN0cmVhbSAqc3RyZWFtKTsKIGV4dGVybiB2b2lkIHJlYWRfc3RyZWFtX2VuZChSZWFkU3Ry ZWFtICpzdHJlYW0pOwogCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9zdG9yYWdlL2Fpby9yZWFk X3N0cmVhbS5jIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9haW8vcmVhZF9zdHJlYW0uYwppbmRleCA1 ODIyMTY0OWYyNy4uY2RlYzkxOGQyOWQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3N0b3JhZ2Uv YWlvL3JlYWRfc3RyZWFtLmMKKysrIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9haW8vcmVhZF9zdHJl YW0uYwpAQCAtNDA2LDE0ICs0MDYsMTYgQEAgcmVhZF9zdHJlYW1fbG9va19haGVhZChSZWFkU3Ry ZWFtICpzdHJlYW0sIGJvb2wgc3VwcHJlc3NfYWR2aWNlKQogICogd3JpdGUgZXh0cmEgZGF0YSBm b3IgZWFjaCBibG9jayBpbnRvIHRoZSBzcGFjZSBwcm92aWRlZCB0byBpdC4gIEl0IHdpbGwKICAq IGFsc28gcmVjZWl2ZSBjYWxsYmFja19wcml2YXRlX2RhdGEgZm9yIGl0cyBvd24gcHVycG9zZXMu CiAgKi8KLVJlYWRTdHJlYW0gKgotcmVhZF9zdHJlYW1fYmVnaW5fcmVsYXRpb24oaW50IGZsYWdz LAotCQkJCQkJICAgQnVmZmVyQWNjZXNzU3RyYXRlZ3kgc3RyYXRlZ3ksCi0JCQkJCQkgICBSZWxh dGlvbiByZWwsCi0JCQkJCQkgICBGb3JrTnVtYmVyIGZvcmtudW0sCi0JCQkJCQkgICBSZWFkU3Ry ZWFtQmxvY2tOdW1iZXJDQiBjYWxsYmFjaywKLQkJCQkJCSAgIHZvaWQgKmNhbGxiYWNrX3ByaXZh dGVfZGF0YSwKLQkJCQkJCSAgIHNpemVfdCBwZXJfYnVmZmVyX2RhdGFfc2l6ZSkKK3N0YXRpYyBS ZWFkU3RyZWFtICoKK3JlYWRfc3RyZWFtX2JlZ2luX2ltcGwoaW50IGZsYWdzLAorCQkJCQkgICBC dWZmZXJBY2Nlc3NTdHJhdGVneSBzdHJhdGVneSwKKwkJCQkJICAgUmVsYXRpb24gcmVsLAorCQkJ CQkgICBTTWdyUmVsYXRpb24gc21nciwKKwkJCQkJICAgY2hhciBzbWdyX3BlcnNpc3RlbmNlLAor CQkJCQkgICBGb3JrTnVtYmVyIGZvcmtudW0sCisJCQkJCSAgIFJlYWRTdHJlYW1CbG9ja051bWJl ckNCIGNhbGxiYWNrLAorCQkJCQkgICB2b2lkICpjYWxsYmFja19wcml2YXRlX2RhdGEsCisJCQkJ CSAgIHNpemVfdCBwZXJfYnVmZmVyX2RhdGFfc2l6ZSkKIHsKIAlSZWFkU3RyZWFtICpzdHJlYW07 CiAJc2l6ZV90CQlzaXplOwpAQCAtNDIyLDkgKzQyNCw2IEBAIHJlYWRfc3RyZWFtX2JlZ2luX3Jl bGF0aW9uKGludCBmbGFncywKIAlpbnQJCQlzdHJhdGVneV9waW5fbGltaXQ7CiAJdWludDMyCQlt YXhfcGlubmVkX2J1ZmZlcnM7CiAJT2lkCQkJdGFibGVzcGFjZV9pZDsKLQlTTWdyUmVsYXRpb24g c21ncjsKLQotCXNtZ3IgPSBSZWxhdGlvbkdldFNtZ3IocmVsKTsKIAogCS8qCiAJICogRGVjaWRl IGhvdyBtYW55IEkvT3Mgd2Ugd2lsbCBhbGxvdyB0byBydW4gYXQgdGhlIHNhbWUgdGltZS4gIFRo YXQKQEAgLTQzNCw3ICs0MzMsNyBAQCByZWFkX3N0cmVhbV9iZWdpbl9yZWxhdGlvbihpbnQgZmxh Z3MsCiAJICovCiAJdGFibGVzcGFjZV9pZCA9IHNtZ3ItPnNtZ3JfcmxvY2F0b3IubG9jYXRvci5z cGNPaWQ7CiAJaWYgKCFPaWRJc1ZhbGlkKE15RGF0YWJhc2VJZCkgfHwKLQkJSXNDYXRhbG9nUmVs YXRpb24ocmVsKSB8fAorCQkocmVsICYmIElzQ2F0YWxvZ1JlbGF0aW9uKHJlbCkpIHx8CiAJCUlz Q2F0YWxvZ1JlbGF0aW9uT2lkKHNtZ3ItPnNtZ3JfcmxvY2F0b3IubG9jYXRvci5yZWxOdW1iZXIp KQogCXsKIAkJLyoKQEAgLTU1MCw4ICs1NDksOCBAQCByZWFkX3N0cmVhbV9iZWdpbl9yZWxhdGlv bihpbnQgZmxhZ3MsCiAJZm9yIChpbnQgaSA9IDA7IGkgPCBtYXhfaW9zOyArK2kpCiAJewogCQlz dHJlYW0tPmlvc1tpXS5vcC5yZWwgPSByZWw7Ci0JCXN0cmVhbS0+aW9zW2ldLm9wLnNtZ3IgPSBS ZWxhdGlvbkdldFNtZ3IocmVsKTsKLQkJc3RyZWFtLT5pb3NbaV0ub3AucGVyc2lzdGVuY2UgPSBy ZWwtPnJkX3JlbC0+cmVscGVyc2lzdGVuY2U7CisJCXN0cmVhbS0+aW9zW2ldLm9wLnNtZ3IgPSBz bWdyOworCQlzdHJlYW0tPmlvc1tpXS5vcC5wZXJzaXN0ZW5jZSA9IHNtZ3JfcGVyc2lzdGVuY2U7 CiAJCXN0cmVhbS0+aW9zW2ldLm9wLmZvcmtudW0gPSBmb3JrbnVtOwogCQlzdHJlYW0tPmlvc1tp XS5vcC5zdHJhdGVneSA9IHN0cmF0ZWd5OwogCX0KQEAgLTU1OSw2ICs1NTgsNjIgQEAgcmVhZF9z dHJlYW1fYmVnaW5fcmVsYXRpb24oaW50IGZsYWdzLAogCXJldHVybiBzdHJlYW07CiB9CiAKKy8q CisgKiBDcmVhdGUgYSBuZXcgcmVhZCBzdHJlYW0gZm9yIHJlYWRpbmcgYSByZWxhdGlvbi4KKyAq IFNlZSByZWFkX3N0cmVhbV9iZWdpbl9pbXBsKCkgZm9yIHRoZSBkZXRhaWxlZCBleHBsYW5hdGlv bi4KKyAqLworUmVhZFN0cmVhbSAqCityZWFkX3N0cmVhbV9iZWdpbl9yZWxhdGlvbihpbnQgZmxh Z3MsCisJCQkJCQkgICBCdWZmZXJBY2Nlc3NTdHJhdGVneSBzdHJhdGVneSwKKwkJCQkJCSAgIFJl bGF0aW9uIHJlbCwKKwkJCQkJCSAgIEZvcmtOdW1iZXIgZm9ya251bSwKKwkJCQkJCSAgIFJlYWRT dHJlYW1CbG9ja051bWJlckNCIGNhbGxiYWNrLAorCQkJCQkJICAgdm9pZCAqY2FsbGJhY2tfcHJp dmF0ZV9kYXRhLAorCQkJCQkJICAgc2l6ZV90IHBlcl9idWZmZXJfZGF0YV9zaXplKQoreworCXJl dHVybiByZWFkX3N0cmVhbV9iZWdpbl9pbXBsKGZsYWdzLAorCQkJCQkJCQkgIHN0cmF0ZWd5LAor CQkJCQkJCQkgIHJlbCwKKwkJCQkJCQkJICBSZWxhdGlvbkdldFNtZ3IocmVsKSwKKwkJCQkJCQkJ ICByZWwtPnJkX3JlbC0+cmVscGVyc2lzdGVuY2UsCisJCQkJCQkJCSAgZm9ya251bSwKKwkJCQkJ CQkJICBjYWxsYmFjaywKKwkJCQkJCQkJICBjYWxsYmFja19wcml2YXRlX2RhdGEsCisJCQkJCQkJ CSAgcGVyX2J1ZmZlcl9kYXRhX3NpemUpOworfQorCisvKgorICogQ3JlYXRlIGEgbmV3IHJlYWQg c3RyZWFtIGZvciByZWFkaW5nIGEgU01nciByZWxhdGlvbi4KKyAqIFNlZSByZWFkX3N0cmVhbV9i ZWdpbl9pbXBsKCkgZm9yIHRoZSBkZXRhaWxlZCBleHBsYW5hdGlvbi4KKyAqLworUmVhZFN0cmVh bSAqCityZWFkX3N0cmVhbV9iZWdpbl9zbWdyX3JlbGF0aW9uKGludCBmbGFncywKKwkJCQkJCQkJ QnVmZmVyQWNjZXNzU3RyYXRlZ3kgc3RyYXRlZ3ksCisJCQkJCQkJCVNNZ3JSZWxhdGlvbiBzbWdy LAorCQkJCQkJCQljaGFyIHNtZ3JfcGVyc2lzdGVuY2UsCisJCQkJCQkJCUZvcmtOdW1iZXIgZm9y a251bSwKKwkJCQkJCQkJUmVhZFN0cmVhbUJsb2NrTnVtYmVyQ0IgY2FsbGJhY2ssCisJCQkJCQkJ CXZvaWQgKmNhbGxiYWNrX3ByaXZhdGVfZGF0YSwKKwkJCQkJCQkJc2l6ZV90IHBlcl9idWZmZXJf ZGF0YV9zaXplKQoreworCWNoYXIJCXBlcnNpc3RlbmNlOworCisJaWYgKHNtZ3JfcGVyc2lzdGVu Y2UgPT0gMCkKKwkJcGVyc2lzdGVuY2UgPSBSRUxQRVJTSVNURU5DRV9QRVJNQU5FTlQ7CisJZWxz ZQorCQlwZXJzaXN0ZW5jZSA9IHNtZ3JfcGVyc2lzdGVuY2U7CisKKwlyZXR1cm4gcmVhZF9zdHJl YW1fYmVnaW5faW1wbChmbGFncywKKwkJCQkJCQkJICBzdHJhdGVneSwKKwkJCQkJCQkJICBOVUxM LAorCQkJCQkJCQkgIHNtZ3IsCisJCQkJCQkJCSAgcGVyc2lzdGVuY2UsCisJCQkJCQkJCSAgZm9y a251bSwKKwkJCQkJCQkJICBjYWxsYmFjaywKKwkJCQkJCQkJICBjYWxsYmFja19wcml2YXRlX2Rh dGEsCisJCQkJCQkJCSAgcGVyX2J1ZmZlcl9kYXRhX3NpemUpOworfQorCiAvKgogICogUHVsbCBv bmUgcGlubmVkIGJ1ZmZlciBvdXQgb2YgYSBzdHJlYW0uICBFYWNoIGNhbGwgcmV0dXJucyBzdWNj ZXNzaXZlCiAgKiBibG9ja3MgaW4gdGhlIG9yZGVyIHNwZWNpZmllZCBieSB0aGUgY2FsbGJhY2su ICBJZiBwZXJfYnVmZmVyX2RhdGFfc2l6ZSB3YXMKLS0gCjIuNDUuMgoK --0000000000007a6292061d5b68d9 Content-Type: text/x-patch; charset="US-ASCII"; name="v2-0003-Use-read-streams-in-CREATE-DATABASE-when-strategy.patch" Content-Disposition: attachment; filename="v2-0003-Use-read-streams-in-CREATE-DATABASE-when-strategy.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lyoam94v2 RnJvbSAzMWEyZDhhN2VlZjcxYmNkNTY4MDQ1MzVmNGU4YWZhOTBjOGU4NmQzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOYXppciBCaWxhbCBZYXZ1eiA8YnlhdnV6ODFAZ21haWwuY29t PgpEYXRlOiBUdWUsIDE2IEp1bCAyMDI0IDEzOjIyOjE1ICswMzAwClN1YmplY3Q6IFtQQVRDSCB2 MiAzLzNdIFVzZSByZWFkIHN0cmVhbXMgaW4gQ1JFQVRFIERBVEFCQVNFIHdoZW4gc3RyYXRlZ3kg aXMKIHdhbF9sb2cKCkNSRUFURSBEQUJBU0UgY29tbWFuZCB1c2VzIFJlbGF0aW9uQ29weVN0b3Jh Z2VVc2luZ0J1ZmZlcigpIGZ1bmN0aW9uIHRvCmNvcHkgYnVmZmVycyB3aGVuIHRoZSBzdHJhdGVn eSBpcyB3YWxfbG9nLiBUaGlzIGZ1bmN0aW9uIHJlYWRzIHNvdXJjZQpidWZmZXJzIHRoZW4gY29w aWVzIHRoZW0gdG8gdGhlIGRlc3RpbmF0aW9uIGJ1ZmZlcnMuIFJlYWQgc3RyZWFtcyBhcmUKdXNl ZCBvbmx5IG9ubHkgd2hpbGUgcmVhZGluZyBzb3VyY2UgYnVmZmVycyBiZWNhdXNlIHRoZSBkZXN0 aW5hdGlvbgpidWZmZXIgaXMgcmVhZCBieSAnUkJNX1pFUk9fQU5EX0xPQ0snIG9wdGlvbiwgc28g aXQgaXMgbm90IGltcG9ydGFudC4KLS0tCiBzcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZt Z3IuYyB8IDUzICsrKysrKysrKysrKysrKysrKysrKysrKysrLS0tCiAxIGZpbGUgY2hhbmdlZCwg NDkgaW5zZXJ0aW9ucygrKSwgNCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2Vu ZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1 Zm1nci5jCmluZGV4IDdjYmNkYzYzYTZmLi4yYWNjMTA5YzRkYiAxMDA2NDQKLS0tIGEvc3JjL2Jh Y2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMKKysrIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9i dWZmZXIvYnVmbWdyLmMKQEAgLTU0LDYgKzU0LDcgQEAKICNpbmNsdWRlICJzdG9yYWdlL2lwYy5o IgogI2luY2x1ZGUgInN0b3JhZ2UvbG1nci5oIgogI2luY2x1ZGUgInN0b3JhZ2UvcHJvYy5oIgor I2luY2x1ZGUgInN0b3JhZ2UvcmVhZF9zdHJlYW0uaCIKICNpbmNsdWRlICJzdG9yYWdlL3NtZ3Iu aCIKICNpbmNsdWRlICJzdG9yYWdlL3N0YW5kYnkuaCIKICNpbmNsdWRlICJ1dGlscy9tZW1kZWJ1 Zy5oIgpAQCAtMTM1LDYgKzEzNiwzMyBAQCB0eXBlZGVmIHN0cnVjdCBTTWdyU29ydEFycmF5CiAJ U01nclJlbGF0aW9uIHNyZWw7CiB9IFNNZ3JTb3J0QXJyYXk7CiAKKy8qCisgKiBIZWxwZXIgc3Ry dWN0IGZvciByZWFkIHN0cmVhbSBvYmplY3QgdXNlZCBpbgorICogUmVsYXRpb25Db3B5U3RvcmFn ZVVzaW5nQnVmZmVyKCkgZnVuY3Rpb24uCisgKi8KK3N0cnVjdCBjb3B5X3N0b3JhZ2VfdXNpbmdf YnVmZmVyX3JlYWRfc3RyZWFtX3ByaXZhdGUKK3sKKwlCbG9ja051bWJlciBibG9ja251bTsKKwlC bG9ja051bWJlciBsYXN0X2Jsb2NrOworfTsKKworLyoKKyAqIENhbGxiYWNrIGZ1bmN0aW9uIHRv IGdldCBuZXh0IGJsb2NrIGZvciByZWFkIHN0cmVhbSBvYmplY3QgdXNlZCBpbgorICogUmVsYXRp b25Db3B5U3RvcmFnZVVzaW5nQnVmZmVyKCkgZnVuY3Rpb24uCisgKi8KK3N0YXRpYyBCbG9ja051 bWJlcgorY29weV9zdG9yYWdlX3VzaW5nX2J1ZmZlcl9yZWFkX3N0cmVhbV9uZXh0X2Jsb2NrKFJl YWRTdHJlYW0gKnN0cmVhbSwKKwkJCQkJCQkJCQkJCSB2b2lkICpjYWxsYmFja19wcml2YXRlX2Rh dGEsCisJCQkJCQkJCQkJCQkgdm9pZCAqcGVyX2J1ZmZlcl9kYXRhKQoreworCXN0cnVjdCBjb3B5 X3N0b3JhZ2VfdXNpbmdfYnVmZmVyX3JlYWRfc3RyZWFtX3ByaXZhdGUgKnAgPSBjYWxsYmFja19w cml2YXRlX2RhdGE7CisKKwlpZiAocC0+YmxvY2tudW0gPCBwLT5sYXN0X2Jsb2NrKQorCQlyZXR1 cm4gcC0+YmxvY2tudW0rKzsKKworCXJldHVybiBJbnZhbGlkQmxvY2tOdW1iZXI7Cit9CisKIC8q IEdVQyB2YXJpYWJsZXMgKi8KIGJvb2wJCXplcm9fZGFtYWdlZF9wYWdlcyA9IGZhbHNlOwogaW50 CQkJYmd3cml0ZXJfbHJ1X21heHBhZ2VzID0gMTAwOwpAQCAtNDY4OCw2ICs0NzE2LDkgQEAgUmVs YXRpb25Db3B5U3RvcmFnZVVzaW5nQnVmZmVyKFJlbEZpbGVMb2NhdG9yIHNyY2xvY2F0b3IsCiAJ UEdJT0FsaWduZWRCbG9jayBidWY7CiAJQnVmZmVyQWNjZXNzU3RyYXRlZ3kgYnN0cmF0ZWd5X3Ny YzsKIAlCdWZmZXJBY2Nlc3NTdHJhdGVneSBic3RyYXRlZ3lfZHN0OworCXN0cnVjdCBjb3B5X3N0 b3JhZ2VfdXNpbmdfYnVmZmVyX3JlYWRfc3RyZWFtX3ByaXZhdGUgcDsKKwlSZWFkU3RyZWFtICpz cmNfc3RyZWFtOworCVNNZ3JSZWxhdGlvbiBzcmNfc21ncjsKIAogCS8qCiAJICogSW4gZ2VuZXJh bCwgd2Ugd2FudCB0byB3cml0ZSBXQUwgd2hlbmV2ZXIgd2FsX2xldmVsID4gJ21pbmltYWwnLCBi dXQgd2UKQEAgLTQ3MTYsMTkgKzQ3NDcsMzEgQEAgUmVsYXRpb25Db3B5U3RvcmFnZVVzaW5nQnVm ZmVyKFJlbEZpbGVMb2NhdG9yIHNyY2xvY2F0b3IsCiAJYnN0cmF0ZWd5X3NyYyA9IEdldEFjY2Vz c1N0cmF0ZWd5KEJBU19CVUxLUkVBRCk7CiAJYnN0cmF0ZWd5X2RzdCA9IEdldEFjY2Vzc1N0cmF0 ZWd5KEJBU19CVUxLV1JJVEUpOwogCisJLyogSW5pdGFsaXplIHN0cmVhbWluZyByZWFkICovCisJ cC5ibG9ja251bSA9IDA7CisJcC5sYXN0X2Jsb2NrID0gbmJsb2NrczsKKwlzcmNfc21nciA9IHNt Z3JvcGVuKHNyY2xvY2F0b3IsIElOVkFMSURfUFJPQ19OVU1CRVIpOworCXNyY19zdHJlYW0gPSBy ZWFkX3N0cmVhbV9iZWdpbl9zbWdyX3JlbGF0aW9uKFJFQURfU1RSRUFNX0ZVTEwsCisJCQkJCQkJ CQkJCQkgYnN0cmF0ZWd5X3NyYywKKwkJCQkJCQkJCQkJCSBzcmNfc21nciwKKwkJCQkJCQkJCQkJ CSBwZXJtYW5lbnQgPyBSRUxQRVJTSVNURU5DRV9QRVJNQU5FTlQgOiBSRUxQRVJTSVNURU5DRV9V TkxPR0dFRCwKKwkJCQkJCQkJCQkJCSBmb3JrTnVtLAorCQkJCQkJCQkJCQkJIGNvcHlfc3RvcmFn ZV91c2luZ19idWZmZXJfcmVhZF9zdHJlYW1fbmV4dF9ibG9jaywKKwkJCQkJCQkJCQkJCSAmcCwK KwkJCQkJCQkJCQkJCSAwKTsKKwogCS8qIEl0ZXJhdGUgb3ZlciBlYWNoIGJsb2NrIG9mIHRoZSBz b3VyY2UgcmVsYXRpb24gZmlsZS4gKi8KIAlmb3IgKGJsa25vID0gMDsgYmxrbm8gPCBuYmxvY2tz OyBibGtubysrKQogCXsKIAkJQ0hFQ0tfRk9SX0lOVEVSUlVQVFMoKTsKIAogCQkvKiBSZWFkIGJs b2NrIGZyb20gc291cmNlIHJlbGF0aW9uLiAqLwotCQlzcmNCdWYgPSBSZWFkQnVmZmVyV2l0aG91 dFJlbGNhY2hlKHNyY2xvY2F0b3IsIGZvcmtOdW0sIGJsa25vLAotCQkJCQkJCQkJCSAgIFJCTV9O T1JNQUwsIGJzdHJhdGVneV9zcmMsCi0JCQkJCQkJCQkJICAgcGVybWFuZW50KTsKKwkJc3JjQnVm ID0gcmVhZF9zdHJlYW1fbmV4dF9idWZmZXIoc3JjX3N0cmVhbSwgTlVMTCk7CiAJCUxvY2tCdWZm ZXIoc3JjQnVmLCBCVUZGRVJfTE9DS19TSEFSRSk7CiAJCXNyY1BhZ2UgPSBCdWZmZXJHZXRQYWdl KHNyY0J1Zik7CiAKLQkJZHN0QnVmID0gUmVhZEJ1ZmZlcldpdGhvdXRSZWxjYWNoZShkc3Rsb2Nh dG9yLCBmb3JrTnVtLCBibGtubywKKwkJZHN0QnVmID0gUmVhZEJ1ZmZlcldpdGhvdXRSZWxjYWNo ZShkc3Rsb2NhdG9yLCBmb3JrTnVtLAorCQkJCQkJCQkJCSAgIEJ1ZmZlckdldEJsb2NrTnVtYmVy KHNyY0J1ZiksCiAJCQkJCQkJCQkJICAgUkJNX1pFUk9fQU5EX0xPQ0ssIGJzdHJhdGVneV9kc3Qs CiAJCQkJCQkJCQkJICAgcGVybWFuZW50KTsKIAkJZHN0UGFnZSA9IEJ1ZmZlckdldFBhZ2UoZHN0 QnVmKTsKQEAgLTQ3NDgsNiArNDc5MSw4IEBAIFJlbGF0aW9uQ29weVN0b3JhZ2VVc2luZ0J1ZmZl cihSZWxGaWxlTG9jYXRvciBzcmNsb2NhdG9yLAogCQlVbmxvY2tSZWxlYXNlQnVmZmVyKGRzdEJ1 Zik7CiAJCVVubG9ja1JlbGVhc2VCdWZmZXIoc3JjQnVmKTsKIAl9CisJQXNzZXJ0KHJlYWRfc3Ry ZWFtX25leHRfYnVmZmVyKHNyY19zdHJlYW0sIE5VTEwpID09IEludmFsaWRCdWZmZXIpOworCXJl YWRfc3RyZWFtX2VuZChzcmNfc3RyZWFtKTsKIAogCUZyZWVBY2Nlc3NTdHJhdGVneShic3RyYXRl Z3lfc3JjKTsKIAlGcmVlQWNjZXNzU3RyYXRlZ3koYnN0cmF0ZWd5X2RzdCk7Ci0tIAoyLjQ1LjIK Cg== --0000000000007a6292061d5b68d9--