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 1vSohe-006D0w-2V for pgsql-hackers@arkaria.postgresql.org; Tue, 09 Dec 2025 03:47:55 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vSohb-002bNM-1k for pgsql-hackers@arkaria.postgresql.org; Tue, 09 Dec 2025 03:47:51 +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 1vSoha-002bND-30 for pgsql-hackers@lists.postgresql.org; Tue, 09 Dec 2025 03:47:51 +0000 Received: from mail-pl1-x633.google.com ([2607:f8b0:4864:20::633]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.96) (envelope-from ) id 1vSohX-003reP-0A for pgsql-hackers@postgresql.org; Tue, 09 Dec 2025 03:47:50 +0000 Received: by mail-pl1-x633.google.com with SMTP id d9443c01a7336-297ec8a6418so5737815ad.1 for ; Mon, 08 Dec 2025 19:47:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1765252067; x=1765856867; darn=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=y36zesN8ZDXErsoDNErm++IX8244xcUpsANLUJ+dq14=; b=HgEe5jmbeUVtGwKnXoMM010ejdMlDolFDSdafoK8tH2us5mPBYa73P1El+vxp0Inr5 0aL1xIkY5QtWruVmTPrOrbX0ysSQWGS3nCDwTHhnLVZzdWUWhgbgXfF9Hj1Z52FGxuXa LgMvmOwER64UvPN4QdUIEO+sA+HOhncQdSj08sRBhuqWKZ4DYGrcdmUzozxvepSPz8BT Pc63ekBqKxQlnRfXFilGGPiVShhH8Pj+o7jZmNqJpsOwQTaWQ3bkmiJTi2uLU3YF+yTx GQ8zFFcvn3uTSexhPR2Gkt+Xdp5mnUEmf/dm1c4lfT7SdYjIyj3z8RkRX0+wCPzv59JG tl9A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1765252067; x=1765856867; 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=y36zesN8ZDXErsoDNErm++IX8244xcUpsANLUJ+dq14=; b=v6WHmL4dFmA4Fa+Qmt1Q1zSQycDo9cGRHft3V9YNVX2ZgKe+fIQ71pJsVR2Ye25Zdh FcrEdKTAKJodkPhbcwuJJo46Rlm136IWywiUqXk8BZRpT7YQnTPqDJOcwwTJRBA2ewG4 ZPdmL/6PYoEaNcuCTIVR8tqi/BolPewcou6cZJ47OdU3g4BCrJf5RFdDcZwzPb7rIFtg NoynVjhOc86urWx0ljIwtHkp3rGoJcB7xWSGxkl0bbiliPo4cb/DYY+8vI3Sft81tTiX 2zhW/Jf6lsiKTMboAPFl2jYYJpcCZwX4rE39xTcIaQk/iOx3NILGHHEFtIYZEjptkgtH UKSQ== X-Forwarded-Encrypted: i=1; AJvYcCVGnDhGFGqVhzhHD/ep33g/pvg3PnEYnUouqLo2TH9DvdKMgIdrUJOiOpnj3foFf/q6VcdJtEHo1z9ThFLK@postgresql.org X-Gm-Message-State: AOJu0YwonntHCZ00h/7SDkfndxpUziz9EqVaBFNUrhhmBASpPRXeThlP Y7ERWh7xmWmd6RyZco264jCD4gX3b7Wvyekw+gIr6NOwO7/4h63V6+5z92rlpUf+B4FBg4prg3J 1MEH4627B01DZ0zKh9mWTGfCgdLr5HCQ= X-Gm-Gg: ASbGncs3MuSQ0o9pJf/YH6QyHq9KPuD5Gq/i2xJr791wXPIL2cGPeLaviqfzGv61blJ P2sMiYxdpUpeq4sQ3M1zB9WWLNQjb9x6xpRLP+P3U0QjFl/pKO1nrcIfcU4jbRnwyZhVkNcEC0H GHum73IvYcLstAAW+WDUEaL9lljZGM2QaIN8Kk78i6OZjdehmTYWW9aZ0A92Ale12zwzGvGDA5+ Aq6jIWY8glNgUnH0m6ZWghG+suVPQrb3UXdLOTWtwMjAAQMOOdNYi6zDTg2WkCahXT0q7YLFr8Y /SzXcyxkTIA5IdF0OVEKdVRMaD/2mSsZct1Gac7fFcxPy4GHPQXA X-Google-Smtp-Source: AGHT+IGaH5Vk8Y/rVKIBtiyFuIObkzdg9llqwX14irO86vik97M6Ocnj51RGkhvXd9hvu0SiYb/LePr73646CgiX5xI= X-Received: by 2002:a05:7300:b0aa:b0:2ab:ca55:89cb with SMTP id 5a478bee46e88-2abca55980emr2297460eec.6.1765252066378; Mon, 08 Dec 2025 19:47:46 -0800 (PST) MIME-Version: 1.0 References: In-Reply-To: From: Thomas Munro Date: Tue, 9 Dec 2025 16:47:08 +1300 X-Gm-Features: AQt7F2rARvuF4w1XSbjVcamZnVBVg4Age7XeT4jScnvynuwblgBYEesmSuTiixU Message-ID: Subject: Re: Trying out read streams in pgvector (an extension) To: Melanie Plageman , Peter Geoghegan Cc: Nazir Bilal Yavuz , "Jonathan S. Katz" , pgsql-hackers Content-Type: multipart/mixed; boundary="0000000000005ba9c806457cc6cc" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --0000000000005ba9c806457cc6cc Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable On Fri, Nov 21, 2025 at 4:28=E2=80=AFAM Melanie Plageman wrote: > I'm not totally opposed to this. My rationale for making it an error > is that the developer could have test cases where all the buffers are > consumed but the code is written such that that won't always happen. > Then if a real production query doesn't consume all the buffers, it > could return wrong results (I think). That will mean the user can't > complete their query until the extension author releases a new version > of their code. But I'm not sure what the right answer is here. Focusing on making sure v19 has a good interface for this, and abandoning thoughts of back-patching a bandaid, and the constraints that leads to, for now... I think it'd be better if that were the consumer's choice. I don't want the consumer to be required to drain the stream before resuming, as that'd be an unprincipled stall. For example, if new WAL arrives over the network then I think it should be possible for recovery's WAL-powered stream of heap pages to resume looking ahead even if recovery hasn't drained the existing stream completely. Peter G (CC'd) and I discussed some problems he had in the index prefetching work, and I tried to extend this a bit to give the semantics he wanted, in point 2 below. It's simple itself, but might lead to some tricky questions higher up. Posted for experimentation. It'll be interesting to see if this goes somewhere. 1. read_stream_resume() as before, but with a new explicit read_stream_pause(): if a block number callback would like to report a temporary lack of information, it should return read_stream_pause(stream), not InvalidBlockNumber. Then after read_stream_resume(stream) is called, the next read_stream_next_buffer() enters the lookahead loop again. While paused, if the consumer drains all the existing buffers in the stream and then one more, it will receive InvalidBuffer, but if the _resume() call is made sooner, the consumer won't ever know about the temporary lack of buffers in the stream. 2. read_stream_yield(): while streaming heap pages that come from TIDs on index pages, Peter didn't like that the executor lost control of how much work was done by the lookahead loop underneath read_stream_next_buffer(). The consumer might have a heap page with some tuples that could be emitted right now, but the block number callback might be evaluating arbitrarily expensive filter qual expressions far ahead, and they might prefer to emit more tuples now before doing an unbounded amount of work finding more. This interface allows some limited coroutine-like multitasking, where the block number callback can return read_stream_yield(stream) to return control back to the consumer periodically if it knows the consumer could already do something else. It works by pausing the stream and resuming it in the next read_stream_next_buffer() call, but that's an internal detail. Some half-baked thoughts about the resulting flow control: Yielding control periodically just when it happens to be possible within the constraints of the volcano executor is an interesting thing to think about. You can only yield if you already have a tuple to emit. There is no saying when control will return to you, and the node you yield to might immediately block on I/O and yet you could have been doing useful CPU work. You probably need an event-driven node-hopping executor to fix that in general, but on the flip side, I can think of one bet that I'd take: if you already have a tuple to emit AND if index scans themselves (not only referenced heap pages) were also streamed AND if a hypothetical read_stream_next_buffer_no_wait(btree_stream) said the next index page you need is not ready yet, then you should yield. You're gambling that other plan nodes will have better luck running without an I/O stall, but you have ~0% chance. Yielding just because you've scanned N index pages/tuples/whatever is harder to think about. The stream shouldn't get far ahead unless it's recently been useful for I/O concurrency (though optimal distance heuristics are an open problem), but in this case a single invocation of the block number callback can call ReadBuffer() an arbitrary number of times, filtering out all the index tuples as it rampages through the whole index IIUC. I see why you might want to yield periodically if you can, but I also wonder how much that can really help if you still have to pick up where you left off next time. I guess it depends on the distribution of matches. It's also clear that any cold-cache testing done with direct I/O enabled will stall abominably as long as that level calls ReadBuffer(), possibly confusing matters. --0000000000005ba9c806457cc6cc Content-Type: text/x-patch; charset="US-ASCII"; name="0001-Introduce-read_stream_-pause-resume-yield.patch" Content-Disposition: attachment; filename="0001-Introduce-read_stream_-pause-resume-yield.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mixrwm7i0 RnJvbSBmZjZkYTQ0ZGY1NDE4ZDczYWQ5ZWMxOTExYzg3YjY2ODk3ZjNiMDg2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUaG9tYXMgTXVucm8gPHRob21hcy5tdW5yb0BnbWFpbC5jb20+ CkRhdGU6IFNhdCwgMTUgSnVuIDIwMjQgMTQ6Mzc6MjYgKzEyMDAKU3ViamVjdDogW1BBVENIIDEv Ml0gSW50cm9kdWNlIHJlYWRfc3RyZWFtX3twYXVzZSxyZXN1bWUseWllbGR9KCkuCgotLS0KIHNy Yy9iYWNrZW5kL3N0b3JhZ2UvYWlvL3JlYWRfc3RyZWFtLmMgfCA1MCArKysrKysrKysrKysrKysr KysrKysrKysrKy0KIHNyYy9pbmNsdWRlL3N0b3JhZ2UvcmVhZF9zdHJlYW0uaCAgICAgfCAgMyAr KwogMiBmaWxlcyBjaGFuZ2VkLCA1MiBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZm IC0tZ2l0IGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9haW8vcmVhZF9zdHJlYW0uYyBiL3NyYy9iYWNr ZW5kL3N0b3JhZ2UvYWlvL3JlYWRfc3RyZWFtLmMKaW5kZXggMDMxZmRlOWY0Y2IuLjk2NGUxYWEy ODFjIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9zdG9yYWdlL2Fpby9yZWFkX3N0cmVhbS5jCisr KyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYWlvL3JlYWRfc3RyZWFtLmMKQEAgLTEwMCwxMSArMTAw LDEzIEBAIHN0cnVjdCBSZWFkU3RyZWFtCiAJaW50MTYJCXBpbm5lZF9idWZmZXJzOwogCWludDE2 CQlkaXN0YW5jZTsKIAlpbnQxNgkJaW5pdGlhbGl6ZWRfYnVmZmVyczsKKwlpbnQxNgkJcmVzdW1l X2Rpc3RhbmNlOwogCWludAkJCXJlYWRfYnVmZmVyc19mbGFnczsKIAlib29sCQlzeW5jX21vZGU7 CQkvKiB1c2luZyBpb19tZXRob2Q9c3luYyAqLwogCWJvb2wJCWJhdGNoX21vZGU7CQkvKiBSRUFE X1NUUkVBTV9VU0VfQkFUQ0hJTkcgKi8KIAlib29sCQlhZHZpY2VfZW5hYmxlZDsKIAlib29sCQl0 ZW1wb3Jhcnk7CisJYm9vbAkJeWllbGRlZDsKIAogCS8qCiAJICogT25lLWJsb2NrIGJ1ZmZlciB0 byBzdXBwb3J0ICd1bmdldHRpbmcnIGEgYmxvY2sgbnVtYmVyLCB0byByZXNvbHZlIGZsb3cKQEAg LTg3OSw3ICs4ODEsMTUgQEAgcmVhZF9zdHJlYW1fbmV4dF9idWZmZXIoUmVhZFN0cmVhbSAqc3Ry ZWFtLCB2b2lkICoqcGVyX2J1ZmZlcl9kYXRhKQogCiAJCS8qIEVuZCBvZiBzdHJlYW0gcmVhY2hl ZD8gICovCiAJCWlmIChzdHJlYW0tPmRpc3RhbmNlID09IDApCi0JCQlyZXR1cm4gSW52YWxpZEJ1 ZmZlcjsKKwkJeworCQkJaWYgKCFzdHJlYW0tPnlpZWxkZWQpCisJCQkJcmV0dXJuIEludmFsaWRC dWZmZXI7CisKKwkJCS8qIFRoZSBjYWxsYmFjayB5aWVsZGVkLiAgUmVzdW1lLiAqLworCQkJc3Ry ZWFtLT55aWVsZGVkID0gZmFsc2U7CisJCQlyZWFkX3N0cmVhbV9yZXN1bWUoc3RyZWFtKTsKKwkJ CUFzc2VydChzdHJlYW0tPmRpc3RhbmNlICE9IDApOworCQl9CiAKIAkJLyoKIAkJICogVGhlIHVz dWFsIG9yZGVyIG9mIG9wZXJhdGlvbnMgaXMgdGhhdCB3ZSBsb29rIGFoZWFkIGF0IHRoZSBib3R0 b20KQEAgLTEwMzQsNiArMTA0NCw0NCBAQCByZWFkX3N0cmVhbV9uZXh0X2Jsb2NrKFJlYWRTdHJl YW0gKnN0cmVhbSwgQnVmZmVyQWNjZXNzU3RyYXRlZ3kgKnN0cmF0ZWd5KQogCXJldHVybiByZWFk X3N0cmVhbV9nZXRfYmxvY2soc3RyZWFtLCBOVUxMKTsKIH0KIAorLyoKKyAqIFRlbXBvcmFyaWx5 IHN0b3AgY29uc3VtaW5nIGJsb2NrIG51bWJlcnMgZnJvbSB0aGUgYmxvY2sgbnVtYmVyIGNhbGxi YWNrLiAgSWYKKyAqIGNhbGxlZCBpbnNpZGUgdGhlIGJsb2NrIG51bWJlciBjYWxsYmFjaywgaXRz IHJldHVybiB2YWx1ZSBzaG91bGQgYmUKKyAqIHJldHVybmVkIGJ5IHRoZSBjYWxsYmFjay4KKyAq LworQmxvY2tOdW1iZXIKK3JlYWRfc3RyZWFtX3BhdXNlKFJlYWRTdHJlYW0gKnN0cmVhbSkKK3sK KwlzdHJlYW0tPnJlc3VtZV9kaXN0YW5jZSA9IHN0cmVhbS0+ZGlzdGFuY2U7CisJc3RyZWFtLT5k aXN0YW5jZSA9IDA7CisJcmV0dXJuIEludmFsaWRCbG9ja051bWJlcjsKK30KKworLyoKKyAqIFJl c3VtZSBsb29raW5nIGFoZWFkIGFmdGVyIHRoZSBibG9jayBudW1iZXIgY2FsbGJhY2sgcmVwb3J0 ZWQgZW5kLW9mLXN0cmVhbS4KKyAqIFRoaXMgaXMgdXNlZnVsIGZvciBzdHJlYW1zIG9mIHNlbGYt cmVmZXJlbnRpYWwgYmxvY2tzLCBhZnRlciBhIGJ1ZmZlciBuZWVkZWQKKyAqIHRvIGJlIGNvbnN1 bWVkIGFuZCBleGFtaW5lZCB0byBmaW5kIG1vcmUgYmxvY2sgbnVtYmVycy4KKyAqLwordm9pZAor cmVhZF9zdHJlYW1fcmVzdW1lKFJlYWRTdHJlYW0gKnN0cmVhbSkKK3sKKwlzdHJlYW0tPmRpc3Rh bmNlID0gc3RyZWFtLT5yZXN1bWVfZGlzdGFuY2U7Cit9CisKKy8qCisgKiBDYWxsZWQgZnJvbSBp bnNpZGUgYSBibG9jayBudW1iZXIgY2FsbGJhY2ssIHRvIHJldHVybiBjb250cm9sIHRvIHRoZSBj YWxsZXIKKyAqIG9mIHJlYWRfc3RyZWFtX25leHRfYnVmZmVyKCkgd2l0aG91dCBsb29raW5nIGZ1 cnRoZXIgYWhlYWQuICBJdHMgcmV0dXJuCisgKiB2YWx1ZSBzaG91bGQgYmUgcmV0dXJuZWQgYnkg dGhlIGNhbGxiYWNrLiAgVGhpcyBpcyBlcXVpdmFsZW50IHRvIHBhdXNpbmcgYW5kCisgKiByZXN1 bWluZyBhdXRvbWF0aWNhbGx5IGF0IHRoZSBuZXh0IGNhbGwgdG8gcmVhZF9zdHJlYW1fbmV4dF9i dWZmZXIoKS4KKyAqLworQmxvY2tOdW1iZXIKK3JlYWRfc3RyZWFtX3lpZWxkKFJlYWRTdHJlYW0g KnN0cmVhbSkKK3sKKwlyZWFkX3N0cmVhbV9wYXVzZShzdHJlYW0pOworCXN0cmVhbS0+eWllbGRl ZCA9IHRydWU7CisJcmV0dXJuIEludmFsaWRCbG9ja051bWJlcjsKK30KKwogLyoKICAqIFJlc2V0 IGEgcmVhZCBzdHJlYW0gYnkgcmVsZWFzaW5nIGFueSBxdWV1ZWQgdXAgYnVmZmVycywgYWxsb3dp bmcgdGhlIHN0cmVhbQogICogdG8gYmUgdXNlZCBhZ2FpbiBmb3IgZGlmZmVyZW50IGJsb2Nrcy4g IFRoaXMgY2FuIGJlIHVzZWQgdG8gY2xlYXIgYW4KZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL3N0 b3JhZ2UvcmVhZF9zdHJlYW0uaCBiL3NyYy9pbmNsdWRlL3N0b3JhZ2UvcmVhZF9zdHJlYW0uaApp bmRleCA5YjBkNjUxNjFkMC4uOGFjNTNkMjkwMmQgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3N0 b3JhZ2UvcmVhZF9zdHJlYW0uaAorKysgYi9zcmMvaW5jbHVkZS9zdG9yYWdlL3JlYWRfc3RyZWFt LmgKQEAgLTk5LDYgKzk5LDkgQEAgZXh0ZXJuIFJlYWRTdHJlYW0gKnJlYWRfc3RyZWFtX2JlZ2lu X3NtZ3JfcmVsYXRpb24oaW50IGZsYWdzLAogCQkJCQkJCQkJCQkJICAgUmVhZFN0cmVhbUJsb2Nr TnVtYmVyQ0IgY2FsbGJhY2ssCiAJCQkJCQkJCQkJCQkgICB2b2lkICpjYWxsYmFja19wcml2YXRl X2RhdGEsCiAJCQkJCQkJCQkJCQkgICBzaXplX3QgcGVyX2J1ZmZlcl9kYXRhX3NpemUpOworZXh0 ZXJuIEJsb2NrTnVtYmVyIHJlYWRfc3RyZWFtX3BhdXNlKFJlYWRTdHJlYW0gKnN0cmVhbSk7Citl eHRlcm4gdm9pZCByZWFkX3N0cmVhbV9yZXN1bWUoUmVhZFN0cmVhbSAqc3RyZWFtKTsKK2V4dGVy biBCbG9ja051bWJlciByZWFkX3N0cmVhbV95aWVsZChSZWFkU3RyZWFtICpzdHJlYW0pOwogZXh0 ZXJuIHZvaWQgcmVhZF9zdHJlYW1fcmVzZXQoUmVhZFN0cmVhbSAqc3RyZWFtKTsKIGV4dGVybiB2 b2lkIHJlYWRfc3RyZWFtX2VuZChSZWFkU3RyZWFtICpzdHJlYW0pOwogCi0tIAoyLjUxLjIKCg== --0000000000005ba9c806457cc6cc Content-Type: text/x-patch; charset="US-ASCII"; name="0002-Add-tests-for-read_stream_-pause-resume-yield.patch" Content-Disposition: attachment; filename="0002-Add-tests-for-read_stream_-pause-resume-yield.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mixrwoqj1 RnJvbSBkZThhODAwYjQ4ODI5ZWY2MTkyMDBhNzFkYmE5MDI4YmUzZWEwOWU5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUaG9tYXMgTXVucm8gPHRob21hcy5tdW5yb0BnbWFpbC5jb20+ CkRhdGU6IFdlZCwgMTIgTm92IDIwMjUgMTY6NDk6NTcgKzEzMDAKU3ViamVjdDogW1BBVENIIDIv Ml0gQWRkIHRlc3RzIGZvciByZWFkX3N0cmVhbV97cGF1c2UscmVzdW1lLHlpZWxkfSgpLgoKLS0t CiBzcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYWlvL01ha2VmaWxlICAgICAgICAgICB8ICAgMyArLQog c3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby9tZXNvbi5idWlsZCAgICAgICAgfCAgIDEgKwogc3Jj L3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby90LzAwMV9haW8ucGwgICAgICAgfCAgMzAgKysrCiBzcmMv dGVzdC9tb2R1bGVzL3Rlc3RfYWlvL3Rlc3RfYWlvLS0xLjAuc3FsICB8ICAxMyArKwogc3JjL3Rl c3QvbW9kdWxlcy90ZXN0X2Fpby90ZXN0X3JlYWRfc3RyZWFtLmMgfCAxODEgKysrKysrKysrKysr KysrKysrKwogc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QgICAgICAgICAgICAgfCAg IDEgKwogNiBmaWxlcyBjaGFuZ2VkLCAyMjggaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQog Y3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90ZXN0L21vZHVsZXMvdGVzdF9haW8vdGVzdF9yZWFkX3N0 cmVhbS5jCgpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby9NYWtlZmlsZSBi L3NyYy90ZXN0L21vZHVsZXMvdGVzdF9haW8vTWFrZWZpbGUKaW5kZXggZjUzY2M2NDY3MWEuLjQ2 NWViMDllZTRmIDEwMDY0NAotLS0gYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYWlvL01ha2VmaWxl CisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9haW8vTWFrZWZpbGUKQEAgLTUsNyArNSw4IEBA IFBHRklMRURFU0MgPSAidGVzdF9haW8gLSB0ZXN0IGNvZGUgZm9yIEFJTyIKIE1PRFVMRV9iaWcg PSB0ZXN0X2FpbwogT0JKUyA9IFwKIAkkKFdJTjMyUkVTKSBcCi0JdGVzdF9haW8ubworCXRlc3Rf YWlvLm8gXAorCXRlc3RfcmVhZF9zdHJlYW0ubwogCiBFWFRFTlNJT04gPSB0ZXN0X2FpbwogREFU QSA9IHRlc3RfYWlvLS0xLjAuc3FsCmRpZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rf YWlvL21lc29uLmJ1aWxkIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby9tZXNvbi5idWlsZApp bmRleCA3M2QyZmQ2OGVhYS4uNmU2ZmNiZmRhZDkgMTAwNjQ0Ci0tLSBhL3NyYy90ZXN0L21vZHVs ZXMvdGVzdF9haW8vbWVzb24uYnVpbGQKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby9t ZXNvbi5idWlsZApAQCAtMiw2ICsyLDcgQEAKIAogdGVzdF9haW9fc291cmNlcyA9IGZpbGVzKAog ICAndGVzdF9haW8uYycsCisgICd0ZXN0X3JlYWRfc3RyZWFtLmMnLAogKQogCiBpZiBob3N0X3N5 c3RlbSA9PSAnd2luZG93cycKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9haW8v dC8wMDFfYWlvLnBsIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby90LzAwMV9haW8ucGwKaW5k ZXggM2YwNDUzNjE5ZTguLjJhMmM2NTIzYTZiIDEwMDY0NAotLS0gYS9zcmMvdGVzdC9tb2R1bGVz L3Rlc3RfYWlvL3QvMDAxX2Fpby5wbAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYWlvL3Qv MDAxX2Fpby5wbApAQCAtMTQ4OSw2ICsxNDg5LDM1IEBAIFNFTEVDVCByZWFkX3JlbF9ibG9ja19s bCgndGJsX2NzX2ZhaWwnLCAzLCBuYmxvY2tzPT4xLCB6ZXJvX29uX2Vycm9yPT50cnVlKTspLAog CSRwc3FsLT5xdWl0KCk7CiB9CiAKKyMgUmVhZCBzdHJlYW0gdGVzdHMKK3N1YiB0ZXN0X3JlYWRf c3RyZWFtCit7CisJbXkgJGlvX21ldGhvZCA9IHNoaWZ0OworCW15ICRub2RlID0gc2hpZnQ7CisJ bXkgKCRyZXQsICRvdXRwdXQpOworCisJbXkgJHBzcWwgPSAkbm9kZS0+YmFja2dyb3VuZF9wc3Fs KCdwb3N0Z3JlcycsIG9uX2Vycm9yX3N0b3AgPT4gMCk7CisKKwkkcHNxbC0+cXVlcnlfc2FmZSgK KwkJcXEoCitDUkVBVEUgVEVNUE9SQVJZIFRBQkxFIHRtcF9yZWFkX3N0cmVhbShkYXRhIGludCBu b3QgbnVsbCk7CitJTlNFUlQgSU5UTyB0bXBfcmVhZF9zdHJlYW0gU0VMRUNUIGdlbmVyYXRlX3Nl cmllcygxLCAxMDAwMCk7CitTRUxFQ1QgdGVzdF9yZWFkX3N0cmVhbV9yZXN1bWUoJ3RtcF9yZWFk X3N0cmVhbScsIDApOworRFJPUCBUQUJMRSB0bXBfcmVhZF9zdHJlYW07CispKTsKKworCSRwc3Fs LT5xdWVyeV9zYWZlKAorCQlxcSgKK0NSRUFURSBURU1QT1JBUlkgVEFCTEUgdG1wX3JlYWRfc3Ry ZWFtKGRhdGEgaW50IG5vdCBudWxsKTsKK0lOU0VSVCBJTlRPIHRtcF9yZWFkX3N0cmVhbSBTRUxF Q1QgZ2VuZXJhdGVfc2VyaWVzKDEsIDEwMDAwKTsKK1NFTEVDVCB0ZXN0X3JlYWRfc3RyZWFtX3lp ZWxkKCd0bXBfcmVhZF9zdHJlYW0nLCAwKTsKK0RST1AgVEFCTEUgdG1wX3JlYWRfc3RyZWFtOwor KSk7CisKKwkkcHNxbC0+cXVpdCgpOworfQorCisKIAogIyBSdW4gYWxsIHRlc3RzIHRoYXQgYXJl IHN1cHBvcnRlZCBmb3IgYWxsIGlvX21ldGhvZHMKIHN1YiB0ZXN0X2dlbmVyaWMKQEAgLTE1MjUs NiArMTU1NCw3IEBAIENIRUNLUE9JTlQ7CiAJdGVzdF9jaGVja3N1bSgkaW9fbWV0aG9kLCAkbm9k ZSk7CiAJdGVzdF9pZ25vcmVfY2hlY2tzdW0oJGlvX21ldGhvZCwgJG5vZGUpOwogCXRlc3RfY2hl Y2tzdW1fY3JlYXRlZGIoJGlvX21ldGhvZCwgJG5vZGUpOworCXRlc3RfcmVhZF9zdHJlYW0oJGlv X21ldGhvZCwgJG5vZGUpOwogCiAgIFNLSVA6CiAJewpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9k dWxlcy90ZXN0X2Fpby90ZXN0X2Fpby0tMS4wLnNxbCBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9h aW8vdGVzdF9haW8tLTEuMC5zcWwKaW5kZXggZTQ5NTQ4MWM0MWUuLmUzNzgxMGI3MjczIDEwMDY0 NAotLS0gYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYWlvL3Rlc3RfYWlvLS0xLjAuc3FsCisrKyBi L3NyYy90ZXN0L21vZHVsZXMvdGVzdF9haW8vdGVzdF9haW8tLTEuMC5zcWwKQEAgLTEwNiwzICsx MDYsMTYgQEAgQVMgJ01PRFVMRV9QQVRITkFNRScgTEFOR1VBR0UgQzsKIENSRUFURSBGVU5DVElP TiBpbmpfaW9fcmVvcGVuX2RldGFjaCgpCiBSRVRVUk5TIHBnX2NhdGFsb2cudm9pZCBTVFJJQ1QK IEFTICdNT0RVTEVfUEFUSE5BTUUnIExBTkdVQUdFIEM7CisKKworCisvKgorICogUmVhZCBzdHJl YW0gcmVsYXRlZCBmdW5jdGlvbnMKKyAqLworQ1JFQVRFIEZVTkNUSU9OIHRlc3RfcmVhZF9zdHJl YW1fcmVzdW1lKHJlbCByZWdjbGFzcywgYmxvY2tubyBpbnQ0KQorUkVUVVJOUyBwZ19jYXRhbG9n LnZvaWQgU1RSSUNUCitBUyAnTU9EVUxFX1BBVEhOQU1FJyBMQU5HVUFHRSBDOworCitDUkVBVEUg RlVOQ1RJT04gdGVzdF9yZWFkX3N0cmVhbV95aWVsZChyZWwgcmVnY2xhc3MsIGJsb2Nrbm8gaW50 NCkKK1JFVFVSTlMgcGdfY2F0YWxvZy52b2lkIFNUUklDVAorQVMgJ01PRFVMRV9QQVRITkFNRScg TEFOR1VBR0UgQzsKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9haW8vdGVzdF9y ZWFkX3N0cmVhbS5jIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby90ZXN0X3JlYWRfc3RyZWFt LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmQxZDQzNmE5MGI3Ci0t LSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby90ZXN0X3JlYWRfc3Ry ZWFtLmMKQEAgLTAsMCArMSwxODEgQEAKKy8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICoKKyAqIHRlc3Rf cmVhZF9zdHJlYW0uYworICoJCUhlbHBlcnMgdG8gd3JpdGUgdGVzdHMgZm9yIHJlYWRfc3RyZWFt LmMKKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMjAtMjAyNSwgUG9zdGdyZVNRTCBHbG9iYWwgRGV2 ZWxvcG1lbnQgR3JvdXAKKyAqCisgKiBJREVOVElGSUNBVElPTgorICoJICBzcmMvdGVzdC9tb2R1 bGVzL3Rlc3RfYWlvL3Rlc3RfcmVhZF9zdHJlYW0uYworICoKKyAqLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQor ICovCisKKyNpbmNsdWRlICJwb3N0Z3Jlcy5oIgorCisjaW5jbHVkZSAiYWNjZXNzL3JlbGF0aW9u LmgiCisjaW5jbHVkZSAiZm1nci5oIgorI2luY2x1ZGUgInN0b3JhZ2UvYnVmbWdyLmgiCisjaW5j bHVkZSAic3RvcmFnZS9yZWFkX3N0cmVhbS5oIgorCit0eXBlZGVmIHN0cnVjdAoreworCUJsb2Nr TnVtYmVyIGJsa25vOworCWludAkJCWNvdW50OworfSB0ZXN0X3JlYWRfc3RyZWFtX3Jlc3VtZV9z dGF0ZTsKKworc3RhdGljIEJsb2NrTnVtYmVyCit0ZXN0X3JlYWRfc3RyZWFtX3Jlc3VtZV9jYihS ZWFkU3RyZWFtICpzdHJlYW0sCisJCQkJCQkgICB2b2lkICpjYWxsYmFja19wcml2YXRlX2RhdGEs CisJCQkJCQkgICB2b2lkICpwZXJfYnVmZmVyX2RhdGEpCit7CisJdGVzdF9yZWFkX3N0cmVhbV9y ZXN1bWVfc3RhdGUgKnN0YXRlID0gY2FsbGJhY2tfcHJpdmF0ZV9kYXRhOworCisJLyogUGVyaW9k aWMgZW5kLW9mLXN0cmVhbS4gKi8KKwlpZiAoKytzdGF0ZS0+Y291bnQgJSAzID09IDApCisJCXJl dHVybiByZWFkX3N0cmVhbV9wYXVzZShzdHJlYW0pOworCisJcmV0dXJuIHN0YXRlLT5ibGtubzsK K30KKworLyoKKyAqIFRlc3QgcmVhZF9zdHJlYW1fcmVzdW1lKCksIGFsbG93aW5nIGEgc3RyZWFt IHRvIGVuZCB0ZW1wb3JhcmlseSBhbmQgdGhlbgorICogY29udGludWUgd2hlcmUgaXQgbGVmdCBv ZmYuCisgKi8KK1BHX0ZVTkNUSU9OX0lORk9fVjEodGVzdF9yZWFkX3N0cmVhbV9yZXN1bWUpOwor RGF0dW0KK3Rlc3RfcmVhZF9zdHJlYW1fcmVzdW1lKFBHX0ZVTkNUSU9OX0FSR1MpCit7CisJT2lk CQkJcmVsaWQgPSBQR19HRVRBUkdfT0lEKDApOworCUJsb2NrTnVtYmVyIGJsa25vID0gUEdfR0VU QVJHX1VJTlQzMigxKTsKKwlSZWxhdGlvbglyZWw7CisJQnVmZmVyCQlidWY7CisJUmVhZFN0cmVh bSAqc3RyZWFtOworCXRlc3RfcmVhZF9zdHJlYW1fcmVzdW1lX3N0YXRlIHN0YXRlID0gey5ibGtu byA9IGJsa25vfTsKKworCXJlbCA9IHJlbGF0aW9uX29wZW4ocmVsaWQsIEFjY2Vzc1NoYXJlTG9j ayk7CisJc3RyZWFtID0gcmVhZF9zdHJlYW1fYmVnaW5fcmVsYXRpb24oUkVBRF9TVFJFQU1fREVG QVVMVCwKKwkJCQkJCQkJCQlOVUxMLAorCQkJCQkJCQkJCXJlbCwKKwkJCQkJCQkJCQlNQUlOX0ZP UktOVU0sCisJCQkJCQkJCQkJdGVzdF9yZWFkX3N0cmVhbV9yZXN1bWVfY2IsCisJCQkJCQkJCQkJ JnN0YXRlLAorCQkJCQkJCQkJCTApOworCisJZm9yIChpbnQgaSA9IDA7IGkgPCAzOyArK2kpCisJ eworCQkvKiBTYW1lIGJsb2NrIHR3aWNlLiAqLworCQlidWYgPSByZWFkX3N0cmVhbV9uZXh0X2J1 ZmZlcihzdHJlYW0sIE5VTEwpOworCQlBc3NlcnQoQnVmZmVyR2V0QmxvY2tOdW1iZXIoYnVmKSA9 PSBibGtubyk7CisJCVJlbGVhc2VCdWZmZXIoYnVmKTsKKwkJYnVmID0gcmVhZF9zdHJlYW1fbmV4 dF9idWZmZXIoc3RyZWFtLCBOVUxMKTsKKwkJQXNzZXJ0KEJ1ZmZlckdldEJsb2NrTnVtYmVyKGJ1 ZikgPT0gYmxrbm8pOworCQlSZWxlYXNlQnVmZmVyKGJ1Zik7CisKKwkJLyogRW5kLW9mLXN0cmVh bS4gKi8KKwkJYnVmID0gcmVhZF9zdHJlYW1fbmV4dF9idWZmZXIoc3RyZWFtLCBOVUxMKTsKKwkJ QXNzZXJ0KGJ1ZiA9PSBJbnZhbGlkQnVmZmVyKTsKKwkJYnVmID0gcmVhZF9zdHJlYW1fbmV4dF9i dWZmZXIoc3RyZWFtLCBOVUxMKTsKKwkJQXNzZXJ0KGJ1ZiA9PSBJbnZhbGlkQnVmZmVyKTsKKwor CQkvKiBSZXN1bWUuICovCisJCXJlYWRfc3RyZWFtX3Jlc3VtZShzdHJlYW0pOworCX0KKworCXJl YWRfc3RyZWFtX2VuZChzdHJlYW0pOworCXJlbGF0aW9uX2Nsb3NlKHJlbCwgTm9Mb2NrKTsKKwor CVBHX1JFVFVSTl9WT0lEKCk7Cit9CisKK3R5cGVkZWYgc3RydWN0Cit7CisJQmxvY2tOdW1iZXIg Ymxrbm87CisJaW50CQkJY291bnQ7CisJaW50CQkJeWllbGRzOworCWludAkJCWJsb2NrczsKK30J CQl0ZXN0X3JlYWRfc3RyZWFtX3lpZWxkX3N0YXRlOworCitzdGF0aWMgQmxvY2tOdW1iZXIKK3Rl c3RfcmVhZF9zdHJlYW1feWllbGRfY2IoUmVhZFN0cmVhbSAqc3RyZWFtLAorCQkJCQkJICB2b2lk ICpjYWxsYmFja19wcml2YXRlX2RhdGEsCisJCQkJCQkgIHZvaWQgKnBlcl9idWZmZXJfZGF0YSkK K3sKKwl0ZXN0X3JlYWRfc3RyZWFtX3lpZWxkX3N0YXRlICpzdGF0ZSA9IGNhbGxiYWNrX3ByaXZh dGVfZGF0YTsKKworCS8qIFlpZWxkIGV2ZXJ5IHRoaXJkIGNhbGwuICovCisJaWYgKCsrc3RhdGUt PmNvdW50ICUgMyA9PSAyKQorCXsKKwkJc3RhdGUtPnlpZWxkcysrOworCQlyZXR1cm4gcmVhZF9z dHJlYW1feWllbGQoc3RyZWFtKTsKKwl9CisKKwlzdGF0ZS0+YmxvY2tzKys7CisJcmV0dXJuIHN0 YXRlLT5ibGtubzsKK30KKworLyoKKyAqIFRlc3QgcmVhZF9zdHJlYW1feWllbGQoKSwgYWxsb3dp bmcgY29udHJvbCB0byBiZSB5aWVsZGVkIHRlbXBvcmFyaWx5IGZyb20KKyAqIHRoZSBsb29rYWhl YWQgbG9vcCBhbmQgcmV0dXJuZWQgdG8gdGhlIGNhbGxlciBvZiByZWFkX3N0cmVhbV9uZXh0X2J1 ZmZlcigpLgorICovCitQR19GVU5DVElPTl9JTkZPX1YxKHRlc3RfcmVhZF9zdHJlYW1feWllbGQp OworRGF0dW0KK3Rlc3RfcmVhZF9zdHJlYW1feWllbGQoUEdfRlVOQ1RJT05fQVJHUykKK3sKKwlP aWQJCQlyZWxpZCA9IFBHX0dFVEFSR19PSUQoMCk7CisJQmxvY2tOdW1iZXIgYmxrbm8gPSBQR19H RVRBUkdfVUlOVDMyKDEpOworCVJlbGF0aW9uCXJlbDsKKwlCdWZmZXIJCWJ1ZjsKKwlSZWFkU3Ry ZWFtICpzdHJlYW07CisJdGVzdF9yZWFkX3N0cmVhbV95aWVsZF9zdGF0ZSBzdGF0ZSA9IHsuYmxr bm8gPSBibGtub307CisKKwlyZWwgPSByZWxhdGlvbl9vcGVuKHJlbGlkLCBBY2Nlc3NTaGFyZUxv Y2spOworCXN0cmVhbSA9IHJlYWRfc3RyZWFtX2JlZ2luX3JlbGF0aW9uKFJFQURfU1RSRUFNX0RF RkFVTFQsCisJCQkJCQkJCQkJTlVMTCwKKwkJCQkJCQkJCQlyZWwsCisJCQkJCQkJCQkJTUFJTl9G T1JLTlVNLAorCQkJCQkJCQkJCXRlc3RfcmVhZF9zdHJlYW1feWllbGRfY2IsCisJCQkJCQkJCQkJ JnN0YXRlLAorCQkJCQkJCQkJCTApOworCisJYnVmID0gcmVhZF9zdHJlYW1fbmV4dF9idWZmZXIo c3RyZWFtLCBOVUxMKTsKKwlBc3NlcnQoQnVmZmVyR2V0QmxvY2tOdW1iZXIoYnVmKSA9PSBibGtu byk7CisJUmVsZWFzZUJ1ZmZlcihidWYpOworCUFzc2VydChzdGF0ZS5ibG9ja3MgPT0gMSk7CisJ QXNzZXJ0KHN0YXRlLnlpZWxkcyA9PSAxKTsKKworCWJ1ZiA9IHJlYWRfc3RyZWFtX25leHRfYnVm ZmVyKHN0cmVhbSwgTlVMTCk7CisJQXNzZXJ0KEJ1ZmZlckdldEJsb2NrTnVtYmVyKGJ1ZikgPT0g Ymxrbm8pOworCVJlbGVhc2VCdWZmZXIoYnVmKTsKKwlBc3NlcnQoc3RhdGUuYmxvY2tzID09IDMp OworCUFzc2VydChzdGF0ZS55aWVsZHMgPT0gMSk7CisKKwlidWYgPSByZWFkX3N0cmVhbV9uZXh0 X2J1ZmZlcihzdHJlYW0sIE5VTEwpOworCUFzc2VydChCdWZmZXJHZXRCbG9ja051bWJlcihidWYp ID09IGJsa25vKTsKKwlSZWxlYXNlQnVmZmVyKGJ1Zik7CisJQXNzZXJ0KHN0YXRlLmJsb2NrcyA9 PSAzKTsKKwlBc3NlcnQoc3RhdGUueWllbGRzID09IDIpOworCisJYnVmID0gcmVhZF9zdHJlYW1f bmV4dF9idWZmZXIoc3RyZWFtLCBOVUxMKTsKKwlBc3NlcnQoQnVmZmVyR2V0QmxvY2tOdW1iZXIo YnVmKSA9PSBibGtubyk7CisJUmVsZWFzZUJ1ZmZlcihidWYpOworCUFzc2VydChzdGF0ZS5ibG9j a3MgPT0gNSk7CisJQXNzZXJ0KHN0YXRlLnlpZWxkcyA9PSAyKTsKKworCWJ1ZiA9IHJlYWRfc3Ry ZWFtX25leHRfYnVmZmVyKHN0cmVhbSwgTlVMTCk7CisJQXNzZXJ0KEJ1ZmZlckdldEJsb2NrTnVt YmVyKGJ1ZikgPT0gYmxrbm8pOworCVJlbGVhc2VCdWZmZXIoYnVmKTsKKwlBc3NlcnQoc3RhdGUu YmxvY2tzID09IDUpOworCUFzc2VydChzdGF0ZS55aWVsZHMgPT0gMyk7CisKKwlidWYgPSByZWFk X3N0cmVhbV9uZXh0X2J1ZmZlcihzdHJlYW0sIE5VTEwpOworCUFzc2VydChCdWZmZXJHZXRCbG9j a051bWJlcihidWYpID09IGJsa25vKTsKKwlSZWxlYXNlQnVmZmVyKGJ1Zik7CisJQXNzZXJ0KHN0 YXRlLmJsb2NrcyA9PSA3KTsKKwlBc3NlcnQoc3RhdGUueWllbGRzID09IDMpOworCisJcmVhZF9z dHJlYW1fZW5kKHN0cmVhbSk7CisJcmVsYXRpb25fY2xvc2UocmVsLCBOb0xvY2spOworCisJUEdf UkVUVVJOX1ZPSUQoKTsKK30KZGlmZiAtLWdpdCBhL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVm cy5saXN0IGIvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKaW5kZXggY2YzZjZhN2Rh ZmQuLjczOTZlOWNlMTRiIDEwMDY0NAotLS0gYS9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMu bGlzdAorKysgYi9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdApAQCAtNDE1OCw2ICs0 MTU4LDcgQEAgdGRfZW50cnkKIHRlU2VjdGlvbgogdGVtcF90YWJsZXNwYWNlc19leHRyYQogdGVz dF9yZV9mbGFncwordGVzdF9yZWFkX3N0cmVhbV9yZXN1bWVfc3RhdGUKIHRlc3RfcmVnZXhfY3R4 CiB0ZXN0X3NobV9tcV9oZWFkZXIKIHRlc3Rfc3BlYwotLSAKMi41MS4yCgo= --0000000000005ba9c806457cc6cc--