Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vzqEj-001N2k-1P for pgsql-hackers@arkaria.postgresql.org; Tue, 10 Mar 2026 06:06:33 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vzqEh-001oMH-2M for pgsql-hackers@arkaria.postgresql.org; Tue, 10 Mar 2026 06:06:32 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vzqEh-001oM9-0T for pgsql-hackers@lists.postgresql.org; Tue, 10 Mar 2026 06:06:31 +0000 Received: from mail-ej1-x62a.google.com ([2a00:1450:4864:20::62a]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1vzqEf-00000001PIv-1IED for pgsql-hackers@lists.postgresql.org; Tue, 10 Mar 2026 06:06:30 +0000 Received: by mail-ej1-x62a.google.com with SMTP id a640c23a62f3a-b9382e59c0eso1012118066b.0 for ; Mon, 09 Mar 2026 23:06:29 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1773122786; cv=none; d=google.com; s=arc-20240605; b=LJ9dvD9misaYZ4xGGGIlGHBIJETFZo5Dt7tY6hQQHX23D35NhRtEmcsc4UmCR6f6JW Q1vyuSH4UldTeOP+yGgLv+SMzL32PXLfrhgJpFWLaEzrei0l8OIM1tCVrPeCOGE022Rm DKiSCV0/V1k+6vWTKANqcSRbp6tJIM89NjJvtgN+ShO//C/Ggm2OHsZ+y/bqm32tU4/7 x3hqPk/hZ+UQFAiCvA5SQyWm1MCMUDmtDCLpTMPmGCcAK2Nr0MmBvzMOhjUzpAkfLXVQ xI90pkj/nezRX8lEmEFiW3gk5bvy7XcQjc5kuPMWgPmZrznVcBM8Cxauwjig0Mxcl9IT mTtg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:dkim-signature; bh=fthSoJGjKyPs0utRK99sxT4FB+jyeGx7uIG03kVpTpg=; fh=w810V/xSCEz11ItLsobfWl1Q8xyyp8tfiBKFaGxRaNk=; b=Ad9QeIl8jg1GA91XR1htrmlgRHiNUmLEURD6dp7xqBNEUt32rMaSwlCivMRKecD0/b CIe5233vob1Hb4m0p5+1YjZKzH4OKA7+EID2zFsdUdh8nYnvEEZOP2uG7sHcqlgtxE/H 8+ZUs7EcV4W9fkyFgV5VdNPzVmQZQ2Es+KBdKseQTSpz5QmiQolCAr8z/F6bccY+phPK ZyPisuxyXA80i8KZBgPvmrNir9D7c7VLwTAIhblejQu61MBrwy3uSuu5xsnBwjiCwpf8 7rEBM8yUfI7azdnDYGfKRE8LBHUOVI2yNZXYuDNf1cJgYj5iNXuN0h+TMCJAsl6Dwz4d jDSQ==; darn=lists.postgresql.org ARC-Authentication-Results: i=1; mx.google.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1773122786; x=1773727586; 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=fthSoJGjKyPs0utRK99sxT4FB+jyeGx7uIG03kVpTpg=; b=cENczs9FNestdkBEKQcm03z5B0p6pW1judGn9POWKiPJcJCMMe8IxfhKKd0tkVfG0e 81ERKQ+fBAgBNon8bbLnk0xwOxUio6q1ofNwDUgwNvGu0mXK4Sm/Buj7iqMmzj3Nu6Te qICERWzfCED76Jqm0R6Dh9ky2oT+jCDkznfW3piN5e4YCIk/wFh4S/l/Mbv46HtOaICu M0G7x4/VsnqidXD2kWcYawW24HiHDXwtD421IhVASQOwsOAnB44CIjpbW/PcSyeai4o7 QeL85TsI7VVMSFoKJEMxfGudFBaC4ZjmHJiX6OfMCkdf+7Cxb1/F8jnsH1dWHWcJctJf +0Jw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1773122786; x=1773727586; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-gg:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=fthSoJGjKyPs0utRK99sxT4FB+jyeGx7uIG03kVpTpg=; b=tLn2AiEirN4t/FPzv+WIrOLTAOljjBcxhBFogtm2qWTFg7vXiTsMRqh7M9fDbJOOzV llDV7r4VQYxdDa2v1I/cx3PzKkVoUhFY5kVcKNITH5WMcwxrffUWb8DcZzIGzg4XvMEd fN/IwQNqCcoh5DRWgu4aZMfvWRBD0KK5eNIIhyElsWmGeX7JwiUMF/ThTAnDQc8FHpTe WgxA8ZO2+G2Tbaxjc/VWddzyafzKqqsVu3F4mnymTmEY+QE0mXhhEcSee+DH5EZ9gWii C4BHMaozX8eC0/7dft4OrQpTzx+T5CJjc5epYvzRPaN06ok5QVB4vPSFm6TyAQn63FmJ 29mg== X-Gm-Message-State: AOJu0YzSvFxWnUb2VawvHSm7fzlT/SndjakPfZNfCsuKDJK6ewAV6MYv CuvHOUxtLZc5oYT/0sSaFdUfkMg23Ny31z3VX10khwYHoA/0BequR0rd/NheFVPdqbKwr++z5Wk xJ1dDKpp3jbKx5/bLPuKkH+rs1MYg4DNKY7+fk1o= X-Gm-Gg: ATEYQzyGNNXjgP3TJzlwyjt7UXMC92OJyVTHn87zvFBlw2WKNM0f7gUojD6EwanETbr NsG/UfY7tlQqmU2OUso2LHKMfHVjHbyl+xROieuNT4ErJqzZPqUWRouWll6bNTF21OL5ZBnm4hf v3qCO7DXi6F5HbUcKhpd/yior045vZv8MEX7KwncNf+1N4nSBtdnPAkXh9Qjm6ImHQt+WsarSUy IxNsaqWmQGzC27X1+60WnxHlcrzm93ivZsJyynhvDtDE+i1ttSVgSVKULcxXLao2RhjkwC0tfS1 9BnkNdNM/rBvx6B2DoIoSU00r7fhjpvRJhFFL1T6dkiY/eT9WBUVo2fxBvJ+O/8kvyQHu2p8eqL t0oJQiLgM3WfmIaUs1fQ= X-Received: by 2002:a17:907:bb49:b0:b97:896:7a0 with SMTP id a640c23a62f3a-b9708964fa6mr223122366b.60.1773122785809; Mon, 09 Mar 2026 23:06:25 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Xuneng Zhou Date: Tue, 10 Mar 2026 14:06:12 +0800 X-Gm-Features: AaiRm53mhxoXi3GWDC6W8nP_4jV7VBDDlRxBdmmznUYDEDCnjRH__VDrT2J8lSA Message-ID: Subject: Re: Streamify more code paths To: pgsql-hackers Cc: Nazir Bilal Yavuz Content-Type: multipart/mixed; boundary="000000000000caf217064ca55138" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --000000000000caf217064ca55138 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Hi, On Mon, Feb 9, 2026 at 6:40=E2=80=AFPM Xuneng Zhou w= rote: > > Hi, > > On Thu, Feb 5, 2026 at 12:01=E2=80=AFPM Xuneng Zhou wrote: > > > > Hi, > > > > On Tue, Dec 30, 2025 at 10:43=E2=80=AFAM Xuneng Zhou wrote: > > > > > > Hi, > > > > > > On Tue, Dec 30, 2025 at 9:51=E2=80=AFAM Xuneng Zhou wrote: > > > > > > > > Hi, > > > > > > > > Thanks for looking into this. > > > > > > > > On Mon, Dec 29, 2025 at 6:58=E2=80=AFPM Nazir Bilal Yavuz wrote: > > > > > > > > > > Hi, > > > > > > > > > > On Sun, 28 Dec 2025 at 14:46, Xuneng Zhou = wrote: > > > > > > > > > > > > Hi, > > > > > > > > > > > > > > Two more to go: > > > > > > > patch 5: Streamify log_newpage_range() WAL logging path > > > > > > > patch 6: Streamify hash index VACUUM primary bucket page read= s > > > > > > > > > > > > > > Benchmarks will be conducted soon. > > > > > > > > > > > > > > > > > > > v6 in the last message has a problem and has not been updated. = Attach > > > > > > the right one again. Sorry for the noise. > > > > > > > > > > 0003 and 0006: > > > > > > > > > > You need to add 'StatApproxReadStreamPrivate' and > > > > > 'HashBulkDeleteStreamPrivate' to the typedefs.list. > > > > > > > > Done. > > > > > > > > > 0005: > > > > > > > > > > @@ -1321,8 +1341,10 @@ log_newpage_range(Relation rel, ForkNumber= forknum, > > > > > nbufs =3D 0; > > > > > while (nbufs < XLR_MAX_BLOCK_ID && blkno < endblk) > > > > > { > > > > > - Buffer buf =3D ReadBufferExtended(rel, forknu= m, blkno, > > > > > - RBM_NORMAL, NUL= L); > > > > > + Buffer buf =3D read_stream_next_buffer(stream= , NULL); > > > > > + > > > > > + if (!BufferIsValid(buf)) > > > > > + break; > > > > > > > > > > We are loosening a check here, there should not be a invalid buff= er in > > > > > the stream until the endblk. I think you can remove this > > > > > BufferIsValid() check, then we can learn if something goes wrong. > > > > > > > > My concern before for not adding assert at the end of streaming is = the > > > > potential early break in here: > > > > > > > > /* Nothing more to do if all remaining blocks were empty. */ > > > > if (nbufs =3D=3D 0) > > > > break; > > > > > > > > After looking more closely, it turns out to be a misunderstanding o= f the logic. > > > > > > > > > 0006: > > > > > > > > > > You can use read_stream_reset() instead of read_stream_end(), the= n you > > > > > can use the same stream with different variables, I believe this = is > > > > > the preferred way. > > > > > > > > > > Rest LGTM! > > > > > > > > > > > > > Yeah, reset seems a more proper way here. > > > > > > > > > > Run pgindent using the updated typedefs.list. > > > > > > > I've completed benchmarking of the v4 streaming read patches across > > three I/O methods (io_uring, sync, worker). Tests were run with cold > > cache on large datasets. > > > > --- Settings --- > > > > shared_buffers =3D '8GB' > > effective_io_concurrency =3D 200 > > io_method =3D $IO_METHOD > > io_workers =3D $IO_WORKERS > > io_max_concurrency =3D $IO_MAX_CONCURRENCY > > track_io_timing =3D on > > autovacuum =3D off > > checkpoint_timeout =3D 1h > > max_wal_size =3D 10GB > > max_parallel_workers_per_gather =3D 0 > > > > --- Machine --- > > CPU: 48-core > > RAM: 256 GB DDR5 > > Disk: 2 x 1.92 TB NVMe SSD > > > > --- Executive Summary --- > > > > The patches provide significant benefits for I/O-bound sequential > > operations, with the greatest improvements seen when using > > asynchronous I/O methods (io_uring and worker). The synchronous I/O > > mode shows reduced but still meaningful gains. > > > > --- Results by I/O Method > > > > Best Results: io_method=3Dworker > > > > bloom_scan: 4.14x (75.9% faster); 93% fewer reads > > pgstattuple: 1.59x (37.1% faster); 94% fewer reads > > hash_vacuum: 1.05x (4.4% faster); 80% fewer reads > > gin_vacuum: 1.06x (5.6% faster); 15% fewer reads > > bloom_vacuum: 1.04x (3.9% faster); 76% fewer reads > > wal_logging: 0.98x (-2.5%, neutral/slightly slower); no change in reads > > > > io_method=3Dio_uring > > > > bloom_scan: 3.12x (68.0% faster); 93% fewer reads > > pgstattuple: 1.50x (33.2% faster); 94% fewer reads > > hash_vacuum: 1.03x (3.3% faster); 80% fewer reads > > gin_vacuum: 1.02x (2.1% faster); 15% fewer reads > > bloom_vacuum: 1.03x (3.4% faster); 76% fewer reads > > wal_logging: 1.00x (-0.5%, neutral); no change in reads > > > > io_method=3Dsync (baseline comparison) > > > > bloom_scan: 1.20x (16.4% faster); 93% fewer reads > > pgstattuple: 1.10x (9.0% faster); 94% fewer reads > > hash_vacuum: 1.01x (0.8% faster); 80% fewer reads > > gin_vacuum: 1.02x (1.7% faster); 15% fewer reads > > bloom_vacuum: 1.03x (2.8% faster); 76% fewer reads > > wal_logging: 0.99x (-0.7%, neutral); no change in reads > > > > --- Observations --- > > > > Async I/O amplifies streaming benefits: The same patches show 3-4x > > improvement with worker/io_uring vs 1.2x with sync. > > > > I/O operation reduction is consistent: All modes show the same ~93-94% > > reduction in I/O operations for bloom_scan and pgstattuple. > > > > VACUUM operations show modest gains: Despite large I/O reductions > > (76-80%), wall-clock improvements are smaller (3-15%) since VACUUM has > > larger CPU overhead (tuple processing, index maintenance, WAL > > logging). > > > > log_newpage_range shows no benefit: The patch provides no improvement (= ~0.97x). > > > > -- > > Best, > > Xuneng > > There was an issue in the wal_log test of the original script. > > --- The original benchmark used: > ALTER TABLE ... SET LOGGED > > This path performs a full table rewrite via ATRewriteTable() > (tablecmds.c). It creates a new relfilenode and copies tuples into it. > It does not call log_newpage_range() on rewritten pages. > > log_newpage_range() may only appear indirectly through the > pending-sync logic in storage.c, and only when: > > wal_level =3D minimal, and > relation size < wal_skip_threshold (default 2MB). > > Our test tables (1M=E2=80=9320M rows) are far larger than 2MB. In that ca= se, > PostgreSQL fsyncs the file instead of WAL-logging it. Therefore, the > previous benchmark measured table rewrite I/O, not the > log_newpage_range() path. > > --- Current design: GIN index build > > The benchmark now uses: > CREATE INDEX ... USING gin (doc_tsv) > > This reliably exercises log_newpage_range() because: > - ginbuild() constructs the index and WAL-logs all new index pages > using log_newpage_range(). > - This is part of the normal GIN build path, independent of wal_skip_thre= shold. > - The streaming-read patch modifies the WAL logging path inside > log_newpage_range(), which this test directly targets. > > --- Results (wal_logging_large) > worker: 1.00x (+0.5%); no meaningful change in reads > io_uring: 1.01x (+1.3%); no meaningful change in reads > sync: 1.01x (+1.1%); no meaningful change in reads > > -- > Best, > Xuneng Here=E2=80=99s v5 of the patchset. The wal_logging_large patch has been removed, as no performance gains were observed in the benchmark runs. --=20 Best, Xuneng --000000000000caf217064ca55138 Content-Type: application/octet-stream; name="v5-0001-Switch-Bloom-scan-paths-to-streaming-read.patch" Content-Disposition: attachment; filename="v5-0001-Switch-Bloom-scan-paths-to-streaming-read.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmk7cv0l0 RnJvbSA3ZTkzMzM4YjUyYTRiZGRlNWNlOTZmNTljOGYyNTJiY2EyMTlkN2EzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBhbHRlcmVnbzY1NSA8ODI0NjYyNTI2QHFxLmNvbT4KRGF0ZTog U2F0LCAyNyBEZWMgMjAyNSAwMDoyODoxMCArMDgwMApTdWJqZWN0OiBbUEFUQ0ggdjUgMS81XSBT d2l0Y2ggQmxvb20gc2NhbiBwYXRocyB0byBzdHJlYW1pbmcgcmVhZC4KClJlcGxhY2UgcGVyLXBh Z2UgUmVhZEJ1ZmZlciBsb29wcyBpbiBibGdldGJpdG1hcCgpIHdpdGggcmVhZF9zdHJlYW1fYmVn aW5fcmVsYXRpb24oKSBhbmQgc2VxdWVudGlhbCBidWZmZXIgaXRlcmF0aW9uLCByZWR1Y2luZyBi dWZmZXIgY2h1cm4gYW5kIGltcHJvdmluZyBzY2FuIGVmZmljaWVuY3kgb24gbGFyZ2UgQmxvb20g aW5kZXhlcy4KLS0tCiBjb250cmliL2Jsb29tL2Jsc2Nhbi5jIHwgMjkgKysrKysrKysrKysrKysr KysrKysrKysrKy0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAyNSBpbnNlcnRpb25zKCspLCA0IGRlbGV0 aW9ucygtKQoKZGlmZiAtLWdpdCBhL2NvbnRyaWIvYmxvb20vYmxzY2FuLmMgYi9jb250cmliL2Js b29tL2Jsc2Nhbi5jCmluZGV4IDBkNzFlZGJlOTFjLi5iMWZkYWJhYWI3NCAxMDA2NDQKLS0tIGEv Y29udHJpYi9ibG9vbS9ibHNjYW4uYworKysgYi9jb250cmliL2Jsb29tL2Jsc2Nhbi5jCkBAIC0x Nyw2ICsxNyw3IEBACiAjaW5jbHVkZSAibWlzY2FkbWluLmgiCiAjaW5jbHVkZSAicGdzdGF0Lmgi CiAjaW5jbHVkZSAic3RvcmFnZS9idWZtZ3IuaCIKKyNpbmNsdWRlICJzdG9yYWdlL3JlYWRfc3Ry ZWFtLmgiCiAKIC8qCiAgKiBCZWdpbiBzY2FuIG9mIGJsb29tIGluZGV4LgpAQCAtNzUsMTEgKzc2 LDEzIEBAIGludDY0CiBibGdldGJpdG1hcChJbmRleFNjYW5EZXNjIHNjYW4sIFRJREJpdG1hcCAq dGJtKQogewogCWludDY0CQludGlkcyA9IDA7Ci0JQmxvY2tOdW1iZXIgYmxrbm8gPSBCTE9PTV9I RUFEX0JMS05PLAorCUJsb2NrTnVtYmVyIGJsa25vLAogCQkJCW5wYWdlczsKIAlpbnQJCQlpOwog CUJ1ZmZlckFjY2Vzc1N0cmF0ZWd5IGJhczsKIAlCbG9vbVNjYW5PcGFxdWUgc28gPSAoQmxvb21T Y2FuT3BhcXVlKSBzY2FuLT5vcGFxdWU7CisJQmxvY2tSYW5nZVJlYWRTdHJlYW1Qcml2YXRlIHA7 CisJUmVhZFN0cmVhbSAqc3RyZWFtOwogCiAJaWYgKHNvLT5zaWduID09IE5VTEwpCiAJewpAQCAt MTE5LDE0ICsxMjIsMjkgQEAgYmxnZXRiaXRtYXAoSW5kZXhTY2FuRGVzYyBzY2FuLCBUSURCaXRt YXAgKnRibSkKIAlpZiAoc2Nhbi0+aW5zdHJ1bWVudCkKIAkJc2Nhbi0+aW5zdHJ1bWVudC0+bnNl YXJjaGVzKys7CiAKKwkvKiBTY2FuIGFsbCBibG9ja3MgZXhjZXB0IHRoZSBtZXRhcGFnZSB1c2lu ZyBzdHJlYW1pbmcgcmVhZHMgKi8KKwlwLmN1cnJlbnRfYmxvY2tudW0gPSBCTE9PTV9IRUFEX0JM S05POworCXAubGFzdF9leGNsdXNpdmUgPSBucGFnZXM7CisKKwkvKgorCSAqIEl0IGlzIHNhZmUg dG8gdXNlIGJhdGNobW9kZSBhcyBibG9ja19yYW5nZV9yZWFkX3N0cmVhbV9jYiB0YWtlcyBubwor CSAqIGxvY2tzLgorCSAqLworCXN0cmVhbSA9IHJlYWRfc3RyZWFtX2JlZ2luX3JlbGF0aW9uKFJF QURfU1RSRUFNX0ZVTEwgfAorCQkJCQkJCQkJCVJFQURfU1RSRUFNX1VTRV9CQVRDSElORywKKwkJ CQkJCQkJCQliYXMsCisJCQkJCQkJCQkJc2Nhbi0+aW5kZXhSZWxhdGlvbiwKKwkJCQkJCQkJCQlN QUlOX0ZPUktOVU0sCisJCQkJCQkJCQkJYmxvY2tfcmFuZ2VfcmVhZF9zdHJlYW1fY2IsCisJCQkJ CQkJCQkJJnAsCisJCQkJCQkJCQkJMCk7CisKIAlmb3IgKGJsa25vID0gQkxPT01fSEVBRF9CTEtO TzsgYmxrbm8gPCBucGFnZXM7IGJsa25vKyspCiAJewogCQlCdWZmZXIJCWJ1ZmZlcjsKIAkJUGFn ZQkJcGFnZTsKIAotCQlidWZmZXIgPSBSZWFkQnVmZmVyRXh0ZW5kZWQoc2Nhbi0+aW5kZXhSZWxh dGlvbiwgTUFJTl9GT1JLTlVNLAotCQkJCQkJCQkJYmxrbm8sIFJCTV9OT1JNQUwsIGJhcyk7Ci0K KwkJYnVmZmVyID0gcmVhZF9zdHJlYW1fbmV4dF9idWZmZXIoc3RyZWFtLCBOVUxMKTsKIAkJTG9j a0J1ZmZlcihidWZmZXIsIEJVRkZFUl9MT0NLX1NIQVJFKTsKIAkJcGFnZSA9IEJ1ZmZlckdldFBh Z2UoYnVmZmVyKTsKIApAQCAtMTYyLDYgKzE4MCw5IEBAIGJsZ2V0Yml0bWFwKEluZGV4U2NhbkRl c2Mgc2NhbiwgVElEQml0bWFwICp0Ym0pCiAJCVVubG9ja1JlbGVhc2VCdWZmZXIoYnVmZmVyKTsK IAkJQ0hFQ0tfRk9SX0lOVEVSUlVQVFMoKTsKIAl9CisKKwlBc3NlcnQocmVhZF9zdHJlYW1fbmV4 dF9idWZmZXIoc3RyZWFtLCBOVUxMKSA9PSBJbnZhbGlkQnVmZmVyKTsKKwlyZWFkX3N0cmVhbV9l bmQoc3RyZWFtKTsKIAlGcmVlQWNjZXNzU3RyYXRlZ3koYmFzKTsKIAogCXJldHVybiBudGlkczsK LS0gCjIuNTEuMAoK --000000000000caf217064ca55138 Content-Type: application/octet-stream; name="v5-0003-Streamify-heap-bloat-estimation-scan.-Introduce-a.patch" Content-Disposition: attachment; filename="v5-0003-Streamify-heap-bloat-estimation-scan.-Introduce-a.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmk7cyac2 RnJvbSBjNzliNzk0OTdiZTI4OGI0MWMxOTUzOTcwYTUwMjcyMDQ0MDA4ZWYzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBhbHRlcmVnbzY1NSA8ODI0NjYyNTI2QHFxLmNvbT4KRGF0ZTog U2F0LCAyNyBEZWMgMjAyNSAwMDoyOTowMiArMDgwMApTdWJqZWN0OiBbUEFUQ0ggdjUgMy81XSBT dHJlYW1pZnkgaGVhcCBibG9hdCBlc3RpbWF0aW9uIHNjYW4uIEludHJvZHVjZSBhIAogcmVhZC1z dHJlYW0gY2FsbGJhY2sgdG8gc2tpcCBhbGwtdmlzaWJsZSBwYWdlcyB2aWEgVk0vRlNNIGxvb2t1 cCBhbmQgCiBzdHJlYW0tcmVhZCB0aGUgcmVzdCwgcmVkdWNpbmcgcGFnZSByZWFkcyBhbmQgaW1w cm92aW5nIHBnc3RhdHR1cGxlX2FwcHJveCAKIGV4ZWN1dGlvbiB0aW1lIG9uIGxhcmdlIHJlbGF0 aW9ucy4KCi0tLQogY29udHJpYi9wZ3N0YXR0dXBsZS9wZ3N0YXRhcHByb3guYyB8IDEyNiArKysr KysrKysrKysrKysrKysrKysrLS0tLS0tLQogc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxp c3QgICB8ICAgMSArCiAyIGZpbGVzIGNoYW5nZWQsIDk2IGluc2VydGlvbnMoKyksIDMxIGRlbGV0 aW9ucygtKQoKZGlmZiAtLWdpdCBhL2NvbnRyaWIvcGdzdGF0dHVwbGUvcGdzdGF0YXBwcm94LmMg Yi9jb250cmliL3Bnc3RhdHR1cGxlL3Bnc3RhdGFwcHJveC5jCmluZGV4IGE1OWZmNGU5ZDRmLi45 OTA0MDk0ZDc2NyAxMDA2NDQKLS0tIGEvY29udHJpYi9wZ3N0YXR0dXBsZS9wZ3N0YXRhcHByb3gu YworKysgYi9jb250cmliL3Bnc3RhdHR1cGxlL3Bnc3RhdGFwcHJveC5jCkBAIC0yMyw2ICsyMyw3 IEBACiAjaW5jbHVkZSAic3RvcmFnZS9idWZtZ3IuaCIKICNpbmNsdWRlICJzdG9yYWdlL2ZyZWVz cGFjZS5oIgogI2luY2x1ZGUgInN0b3JhZ2UvcHJvY2FycmF5LmgiCisjaW5jbHVkZSAic3RvcmFn ZS9yZWFkX3N0cmVhbS5oIgogCiBQR19GVU5DVElPTl9JTkZPX1YxKHBnc3RhdHR1cGxlX2FwcHJv eCk7CiBQR19GVU5DVElPTl9JTkZPX1YxKHBnc3RhdHR1cGxlX2FwcHJveF92MV81KTsKQEAgLTQ1 LDYgKzQ2LDYxIEBAIHR5cGVkZWYgc3RydWN0IG91dHB1dF90eXBlCiAKICNkZWZpbmUgTlVNX09V VFBVVF9DT0xVTU5TIDEwCiAKKy8qCisgKiBTdHJ1Y3QgZm9yIHN0YXRhcHByb3hfaGVhcCByZWFk IHN0cmVhbSBjYWxsYmFjay4KKyAqLwordHlwZWRlZiBzdHJ1Y3QgU3RhdEFwcHJveFJlYWRTdHJl YW1Qcml2YXRlCit7CisJUmVsYXRpb24JcmVsOworCW91dHB1dF90eXBlICpzdGF0OworCUJsb2Nr TnVtYmVyIGN1cnJlbnRfYmxvY2tudW07CisJQmxvY2tOdW1iZXIgbmJsb2NrczsKKwlCbG9ja051 bWJlciBzY2FubmVkOwkJLyogY291bnQgb2YgcGFnZXMgYWN0dWFsbHkgcmVhZCAqLworCUJ1ZmZl cgkJdm1idWZmZXI7CQkvKiBmb3IgVk0gbG9va3VwcyAqLworfSBTdGF0QXBwcm94UmVhZFN0cmVh bVByaXZhdGU7CisKKy8qCisgKiBSZWFkIHN0cmVhbSBjYWxsYmFjayBmb3Igc3RhdGFwcHJveF9o ZWFwLgorICoKKyAqIFRoaXMgY2FsbGJhY2sgY2hlY2tzIHRoZSB2aXNpYmlsaXR5IG1hcCBmb3Ig ZWFjaCBibG9jay4gSWYgdGhlIGJsb2NrIGlzCisgKiBhbGwtdmlzaWJsZSwgd2UgY2FuIGdldCB0 aGUgZnJlZSBzcGFjZSBmcm9tIHRoZSBGU00gd2l0aG91dCByZWFkaW5nIHRoZQorICogYWN0dWFs IHBhZ2UsIGFuZCBza2lwIHRvIHRoZSBuZXh0IGJsb2NrLiBPbmx5IGJsb2NrcyB0aGF0IGFyZSBu b3QKKyAqIGFsbC12aXNpYmxlIGFyZSByZXR1cm5lZCBmb3IgYWN0dWFsIHJlYWRpbmcuCisgKi8K K3N0YXRpYyBCbG9ja051bWJlcgorc3RhdGFwcHJveF9oZWFwX3JlYWRfc3RyZWFtX25leHQoUmVh ZFN0cmVhbSAqc3RyZWFtLAorCQkJCQkJCQkgdm9pZCAqY2FsbGJhY2tfcHJpdmF0ZV9kYXRhLAor CQkJCQkJCQkgdm9pZCAqcGVyX2J1ZmZlcl9kYXRhKQoreworCVN0YXRBcHByb3hSZWFkU3RyZWFt UHJpdmF0ZSAqcCA9IGNhbGxiYWNrX3ByaXZhdGVfZGF0YTsKKworCXdoaWxlIChwLT5jdXJyZW50 X2Jsb2NrbnVtIDwgcC0+bmJsb2NrcykKKwl7CisJCUJsb2NrTnVtYmVyIGJsa25vID0gcC0+Y3Vy cmVudF9ibG9ja251bSsrOworCQlTaXplCQlmcmVlc3BhY2U7CisKKwkJQ0hFQ0tfRk9SX0lOVEVS UlVQVFMoKTsKKworCQkvKgorCQkgKiBJZiB0aGUgcGFnZSBoYXMgb25seSB2aXNpYmxlIHR1cGxl cywgdGhlbiB3ZSBjYW4gZmluZCBvdXQgdGhlIGZyZWUKKwkJICogc3BhY2UgZnJvbSB0aGUgRlNN IGFuZCBtb3ZlIG9uIHdpdGhvdXQgcmVhZGluZyB0aGUgcGFnZS4KKwkJICovCisJCWlmIChWTV9B TExfVklTSUJMRShwLT5yZWwsIGJsa25vLCAmcC0+dm1idWZmZXIpKQorCQl7CisJCQlmcmVlc3Bh Y2UgPSBHZXRSZWNvcmRlZEZyZWVTcGFjZShwLT5yZWwsIGJsa25vKTsKKwkJCXAtPnN0YXQtPnR1 cGxlX2xlbiArPSBCTENLU1ogLSBmcmVlc3BhY2U7CisJCQlwLT5zdGF0LT5mcmVlX3NwYWNlICs9 IGZyZWVzcGFjZTsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJLyogVGhpcyBibG9jayBuZWVkcyB0 byBiZSByZWFkICovCisJCXAtPnNjYW5uZWQrKzsKKwkJcmV0dXJuIGJsa25vOworCX0KKworCXJl dHVybiBJbnZhbGlkQmxvY2tOdW1iZXI7Cit9CisKIC8qCiAgKiBUaGlzIGZ1bmN0aW9uIHRha2Vz IGFuIGFscmVhZHkgb3BlbiByZWxhdGlvbiBhbmQgc2NhbnMgaXRzIHBhZ2VzLAogICogc2tpcHBp bmcgdGhvc2UgdGhhdCBoYXZlIHRoZSBjb3JyZXNwb25kaW5nIHZpc2liaWxpdHkgbWFwIGJpdCBz ZXQuCkBAIC01OCw1MyArMTE0LDU4IEBAIHR5cGVkZWYgc3RydWN0IG91dHB1dF90eXBlCiBzdGF0 aWMgdm9pZAogc3RhdGFwcHJveF9oZWFwKFJlbGF0aW9uIHJlbCwgb3V0cHV0X3R5cGUgKnN0YXQp CiB7Ci0JQmxvY2tOdW1iZXIgc2Nhbm5lZCwKLQkJCQluYmxvY2tzLAotCQkJCWJsa25vOwotCUJ1 ZmZlcgkJdm1idWZmZXIgPSBJbnZhbGlkQnVmZmVyOworCUJsb2NrTnVtYmVyIG5ibG9ja3M7CiAJ QnVmZmVyQWNjZXNzU3RyYXRlZ3kgYnN0cmF0ZWd5OwogCVRyYW5zYWN0aW9uSWQgT2xkZXN0WG1p bjsKKwlTdGF0QXBwcm94UmVhZFN0cmVhbVByaXZhdGUgcDsKKwlSZWFkU3RyZWFtICpzdHJlYW07 CiAKIAlPbGRlc3RYbWluID0gR2V0T2xkZXN0Tm9uUmVtb3ZhYmxlVHJhbnNhY3Rpb25JZChyZWwp OwogCWJzdHJhdGVneSA9IEdldEFjY2Vzc1N0cmF0ZWd5KEJBU19CVUxLUkVBRCk7CiAKIAluYmxv Y2tzID0gUmVsYXRpb25HZXROdW1iZXJPZkJsb2NrcyhyZWwpOwotCXNjYW5uZWQgPSAwOwogCi0J Zm9yIChibGtubyA9IDA7IGJsa25vIDwgbmJsb2NrczsgYmxrbm8rKykKKwkvKiBJbml0aWFsaXpl IHJlYWQgc3RyZWFtIHByaXZhdGUgZGF0YSAqLworCXAucmVsID0gcmVsOworCXAuc3RhdCA9IHN0 YXQ7CisJcC5jdXJyZW50X2Jsb2NrbnVtID0gMDsKKwlwLm5ibG9ja3MgPSBuYmxvY2tzOworCXAu c2Nhbm5lZCA9IDA7CisJcC52bWJ1ZmZlciA9IEludmFsaWRCdWZmZXI7CisKKwkvKgorCSAqIENy ZWF0ZSB0aGUgcmVhZCBzdHJlYW0uIFdlIGRvbid0IHVzZSBSRUFEX1NUUkVBTV9VU0VfQkFUQ0hJ TkcgYmVjYXVzZQorCSAqIHRoZSBjYWxsYmFjayBhY2Nlc3NlcyB0aGUgdmlzaWJpbGl0eSBtYXAg d2hpY2ggbWF5IG5lZWQgdG8gcmVhZCBWTQorCSAqIHBhZ2VzLiBXaGlsZSB0aGlzIHNob3VsZG4n dCBjYXVzZSBkZWFkbG9ja3MsIHdlIGVyciBvbiB0aGUgc2lkZSBvZgorCSAqIGNhdXRpb24uCisJ ICovCisJc3RyZWFtID0gcmVhZF9zdHJlYW1fYmVnaW5fcmVsYXRpb24oUkVBRF9TVFJFQU1fRlVM TCwKKwkJCQkJCQkJCQlic3RyYXRlZ3ksCisJCQkJCQkJCQkJcmVsLAorCQkJCQkJCQkJCU1BSU5f Rk9SS05VTSwKKwkJCQkJCQkJCQlzdGF0YXBwcm94X2hlYXBfcmVhZF9zdHJlYW1fbmV4dCwKKwkJ CQkJCQkJCQkmcCwKKwkJCQkJCQkJCQkwKTsKKworCWZvciAoOzspCiAJewogCQlCdWZmZXIJCWJ1 ZjsKIAkJUGFnZQkJcGFnZTsKIAkJT2Zmc2V0TnVtYmVyIG9mZm51bSwKIAkJCQkJbWF4b2ZmOwot CQlTaXplCQlmcmVlc3BhY2U7Ci0KLQkJQ0hFQ0tfRk9SX0lOVEVSUlVQVFMoKTsKLQotCQkvKgot CQkgKiBJZiB0aGUgcGFnZSBoYXMgb25seSB2aXNpYmxlIHR1cGxlcywgdGhlbiB3ZSBjYW4gZmlu ZCBvdXQgdGhlIGZyZWUKLQkJICogc3BhY2UgZnJvbSB0aGUgRlNNIGFuZCBtb3ZlIG9uLgotCQkg Ki8KLQkJaWYgKFZNX0FMTF9WSVNJQkxFKHJlbCwgYmxrbm8sICZ2bWJ1ZmZlcikpCi0JCXsKLQkJ CWZyZWVzcGFjZSA9IEdldFJlY29yZGVkRnJlZVNwYWNlKHJlbCwgYmxrbm8pOwotCQkJc3RhdC0+ dHVwbGVfbGVuICs9IEJMQ0tTWiAtIGZyZWVzcGFjZTsKLQkJCXN0YXQtPmZyZWVfc3BhY2UgKz0g ZnJlZXNwYWNlOwotCQkJY29udGludWU7Ci0JCX0KKwkJQmxvY2tOdW1iZXIgYmxrbm87CiAKLQkJ YnVmID0gUmVhZEJ1ZmZlckV4dGVuZGVkKHJlbCwgTUFJTl9GT1JLTlVNLCBibGtubywKLQkJCQkJ CQkJIFJCTV9OT1JNQUwsIGJzdHJhdGVneSk7CisJCWJ1ZiA9IHJlYWRfc3RyZWFtX25leHRfYnVm ZmVyKHN0cmVhbSwgTlVMTCk7CisJCWlmIChidWYgPT0gSW52YWxpZEJ1ZmZlcikKKwkJCWJyZWFr OwogCiAJCUxvY2tCdWZmZXIoYnVmLCBCVUZGRVJfTE9DS19TSEFSRSk7CiAKIAkJcGFnZSA9IEJ1 ZmZlckdldFBhZ2UoYnVmKTsKKwkJYmxrbm8gPSBCdWZmZXJHZXRCbG9ja051bWJlcihidWYpOwog CiAJCXN0YXQtPmZyZWVfc3BhY2UgKz0gUGFnZUdldEV4YWN0RnJlZVNwYWNlKHBhZ2UpOwogCi0J CS8qIFdlIG1heSBjb3VudCB0aGUgcGFnZSBhcyBzY2FubmVkIGV2ZW4gaWYgaXQncyBuZXcvZW1w dHkgKi8KLQkJc2Nhbm5lZCsrOwotCiAJCWlmIChQYWdlSXNOZXcocGFnZSkgfHwgUGFnZUlzRW1w dHkocGFnZSkpCiAJCXsKIAkJCVVubG9ja1JlbGVhc2VCdWZmZXIoYnVmKTsKQEAgLTE2OSw2ICsy MzAsOSBAQCBzdGF0YXBwcm94X2hlYXAoUmVsYXRpb24gcmVsLCBvdXRwdXRfdHlwZSAqc3RhdCkK IAkJVW5sb2NrUmVsZWFzZUJ1ZmZlcihidWYpOwogCX0KIAorCUFzc2VydChwLmN1cnJlbnRfYmxv Y2tudW0gPT0gbmJsb2Nrcyk7CisJcmVhZF9zdHJlYW1fZW5kKHN0cmVhbSk7CisKIAlzdGF0LT50 YWJsZV9sZW4gPSAodWludDY0KSBuYmxvY2tzICogQkxDS1NaOwogCiAJLyoKQEAgLTE3OSw3ICsy NDMsNyBAQCBzdGF0YXBwcm94X2hlYXAoUmVsYXRpb24gcmVsLCBvdXRwdXRfdHlwZSAqc3RhdCkK IAkgKiB0dXBsZXMgaW4gYWxsLXZpc2libGUgcGFnZXMsIHNvIG5vIGNvcnJlY3Rpb24gaXMgbmVl ZGVkIGZvciB0aGF0LCBhbmQKIAkgKiB3ZSBhbHJlYWR5IGFjY291bnRlZCBmb3IgdGhlIHNwYWNl IGluIHRob3NlIHBhZ2VzLCB0b28uCiAJICovCi0Jc3RhdC0+dHVwbGVfY291bnQgPSB2YWNfZXN0 aW1hdGVfcmVsdHVwbGVzKHJlbCwgbmJsb2Nrcywgc2Nhbm5lZCwKKwlzdGF0LT50dXBsZV9jb3Vu dCA9IHZhY19lc3RpbWF0ZV9yZWx0dXBsZXMocmVsLCBuYmxvY2tzLCBwLnNjYW5uZWQsCiAJCQkJ CQkJCQkJCSAgIHN0YXQtPnR1cGxlX2NvdW50KTsKIAogCS8qIEl0J3Mgbm90IGNsZWFyIGlmIHdl IGNvdWxkIGdldCAtMSBoZXJlLCBidXQgYmUgc2FmZS4gKi8KQEAgLTE5MCwxNiArMjU0LDE2IEBA IHN0YXRhcHByb3hfaGVhcChSZWxhdGlvbiByZWwsIG91dHB1dF90eXBlICpzdGF0KQogCSAqLwog CWlmIChuYmxvY2tzICE9IDApCiAJewotCQlzdGF0LT5zY2FubmVkX3BlcmNlbnQgPSAxMDAuMCAq IHNjYW5uZWQgLyBuYmxvY2tzOworCQlzdGF0LT5zY2FubmVkX3BlcmNlbnQgPSAxMDAuMCAqIHAu c2Nhbm5lZCAvIG5ibG9ja3M7CiAJCXN0YXQtPnR1cGxlX3BlcmNlbnQgPSAxMDAuMCAqIHN0YXQt PnR1cGxlX2xlbiAvIHN0YXQtPnRhYmxlX2xlbjsKIAkJc3RhdC0+ZGVhZF90dXBsZV9wZXJjZW50 ID0gMTAwLjAgKiBzdGF0LT5kZWFkX3R1cGxlX2xlbiAvIHN0YXQtPnRhYmxlX2xlbjsKIAkJc3Rh dC0+ZnJlZV9wZXJjZW50ID0gMTAwLjAgKiBzdGF0LT5mcmVlX3NwYWNlIC8gc3RhdC0+dGFibGVf bGVuOwogCX0KIAotCWlmIChCdWZmZXJJc1ZhbGlkKHZtYnVmZmVyKSkKKwlpZiAoQnVmZmVySXNW YWxpZChwLnZtYnVmZmVyKSkKIAl7Ci0JCVJlbGVhc2VCdWZmZXIodm1idWZmZXIpOwotCQl2bWJ1 ZmZlciA9IEludmFsaWRCdWZmZXI7CisJCVJlbGVhc2VCdWZmZXIocC52bWJ1ZmZlcik7CisJCXAu dm1idWZmZXIgPSBJbnZhbGlkQnVmZmVyOwogCX0KIH0KIApkaWZmIC0tZ2l0IGEvc3JjL3Rvb2xz L3BnaW5kZW50L3R5cGVkZWZzLmxpc3QgYi9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlz dAppbmRleCA1Yzg4ZmE5MmY0ZS4uZGM2ZmMyOGZjYWIgMTAwNjQ0Ci0tLSBhL3NyYy90b29scy9w Z2luZGVudC90eXBlZGVmcy5saXN0CisrKyBiL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5s aXN0CkBAIC0yODk4LDYgKzI4OTgsNyBAQCBTdGFydFJlcGxpY2F0aW9uQ21kCiBTdGFydHVwU3Rh dHVzRW51bQogU3RhdEVudHJ5CiBTdGF0RXh0RW50cnkKK1N0YXRBcHByb3hSZWFkU3RyZWFtUHJp dmF0ZQogU3RhdGVGaWxlQ2h1bmsKIFN0YXRpc3RpY0V4dEluZm8KIFN0YXRzQnVpbGREYXRhCi0t IAoyLjUxLjAKCg== --000000000000caf217064ca55138 Content-Type: application/octet-stream; name="v5-0004-Replace-synchronous-ReadBufferExtended-loop-with-.patch" Content-Disposition: attachment; filename="v5-0004-Replace-synchronous-ReadBufferExtended-loop-with-.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmk7cyai3 RnJvbSA5NGJkYTY2OGUwMzE0OTY0MDI2NDk3MWYzOTIzNjI2MzY5MGUwOWZiIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBhbHRlcmVnbzY1NSA8ODI0NjYyNTI2QHFxLmNvbT4KRGF0ZTog U2F0LCAyNyBEZWMgMjAyNSAwMDoyOTowOSArMDgwMApTdWJqZWN0OiBbUEFUQ0ggdjUgNC81XSBS ZXBsYWNlIHN5bmNocm9ub3VzIFJlYWRCdWZmZXJFeHRlbmRlZCgpIGxvb3Agd2l0aCB0aGUKIHN0 cmVhbWluZyByZWFkIGluIGdpbnZhY3V1bWNsZWFudXAoKSB0byBpbXByb3ZlIEkvTyBlZmZpY2ll bmN5IGR1cmluZyBHSU4KIGluZGV4IHZhY3V1bSBjbGVhbnVwIG9wZXJhdGlvbnMKCi0tLQogc3Jj L2JhY2tlbmQvYWNjZXNzL2dpbi9naW52YWN1dW0uYyB8IDI4ICsrKysrKysrKysrKysrKysrKysr KysrKysrLS0KIDEgZmlsZSBjaGFuZ2VkLCAyNiBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygt KQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9naW4vZ2ludmFjdXVtLmMgYi9zcmMv YmFja2VuZC9hY2Nlc3MvZ2luL2dpbnZhY3V1bS5jCmluZGV4IGQ3YmFmN2M4NDdjLi41OGUwNWM3 MTI1NiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNzL2dpbi9naW52YWN1dW0uYworKysg Yi9zcmMvYmFja2VuZC9hY2Nlc3MvZ2luL2dpbnZhY3V1bS5jCkBAIC0yMiw2ICsyMiw3IEBACiAj aW5jbHVkZSAic3RvcmFnZS9pbmRleGZzbS5oIgogI2luY2x1ZGUgInN0b3JhZ2UvbG1nci5oIgog I2luY2x1ZGUgInN0b3JhZ2UvcHJlZGljYXRlLmgiCisjaW5jbHVkZSAic3RvcmFnZS9yZWFkX3N0 cmVhbS5oIgogI2luY2x1ZGUgInV0aWxzL21lbXV0aWxzLmgiCiAKIHN0cnVjdCBHaW5WYWN1dW1T dGF0ZQpAQCAtNjkzLDYgKzY5NCw4IEBAIGdpbnZhY3V1bWNsZWFudXAoSW5kZXhWYWN1dW1JbmZv ICppbmZvLCBJbmRleEJ1bGtEZWxldGVSZXN1bHQgKnN0YXRzKQogCUJsb2NrTnVtYmVyIHRvdEZy ZWVQYWdlczsKIAlHaW5TdGF0ZQlnaW5zdGF0ZTsKIAlHaW5TdGF0c0RhdGEgaWR4U3RhdDsKKwlC bG9ja1JhbmdlUmVhZFN0cmVhbVByaXZhdGUgcDsKKwlSZWFkU3RyZWFtICpzdHJlYW07CiAKIAkv KgogCSAqIEluIGFuIGF1dG92YWN1dW0gYW5hbHl6ZSwgd2Ugd2FudCB0byBjbGVhbiB1cCBwZW5k aW5nIGluc2VydGlvbnMuCkBAIC03NDMsNiArNzQ2LDI0IEBAIGdpbnZhY3V1bWNsZWFudXAoSW5k ZXhWYWN1dW1JbmZvICppbmZvLCBJbmRleEJ1bGtEZWxldGVSZXN1bHQgKnN0YXRzKQogCiAJdG90 RnJlZVBhZ2VzID0gMDsKIAorCS8qIFNjYW4gYWxsIGJsb2NrcyBzdGFydGluZyBmcm9tIHRoZSBy b290IHVzaW5nIHN0cmVhbWluZyByZWFkcyAqLworCXAuY3VycmVudF9ibG9ja251bSA9IEdJTl9S T09UX0JMS05POworCXAubGFzdF9leGNsdXNpdmUgPSBucGFnZXM7CisKKwkvKgorCSAqIEl0IGlz IHNhZmUgdG8gdXNlIGJhdGNobW9kZSBhcyBibG9ja19yYW5nZV9yZWFkX3N0cmVhbV9jYiB0YWtl cyBubworCSAqIGxvY2tzLgorCSAqLworCXN0cmVhbSA9IHJlYWRfc3RyZWFtX2JlZ2luX3JlbGF0 aW9uKFJFQURfU1RSRUFNX01BSU5URU5BTkNFIHwKKwkJCQkJCQkJCQlSRUFEX1NUUkVBTV9GVUxM IHwKKwkJCQkJCQkJCQlSRUFEX1NUUkVBTV9VU0VfQkFUQ0hJTkcsCisJCQkJCQkJCQkJaW5mby0+ c3RyYXRlZ3ksCisJCQkJCQkJCQkJaW5kZXgsCisJCQkJCQkJCQkJTUFJTl9GT1JLTlVNLAorCQkJ CQkJCQkJCWJsb2NrX3JhbmdlX3JlYWRfc3RyZWFtX2NiLAorCQkJCQkJCQkJCSZwLAorCQkJCQkJ CQkJCTApOworCiAJZm9yIChibGtubyA9IEdJTl9ST09UX0JMS05POyBibGtubyA8IG5wYWdlczsg Ymxrbm8rKykKIAl7CiAJCUJ1ZmZlcgkJYnVmZmVyOwpAQCAtNzUwLDggKzc3MSw4IEBAIGdpbnZh Y3V1bWNsZWFudXAoSW5kZXhWYWN1dW1JbmZvICppbmZvLCBJbmRleEJ1bGtEZWxldGVSZXN1bHQg KnN0YXRzKQogCiAJCXZhY3V1bV9kZWxheV9wb2ludChmYWxzZSk7CiAKLQkJYnVmZmVyID0gUmVh ZEJ1ZmZlckV4dGVuZGVkKGluZGV4LCBNQUlOX0ZPUktOVU0sIGJsa25vLAotCQkJCQkJCQkJUkJN X05PUk1BTCwgaW5mby0+c3RyYXRlZ3kpOworCQlidWZmZXIgPSByZWFkX3N0cmVhbV9uZXh0X2J1 ZmZlcihzdHJlYW0sIE5VTEwpOworCiAJCUxvY2tCdWZmZXIoYnVmZmVyLCBHSU5fU0hBUkUpOwog CQlwYWdlID0gQnVmZmVyR2V0UGFnZShidWZmZXIpOwogCkBAIC03NzYsNiArNzk3LDkgQEAgZ2lu dmFjdXVtY2xlYW51cChJbmRleFZhY3V1bUluZm8gKmluZm8sIEluZGV4QnVsa0RlbGV0ZVJlc3Vs dCAqc3RhdHMpCiAJCVVubG9ja1JlbGVhc2VCdWZmZXIoYnVmZmVyKTsKIAl9CiAKKwlBc3NlcnQo cmVhZF9zdHJlYW1fbmV4dF9idWZmZXIoc3RyZWFtLCBOVUxMKSA9PSBJbnZhbGlkQnVmZmVyKTsK KwlyZWFkX3N0cmVhbV9lbmQoc3RyZWFtKTsKKwogCS8qIFVwZGF0ZSB0aGUgbWV0YXBhZ2Ugd2l0 aCBhY2N1cmF0ZSBwYWdlIGFuZCBlbnRyeSBjb3VudHMgKi8KIAlpZHhTdGF0Lm5Ub3RhbFBhZ2Vz ID0gbnBhZ2VzOwogCWdpblVwZGF0ZVN0YXRzKGluZm8tPmluZGV4LCAmaWR4U3RhdCwgZmFsc2Up OwotLSAKMi41MS4wCgo= --000000000000caf217064ca55138 Content-Type: application/octet-stream; name="v5-0002-Streamify-Bloom-VACUUM-paths.patch" Content-Disposition: attachment; filename="v5-0002-Streamify-Bloom-VACUUM-paths.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmk7cya51 RnJvbSA0MzA3ZjdkYzA3MzVhNDk5ZDUxODI2NDAyZDMwZDJjNDIwZGNkMGQ0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBhbHRlcmVnbzY1NSA8ODI0NjYyNTI2QHFxLmNvbT4KRGF0ZTog U2F0LCAyNyBEZWMgMjAyNSAwMDoyODo0OSArMDgwMApTdWJqZWN0OiBbUEFUQ0ggdjUgMi81XSBT dHJlYW1pZnkgQmxvb20gVkFDVVVNIHBhdGhzLgoKVXNlIHN0cmVhbWluZyByZWFkcyBpbiBibGJ1 bGtkZWxldGUoKSBhbmQgYmx2YWN1dW1jbGVhbnVwKCkgdG8gaXRlcmF0ZSBpbmRleCBwYWdlcyB3 aXRob3V0IHJlcGVhdGVkIFJlYWRCdWZmZXIgY2FsbHMsIGltcHJvdmluZyBWQUNVVU0gcGVyZm9y bWFuY2UgYW5kIHJlZHVjaW5nIGJ1ZmZlciBtYW5hZ2VyIG92ZXJoZWFkIGR1cmluZyBtYWludGVu YW5jZSBvcGVyYXRpb25zLgotLS0KIGNvbnRyaWIvYmxvb20vYmx2YWN1dW0uYyB8IDU1ICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0KIDEgZmlsZSBjaGFuZ2VkLCA1MSBp bnNlcnRpb25zKCspLCA0IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2NvbnRyaWIvYmxvb20v Ymx2YWN1dW0uYyBiL2NvbnRyaWIvYmxvb20vYmx2YWN1dW0uYwppbmRleCBlNjhhOTAwOGY1Ni4u NzQ1MjMwMmYwMjIgMTAwNjQ0Ci0tLSBhL2NvbnRyaWIvYmxvb20vYmx2YWN1dW0uYworKysgYi9j b250cmliL2Jsb29tL2JsdmFjdXVtLmMKQEAgLTE3LDYgKzE3LDcgQEAKICNpbmNsdWRlICJjb21t YW5kcy92YWN1dW0uaCIKICNpbmNsdWRlICJzdG9yYWdlL2J1Zm1nci5oIgogI2luY2x1ZGUgInN0 b3JhZ2UvaW5kZXhmc20uaCIKKyNpbmNsdWRlICJzdG9yYWdlL3JlYWRfc3RyZWFtLmgiCiAKIAog LyoKQEAgLTQwLDYgKzQxLDggQEAgYmxidWxrZGVsZXRlKEluZGV4VmFjdXVtSW5mbyAqaW5mbywg SW5kZXhCdWxrRGVsZXRlUmVzdWx0ICpzdGF0cywKIAlQYWdlCQlwYWdlOwogCUJsb29tTWV0YVBh Z2VEYXRhICptZXRhRGF0YTsKIAlHZW5lcmljWExvZ1N0YXRlICpneGxvZ1N0YXRlOworCUJsb2Nr UmFuZ2VSZWFkU3RyZWFtUHJpdmF0ZSBwOworCVJlYWRTdHJlYW0gKnN0cmVhbTsKIAogCWlmIChz dGF0cyA9PSBOVUxMKQogCQlzdGF0cyA9IHBhbGxvYzBfb2JqZWN0KEluZGV4QnVsa0RlbGV0ZVJl c3VsdCk7CkBAIC01MSw2ICs1NCwyNSBAQCBibGJ1bGtkZWxldGUoSW5kZXhWYWN1dW1JbmZvICpp bmZvLCBJbmRleEJ1bGtEZWxldGVSZXN1bHQgKnN0YXRzLAogCSAqIHRoZXkgY2FuJ3QgY29udGFp biB0dXBsZXMgdG8gZGVsZXRlLgogCSAqLwogCW5wYWdlcyA9IFJlbGF0aW9uR2V0TnVtYmVyT2ZC bG9ja3MoaW5kZXgpOworCisJLyogU2NhbiBhbGwgYmxvY2tzIGV4Y2VwdCB0aGUgbWV0YXBhZ2Ug dXNpbmcgc3RyZWFtaW5nIHJlYWRzICovCisJcC5jdXJyZW50X2Jsb2NrbnVtID0gQkxPT01fSEVB RF9CTEtOTzsKKwlwLmxhc3RfZXhjbHVzaXZlID0gbnBhZ2VzOworCisJLyoKKwkgKiBJdCBpcyBz YWZlIHRvIHVzZSBiYXRjaG1vZGUgYXMgYmxvY2tfcmFuZ2VfcmVhZF9zdHJlYW1fY2IgdGFrZXMg bm8KKwkgKiBsb2Nrcy4KKwkgKi8KKwlzdHJlYW0gPSByZWFkX3N0cmVhbV9iZWdpbl9yZWxhdGlv bihSRUFEX1NUUkVBTV9NQUlOVEVOQU5DRSB8CisJCQkJCQkJCQkJUkVBRF9TVFJFQU1fRlVMTCB8 CisJCQkJCQkJCQkJUkVBRF9TVFJFQU1fVVNFX0JBVENISU5HLAorCQkJCQkJCQkJCWluZm8tPnN0 cmF0ZWd5LAorCQkJCQkJCQkJCWluZGV4LAorCQkJCQkJCQkJCU1BSU5fRk9SS05VTSwKKwkJCQkJ CQkJCQlibG9ja19yYW5nZV9yZWFkX3N0cmVhbV9jYiwKKwkJCQkJCQkJCQkmcCwKKwkJCQkJCQkJ CQkwKTsKKwogCWZvciAoYmxrbm8gPSBCTE9PTV9IRUFEX0JMS05POyBibGtubyA8IG5wYWdlczsg Ymxrbm8rKykKIAl7CiAJCUJsb29tVHVwbGUgKml0dXAsCkBAIC01OSw4ICs4MSw3IEBAIGJsYnVs a2RlbGV0ZShJbmRleFZhY3V1bUluZm8gKmluZm8sIEluZGV4QnVsa0RlbGV0ZVJlc3VsdCAqc3Rh dHMsCiAKIAkJdmFjdXVtX2RlbGF5X3BvaW50KGZhbHNlKTsKIAotCQlidWZmZXIgPSBSZWFkQnVm ZmVyRXh0ZW5kZWQoaW5kZXgsIE1BSU5fRk9SS05VTSwgYmxrbm8sCi0JCQkJCQkJCQlSQk1fTk9S TUFMLCBpbmZvLT5zdHJhdGVneSk7CisJCWJ1ZmZlciA9IHJlYWRfc3RyZWFtX25leHRfYnVmZmVy KHN0cmVhbSwgTlVMTCk7CiAKIAkJTG9ja0J1ZmZlcihidWZmZXIsIEJVRkZFUl9MT0NLX0VYQ0xV U0lWRSk7CiAJCWd4bG9nU3RhdGUgPSBHZW5lcmljWExvZ1N0YXJ0KGluZGV4KTsKQEAgLTEzMyw2 ICsxNTQsOSBAQCBibGJ1bGtkZWxldGUoSW5kZXhWYWN1dW1JbmZvICppbmZvLCBJbmRleEJ1bGtE ZWxldGVSZXN1bHQgKnN0YXRzLAogCQlVbmxvY2tSZWxlYXNlQnVmZmVyKGJ1ZmZlcik7CiAJfQog CisJQXNzZXJ0KHJlYWRfc3RyZWFtX25leHRfYnVmZmVyKHN0cmVhbSwgTlVMTCkgPT0gSW52YWxp ZEJ1ZmZlcik7CisJcmVhZF9zdHJlYW1fZW5kKHN0cmVhbSk7CisKIAkvKgogCSAqIFVwZGF0ZSB0 aGUgbWV0YXBhZ2UncyBub3RGdWxsUGFnZSBsaXN0IHdpdGggd2hhdGV2ZXIgd2UgZm91bmQuICBP dXIKIAkgKiBpbmZvIGNvdWxkIGFscmVhZHkgYmUgb3V0IG9mIGRhdGUgYXQgdGhpcyBwb2ludCwg YnV0IGJsaW5zZXJ0KCkgd2lsbApAQCAtMTY2LDYgKzE5MCw4IEBAIGJsdmFjdXVtY2xlYW51cChJ bmRleFZhY3V1bUluZm8gKmluZm8sIEluZGV4QnVsa0RlbGV0ZVJlc3VsdCAqc3RhdHMpCiAJUmVs YXRpb24JaW5kZXggPSBpbmZvLT5pbmRleDsKIAlCbG9ja051bWJlciBucGFnZXMsCiAJCQkJYmxr bm87CisJQmxvY2tSYW5nZVJlYWRTdHJlYW1Qcml2YXRlIHA7CisJUmVhZFN0cmVhbSAqc3RyZWFt OwogCiAJaWYgKGluZm8tPmFuYWx5emVfb25seSkKIAkJcmV0dXJuIHN0YXRzOwpAQCAtMTgxLDYg KzIwNywyNSBAQCBibHZhY3V1bWNsZWFudXAoSW5kZXhWYWN1dW1JbmZvICppbmZvLCBJbmRleEJ1 bGtEZWxldGVSZXN1bHQgKnN0YXRzKQogCXN0YXRzLT5udW1fcGFnZXMgPSBucGFnZXM7CiAJc3Rh dHMtPnBhZ2VzX2ZyZWUgPSAwOwogCXN0YXRzLT5udW1faW5kZXhfdHVwbGVzID0gMDsKKworCS8q IFNjYW4gYWxsIGJsb2NrcyBleGNlcHQgdGhlIG1ldGFwYWdlIHVzaW5nIHN0cmVhbWluZyByZWFk cyAqLworCXAuY3VycmVudF9ibG9ja251bSA9IEJMT09NX0hFQURfQkxLTk87CisJcC5sYXN0X2V4 Y2x1c2l2ZSA9IG5wYWdlczsKKworCS8qCisJICogSXQgaXMgc2FmZSB0byB1c2UgYmF0Y2htb2Rl IGFzIGJsb2NrX3JhbmdlX3JlYWRfc3RyZWFtX2NiIHRha2VzIG5vCisJICogbG9ja3MuCisJICov CisJc3RyZWFtID0gcmVhZF9zdHJlYW1fYmVnaW5fcmVsYXRpb24oUkVBRF9TVFJFQU1fTUFJTlRF TkFOQ0UgfAorCQkJCQkJCQkJCVJFQURfU1RSRUFNX0ZVTEwgfAorCQkJCQkJCQkJCVJFQURfU1RS RUFNX1VTRV9CQVRDSElORywKKwkJCQkJCQkJCQlpbmZvLT5zdHJhdGVneSwKKwkJCQkJCQkJCQlp bmRleCwKKwkJCQkJCQkJCQlNQUlOX0ZPUktOVU0sCisJCQkJCQkJCQkJYmxvY2tfcmFuZ2VfcmVh ZF9zdHJlYW1fY2IsCisJCQkJCQkJCQkJJnAsCisJCQkJCQkJCQkJMCk7CisKIAlmb3IgKGJsa25v ID0gQkxPT01fSEVBRF9CTEtOTzsgYmxrbm8gPCBucGFnZXM7IGJsa25vKyspCiAJewogCQlCdWZm ZXIJCWJ1ZmZlcjsKQEAgLTE4OCw4ICsyMzMsNyBAQCBibHZhY3V1bWNsZWFudXAoSW5kZXhWYWN1 dW1JbmZvICppbmZvLCBJbmRleEJ1bGtEZWxldGVSZXN1bHQgKnN0YXRzKQogCiAJCXZhY3V1bV9k ZWxheV9wb2ludChmYWxzZSk7CiAKLQkJYnVmZmVyID0gUmVhZEJ1ZmZlckV4dGVuZGVkKGluZGV4 LCBNQUlOX0ZPUktOVU0sIGJsa25vLAotCQkJCQkJCQkJUkJNX05PUk1BTCwgaW5mby0+c3RyYXRl Z3kpOworCQlidWZmZXIgPSByZWFkX3N0cmVhbV9uZXh0X2J1ZmZlcihzdHJlYW0sIE5VTEwpOwog CQlMb2NrQnVmZmVyKGJ1ZmZlciwgQlVGRkVSX0xPQ0tfU0hBUkUpOwogCQlwYWdlID0gQnVmZmVy R2V0UGFnZShidWZmZXIpOwogCkBAIC0yMDYsNiArMjUwLDkgQEAgYmx2YWN1dW1jbGVhbnVwKElu ZGV4VmFjdXVtSW5mbyAqaW5mbywgSW5kZXhCdWxrRGVsZXRlUmVzdWx0ICpzdGF0cykKIAkJVW5s b2NrUmVsZWFzZUJ1ZmZlcihidWZmZXIpOwogCX0KIAorCUFzc2VydChyZWFkX3N0cmVhbV9uZXh0 X2J1ZmZlcihzdHJlYW0sIE5VTEwpID09IEludmFsaWRCdWZmZXIpOworCXJlYWRfc3RyZWFtX2Vu ZChzdHJlYW0pOworCiAJSW5kZXhGcmVlU3BhY2VNYXBWYWN1dW0oaW5mby0+aW5kZXgpOwogCiAJ cmV0dXJuIHN0YXRzOwotLSAKMi41MS4wCgo= --000000000000caf217064ca55138 Content-Type: application/octet-stream; name="v5-0005-Streamify-hash-index-VACUUM-primary-bucket-page-r.patch" Content-Disposition: attachment; filename="v5-0005-Streamify-hash-index-VACUUM-primary-bucket-page-r.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmk7cyan4 RnJvbSAxMWNjMmQ2YmJhOGYxNDAxNmVmNDdmYTk0YzA4YmY2MGQ5ODcyNjRlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBhbHRlcmVnbzY1NSA8ODI0NjYyNTI2QHFxLmNvbT4KRGF0ZTog U3VuLCAyOCBEZWMgMjAyNSAxODoyOToyOCArMDgwMApTdWJqZWN0OiBbUEFUQ0ggdjUgNS81XSBT dHJlYW1pZnkgaGFzaCBpbmRleCBWQUNVVU0gcHJpbWFyeSBidWNrZXQgcGFnZSByZWFkcwoKUmVm YWN0b3IgaGFzaGJ1bGtkZWxldGUoKSB0byB1c2UgdGhlIFJlYWQgU3RyZWFtICBmb3IgcHJpbWFy eSBidWNrZXQKcGFnZXMuIFRoaXMgZW5hYmxlcyBwcmVmZXRjaGluZyBvZiB1cGNvbWluZyBidWNr ZXRzIHdoaWxlIHRoZSBjdXJyZW50Cm9uZSBpcyBiZWluZyBwcm9jZXNzZWQsIGltcHJvdmluZyBJ L08gZWZmaWNpZW5jeSBkdXJpbmcgaGFzaCBpbmRleAp2YWN1dW0gb3BlcmF0aW9ucy4KLS0tCiBz cmMvYmFja2VuZC9hY2Nlc3MvaGFzaC9oYXNoLmMgICB8IDgwICsrKysrKysrKysrKysrKysrKysr KysrKysrKysrKy0tCiBzcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdCB8ICAxICsKIDIg ZmlsZXMgY2hhbmdlZCwgNzggaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGFzaC9oYXNoLmMgYi9zcmMvYmFja2VuZC9hY2Nlc3Mv aGFzaC9oYXNoLmMKaW5kZXggZTM4ODI1MmFmZGMuLjAxMjE5YzAwMTVlIDEwMDY0NAotLS0gYS9z cmMvYmFja2VuZC9hY2Nlc3MvaGFzaC9oYXNoLmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hh c2gvaGFzaC5jCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSAibm9kZXMvZXhlY25vZGVzLmgi CiAjaW5jbHVkZSAib3B0aW1pemVyL3BsYW5jYXQuaCIKICNpbmNsdWRlICJwZ3N0YXQuaCIKKyNp bmNsdWRlICJzdG9yYWdlL3JlYWRfc3RyZWFtLmgiCiAjaW5jbHVkZSAidXRpbHMvZm1ncnByb3Rv cy5oIgogI2luY2x1ZGUgInV0aWxzL2luZGV4X3NlbGZ1bmNzLmgiCiAjaW5jbHVkZSAidXRpbHMv cmVsLmgiCkBAIC00MiwxMiArNDMsMjMgQEAgdHlwZWRlZiBzdHJ1Y3QKIAlSZWxhdGlvbgloZWFw UmVsOwkJLyogaGVhcCByZWxhdGlvbiBkZXNjcmlwdG9yICovCiB9IEhhc2hCdWlsZFN0YXRlOwog CisvKiBXb3JraW5nIHN0YXRlIGZvciBzdHJlYW1pbmcgcmVhZHMgaW4gaGFzaGJ1bGtkZWxldGUg Ki8KK3R5cGVkZWYgc3RydWN0Cit7CisJSGFzaE1ldGFQYWdlIG1ldGFwOwkJCS8qIGNhY2hlZCBt ZXRhcGFnZSBmb3IgQlVDS0VUX1RPX0JMS05PICovCisJQnVja2V0CQluZXh0X2J1Y2tldDsJLyog bmV4dCBidWNrZXQgdG8gcHJlZmV0Y2ggKi8KKwlCdWNrZXQJCW1heF9idWNrZXQ7CQkvKiBzdG9w IHdoZW4gbmV4dF9idWNrZXQgPiBtYXhfYnVja2V0ICovCit9IEhhc2hCdWxrRGVsZXRlU3RyZWFt UHJpdmF0ZTsKKwogc3RhdGljIHZvaWQgaGFzaGJ1aWxkQ2FsbGJhY2soUmVsYXRpb24gaW5kZXgs CiAJCQkJCQkJICBJdGVtUG9pbnRlciB0aWQsCiAJCQkJCQkJICBEYXR1bSAqdmFsdWVzLAogCQkJ CQkJCSAgYm9vbCAqaXNudWxsLAogCQkJCQkJCSAgYm9vbCB0dXBsZUlzQWxpdmUsCiAJCQkJCQkJ ICB2b2lkICpzdGF0ZSk7CitzdGF0aWMgQmxvY2tOdW1iZXIgaGFzaF9idWxrZGVsZXRlX3JlYWRf c3RyZWFtX2NiKFJlYWRTdHJlYW0gKnN0cmVhbSwKKwkJCQkJCQkJCQkJCSAgdm9pZCAqY2FsbGJh Y2tfcHJpdmF0ZV9kYXRhLAorCQkJCQkJCQkJCQkJICB2b2lkICpwZXJfYnVmZmVyX2RhdGEpOwog CiAKIC8qCkBAIC00NTAsNiArNDYyLDI3IEBAIGhhc2hlbmRzY2FuKEluZGV4U2NhbkRlc2Mgc2Nh bikKIAlzY2FuLT5vcGFxdWUgPSBOVUxMOwogfQogCisvKgorICogUmVhZCBzdHJlYW0gY2FsbGJh Y2sgZm9yIGhhc2hidWxrZGVsZXRlLgorICoKKyAqIFJldHVybnMgdGhlIGJsb2NrIG51bWJlciBv ZiB0aGUgcHJpbWFyeSBwYWdlIGZvciB0aGUgbmV4dCBidWNrZXQgdG8KKyAqIHZhY3V1bSwgdXNp bmcgdGhlIEJVQ0tFVF9UT19CTEtOTyBtYXBwaW5nIGZyb20gdGhlIGNhY2hlZCBtZXRhcGFnZS4K KyAqLworc3RhdGljIEJsb2NrTnVtYmVyCitoYXNoX2J1bGtkZWxldGVfcmVhZF9zdHJlYW1fY2Io UmVhZFN0cmVhbSAqc3RyZWFtLAorCQkJCQkJCSAgIHZvaWQgKmNhbGxiYWNrX3ByaXZhdGVfZGF0 YSwKKwkJCQkJCQkgICB2b2lkICpwZXJfYnVmZmVyX2RhdGEpCit7CisJSGFzaEJ1bGtEZWxldGVT dHJlYW1Qcml2YXRlICpwID0gY2FsbGJhY2tfcHJpdmF0ZV9kYXRhOworCUJ1Y2tldAkJYnVja2V0 OworCisJaWYgKHAtPm5leHRfYnVja2V0ID4gcC0+bWF4X2J1Y2tldCkKKwkJcmV0dXJuIEludmFs aWRCbG9ja051bWJlcjsKKworCWJ1Y2tldCA9IHAtPm5leHRfYnVja2V0Kys7CisJcmV0dXJuIEJV Q0tFVF9UT19CTEtOTyhwLT5tZXRhcCwgYnVja2V0KTsKK30KKwogLyoKICAqIEJ1bGsgZGVsZXRp b24gb2YgYWxsIGluZGV4IGVudHJpZXMgcG9pbnRpbmcgdG8gYSBzZXQgb2YgaGVhcCB0dXBsZXMu CiAgKiBUaGUgc2V0IG9mIHRhcmdldCB0dXBsZXMgaXMgc3BlY2lmaWVkIHZpYSBhIGNhbGxiYWNr IHJvdXRpbmUgdGhhdCB0ZWxscwpAQCAtNDc0LDYgKzUwNyw4IEBAIGhhc2hidWxrZGVsZXRlKElu ZGV4VmFjdXVtSW5mbyAqaW5mbywgSW5kZXhCdWxrRGVsZXRlUmVzdWx0ICpzdGF0cywKIAlCdWZm ZXIJCW1ldGFidWYgPSBJbnZhbGlkQnVmZmVyOwogCUhhc2hNZXRhUGFnZSBtZXRhcDsKIAlIYXNo TWV0YVBhZ2UgY2FjaGVkbWV0YXA7CisJSGFzaEJ1bGtEZWxldGVTdHJlYW1Qcml2YXRlIHN0cmVh bV9wcml2YXRlOworCVJlYWRTdHJlYW0gKnN0cmVhbSA9IE5VTEw7CiAKIAl0dXBsZXNfcmVtb3Zl ZCA9IDA7CiAJbnVtX2luZGV4X3R1cGxlcyA9IDA7CkBAIC00OTQsNyArNTI5LDI1IEBAIGhhc2hi dWxrZGVsZXRlKEluZGV4VmFjdXVtSW5mbyAqaW5mbywgSW5kZXhCdWxrRGVsZXRlUmVzdWx0ICpz dGF0cywKIAljdXJfYnVja2V0ID0gMDsKIAljdXJfbWF4YnVja2V0ID0gb3JpZ19tYXhidWNrZXQ7 CiAKLWxvb3BfdG9wOgorCS8qIFNldCB1cCBzdHJlYW1pbmcgcmVhZCBmb3IgcHJpbWFyeSBidWNr ZXQgcGFnZXMgKi8KKwlzdHJlYW1fcHJpdmF0ZS5tZXRhcCA9IGNhY2hlZG1ldGFwOworCXN0cmVh bV9wcml2YXRlLm5leHRfYnVja2V0ID0gY3VyX2J1Y2tldDsKKwlzdHJlYW1fcHJpdmF0ZS5tYXhf YnVja2V0ID0gY3VyX21heGJ1Y2tldDsKKworCS8qCisJICogSXQgaXMgc2FmZSB0byB1c2UgYmF0 Y2htb2RlIGFzIGhhc2hfYnVsa2RlbGV0ZV9yZWFkX3N0cmVhbV9jYiB0YWtlcyBubworCSAqIGxv Y2tzLgorCSAqLworCXN0cmVhbSA9IHJlYWRfc3RyZWFtX2JlZ2luX3JlbGF0aW9uKFJFQURfU1RS RUFNX01BSU5URU5BTkNFIHwKKwkJCQkJCQkJCQlSRUFEX1NUUkVBTV9VU0VfQkFUQ0hJTkcsCisJ CQkJCQkJCQkJaW5mby0+c3RyYXRlZ3ksCisJCQkJCQkJCQkJcmVsLAorCQkJCQkJCQkJCU1BSU5f Rk9SS05VTSwKKwkJCQkJCQkJCQloYXNoX2J1bGtkZWxldGVfcmVhZF9zdHJlYW1fY2IsCisJCQkJ CQkJCQkJJnN0cmVhbV9wcml2YXRlLAorCQkJCQkJCQkJCTApOworCitidWNrZXRfbG9vcDoKIAl3 aGlsZSAoY3VyX2J1Y2tldCA8PSBjdXJfbWF4YnVja2V0KQogCXsKIAkJQmxvY2tOdW1iZXIgYnVj a2V0X2Jsa25vOwpAQCAtNTE0LDcgKzU2Nyw4IEBAIGxvb3BfdG9wOgogCQkgKiBXZSBuZWVkIHRv IGFjcXVpcmUgYSBjbGVhbnVwIGxvY2sgb24gdGhlIHByaW1hcnkgYnVja2V0IHBhZ2UgdG8gb3V0 CiAJCSAqIHdhaXQgY29uY3VycmVudCBzY2FucyBiZWZvcmUgZGVsZXRpbmcgdGhlIGRlYWQgdHVw bGVzLgogCQkgKi8KLQkJYnVmID0gUmVhZEJ1ZmZlckV4dGVuZGVkKHJlbCwgTUFJTl9GT1JLTlVN LCBibGtubywgUkJNX05PUk1BTCwgaW5mby0+c3RyYXRlZ3kpOworCQlidWYgPSByZWFkX3N0cmVh bV9uZXh0X2J1ZmZlcihzdHJlYW0sIE5VTEwpOworCQlBc3NlcnQoQnVmZmVySXNWYWxpZChidWYp KTsKIAkJTG9ja0J1ZmZlckZvckNsZWFudXAoYnVmKTsKIAkJX2hhc2hfY2hlY2twYWdlKHJlbCwg YnVmLCBMSF9CVUNLRVRfUEFHRSk7CiAKQEAgLTU0NSw2ICs1OTksMTYgQEAgbG9vcF90b3A6CiAJ CQl7CiAJCQkJY2FjaGVkbWV0YXAgPSBfaGFzaF9nZXRjYWNoZWRtZXRhcChyZWwsICZtZXRhYnVm LCB0cnVlKTsKIAkJCQlBc3NlcnQoY2FjaGVkbWV0YXAgIT0gTlVMTCk7CisKKwkJCQkvKgorCQkJ CSAqIFJlc2V0IHN0cmVhbSB3aXRoIHVwZGF0ZWQgbWV0YWRhdGEgZm9yIHJlbWFpbmluZyBidWNr ZXRzLgorCQkJCSAqIFRoZSBCVUNLRVRfVE9fQkxLTk8gbWFwcGluZyBkZXBlbmRzIG9uIGhhc2ht X3NwYXJlc1tdLAorCQkJCSAqIHdoaWNoIG1heSBoYXZlIGNoYW5nZWQuCisJCQkJICovCisJCQkJ c3RyZWFtX3ByaXZhdGUubWV0YXAgPSBjYWNoZWRtZXRhcDsKKwkJCQlzdHJlYW1fcHJpdmF0ZS5u ZXh0X2J1Y2tldCA9IGN1cl9idWNrZXQgKyAxOworCQkJCXN0cmVhbV9wcml2YXRlLm1heF9idWNr ZXQgPSBjdXJfbWF4YnVja2V0OworCQkJCXJlYWRfc3RyZWFtX3Jlc2V0KHN0cmVhbSk7CiAJCQl9 CiAJCX0KIApAQCAtNTc3LDkgKzY0MSwxOSBAQCBsb29wX3RvcDoKIAkJY2FjaGVkbWV0YXAgPSBf aGFzaF9nZXRjYWNoZWRtZXRhcChyZWwsICZtZXRhYnVmLCB0cnVlKTsKIAkJQXNzZXJ0KGNhY2hl ZG1ldGFwICE9IE5VTEwpOwogCQljdXJfbWF4YnVja2V0ID0gY2FjaGVkbWV0YXAtPmhhc2htX21h eGJ1Y2tldDsKLQkJZ290byBsb29wX3RvcDsKKworCQkvKiBSZXNldCBzdHJlYW0gdG8gcHJvY2Vz cyBhZGRpdGlvbmFsIGJ1Y2tldHMgZnJvbSBzcGxpdCAqLworCQlzdHJlYW1fcHJpdmF0ZS5tZXRh cCA9IGNhY2hlZG1ldGFwOworCQlzdHJlYW1fcHJpdmF0ZS5uZXh0X2J1Y2tldCA9IGN1cl9idWNr ZXQ7CisJCXN0cmVhbV9wcml2YXRlLm1heF9idWNrZXQgPSBjdXJfbWF4YnVja2V0OworCQlyZWFk X3N0cmVhbV9yZXNldChzdHJlYW0pOworCQlnb3RvIGJ1Y2tldF9sb29wOwogCX0KIAorCS8qIFN0 cmVhbSBzaG91bGQgYmUgZXhoYXVzdGVkIHNpbmNlIHdlIHByb2Nlc3NlZCBhbGwgYnVja2V0cyAq LworCUFzc2VydChyZWFkX3N0cmVhbV9uZXh0X2J1ZmZlcihzdHJlYW0sIE5VTEwpID09IEludmFs aWRCdWZmZXIpOworCXJlYWRfc3RyZWFtX2VuZChzdHJlYW0pOworCiAJLyogT2theSwgd2UncmUg cmVhbGx5IGRvbmUuICBVcGRhdGUgdHVwbGUgY291bnQgaW4gbWV0YXBhZ2UuICovCiAJU1RBUlRf Q1JJVF9TRUNUSU9OKCk7CiAKZGlmZiAtLWdpdCBhL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVm cy5saXN0IGIvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKaW5kZXggZGM2ZmMyOGZj YWIuLjU3MmJlNTU5OGYyIDEwMDY0NAotLS0gYS9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMu bGlzdAorKysgYi9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdApAQCAtMTE3Niw2ICsx MTc2LDcgQEAgSGFzaEFnZ0JhdGNoCiBIYXNoQWdnU3BpbGwKIEhhc2hBbGxvY0Z1bmMKIEhhc2hC dWlsZFN0YXRlCitIYXNoQnVsa0RlbGV0ZVN0cmVhbVByaXZhdGUKIEhhc2hDb21wYXJlRnVuYwog SGFzaENvcHlGdW5jCiBIYXNoSW5kZXhTdGF0Ci0tIAoyLjUxLjAKCg== --000000000000caf217064ca55138--