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 1siqxO-00ABZD-TX for pgsql-hackers@arkaria.postgresql.org; Tue, 27 Aug 2024 07:49:39 +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 1siqxL-003N9J-NR for pgsql-hackers@arkaria.postgresql.org; Tue, 27 Aug 2024 07:49:36 +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.94.2) (envelope-from ) id 1siqxL-003N9B-3A for pgsql-hackers@lists.postgresql.org; Tue, 27 Aug 2024 07:49:35 +0000 Received: from mail-pl1-x62b.google.com ([2607:f8b0:4864:20::62b]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.94.2) (envelope-from ) id 1siqxI-001eSz-GT for pgsql-hackers@lists.postgresql.org; Tue, 27 Aug 2024 07:49:34 +0000 Received: by mail-pl1-x62b.google.com with SMTP id d9443c01a7336-201df0b2df4so42021825ad.0 for ; Tue, 27 Aug 2024 00:49:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1724744971; x=1725349771; 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=G3FJgJcHncesLwNlECtCCkAlGE71yfS4y/Q5ositgQY=; b=Z7Jk16RREY2N1jZz1fZL7H5Kh+blY9L9K6k8n2M9zsN5FZzWLvbo/GPtfHrQUMx1Tb Z01wE7eXGCtcXx83hMQ79XF8T61/I93xngWo/3o3xAjV0sKsYsbwSWSQTS54R+4FvH/7 BNPCG09sVPpSvEOFd14NEbCQEogtUywqkFktfHMlqxrS9RJkQskDpJNGAjiPfaT3oH4V o4PWDXSTGuFKDB4fHb1gKsWnoR7ZMMa796FR3GK17IGOi+MF5uARQ/8iHFKLyIOOwZqM Ts6342LzopQYyha2cw+UlSIQtWxMKOwr2WlfcGzWr5Njrf3zm8ZqY/MxKmxQL4zEi5+n HbbQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1724744971; x=1725349771; 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=G3FJgJcHncesLwNlECtCCkAlGE71yfS4y/Q5ositgQY=; b=t8J5NFW3eCI0pSVxYmORDG71kh6fhQ77kwLUJBHKqj0mJHfyfEiEVNOJqWOea0NZi+ 3wM5QxfoyjZHPGBnLFwXMF1T+s2+ypE8lJWirQlhXdnHddJhRwlt5WL50Ul/lXzHBKDs mScHTp2es3LSWQMcLNJnVMGPuIKqA0opxmW9iI8tFPTgZHrulT3Echwvd9LwlaXixVgC 21osfxnjs/6c94nla+AVoieW/Ku4jYzJJOGaqTeKcp5K/Iol4EwEqHkOi7Pj0iurRYxF S9UbmH1TamvQaHpOmorvZfip5WC/Y1saio3wps70IAUosIpUbEbMEu6Kv7FAn0YgM6Ie kjTg== X-Gm-Message-State: AOJu0YxkTtzTh6YqNuUhAAfQamfTJXXU+QOdRuAaxs3q7OEH2L5pal/M Ft51mOjr7Qtxt1LewDpb8hF7ZRJ1162yclCbzecpiD7//7ksi41zNzQV4BvSKv/0awo6I9C9TYu eWKxEq6hfDo7BAR/wBN8/gDAloh26O/ca X-Google-Smtp-Source: AGHT+IHDOZpejEJv5w+RqRjWMcoloAm+XOvxb5nByCKyxNsun3D/oiIymaM4oziLPqfDZiSwL1pH9SOuQ5SxA5gzsTA= X-Received: by 2002:a17:90a:3fc2:b0:2d3:d239:24c2 with SMTP id 98e67ed59e1d1-2d646c25399mr12084953a91.19.1724744971214; Tue, 27 Aug 2024 00:49:31 -0700 (PDT) MIME-Version: 1.0 References: <20240820184742.f2.nmisch@google.com> <20240823190124.9e@rfd.leadboat.com> In-Reply-To: <20240823190124.9e@rfd.leadboat.com> From: Nazir Bilal Yavuz Date: Tue, 27 Aug 2024 10:49:19 +0300 Message-ID: Subject: Re: Use read streams in pg_visibility To: Noah Misch Cc: PostgreSQL Hackers Content-Type: multipart/mixed; boundary="0000000000005682250620a57b40" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --0000000000005682250620a57b40 Content-Type: text/plain; charset="UTF-8" Hi, On Fri, 23 Aug 2024 at 22:01, Noah Misch wrote: > > On Fri, Aug 23, 2024 at 02:20:06PM +0300, Nazir Bilal Yavuz wrote: > > On Tue, 20 Aug 2024 at 21:47, Noah Misch wrote: > > > On Tue, Aug 13, 2024 at 03:22:27PM +0300, Nazir Bilal Yavuz wrote: > > > > The downside of this approach is there are too many "vmbuffer is valid > > > > but BufferGetBlockNumber(*vmbuffer) is not equal to mapBlock, so > > > > vmbuffer needs to be read again" cases in the read stream version (700 > > > > vs 20 for the 6 GB table). This is caused by the callback function of > > > > the read stream reading a new vmbuf while getting next block numbers. > > > > So, vmbuf is wrong when we are checking visibility map bits that might > > > > have changed while we were acquiring the page lock. > > > > > > Did the test that found 700 "read again" use a different procedure than the > > > one shared as setup.sh down-thread? Using that script alone, none of the vm > > > bits are set, so I'd not expect any heap page reads. > > > > Yes, it is basically the same script but the query is 'SELECT > > pg_check_visible('${TABLE}'::regclass);'. > > I gather the scripts deal exclusively in tables with no vm bits set, so > pg_visibility did no heap page reads under those scripts. But the '700 "read > again"' result suggests either I'm guessing wrong, or that result came from a > different test procedure. Thoughts? Sorry, yes. You need to run VACUUM on the test table before running the query. The script is attached. You can run the script with [corrupt | visibility] arguments to test the related patches. > > > The "vmbuffer needs to be read again" regression fits what I would expect the > > > v1 patch to do with a table having many vm bits set. In general, I think the > > > fix is to keep two heap Buffer vars, so the callback can work on one vmbuffer > > > while collect_corrupt_items() works on another vmbuffer. Much of the time, > > > they'll be the same buffer. It could be as simple as that, but you could > > > consider further optimizations like these: > > > > Thanks for the suggestion. Keeping two vmbuffers lowered the count of > > "read-again" cases to ~40. I ran the test again and the timing > > improvement is ~5% now. > > > I think the number of "read-again" cases are low enough now. > > Agreed. The increase from 20 to 40 is probably an increase in buffer mapping > lookups, not an increase in I/O. > > > Does creating something like > > pg_general_read_stream_next_block() in read_stream code and exporting > > it makes sense? > > To me, that name isn't conveying the function's behavior, and the words "pg_" > and "general_" aren't adding information there. How about one of these names > or similar: > > seq_read_stream_cb > sequential_read_stream_cb > block_range_read_stream_cb I liked the block_range_read_stream_cb. Attached patches for that (first 3 patches). I chose an nblocks way instead of last_blocks in the struct. > > > The callback doesn't return blocks having zero vm bits, so the blkno variable > > > is not accurate. I didn't test, but I think the loop's "Recheck to avoid > > > returning spurious results." looks at the bit for the wrong block. If that's > > > what v1 does, could you expand the test file to catch that? For example, make > > > a two-block table with only the second block all-visible. > > > > Yes, it was not accurate. I am getting blockno from the buffer now. I > > checked and confirmed it is working as expected by manually logging > > blocknos returned from the read stream. I am not sure how to add a > > test case for this. > > VACUUM FREEZE makes an all-visible, all-frozen table. DELETE of a particular > TID, even if rolled back, clears both vm bits for the TID's page. Past tests > like that had instability problems. One cause is a concurrent session's XID > or snapshot, which can prevent VACUUM setting vm bits. Using a TEMP table may > have been one of the countermeasures, but I don't remember clearly. Hence, > please search the archives or the existing pg_visibility tests for how we > dealt with that. It may not be problem for this particular test. Thanks for the information, I will check these. What I still do not understand is how to make sure that only the second block is processed and the first one is skipped. pg_check_visible() and pg_check_frozen() returns TIDs that cause corruption in the visibility map, there is no information about block numbers. > > There is one behavioral change introduced with the patches. It could > > happen when collect_corrupt_items() is called with both all_visible > > and all_frozen being true. > > -> Let's say VM_ALL_FROZEN() returns true but VM_ALL_VISIBLE() returns > > false in callback. Callback returns this block number because > > VM_ALL_FROZEN() is true. > > -> At the /* Recheck to avoid returning spurious results. */ part, we > > should only check VM_ALL_FROZEN() again as this was returning true in > > the callback. But we check both VM_ALL_FROZEN() and VM_ALL_VISIBLE(). > > VM_ALL_FROZEN() returns false and VM_ALL_VISIBLE() returns true now > > (vice versa of callback). > > -> We were skipping this block in the master but the patched version > > does not skip that. > > > > Is this a problem? If this is a problem, a solution might be to > > callback return values of VM_ALL_FROZEN() and VM_ALL_VISIBLE() in the > > per_buffer_data. > > No, I don't consider that a problem. That's not making us do additional I/O, > just testing more bits within the pages we're already loading. The difference > in behavior is user-visible, but it's the same behavior change the user would > get if the timing had been a bit different. Thanks for the clarification. -- Regards, Nazir Bilal Yavuz Microsoft --0000000000005682250620a57b40 Content-Type: application/x-patch; name="v3-0001-Add-general-use-struct-and-callback-to-read-strea.patch" Content-Disposition: attachment; filename="v3-0001-Add-general-use-struct-and-callback-to-read-strea.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_m0c3q4660 RnJvbSA1NWU4ZTc4ZDA1YjEzNWJhYmY4ZmY4Yzg0ZmI5NzQ3YWQxOWM1OGMxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOYXppciBCaWxhbCBZYXZ1eiA8YnlhdnV6ODFAZ21haWwuY29t PgpEYXRlOiBNb24sIDI2IEF1ZyAyMDI0IDEyOjEyOjUyICswMzAwClN1YmplY3Q6IFtQQVRDSCB2 MyAxLzVdIEFkZCBnZW5lcmFsLXVzZSBzdHJ1Y3QgYW5kIGNhbGxiYWNrIHRvIHJlYWQgc3RyZWFt CgpOdW1iZXIgb2YgY2FsbGJhY2tzIHRoYXQganVzdCBpdGVyYXRlcyBvdmVyIGJsb2NrIHJhbmdl IGluIHJlYWQgc3RyZWFtCmFyZSBpbmNyZWFzaW5nLiBTbywgYWRkIGdlbmVyYWwtdXNlIHN0cnVj dCBhbmQgY2FsbGJhY2sgdG8gcmVhZCBzdHJlYW0uCi0tLQogc3JjL2luY2x1ZGUvc3RvcmFnZS9y ZWFkX3N0cmVhbS5oICAgICB8IDEyICsrKysrKysrKysrKwogc3JjL2JhY2tlbmQvc3RvcmFnZS9h aW8vcmVhZF9zdHJlYW0uYyB8IDE3ICsrKysrKysrKysrKysrKysrCiBzcmMvdG9vbHMvcGdpbmRl bnQvdHlwZWRlZnMubGlzdCAgICAgIHwgIDEgKwogMyBmaWxlcyBjaGFuZ2VkLCAzMCBpbnNlcnRp b25zKCspCgpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvc3RvcmFnZS9yZWFkX3N0cmVhbS5oIGIv c3JjL2luY2x1ZGUvc3RvcmFnZS9yZWFkX3N0cmVhbS5oCmluZGV4IDRlNTk5OTA0ZjI2Li43NjEz YzFlMzYxYyAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvc3RvcmFnZS9yZWFkX3N0cmVhbS5oCisr KyBiL3NyYy9pbmNsdWRlL3N0b3JhZ2UvcmVhZF9zdHJlYW0uaApAQCAtNDUsMTEgKzQ1LDIzIEBA CiBzdHJ1Y3QgUmVhZFN0cmVhbTsKIHR5cGVkZWYgc3RydWN0IFJlYWRTdHJlYW0gUmVhZFN0cmVh bTsKIAorLyoKKyAqIEdlbmVyYWwtdXNlIHN0cnVjdCB0byB1c2UgaW4gY2FsbGJhY2sgZnVuY3Rp b25zIGZvciBibG9jayByYW5nZSBzY2Fucy4KKyAqLwordHlwZWRlZiBzdHJ1Y3QgQmxvY2tSYW5n ZVJlYWRTdHJlYW1Qcml2YXRlCit7CisJQmxvY2tOdW1iZXIgYmxvY2tudW07CisJQmxvY2tOdW1i ZXIgbmJsb2NrczsKK30gQmxvY2tSYW5nZVJlYWRTdHJlYW1Qcml2YXRlOworCiAvKiBDYWxsYmFj ayB0aGF0IHJldHVybnMgdGhlIG5leHQgYmxvY2sgbnVtYmVyIHRvIHJlYWQuICovCiB0eXBlZGVm IEJsb2NrTnVtYmVyICgqUmVhZFN0cmVhbUJsb2NrTnVtYmVyQ0IpIChSZWFkU3RyZWFtICpzdHJl YW0sCiAJCQkJCQkJCQkJCQl2b2lkICpjYWxsYmFja19wcml2YXRlX2RhdGEsCiAJCQkJCQkJCQkJ CQl2b2lkICpwZXJfYnVmZmVyX2RhdGEpOwogCitleHRlcm4gQmxvY2tOdW1iZXIgYmxvY2tfcmFu Z2VfcmVhZF9zdHJlYW1fY2IoUmVhZFN0cmVhbSAqc3RyZWFtLAorCQkJCQkJCQkJCQkgIHZvaWQg KmNhbGxiYWNrX3ByaXZhdGVfZGF0YSwKKwkJCQkJCQkJCQkJICB2b2lkICpwZXJfYnVmZmVyX2Rh dGEpOwogZXh0ZXJuIFJlYWRTdHJlYW0gKnJlYWRfc3RyZWFtX2JlZ2luX3JlbGF0aW9uKGludCBm bGFncywKIAkJCQkJCQkJCQkJICBCdWZmZXJBY2Nlc3NTdHJhdGVneSBzdHJhdGVneSwKIAkJCQkJ CQkJCQkJICBSZWxhdGlvbiByZWwsCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9zdG9yYWdlL2Fp by9yZWFkX3N0cmVhbS5jIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9haW8vcmVhZF9zdHJlYW0uYwpp bmRleCBhODNjMThjMmE0Yi4uOTM3ZDAwMWVmMDggMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3N0 b3JhZ2UvYWlvL3JlYWRfc3RyZWFtLmMKKysrIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9haW8vcmVh ZF9zdHJlYW0uYwpAQCAtMTY2LDYgKzE2NiwyMyBAQCBnZXRfcGVyX2J1ZmZlcl9kYXRhKFJlYWRT dHJlYW0gKnN0cmVhbSwgaW50MTYgYnVmZmVyX2luZGV4KQogCQlzdHJlYW0tPnBlcl9idWZmZXJf ZGF0YV9zaXplICogYnVmZmVyX2luZGV4OwogfQogCisvKgorICogR2VuZXJhbC11c2UgY2FsbGJh Y2sgZnVuY3Rpb24gZm9yIGJsb2NrIHJhbmdlIHNjYW5zLiBDYWxsYmFjayBsb29wcyBiZXR3ZWVu CisgKiBibG9ja251bSAoaW5jbHVzaXZlKSBhbmQgbmJsb2NrcyAoZXhjbHVzaXZlKS4KKyAqLwor QmxvY2tOdW1iZXIKK2Jsb2NrX3JhbmdlX3JlYWRfc3RyZWFtX2NiKFJlYWRTdHJlYW0gKnN0cmVh bSwKKwkJCQkJCSAgIHZvaWQgKmNhbGxiYWNrX3ByaXZhdGVfZGF0YSwKKwkJCQkJCSAgIHZvaWQg KnBlcl9idWZmZXJfZGF0YSkKK3sKKwlCbG9ja1JhbmdlUmVhZFN0cmVhbVByaXZhdGUgKnAgPSBj YWxsYmFja19wcml2YXRlX2RhdGE7CisKKwlpZiAocC0+YmxvY2tudW0gPCBwLT5uYmxvY2tzKQor CQlyZXR1cm4gcC0+YmxvY2tudW0rKzsKKworCXJldHVybiBJbnZhbGlkQmxvY2tOdW1iZXI7Cit9 CisKIC8qCiAgKiBBc2sgdGhlIGNhbGxiYWNrIHdoaWNoIGJsb2NrIGl0IHdvdWxkIGxpa2UgdXMg dG8gcmVhZCBuZXh0LCB3aXRoIGEgc21hbGwKICAqIGJ1ZmZlciBpbiBmcm9udCB0byBhbGxvdyBy ZWFkX3N0cmVhbV91bmdldF9ibG9jaygpIHRvIHdvcmsgYW5kIHRvIGFsbG93IHRoZQpkaWZmIC0t Z2l0IGEvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QgYi9zcmMvdG9vbHMvcGdpbmRl bnQvdHlwZWRlZnMubGlzdAppbmRleCA5ZTk1MWE5ZTZmMy4uZGYzZjMzNmJlYzAgMTAwNjQ0Ci0t LSBhL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0CisrKyBiL3NyYy90b29scy9wZ2lu ZGVudC90eXBlZGVmcy5saXN0CkBAIC0yNzUsNiArMjc1LDcgQEAgQmxvY2tJZAogQmxvY2tJZERh dGEKIEJsb2NrSW5mb1JlY29yZAogQmxvY2tOdW1iZXIKK0Jsb2NrUmFuZ2VSZWFkU3RyZWFtUHJp dmF0ZQogQmxvY2tSZWZUYWJsZQogQmxvY2tSZWZUYWJsZUJ1ZmZlcgogQmxvY2tSZWZUYWJsZUNo dW5rCi0tIAoyLjQ1LjIKCg== --0000000000005682250620a57b40 Content-Type: application/x-patch; name="v3-0002-pg_prewarm-Use-generic-use-read-stream-struct-and.patch" Content-Disposition: attachment; filename="v3-0002-pg_prewarm-Use-generic-use-read-stream-struct-and.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_m0c3q74b1 RnJvbSAwMWRlNWZmOTU0ZjdkYjZhNzQ5ZWJmYzBiMTI4MWVkMDEwYjVlOGY5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOYXppciBCaWxhbCBZYXZ1eiA8YnlhdnV6ODFAZ21haWwuY29t PgpEYXRlOiBNb24sIDI2IEF1ZyAyMDI0IDEyOjE2OjA2ICswMzAwClN1YmplY3Q6IFtQQVRDSCB2 MyAyLzVdIHBnX3ByZXdhcm06IFVzZSBnZW5lcmljLXVzZSByZWFkIHN0cmVhbSBzdHJ1Y3QgYW5k CiBjYWxsYmFjawoKSW5zdGVhZCBvZiBjcmVhdGluZyBhbm90aGVyIHJlYWQgc3RyZWFtIHN0cnVj dCBhbmQgY2FsbGJhY2ssIHVzZSBnZW5lcmljCm9uZSB0aGF0IGlzIGV4cG9ydGVkIGZyb20gcmVh ZCBzdHJlYW0uCi0tLQogY29udHJpYi9wZ19wcmV3YXJtL3BnX3ByZXdhcm0uYyB8IDI1ICsrKy0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAzIGluc2VydGlvbnMoKyksIDIy IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2NvbnRyaWIvcGdfcHJld2FybS9wZ19wcmV3YXJt LmMgYi9jb250cmliL3BnX3ByZXdhcm0vcGdfcHJld2FybS5jCmluZGV4IDVjODU5ZTk4M2M1Li44 ODk2MzlhMDlhMyAxMDA2NDQKLS0tIGEvY29udHJpYi9wZ19wcmV3YXJtL3BnX3ByZXdhcm0uYwor KysgYi9jb250cmliL3BnX3ByZXdhcm0vcGdfcHJld2FybS5jCkBAIC0zOSwyNSArMzksNiBAQCB0 eXBlZGVmIGVudW0KIAogc3RhdGljIFBHSU9BbGlnbmVkQmxvY2sgYmxvY2tidWZmZXI7CiAKLXN0 cnVjdCBwZ19wcmV3YXJtX3JlYWRfc3RyZWFtX3ByaXZhdGUKLXsKLQlCbG9ja051bWJlciBibG9j a251bTsKLQlpbnQ2NAkJbGFzdF9ibG9jazsKLX07Ci0KLXN0YXRpYyBCbG9ja051bWJlcgotcGdf cHJld2FybV9yZWFkX3N0cmVhbV9uZXh0X2Jsb2NrKFJlYWRTdHJlYW0gKnN0cmVhbSwKLQkJCQkJ CQkJICB2b2lkICpjYWxsYmFja19wcml2YXRlX2RhdGEsCi0JCQkJCQkJCSAgdm9pZCAqcGVyX2J1 ZmZlcl9kYXRhKQotewotCXN0cnVjdCBwZ19wcmV3YXJtX3JlYWRfc3RyZWFtX3ByaXZhdGUgKnAg PSBjYWxsYmFja19wcml2YXRlX2RhdGE7Ci0KLQlpZiAocC0+YmxvY2tudW0gPD0gcC0+bGFzdF9i bG9jaykKLQkJcmV0dXJuIHAtPmJsb2NrbnVtKys7Ci0KLQlyZXR1cm4gSW52YWxpZEJsb2NrTnVt YmVyOwotfQotCiAvKgogICogcGdfcHJld2FybShyZWdjbGFzcywgbW9kZSB0ZXh0LCBmb3JrIHRl eHQsCiAgKgkJCSAgZmlyc3RfYmxvY2sgaW50OCwgbGFzdF9ibG9jayBpbnQ4KQpAQCAtMjAzLDcg KzE4NCw3IEBAIHBnX3ByZXdhcm0oUEdfRlVOQ1RJT05fQVJHUykKIAl9CiAJZWxzZSBpZiAocHR5 cGUgPT0gUFJFV0FSTV9CVUZGRVIpCiAJewotCQlzdHJ1Y3QgcGdfcHJld2FybV9yZWFkX3N0cmVh bV9wcml2YXRlIHA7CisJCUJsb2NrUmFuZ2VSZWFkU3RyZWFtUHJpdmF0ZSBwOwogCQlSZWFkU3Ry ZWFtICpzdHJlYW07CiAKIAkJLyoKQEAgLTIxMiwxMyArMTkzLDEzIEBAIHBnX3ByZXdhcm0oUEdf RlVOQ1RJT05fQVJHUykKIAogCQkvKiBTZXQgdXAgdGhlIHByaXZhdGUgc3RhdGUgZm9yIG91ciBz dHJlYW1pbmcgYnVmZmVyIHJlYWQgY2FsbGJhY2suICovCiAJCXAuYmxvY2tudW0gPSBmaXJzdF9i bG9jazsKLQkJcC5sYXN0X2Jsb2NrID0gbGFzdF9ibG9jazsKKwkJcC5uYmxvY2tzID0gbGFzdF9i bG9jayArIDE7CiAKIAkJc3RyZWFtID0gcmVhZF9zdHJlYW1fYmVnaW5fcmVsYXRpb24oUkVBRF9T VFJFQU1fRlVMTCwKIAkJCQkJCQkJCQkJTlVMTCwKIAkJCQkJCQkJCQkJcmVsLAogCQkJCQkJCQkJ CQlmb3JrTnVtYmVyLAotCQkJCQkJCQkJCQlwZ19wcmV3YXJtX3JlYWRfc3RyZWFtX25leHRfYmxv Y2ssCisJCQkJCQkJCQkJCWJsb2NrX3JhbmdlX3JlYWRfc3RyZWFtX2NiLAogCQkJCQkJCQkJCQkm cCwKIAkJCQkJCQkJCQkJMCk7CiAKLS0gCjIuNDUuMgoK --0000000000005682250620a57b40 Content-Type: application/x-patch; name="v3-0003-RelationCopyStorageUsingBuffer-Use-generic-use-re.patch" Content-Disposition: attachment; filename="v3-0003-RelationCopyStorageUsingBuffer-Use-generic-use-re.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_m0c3q9gh2 RnJvbSBhZmM4YzUwYzM5MjEyZTAxNmY3MWVlMjg3MDYyYzI4N2ZmZmJhY2MyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOYXppciBCaWxhbCBZYXZ1eiA8YnlhdnV6ODFAZ21haWwuY29t PgpEYXRlOiBNb24sIDI2IEF1ZyAyMDI0IDEyOjI0OjI2ICswMzAwClN1YmplY3Q6IFtQQVRDSCB2 MyAzLzVdIFJlbGF0aW9uQ29weVN0b3JhZ2VVc2luZ0J1ZmZlcjogVXNlIGdlbmVyaWMtdXNlIHJl YWQKIHN0cmVhbSBzdHJ1Y3QgYW5kIGNhbGxiYWNrCgpJbnN0ZWFkIG9mIGNyZWF0aW5nIGFub3Ro ZXIgcmVhZCBzdHJlYW0gc3RydWN0IGFuZCBjYWxsYmFjaywgdXNlIGdlbmVyaWMKb25lIHRoYXQg aXMgZXhwb3J0ZWQgZnJvbSByZWFkIHN0cmVhbS4KLS0tCiBzcmMvYmFja2VuZC9zdG9yYWdlL2J1 ZmZlci9idWZtZ3IuYyB8IDMxICsrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAxIGZpbGUg Y2hhbmdlZCwgMiBpbnNlcnRpb25zKCspLCAyOSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9z cmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2Uv YnVmZmVyL2J1Zm1nci5jCmluZGV4IGZiMzhjN2JkZDQ1Li5jMDRlNDczMzkyMSAxMDA2NDQKLS0t IGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMKKysrIGIvc3JjL2JhY2tlbmQv c3RvcmFnZS9idWZmZXIvYnVmbWdyLmMKQEAgLTEzNiwzMyArMTM2LDYgQEAgdHlwZWRlZiBzdHJ1 Y3QgU01nclNvcnRBcnJheQogCVNNZ3JSZWxhdGlvbiBzcmVsOwogfSBTTWdyU29ydEFycmF5Owog Ci0vKgotICogSGVscGVyIHN0cnVjdCBmb3IgcmVhZCBzdHJlYW0gb2JqZWN0IHVzZWQgaW4KLSAq IFJlbGF0aW9uQ29weVN0b3JhZ2VVc2luZ0J1ZmZlcigpIGZ1bmN0aW9uLgotICovCi1zdHJ1Y3Qg Y29weV9zdG9yYWdlX3VzaW5nX2J1ZmZlcl9yZWFkX3N0cmVhbV9wcml2YXRlCi17Ci0JQmxvY2tO dW1iZXIgYmxvY2tudW07Ci0JQmxvY2tOdW1iZXIgbmJsb2NrczsKLX07Ci0KLS8qCi0gKiBDYWxs YmFjayBmdW5jdGlvbiB0byBnZXQgbmV4dCBibG9jayBmb3IgcmVhZCBzdHJlYW0gb2JqZWN0IHVz ZWQgaW4KLSAqIFJlbGF0aW9uQ29weVN0b3JhZ2VVc2luZ0J1ZmZlcigpIGZ1bmN0aW9uLgotICov Ci1zdGF0aWMgQmxvY2tOdW1iZXIKLWNvcHlfc3RvcmFnZV91c2luZ19idWZmZXJfcmVhZF9zdHJl YW1fbmV4dF9ibG9jayhSZWFkU3RyZWFtICpzdHJlYW0sCi0JCQkJCQkJCQkJCQkgdm9pZCAqY2Fs bGJhY2tfcHJpdmF0ZV9kYXRhLAotCQkJCQkJCQkJCQkJIHZvaWQgKnBlcl9idWZmZXJfZGF0YSkK LXsKLQlzdHJ1Y3QgY29weV9zdG9yYWdlX3VzaW5nX2J1ZmZlcl9yZWFkX3N0cmVhbV9wcml2YXRl ICpwID0gY2FsbGJhY2tfcHJpdmF0ZV9kYXRhOwotCi0JaWYgKHAtPmJsb2NrbnVtIDwgcC0+bmJs b2NrcykKLQkJcmV0dXJuIHAtPmJsb2NrbnVtKys7Ci0KLQlyZXR1cm4gSW52YWxpZEJsb2NrTnVt YmVyOwotfQotCiAvKiBHVUMgdmFyaWFibGVzICovCiBib29sCQl6ZXJvX2RhbWFnZWRfcGFnZXMg PSBmYWxzZTsKIGludAkJCWJnd3JpdGVyX2xydV9tYXhwYWdlcyA9IDEwMDsKQEAgLTQ3MTAsNyAr NDY4Myw3IEBAIFJlbGF0aW9uQ29weVN0b3JhZ2VVc2luZ0J1ZmZlcihSZWxGaWxlTG9jYXRvciBz cmNsb2NhdG9yLAogCVBHSU9BbGlnbmVkQmxvY2sgYnVmOwogCUJ1ZmZlckFjY2Vzc1N0cmF0ZWd5 IGJzdHJhdGVneV9zcmM7CiAJQnVmZmVyQWNjZXNzU3RyYXRlZ3kgYnN0cmF0ZWd5X2RzdDsKLQlz dHJ1Y3QgY29weV9zdG9yYWdlX3VzaW5nX2J1ZmZlcl9yZWFkX3N0cmVhbV9wcml2YXRlIHA7CisJ QmxvY2tSYW5nZVJlYWRTdHJlYW1Qcml2YXRlIHA7CiAJUmVhZFN0cmVhbSAqc3JjX3N0cmVhbTsK IAlTTWdyUmVsYXRpb24gc3JjX3NtZ3I7CiAKQEAgLTQ3NTAsNyArNDcyMyw3IEBAIFJlbGF0aW9u Q29weVN0b3JhZ2VVc2luZ0J1ZmZlcihSZWxGaWxlTG9jYXRvciBzcmNsb2NhdG9yLAogCQkJCQkJ CQkJCQkJIHNyY19zbWdyLAogCQkJCQkJCQkJCQkJIHBlcm1hbmVudCA/IFJFTFBFUlNJU1RFTkNF X1BFUk1BTkVOVCA6IFJFTFBFUlNJU1RFTkNFX1VOTE9HR0VELAogCQkJCQkJCQkJCQkJIGZvcmtO dW0sCi0JCQkJCQkJCQkJCQkgY29weV9zdG9yYWdlX3VzaW5nX2J1ZmZlcl9yZWFkX3N0cmVhbV9u ZXh0X2Jsb2NrLAorCQkJCQkJCQkJCQkJIGJsb2NrX3JhbmdlX3JlYWRfc3RyZWFtX2NiLAogCQkJ CQkJCQkJCQkJICZwLAogCQkJCQkJCQkJCQkJIDApOwogCi0tIAoyLjQ1LjIKCg== --0000000000005682250620a57b40 Content-Type: application/x-patch; name="v3-0004-Use-read-stream-in-pg_visibility-in-collect_visib.patch" Content-Disposition: attachment; filename="v3-0004-Use-read-stream-in-pg_visibility-in-collect_visib.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_m0c3qc5n3 RnJvbSBmYmJjYTZlMWMyN2U0NWFmYWU5MTM3MjI4ODExZDlmYTExYTdhMTk3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOYXppciBCaWxhbCBZYXZ1eiA8YnlhdnV6ODFAZ21haWwuY29t PgpEYXRlOiBNb24sIDI2IEF1ZyAyMDI0IDE1OjQ1OjIwICswMzAwClN1YmplY3Q6IFtQQVRDSCB2 MyA0LzVdIFVzZSByZWFkIHN0cmVhbSBpbiBwZ192aXNpYmlsaXR5IGluCiBjb2xsZWN0X3Zpc2li aWxpdHlfZGF0YSgpCgpJbnN0ZWFkIG9mIHJlYWRpbmcgYmxvY2tzIHdpdGggUmVhZEJ1ZmZlckV4 dGVuZGVkKCkgaW4KY29sbGVjdF92aXNpYmlsaXR5X2RhdGEoKSwgdXNlIHJlYWQgc3RyZWFtLgoK VGhpcyBjaGFuZ2UgcHJvdmlkZXMgYWJvdXQgNCUgcGVyZm9ybWFuY2UgaW1wcm92ZW1lbnQuCi0t LQogY29udHJpYi9wZ192aXNpYmlsaXR5L3BnX3Zpc2liaWxpdHkuYyB8IDI2ICsrKysrKysrKysr KysrKysrKysrKysrKy0tCiAxIGZpbGUgY2hhbmdlZCwgMjQgaW5zZXJ0aW9ucygrKSwgMiBkZWxl dGlvbnMoLSkKCmRpZmYgLS1naXQgYS9jb250cmliL3BnX3Zpc2liaWxpdHkvcGdfdmlzaWJpbGl0 eS5jIGIvY29udHJpYi9wZ192aXNpYmlsaXR5L3BnX3Zpc2liaWxpdHkuYwppbmRleCA3NzNiYTky ZTQ1NC4uNmM2NGY1ZWFkN2UgMTAwNjQ0Ci0tLSBhL2NvbnRyaWIvcGdfdmlzaWJpbGl0eS9wZ192 aXNpYmlsaXR5LmMKKysrIGIvY29udHJpYi9wZ192aXNpYmlsaXR5L3BnX3Zpc2liaWxpdHkuYwpA QCAtMjEsNiArMjEsNyBAQAogI2luY2x1ZGUgInN0b3JhZ2UvYnVmbWdyLmgiCiAjaW5jbHVkZSAi c3RvcmFnZS9wcm9jLmgiCiAjaW5jbHVkZSAic3RvcmFnZS9wcm9jYXJyYXkuaCIKKyNpbmNsdWRl ICJzdG9yYWdlL3JlYWRfc3RyZWFtLmgiCiAjaW5jbHVkZSAic3RvcmFnZS9zbWdyLmgiCiAjaW5j bHVkZSAidXRpbHMvcmVsLmgiCiAjaW5jbHVkZSAidXRpbHMvc25hcG1nci5oIgpAQCAtNDc4LDYg KzQ3OSw4IEBAIGNvbGxlY3RfdmlzaWJpbGl0eV9kYXRhKE9pZCByZWxpZCwgYm9vbCBpbmNsdWRl X3BkKQogCUJsb2NrTnVtYmVyIGJsa25vOwogCUJ1ZmZlcgkJdm1idWZmZXIgPSBJbnZhbGlkQnVm ZmVyOwogCUJ1ZmZlckFjY2Vzc1N0cmF0ZWd5IGJzdHJhdGVneSA9IEdldEFjY2Vzc1N0cmF0ZWd5 KEJBU19CVUxLUkVBRCk7CisJQmxvY2tSYW5nZVJlYWRTdHJlYW1Qcml2YXRlIHA7CisJUmVhZFN0 cmVhbSAqc3RyZWFtID0gTlVMTDsKIAogCXJlbCA9IHJlbGF0aW9uX29wZW4ocmVsaWQsIEFjY2Vz c1NoYXJlTG9jayk7CiAKQEAgLTQ4OSw2ICs0OTIsMjAgQEAgY29sbGVjdF92aXNpYmlsaXR5X2Rh dGEoT2lkIHJlbGlkLCBib29sIGluY2x1ZGVfcGQpCiAJaW5mby0+bmV4dCA9IDA7CiAJaW5mby0+ Y291bnQgPSBuYmxvY2tzOwogCisJLyogQ3JhdGUgYSByZWFkIHN0cmVhbSBpZiByZWFkIHdpbGwg YmUgZG9uZS4gKi8KKwlpZiAoaW5jbHVkZV9wZCkKKwl7CisJCXAuYmxvY2tudW0gPSAwOworCQlw Lm5ibG9ja3MgPSBuYmxvY2tzOworCQlzdHJlYW0gPSByZWFkX3N0cmVhbV9iZWdpbl9yZWxhdGlv bihSRUFEX1NUUkVBTV9GVUxMLAorCQkJCQkJCQkJCQlic3RyYXRlZ3ksCisJCQkJCQkJCQkJCXJl bCwKKwkJCQkJCQkJCQkJTUFJTl9GT1JLTlVNLAorCQkJCQkJCQkJCQlibG9ja19yYW5nZV9yZWFk X3N0cmVhbV9jYiwKKwkJCQkJCQkJCQkJJnAsCisJCQkJCQkJCQkJCTApOworCX0KKwogCWZvciAo Ymxrbm8gPSAwOyBibGtubyA8IG5ibG9ja3M7ICsrYmxrbm8pCiAJewogCQlpbnQzMgkJbWFwYml0 czsKQEAgLTUxMyw4ICs1MzAsNyBAQCBjb2xsZWN0X3Zpc2liaWxpdHlfZGF0YShPaWQgcmVsaWQs IGJvb2wgaW5jbHVkZV9wZCkKIAkJCUJ1ZmZlcgkJYnVmZmVyOwogCQkJUGFnZQkJcGFnZTsKIAot CQkJYnVmZmVyID0gUmVhZEJ1ZmZlckV4dGVuZGVkKHJlbCwgTUFJTl9GT1JLTlVNLCBibGtubywg UkJNX05PUk1BTCwKLQkJCQkJCQkJCQlic3RyYXRlZ3kpOworCQkJYnVmZmVyID0gcmVhZF9zdHJl YW1fbmV4dF9idWZmZXIoc3RyZWFtLCBOVUxMKTsKIAkJCUxvY2tCdWZmZXIoYnVmZmVyLCBCVUZG RVJfTE9DS19TSEFSRSk7CiAKIAkJCXBhZ2UgPSBCdWZmZXJHZXRQYWdlKGJ1ZmZlcik7CkBAIC01 MjUsNiArNTQxLDEyIEBAIGNvbGxlY3RfdmlzaWJpbGl0eV9kYXRhKE9pZCByZWxpZCwgYm9vbCBp bmNsdWRlX3BkKQogCQl9CiAJfQogCisJaWYgKGluY2x1ZGVfcGQgJiYgc3RyZWFtKQorCXsKKwkJ QXNzZXJ0KHJlYWRfc3RyZWFtX25leHRfYnVmZmVyKHN0cmVhbSwgTlVMTCkgPT0gSW52YWxpZEJ1 ZmZlcik7CisJCXJlYWRfc3RyZWFtX2VuZChzdHJlYW0pOworCX0KKwogCS8qIENsZWFuIHVwLiAq LwogCWlmICh2bWJ1ZmZlciAhPSBJbnZhbGlkQnVmZmVyKQogCQlSZWxlYXNlQnVmZmVyKHZtYnVm ZmVyKTsKLS0gCjIuNDUuMgoK --0000000000005682250620a57b40 Content-Type: application/x-patch; name="v3-0005-Use-read-stream-in-pg_visibility-in-collect_corru.patch" Content-Disposition: attachment; filename="v3-0005-Use-read-stream-in-pg_visibility-in-collect_corru.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_m0c3qeh24 RnJvbSBhYWU1ZGVkN2MzYjNmNzYwMGYwMTY3NGE2MjAwNjQ1ZDEwZDA3MTE2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOYXppciBCaWxhbCBZYXZ1eiA8YnlhdnV6ODFAZ21haWwuY29t PgpEYXRlOiBGcmksIDIzIEF1ZyAyMDI0IDEwOjE1OjA5ICswMzAwClN1YmplY3Q6IFtQQVRDSCB2 MyA1LzVdIFVzZSByZWFkIHN0cmVhbSBpbiBwZ192aXNpYmlsaXR5IGluCiBjb2xsZWN0X2NvcnJ1 cHRfaXRlbXMoKQoKSW5zdGVhZCBvZiByZWFkaW5nIGJsb2NrcyB3aXRoIFJlYWRCdWZmZXJFeHRl bmRlZCgpIGluCmNvbGxlY3RfY29ycnVwdF9pdGVtcygpLCB1c2UgcmVhZCBzdHJlYW0uCgpUaGlz IGNoYW5nZSBwcm92aWRlcyBhYm91dCA1JSBwZXJmb3JtYW5jZSBpbXByb3ZlbWVudC4KLS0tCiBj b250cmliL3BnX3Zpc2liaWxpdHkvcGdfdmlzaWJpbGl0eS5jIHwgODcgKysrKysrKysrKysrKysr KysrKysrKy0tLS0tCiAxIGZpbGUgY2hhbmdlZCwgNzIgaW5zZXJ0aW9ucygrKSwgMTUgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvY29udHJpYi9wZ192aXNpYmlsaXR5L3BnX3Zpc2liaWxpdHku YyBiL2NvbnRyaWIvcGdfdmlzaWJpbGl0eS9wZ192aXNpYmlsaXR5LmMKaW5kZXggNmM2NGY1ZWFk N2UuLjc1YTViMzYyZmUyIDEwMDY0NAotLS0gYS9jb250cmliL3BnX3Zpc2liaWxpdHkvcGdfdmlz aWJpbGl0eS5jCisrKyBiL2NvbnRyaWIvcGdfdmlzaWJpbGl0eS9wZ192aXNpYmlsaXR5LmMKQEAg LTQyLDYgKzQyLDIwIEBAIHR5cGVkZWYgc3RydWN0IGNvcnJ1cHRfaXRlbXMKIAlJdGVtUG9pbnRl ciB0aWRzOwogfSBjb3JydXB0X2l0ZW1zOwogCisvKgorICogSGVscGVyIHN0cnVjdCBmb3IgcmVh ZCBzdHJlYW0gb2JqZWN0IHVzZWQgaW4KKyAqIGNvbGxlY3RfY29ycnVwdF9pdGVtcygpIGZ1bmN0 aW9uLgorICovCitzdHJ1Y3QgY29sbGVjdF9jb3JydXB0X2l0ZW1zX3JlYWRfc3RyZWFtX3ByaXZh dGUKK3sKKwlib29sCQlhbGxfZnJvemVuOworCWJvb2wJCWFsbF92aXNpYmxlOworCUJsb2NrTnVt YmVyIGJsb2NrbnVtOworCUJsb2NrTnVtYmVyIG5ibG9ja3M7CisJUmVsYXRpb24JcmVsOworCUJ1 ZmZlcgkgICAqdm1idWZmZXI7Cit9OworCiBQR19GVU5DVElPTl9JTkZPX1YxKHBnX3Zpc2liaWxp dHlfbWFwKTsKIFBHX0ZVTkNUSU9OX0lORk9fVjEocGdfdmlzaWJpbGl0eV9tYXBfcmVsKTsKIFBH X0ZVTkNUSU9OX0lORk9fVjEocGdfdmlzaWJpbGl0eSk7CkBAIC02MzIsNiArNjQ2LDM4IEBAIEdl dFN0cmljdE9sZGVzdE5vblJlbW92YWJsZVRyYW5zYWN0aW9uSWQoUmVsYXRpb24gcmVsKQogCX0K IH0KIAorLyoKKyAqIENhbGxiYWNrIGZ1bmN0aW9uIHRvIGdldCBuZXh0IGJsb2NrIGZvciByZWFk IHN0cmVhbSBvYmplY3QgdXNlZCBpbgorICogY29sbGVjdF9jb3JydXB0X2l0ZW1zKCkgZnVuY3Rp b24uCisgKi8KK3N0YXRpYyBCbG9ja051bWJlcgorY29sbGVjdF9jb3JydXB0X2l0ZW1zX3JlYWRf c3RyZWFtX25leHRfYmxvY2soUmVhZFN0cmVhbSAqc3RyZWFtLAorCQkJCQkJCQkJCQkgdm9pZCAq Y2FsbGJhY2tfcHJpdmF0ZV9kYXRhLAorCQkJCQkJCQkJCQkgdm9pZCAqcGVyX2J1ZmZlcl9kYXRh KQoreworCXN0cnVjdCBjb2xsZWN0X2NvcnJ1cHRfaXRlbXNfcmVhZF9zdHJlYW1fcHJpdmF0ZSAq cCA9IGNhbGxiYWNrX3ByaXZhdGVfZGF0YTsKKworCWZvciAoOyBwLT5ibG9ja251bSA8IHAtPm5i bG9ja3M7IHAtPmJsb2NrbnVtKyspCisJeworCQlib29sCQljaGVja19mcm96ZW4gPSBmYWxzZTsK KwkJYm9vbAkJY2hlY2tfdmlzaWJsZSA9IGZhbHNlOworCisJCS8qIE1ha2Ugc3VyZSB3ZSBhcmUg aW50ZXJydXB0aWJsZS4gKi8KKwkJQ0hFQ0tfRk9SX0lOVEVSUlVQVFMoKTsKKworCQlpZiAocC0+ YWxsX2Zyb3plbiAmJiBWTV9BTExfRlJPWkVOKHAtPnJlbCwgcC0+YmxvY2tudW0sIHAtPnZtYnVm ZmVyKSkKKwkJCWNoZWNrX2Zyb3plbiA9IHRydWU7CisJCWlmIChwLT5hbGxfdmlzaWJsZSAmJiBW TV9BTExfVklTSUJMRShwLT5yZWwsIHAtPmJsb2NrbnVtLCBwLT52bWJ1ZmZlcikpCisJCQljaGVj a192aXNpYmxlID0gdHJ1ZTsKKwkJaWYgKCFjaGVja192aXNpYmxlICYmICFjaGVja19mcm96ZW4p CisJCQljb250aW51ZTsKKworCQlyZXR1cm4gcC0+YmxvY2tudW0rKzsKKwl9CisKKwlyZXR1cm4g SW52YWxpZEJsb2NrTnVtYmVyOworfQorCiAvKgogICogUmV0dXJucyBhIGxpc3Qgb2YgaXRlbXMg d2hvc2UgdmlzaWJpbGl0eSBtYXAgaW5mb3JtYXRpb24gZG9lcyBub3QgbWF0Y2gKICAqIHRoZSBz dGF0dXMgb2YgdGhlIHR1cGxlcyBvbiB0aGUgcGFnZS4KQEAgLTY1NCw4ICs3MDAsMTIgQEAgY29s bGVjdF9jb3JydXB0X2l0ZW1zKE9pZCByZWxpZCwgYm9vbCBhbGxfdmlzaWJsZSwgYm9vbCBhbGxf ZnJvemVuKQogCWNvcnJ1cHRfaXRlbXMgKml0ZW1zOwogCUJsb2NrTnVtYmVyIGJsa25vOwogCUJ1 ZmZlcgkJdm1idWZmZXIgPSBJbnZhbGlkQnVmZmVyOworCUJ1ZmZlcgkJc3RyZWFtX3ZtYnVmZmVy ID0gSW52YWxpZEJ1ZmZlcjsKIAlCdWZmZXJBY2Nlc3NTdHJhdGVneSBic3RyYXRlZ3kgPSBHZXRB Y2Nlc3NTdHJhdGVneShCQVNfQlVMS1JFQUQpOwogCVRyYW5zYWN0aW9uSWQgT2xkZXN0WG1pbiA9 IEludmFsaWRUcmFuc2FjdGlvbklkOworCXN0cnVjdCBjb2xsZWN0X2NvcnJ1cHRfaXRlbXNfcmVh ZF9zdHJlYW1fcHJpdmF0ZSBwOworCVJlYWRTdHJlYW0gKnN0cmVhbTsKKwlCdWZmZXIJCWJ1ZmZl cjsKIAogCXJlbCA9IHJlbGF0aW9uX29wZW4ocmVsaWQsIEFjY2Vzc1NoYXJlTG9jayk7CiAKQEAg LTY4MCwxMiArNzMwLDI1IEBAIGNvbGxlY3RfY29ycnVwdF9pdGVtcyhPaWQgcmVsaWQsIGJvb2wg YWxsX3Zpc2libGUsIGJvb2wgYWxsX2Zyb3plbikKIAlpdGVtcy0+Y291bnQgPSA2NDsKIAlpdGVt cy0+dGlkcyA9IHBhbGxvYyhpdGVtcy0+Y291bnQgKiBzaXplb2YoSXRlbVBvaW50ZXJEYXRhKSk7 CiAKKwlwLmJsb2NrbnVtID0gMDsKKwlwLm5ibG9ja3MgPSBuYmxvY2tzOworCXAucmVsID0gcmVs OworCXAudm1idWZmZXIgPSAmc3RyZWFtX3ZtYnVmZmVyOworCXAuYWxsX2Zyb3plbiA9IGFsbF9m cm96ZW47CisJcC5hbGxfdmlzaWJsZSA9IGFsbF92aXNpYmxlOworCXN0cmVhbSA9IHJlYWRfc3Ry ZWFtX2JlZ2luX3JlbGF0aW9uKFJFQURfU1RSRUFNX0ZVTEwsCisJCQkJCQkJCQkJYnN0cmF0ZWd5 LAorCQkJCQkJCQkJCXJlbCwKKwkJCQkJCQkJCQlNQUlOX0ZPUktOVU0sCisJCQkJCQkJCQkJY29s bGVjdF9jb3JydXB0X2l0ZW1zX3JlYWRfc3RyZWFtX25leHRfYmxvY2ssCisJCQkJCQkJCQkJJnAs CisJCQkJCQkJCQkJMCk7CisKIAkvKiBMb29wIG92ZXIgZXZlcnkgYmxvY2sgaW4gdGhlIHJlbGF0 aW9uLiAqLwotCWZvciAoYmxrbm8gPSAwOyBibGtubyA8IG5ibG9ja3M7ICsrYmxrbm8pCisJd2hp bGUgKChidWZmZXIgPSByZWFkX3N0cmVhbV9uZXh0X2J1ZmZlcihzdHJlYW0sIE5VTEwpKSAhPSBJ bnZhbGlkQnVmZmVyKQogCXsKIAkJYm9vbAkJY2hlY2tfZnJvemVuID0gZmFsc2U7CiAJCWJvb2wJ CWNoZWNrX3Zpc2libGUgPSBmYWxzZTsKLQkJQnVmZmVyCQlidWZmZXI7CiAJCVBhZ2UJCXBhZ2U7 CiAJCU9mZnNldE51bWJlciBvZmZudW0sCiAJCQkJCW1heG9mZjsKQEAgLTY5MywyOSArNzU2LDE5 IEBAIGNvbGxlY3RfY29ycnVwdF9pdGVtcyhPaWQgcmVsaWQsIGJvb2wgYWxsX3Zpc2libGUsIGJv b2wgYWxsX2Zyb3plbikKIAkJLyogTWFrZSBzdXJlIHdlIGFyZSBpbnRlcnJ1cHRpYmxlLiAqLwog CQlDSEVDS19GT1JfSU5URVJSVVBUUygpOwogCi0JCS8qIFVzZSB0aGUgdmlzaWJpbGl0eSBtYXAg dG8gZGVjaWRlIHdoZXRoZXIgdG8gY2hlY2sgdGhpcyBwYWdlLiAqLwotCQlpZiAoYWxsX2Zyb3pl biAmJiBWTV9BTExfRlJPWkVOKHJlbCwgYmxrbm8sICZ2bWJ1ZmZlcikpCi0JCQljaGVja19mcm96 ZW4gPSB0cnVlOwotCQlpZiAoYWxsX3Zpc2libGUgJiYgVk1fQUxMX1ZJU0lCTEUocmVsLCBibGtu bywgJnZtYnVmZmVyKSkKLQkJCWNoZWNrX3Zpc2libGUgPSB0cnVlOwotCQlpZiAoIWNoZWNrX3Zp c2libGUgJiYgIWNoZWNrX2Zyb3plbikKLQkJCWNvbnRpbnVlOwotCi0JCS8qIFJlYWQgYW5kIGxv Y2sgdGhlIHBhZ2UuICovCi0JCWJ1ZmZlciA9IFJlYWRCdWZmZXJFeHRlbmRlZChyZWwsIE1BSU5f Rk9SS05VTSwgYmxrbm8sIFJCTV9OT1JNQUwsCi0JCQkJCQkJCQlic3RyYXRlZ3kpOwogCQlMb2Nr QnVmZmVyKGJ1ZmZlciwgQlVGRkVSX0xPQ0tfU0hBUkUpOwogCiAJCXBhZ2UgPSBCdWZmZXJHZXRQ YWdlKGJ1ZmZlcik7CiAJCW1heG9mZiA9IFBhZ2VHZXRNYXhPZmZzZXROdW1iZXIocGFnZSk7CisJ CWJsa25vID0gQnVmZmVyR2V0QmxvY2tOdW1iZXIoYnVmZmVyKTsKIAogCQkvKgogCQkgKiBUaGUg dmlzaWJpbGl0eSBtYXAgYml0cyBtaWdodCBoYXZlIGNoYW5nZWQgd2hpbGUgd2Ugd2VyZSBhY3F1 aXJpbmcKIAkJICogdGhlIHBhZ2UgbG9jay4gIFJlY2hlY2sgdG8gYXZvaWQgcmV0dXJuaW5nIHNw dXJpb3VzIHJlc3VsdHMuCiAJCSAqLwotCQlpZiAoY2hlY2tfZnJvemVuICYmICFWTV9BTExfRlJP WkVOKHJlbCwgYmxrbm8sICZ2bWJ1ZmZlcikpCisJCWlmIChhbGxfZnJvemVuICYmICFWTV9BTExf RlJPWkVOKHJlbCwgYmxrbm8sICZ2bWJ1ZmZlcikpCiAJCQljaGVja19mcm96ZW4gPSBmYWxzZTsK LQkJaWYgKGNoZWNrX3Zpc2libGUgJiYgIVZNX0FMTF9WSVNJQkxFKHJlbCwgYmxrbm8sICZ2bWJ1 ZmZlcikpCisJCWlmIChhbGxfdmlzaWJsZSAmJiAhVk1fQUxMX1ZJU0lCTEUocmVsLCBibGtubywg JnZtYnVmZmVyKSkKIAkJCWNoZWNrX3Zpc2libGUgPSBmYWxzZTsKIAkJaWYgKCFjaGVja192aXNp YmxlICYmICFjaGVja19mcm96ZW4pCiAJCXsKQEAgLTgwMCwxMCArODUzLDE0IEBAIGNvbGxlY3Rf Y29ycnVwdF9pdGVtcyhPaWQgcmVsaWQsIGJvb2wgYWxsX3Zpc2libGUsIGJvb2wgYWxsX2Zyb3pl bikKIAogCQlVbmxvY2tSZWxlYXNlQnVmZmVyKGJ1ZmZlcik7CiAJfQorCUFzc2VydChyZWFkX3N0 cmVhbV9uZXh0X2J1ZmZlcihzdHJlYW0sIE5VTEwpID09IEludmFsaWRCdWZmZXIpOworCXJlYWRf c3RyZWFtX2VuZChzdHJlYW0pOwogCiAJLyogQ2xlYW4gdXAuICovCiAJaWYgKHZtYnVmZmVyICE9 IEludmFsaWRCdWZmZXIpCiAJCVJlbGVhc2VCdWZmZXIodm1idWZmZXIpOworCWlmIChzdHJlYW1f dm1idWZmZXIgIT0gSW52YWxpZEJ1ZmZlcikKKwkJUmVsZWFzZUJ1ZmZlcihzdHJlYW1fdm1idWZm ZXIpOwogCXJlbGF0aW9uX2Nsb3NlKHJlbCwgQWNjZXNzU2hhcmVMb2NrKTsKIAogCS8qCi0tIAoy LjQ1LjIKCg== --0000000000005682250620a57b40 Content-Type: application/x-sh; name="setup.sh" Content-Disposition: attachment; filename="setup.sh" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_m0c3qkig5 IyEgL2Jpbi9iYXNoCgpDT01NQU5EPSQxCgpEQk5BTUU9InRlc3QiClRBQkxFPSJ0ZXN0X3RhYmxl IgpPVVRQVVQ9IiR7MX1fcGF0Y2hlZCIKTj0xMDAKUVVFUlk9IiIKCnNldHVwKCkgewogICAgcm0g LWYgJHtPVVRQVVR9CiAgICBwc3FsIC1jICJDUkVBVEUgRVhURU5TSU9OIElGIE5PVCBFWElTVFMg cGdfdmlzaWJpbGl0eTsiICR7REJOQU1FfQogICAgcHNxbCAtYyAiRFJPUCBUQUJMRSBJRiBFWElT VFMgJHtUQUJMRX07IENSRUFURSBUQUJMRSAke1RBQkxFfSBhcyBzZWxlY3QgcmVwZWF0KCdhJywg MTAwKSB8fCBpIHx8IHJlcGVhdCgnYicsIDUwMCkgYXMgZmlsbGVyIGZyb20gZ2VuZXJhdGVfc2Vy aWVzKDEsIDkwMDAwMDApIGFzIGk7IiAke0RCTkFNRX0KfQoKY29ycnVwdCgpIHsKICAgIFFVRVJZ PSJTRUxFQ1QgcGdfY2hlY2tfdmlzaWJsZSgnJHtUQUJMRX0nOjpyZWdjbGFzcyk7IgogICAgcHNx bCAtYyAiVkFDVVVNICR7VEFCTEV9OyIgJHtEQk5BTUV9Cn0KCnZpc2liaWxpdHkoKSB7CiAgICBR VUVSWT0iU0VMRUNUICogRlJPTSBwZ192aXNpYmlsaXR5KCcke1RBQkxFfSc6OnJlZ2NsYXNzKSB3 aGVyZSBibGtubyA9IC0xOyIKfQoKcnVuICgpIHsKICAgIGZvciBpIGluICQoIHNlcSAxICR7Tn0g KQogICAgZG8KICAgICAgICAjIGRyb3BfT1NfY2FjaGU7CiAgICAgICAgcHNxbCAtYyAiJHtRVUVS WX0iICR7REJOQU1FfSB8IGdyZXAgJ1RpbWUnIHwgYXdrIC1GICcgJyAne3ByaW50ICQyfScgPj4g JHtPVVRQVVR9OwogICAgZG9uZQp9CgpjYXNlICRDT01NQU5EIGluCgogICAgY29ycnVwdCkKICAg ICAgICBzZXR1cAogICAgICAgIGNvcnJ1cHQKICAgICAgICBydW4KICAgIDs7CgogICAgdmlzaWJp bGl0eSkKICAgICAgICBzZXR1cAogICAgICAgIHZpc2liaWxpdHkKICAgICAgICBydW4KICAgIDs7 CgogICAgKikKICAgICAgICBlY2hvICJ3cm9uZyBjb21tYW5kIgogICAgICAgIGV4aXQgMQogICAg OzsKZXNhYwo= --0000000000005682250620a57b40--