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 1wA63t-0023je-0e for pgsql-hackers@arkaria.postgresql.org; Tue, 07 Apr 2026 13:01:45 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1wA62s-00HSfO-2J for pgsql-hackers@arkaria.postgresql.org; Tue, 07 Apr 2026 13:00:43 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1wA62S-00HOkj-0k for pgsql-hackers@lists.postgresql.org; Tue, 07 Apr 2026 13:00:16 +0000 Received: from mail-lf1-x130.google.com ([2a00:1450:4864:20::130]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1wA62P-000000016Fk-43W9 for pgsql-hackers@postgresql.org; Tue, 07 Apr 2026 13:00:16 +0000 Received: by mail-lf1-x130.google.com with SMTP id 2adb3069b0e04-5a2c500750dso6262230e87.1 for ; Tue, 07 Apr 2026 06:00:13 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1775566812; cv=none; d=google.com; s=arc-20240605; b=T0D2bpkEW2dEIM+x+q2KOQoLmUkTPSFFgq4tcn02cEfagzd+Vor/yV+bu/C6yF/trz ArotwzfCGgKW2XqFC6BKXY1AYmsMNlRjFcN1YyVzOxSbeP9rmF4ZzHU4xhEkH8SKAAcN y8vMMVxXvb81yS2kHO/pAJjtR5h2oME2fW04VtFnQnXi/YlKdO8Bl26yinxXxF8SD9Id BNcI4T55GkyvKv3LM9YFXy1y0xfAXBRh0jMGccOz0CiqE+hi+3U9txYB85IH7Msh90oI 6SQXNqSMXeptUPqwuAoT38QPtiHIGk5kvhq3PnhyRi2DFEh2IQS+ZoEdI1zA54B3/Ow0 q+gA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605; h=to:subject:message-id:date:from:in-reply-to:references:mime-version :dkim-signature; bh=gOIdV1UptKA9qp2tk0C86Tpk1f3WNSnL7ra5IELbwEU=; fh=FIa6CnAOcDlblDMIqVQXhn30ONA1aoHzZ0tfczHgg8I=; b=KbfgI93rCS/4XU2uBm6rXe5mQo1elqS6sUh8SuAbRDoeJmbrs2FGifiGY0TRPf4rVR t+6v6GmzGgCS+POSG03dfx847WVFCqc3eUg4KJuKm/11j3DkXlboxWzx+W/m7sX2le9W 44QGq8zt2xS+N4x+vtW1ty1wqYWQiWiztPkRBaEhd+j1CJO5vBRqdtpb2IMTy0TLFyZs PFELauJDj9XU0PAtrCTIP1kUxmAFxWi2k2kycHGPi1yGXlc3mb4N9mssh6+fyOqNqEQb s0DWRuxuQxhANs7uqiWPGB628HEbHS46e/js95+qtw3rNVLlmYdoB4Lwd9cQPPAblm9p JZuw==; darn=postgresql.org ARC-Authentication-Results: i=1; mx.google.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mianetworks.net; s=google; t=1775566812; x=1776171612; darn=postgresql.org; h=to:subject:message-id:date:from:in-reply-to:references:mime-version :from:to:cc:subject:date:message-id:reply-to; bh=gOIdV1UptKA9qp2tk0C86Tpk1f3WNSnL7ra5IELbwEU=; b=Rqj6nSQfjs4/Nr1MxZEL7mEEMvpsh56wd+jKZBz9bMBJMSnWqiS56NQykaRfG7EQOh uZ4AJUpgKHU9tKQbz5htGDJ2gDfzZWg/AwO/LKTswZoSv5D1DnNVKOf8VMlB7zfeRMNo qyJbBfBPotzeC+phw3dLZDQIhKhYleblG2gda+eVKo23fyM9ph6ITGvR+m7FeNAwRHz5 F91OvoUJ+SUMZKKhnMLq8ZCL/loUuHXpjambnXcvbT1MRsfyVglBzDczXV2omwesaKJL OxgxyjMhEgpJ6HOgCzm8ufe/xNTtD5de1WVzmrgOdpktKb8ElKFqiNx7xv68yUPB+j3N J0aA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1775566812; x=1776171612; h=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=gOIdV1UptKA9qp2tk0C86Tpk1f3WNSnL7ra5IELbwEU=; b=aqzA6OpG0BamwOmGleMBnHWD9gWP2ePEBQSjWdvHG8/b8lmuNp3bNzhml+LH9uAsUP DRZjbuhtdNBvEjZckau2nCWgs3s2HTDWn3c5tVmxv/TR38Dq0ST+rcKymi0xYRCWPPVe +H3O0IpamkecUT70L3i9uQypVvrFKJhwlNiYXlrg8DEqswY90QFLkyektFfGYnIh+lMA pq9gKqtediYy2C/JUYktU9ry9GGijrIaLTxzmxW9S7eKbs5vkkDivVLKGnzelkDQsCRv RxdMefi84mgqS3DZK3BtJL47ZERcF+DaAUp05wG5t/+dh4QTIrMPo8mrfYvTeQBncfS8 yRXg== X-Gm-Message-State: AOJu0Yxbp0UJQQb2D2YpPuhtJAQX8DHO1m6foCx7K1OyET1GTk9okQz7 Li4tAPgfuaeBH+xQj74drYsFbTOUk3BfRwyLCJ4j1Nge5D3sldQ6KqsHi0fArmm3uSekSPk2aiX 7Z8GSvuCPMdJ6M/epISRxHBiBEbZ4n+CM3nmnTOcvfig5pASZjFd0qUd7 X-Gm-Gg: AeBDieuAznj+lBDCwNBrTJJxJHWdqAkIxYh0KdGLoNXt7unDACuF55oyCjyZwxMig75 Jx8HlX9lDcK8/ec4wx3tyNBujJIvqgj90D5L2YtSVwWoV446SZx0ETVeW5udDVtu/kj05dHvsBq KRisjLHymmre3+TXuqPuRNi92Lk3/SVh5oUJxEXJtbJ/ayhh54KB6ifBT28LAR/1KpCNbwbvVu9 ypw6UBBjpMjHLdbgwgRN0kBuew6+Ud3QOMQVNj0uL5WMvKcwH48cPiFrWftHKtfXzHDsI1oSO2n KfQgzvTP X-Received: by 2002:a05:6512:3d1b:b0:5a2:a073:50f8 with SMTP id 2adb3069b0e04-5a337583211mr5589046e87.24.1775566812128; Tue, 07 Apr 2026 06:00:12 -0700 (PDT) MIME-Version: 1.0 References: <2BE661BA-D909-4093-BF78-DB9B0C099337@gmail.com> <77FA04FE-1F84-4DA1-8855-8BBFD8CC889A@gmail.com> <72AA2663-B642-4FB1-BDC2-5FAFF2D2DF15@gmail.com> In-Reply-To: From: Evan Montgomery-Recht Date: Tue, 7 Apr 2026 08:59:59 -0400 X-Gm-Features: AQROBzAy43bJdLrsmwgkWlK-8iqQiOV2Jnhbuq0AIanZhC_xM0T5dNmOFtE6B9c Message-ID: Subject: Re: Eliminating SPI / SQL from some RI triggers - take 3 To: PostgreSQL-development Content-Type: multipart/mixed; boundary="0000000000001cd5bf064ede5dac" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --0000000000001cd5bf064ede5dac Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Hi Amit, First time contributing to this project, let me know if I missed something or need to adjust what I put together. I found a crash in the RI fast-path FK check code introduced by 2da86c1ef9b and extended by b7b27eb41a5. C-language extensions that use SPI to INSERT into tables with multiple FK constraints hit an assertion failure (or, without assertions, a server crash) when the batch callback fires. I discovered this via PostGIS's topology CI -- toTopoGeom() uses SPI to insert into edge_data, which has 4 immediate FK constraints referencing node and face. PG 18 passes the same test; the master crashes. This appears to be a separate issue from Chao Li's deferred-trigger batching bug; the patches touch different files and don't conflict. I did do a regression test on the merge referenced both PostgreSQL and PostGIS (to validate that this works.) The problem: ri_FastPathGetEntry() opens pk_rel/idx_rel and creates TupleTableSlots, registering them with the current resource owner -- the SPI portal's. The batch callback ri_FastPathTeardown() only fires when query_depth =3D=3D 0 (via FireAfterTriggerBatchCallbacks), but by that time the inner portal has finished and its resource owner has released the relation references and TupleDesc pins. The teardown then tries to close relations whose refcounts are already zero: TRAP: failed Assert("rel->rd_refcnt > 0"), File: "relcache.c" RelationDecrementReferenceCount -> RelationClose -> index_close -> ri_FastPathTeardown -> ri_FastPathEndBatch -> FireAfterTriggerBatchCallbacks -> AfterTriggerEndQuery -> standard_ExecutorFinish and TupleDesc pins that are no longer tracked by any resource owner cause "tupdesc reference not owned by resource owner" errors. Note that simple PL/pgSQL functions don't trigger this because PL/pgSQL's SPI connection spans the entire function call, so the portal's resource owner outlives the batch callback. The crash requires nested SPI from a C extension, which creates a shorter-lived portal. The attached patch (against master, for application) fixes this by transferring both relation references and TupleDesc pins from the current resource owner to CurTransactionResourceOwner immediately after creating them in ri_FastPathGetEntry(). The transfer uses RelationIncrementReferenceCount / PinTupleDesc under the target owner followed by RelationDecrementReferenceCount / ReleaseTupleDesc under the original. I chose this over switching CurrentResourceOwner around the table_open/index_open calls because the latter also affects transient buffer pins acquired during catalog lookups inside those functions. ri_FastPathTeardown is updated to clear any buffered tuples (whose buffer pins belong to the current resource owner) before switching to CurTransactionResourceOwner for the close/drop operations. The patch also adds a test module (test_spi_func) with a C function that executes SQL via SPI_connect/SPI_execute/SPI_finish, since this crash cannot be triggered from PL/pgSQL. The test exercises the C-level SPI INSERT with multiple FK constraints, FK violations, and nested PL/pgSQL-calls-C-SPI (matching the PostGIS call pattern). This is purely a correctness fix with no performance or backward compatibility impact. No documentation changes are needed since this is an internal bug fix. The patch compiles cleanly and passes pgindent, clang-tidy, and cppcheck. All 247 regression subtests pass, along with the full meson test suite (370 ok, 0 fail, 21 skipped) (skipped due to hardware availability on my side this week). I also verified the PostGIS topology test (toTopoGeom) passes clean with no warnings, and tested abort paths (FK violation, transaction rollback, subtransaction abort via EXCEPTION blocks) (not in scope of PostgreSQL but more for my own verification that things work). Code coverage on the new lines is 100%. Tested on macOS (aarch64) and Linux (aarch64, via Docker). Unrelated to my patch, SonarCloud flagged a potential issue in recheck_matched_pk_tuple() (line 3370): the function loops over ii_NumIndexKeyAttrs elements of the skeys array, but the caller in ri_FastPathFlushArray passes recheck_skey[1] -- an array of exactly one element. This is safe because ri_FastPathFlushArray is the single-column FK path, so ii_NumIndexKeyAttrs is always 1 there. However, the function signature doesn't communicate this constraint, which flags as CWE-125 (out-of-bounds read) / CERT C ARR30-C. Adding an nkeys parameter (like ri_FastPathProbeOne already has) would make the contract explicit. Unrelated to PostgreSQL directly, I currently have a workaround for the changes I'm making to PostGIS to test out some performance enhancements. I left comments in the code so that if this gets accepted, I can revert to a cleaner approach, as this appears to only affect pg19 based on the testing I've done so far. If there's a cleaner approach or a larger underlying issue, I'm definitely willing to keep testing to find a better solution. -- thanks, Evan Montgomery-Recht On Mon, Apr 6, 2026 at 10:12=E2=80=AFPM Amit Langote wrote: > > On Tue, Apr 7, 2026 at 10:46=E2=80=AFAM Chao Li = wrote: > > > On Apr 6, 2026, at 17:45, Amit Langote wrot= e: > > > On Fri, Apr 3, 2026 at 6:39=E2=80=AFPM Amit Langote wrote: > > >> On Fri, Apr 3, 2026 at 5:58=E2=80=AFPM Chao Li wrote: > > >>> I spent several hours debugging this patch today, and I found a pro= blem where the batch mode doesn't seem to handle deferred RI triggers, alth= ough the commit message suggests that it should. > > >>> > > >>> I traced this scenario: > > >>> ``` > > >>> CREATE TABLE pk (a int primary key); > > >>> CREATE TABLE fk (a int references pk(a) DEFERRABLE INITIALLY DEFERR= ED); > > >>> BEGIN; > > >>> INSERT INTO fk VALUES (1); > > >>> INSERT INTO pk VALUES (1); > > >>> COMMIT; > > >>> ``` > > >>> > > >>> When COMMIT is executed, it reaches RI_FKey_check(), where AfterTri= ggerIsActive() checks whether afterTriggers.query_depth >=3D 0. But in the = deferred case, afterTriggers.query_depth is -1. > > >>> > > >>> From the code: > > >>> ``` > > >>> if (ri_fastpath_is_applicable(riinfo)) > > >>> { > > >>> if (AfterTriggerIsActive()) > > >>> { > > >>> /* Batched path: buffer and probe in groups = */ > > >>> ri_FastPathBatchAdd(riinfo, fk_rel, newslot)= ; > > >>> } > > >>> else > > >>> { > > >>> /* ALTER TABLE validation: per-row, no cache= */ > > >>> ri_FastPathCheck(riinfo, fk_rel, newslot); > > >>> } > > >>> return PointerGetDatum(NULL); > > >>> } > > >>> ``` > > >>> > > >>> So this ends up falling back to the per-row path for deferred RI ch= ecks at COMMIT, even though the intent here seems to be only to bypass the = ALTER TABLE validation case, where batch callbacks would never fire, and My= TriggerDepth is 0. So, maybe we can just check MyTriggerDepth>0 in AfterTri= ggerIsActive(). > > >>> > > >>> I tried the attached fix. With it, deferred triggers go through the= batch mode, and all existing tests still pass. > > >> > > >> I think you might be right. Thanks for the patch. It looks correct > > >> to me at a glance, but I will need to check it a bit more closely > > >> before committing. > > > > > > Thinking about this some more, your fix is on the right track but > > > needs a bit more work -- MyTriggerDepth > 0 is too broad since it > > > fires for BEFORE triggers too. I have a revised version using a new > > > afterTriggerFiringDepth counter that I'll push shortly. > > > > > > Added an open item for tracking in the meantime: > > > https://wiki.postgresql.org/wiki/PostgreSQL_19_Open_Items#Open_Issues > > > > V2 looks good to me. Besides the normal cases, I also traced an abnorma= l case to verify that afterTriggerFiringDepth is always reset to 0: > > ``` > > evantest=3D# begin; > > BEGIN > > evantest=3D*# INSERT INTO fk VALUES (2); > > INSERT 0 1 > > evantest=3D*# commit; > > ERROR: insert or update on table "fk" violates foreign key constraint = "fk_a_fkey" > > DETAIL: Key (a)=3D(2) is not present in table "pk". > > ``` > > Thanks for checking. Pushed. > > -- > Thanks, Amit Langote > > --0000000000001cd5bf064ede5dac Content-Type: application/octet-stream; name="v1-0001-Fix-RI-fast-path-crash-when-FK-triggers-fire-unde.patch" Content-Disposition: attachment; filename="v1-0001-Fix-RI-fast-path-crash-when-FK-triggers-fire-unde.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnomis4u0 RnJvbSAzOTZmZmVmNGFmNGRlYTYyNjhmYzc0YjRiNWE1ZjQ4YjRiMDRjODkyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBFdmFuIE1vbnRnb21lcnktUmVjaHQgPG1vbnRnZUBtaWFuZXR3 b3Jrcy5uZXQ+CkRhdGU6IFN1biwgNSBBcHIgMjAyNiAyMjoyMzoyNiAtMDQwMApTdWJqZWN0OiBb UEFUQ0ggdjFdIEZpeCBSSSBmYXN0LXBhdGggY3Jhc2ggd2hlbiBGSyB0cmlnZ2VycyBmaXJlIHVu ZGVyIG5lc3RlZAogU1BJCgpUaGUgZmFzdC1wYXRoIEZLIGNoZWNrIGNvZGUgKHJpX0Zhc3RQYXRo R2V0RW50cnkpIG9wZW5zIFBLIHJlbGF0aW9ucywKY3JlYXRlcyBUdXBsZVRhYmxlU2xvdHMsIGFu ZCBjYWNoZXMgdGhlbSBpbiBSSV9GYXN0UGF0aEVudHJ5IGZvciB0aGUKZHVyYXRpb24gb2YgYSB0 cmlnZ2VyIGJhdGNoLiAgVGhlIGJhdGNoIGNhbGxiYWNrIChyaV9GYXN0UGF0aFRlYXJkb3duKQp0 aGF0IGNsb3NlcyB0aGVtIGZpcmVzIG9ubHkgYXQgcXVlcnlfZGVwdGggPT0gMCB2aWEKRmlyZUFm dGVyVHJpZ2dlckJhdGNoQ2FsbGJhY2tzKCkuCgpXaGVuIEZLIHRyaWdnZXJzIGZpcmUgaW5zaWRl IGEgbmVzdGVkIFNQSSBjb250ZXh0IC0tIGZvciBleGFtcGxlLCBhCkMtbGFuZ3VhZ2UgZnVuY3Rp b24gc3VjaCBhcyBQb3N0R0lTJ3MgdG9wb2dlb19hZGRMaW5lU3RyaW5nKCkgdGhhdAp1c2VzIFNQ SV9jb25uZWN0L1NQSV9leGVjdXRlIHRvIElOU0VSVCBpbnRvIGEgdGFibGUgd2l0aCBtdWx0aXBs ZSBGSwpjb25zdHJhaW50cyAtLSB0aGUgcmVsYXRpb25zIGFuZCBUdXBsZURlc2MgcGlucyBhcmUg cmVnaXN0ZXJlZCB3aXRoCnRoZSBTUEkgcG9ydGFsJ3MgcmVzb3VyY2Ugb3duZXIuICBXaGVuIHRo YXQgcG9ydGFsIGZpbmlzaGVzIGFuZCBpdHMKcmVzb3VyY2Ugb3duZXIgaXMgcmVsZWFzZWQsIHRo ZSByZWZlcmVuY2VzIGFyZSBkZWNyZW1lbnRlZC4gIExhdGVyLAp3aGVuIHRoZSBiYXRjaCBjYWxs YmFjayBmaXJlcyBhdCBxdWVyeV9kZXB0aCA9PSAwLCByaV9GYXN0UGF0aFRlYXJkb3duCmF0dGVt cHRzIHRvIGNsb3NlIHJlbGF0aW9ucyB3aG9zZSByZWZlcmVuY2UgY291bnRzIGFyZSBhbHJlYWR5 IHplcm8sCnRyaWdnZXJpbmc6CgogIFRSQVA6IGZhaWxlZCBBc3NlcnQoInJlbC0+cmRfcmVmY250 ID4gMCIpCiAgaW4gUmVsYXRpb25EZWNyZW1lbnRSZWZlcmVuY2VDb3VudCwgY2FsbGVkIGZyb20g aW5kZXhfY2xvc2UKCmFuZCBUdXBsZURlc2MgcGlucyB0aGF0IGFyZSBubyBsb25nZXIgdHJhY2tl ZCBieSBhbnkgcmVzb3VyY2Ugb3duZXIKY2F1c2UgInR1cGRlc2MgcmVmZXJlbmNlIG5vdCBvd25l ZCBieSByZXNvdXJjZSBvd25lciIgZXJyb3JzLgoKRml4IGJ5IHRyYW5zZmVycmluZyBib3RoIHJl bGF0aW9uIHJlZmVyZW5jZXMgYW5kIFR1cGxlRGVzYyBwaW5zIGZyb20KdGhlIGN1cnJlbnQgKGlu bmVyKSByZXNvdXJjZSBvd25lciB0byBDdXJUcmFuc2FjdGlvblJlc291cmNlT3duZXIKaW1tZWRp YXRlbHkgYWZ0ZXIgY3JlYXRpbmcgdGhlbS4gIHJpX0Zhc3RQYXRoVGVhcmRvd24gaXMgdXBkYXRl ZCB0bwpjbGVhciBhbnkgYnVmZmVyZWQgdHVwbGVzICh3aG9zZSBidWZmZXIgcGlucyBiZWxvbmcg dG8gdGhlIGN1cnJlbnQKcmVzb3VyY2Ugb3duZXIpIGJlZm9yZSBzd2l0Y2hpbmcgdG8gQ3VyVHJh bnNhY3Rpb25SZXNvdXJjZU93bmVyIGZvcgp0aGUgY2xvc2UvZHJvcCBvcGVyYXRpb25zLgoKVGhl IHRyYW5zZmVyIHVzZXMgUmVsYXRpb25JbmNyZW1lbnRSZWZlcmVuY2VDb3VudCAvIFBpblR1cGxl RGVzYyB1bmRlcgp0aGUgdGFyZ2V0IG93bmVyIGZvbGxvd2VkIGJ5IFJlbGF0aW9uRGVjcmVtZW50 UmVmZXJlbmNlQ291bnQgLwpSZWxlYXNlVHVwbGVEZXNjIHVuZGVyIHRoZSBvcmlnaW5hbCwgcmF0 aGVyIHRoYW4gc3dpdGNoaW5nCkN1cnJlbnRSZXNvdXJjZU93bmVyIGFyb3VuZCB0aGUgdGFibGVf b3Blbi9pbmRleF9vcGVuIGNhbGxzLCBiZWNhdXNlCnRoZSBsYXR0ZXIgd291bGQgYWxzbyBhZmZl Y3QgdHJhbnNpZW50IGJ1ZmZlciBwaW5zIGFjcXVpcmVkIGR1cmluZwpjYXRhbG9nIGxvb2t1cHMg aW5zaWRlIHRob3NlIGZ1bmN0aW9ucy4KCkFkZCBhIHRlc3QgbW9kdWxlICh0ZXN0X3NwaV9mdW5j KSB3aXRoIGEgQyBmdW5jdGlvbiB0aGF0IGV4ZWN1dGVzClNRTCB2aWEgU1BJLCByZXByb2R1Y2lu ZyB0aGUgY3Jhc2ggc2NlbmFyaW8gdGhhdCBzaW1wbGUgUEwvcGdTUUwKY2Fubm90IHRyaWdnZXIu CgpCdWcgZm91bmQgdmlhIFBvc3RHSVMgdG9wb2xvZ3kgQ0k6IHRvVG9wb0dlb20oKSAtPiBTUEkg SU5TRVJUIGludG8KZWRnZV9kYXRhICg0IGltbWVkaWF0ZSBGSyBjb25zdHJhaW50cykgY3Jhc2hl cyBvbiBQRyAxOWRldmVsIGJ1dApwYXNzZXMgb24gUEcgMTguCgpEaXNjdXNzaW9uOiBodHRwczov L3Bvc3Rnci5lcy9tL0NBK0hpd3FGNEMwd3MzY08rejVjTGtQdXZ3bkF3a1NwN3NmdmdHajN5UT1M aTZLTk1xQUBtYWlsLmdtYWlsLmNvbQotLS0KIHNyYy9iYWNrZW5kL3V0aWxzL2FkdC9yaV90cmln Z2Vycy5jICAgICAgICAgICB8IDU5ICsrKysrKysrKysrKysrCiBzcmMvdGVzdC9tb2R1bGVzL21l c29uLmJ1aWxkICAgICAgICAgICAgICAgICAgfCAgMSArCiAuLi4vdGVzdF9zcGlfZnVuYy9leHBl Y3RlZC9yaV9mYXN0cGF0aC5vdXQgICAgfCA3OSArKysrKysrKysrKysrKysrKysrCiBzcmMvdGVz dC9tb2R1bGVzL3Rlc3Rfc3BpX2Z1bmMvbWVzb24uYnVpbGQgICAgfCAzMSArKysrKysrKwogLi4u L21vZHVsZXMvdGVzdF9zcGlfZnVuYy9zcWwvcmlfZmFzdHBhdGguc3FsIHwgNjUgKysrKysrKysr KysrKysrCiAuLi4vdGVzdF9zcGlfZnVuYy90ZXN0X3NwaV9mdW5jLS0xLjAuc3FsICAgICAgfCAg OSArKysKIC4uLi9tb2R1bGVzL3Rlc3Rfc3BpX2Z1bmMvdGVzdF9zcGlfZnVuYy5jICAgICB8IDUx ICsrKysrKysrKysrKwogLi4uL3Rlc3Rfc3BpX2Z1bmMvdGVzdF9zcGlfZnVuYy5jb250cm9sICAg ICAgIHwgIDQgKwogOCBmaWxlcyBjaGFuZ2VkLCAyOTkgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1v ZGUgMTAwNjQ0IHNyYy90ZXN0L21vZHVsZXMvdGVzdF9zcGlfZnVuYy9leHBlY3RlZC9yaV9mYXN0 cGF0aC5vdXQKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc3BpX2Z1 bmMvbWVzb24uYnVpbGQKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMvdGVzdC9tb2R1bGVzL3Rlc3Rf c3BpX2Z1bmMvc3FsL3JpX2Zhc3RwYXRoLnNxbAogY3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90ZXN0 L21vZHVsZXMvdGVzdF9zcGlfZnVuYy90ZXN0X3NwaV9mdW5jLS0xLjAuc3FsCiBjcmVhdGUgbW9k ZSAxMDA2NDQgc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3NwaV9mdW5jL3Rlc3Rfc3BpX2Z1bmMuYwog Y3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90ZXN0L21vZHVsZXMvdGVzdF9zcGlfZnVuYy90ZXN0X3Nw aV9mdW5jLmNvbnRyb2wKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9hZHQvcmlfdHJp Z2dlcnMuYyBiL3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9yaV90cmlnZ2Vycy5jCmluZGV4IDg0Zjlm ZWNkYjRjLi45NDM0Njg5MjE1MSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3Jp X3RyaWdnZXJzLmMKKysrIGIvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3JpX3RyaWdnZXJzLmMKQEAg LTUyLDYgKzUyLDcgQEAKICNpbmNsdWRlICJ1dGlscy9sc3lzY2FjaGUuaCIKICNpbmNsdWRlICJ1 dGlscy9tZW11dGlscy5oIgogI2luY2x1ZGUgInV0aWxzL3JlbC5oIgorI2luY2x1ZGUgInV0aWxz L3Jlc293bmVyLmgiCiAjaW5jbHVkZSAidXRpbHMvcmxzLmgiCiAjaW5jbHVkZSAidXRpbHMvcnVs ZXV0aWxzLmgiCiAjaW5jbHVkZSAidXRpbHMvc25hcG1nci5oIgpAQCAtNDE0OCw2ICs0MTQ5LDI1 IEBAIHJpX0Zhc3RQYXRoVGVhcmRvd24odm9pZCkKIAloYXNoX3NlcV9pbml0KCZzdGF0dXMsIHJp X2Zhc3RwYXRoX2NhY2hlKTsKIAl3aGlsZSAoKGVudHJ5ID0gaGFzaF9zZXFfc2VhcmNoKCZzdGF0 dXMpKSAhPSBOVUxMKQogCXsKKwkJUmVzb3VyY2VPd25lciBvbGRvd25lcjsKKworCQkvKgorCQkg KiBGaXJzdCwgY2xlYXIgYW55IGJ1ZmZlcmVkIHR1cGxlIGZyb20gdGhlIHNsb3RzLiAgVGhpcyBt dXN0IGhhcHBlbgorCQkgKiB1bmRlciB0aGUgY3VycmVudCByZXNvdXJjZSBvd25lciBiZWNhdXNl IGJ1ZmZlciBwaW5zIGZyb20gdGhlIGxhc3QKKwkJICogaW5kZXggc2NhbiBiZWxvbmcgdG8gaXQu CisJCSAqLworCQlpZiAoZW50cnktPnBrX3Nsb3QpCisJCQlFeGVjQ2xlYXJUdXBsZShlbnRyeS0+ cGtfc2xvdCk7CisJCWlmIChlbnRyeS0+Zmtfc2xvdCkKKwkJCUV4ZWNDbGVhclR1cGxlKGVudHJ5 LT5ma19zbG90KTsKKworCQkvKgorCQkgKiBOb3cgc3dpdGNoIHRvIEN1clRyYW5zYWN0aW9uUmVz b3VyY2VPd25lciBmb3IgY2xvc2luZyByZWxhdGlvbnMgYW5kCisJCSAqIGRyb3BwaW5nIHNsb3Rz LCBzaW5jZSB0aGF0J3Mgd2hlcmUgdGhlaXIgcmVmcyB3ZXJlIHRyYW5zZmVycmVkIGluCisJCSAq IHJpX0Zhc3RQYXRoR2V0RW50cnkoKS4KKwkJICovCisJCW9sZG93bmVyID0gQ3VycmVudFJlc291 cmNlT3duZXI7CisJCUN1cnJlbnRSZXNvdXJjZU93bmVyID0gQ3VyVHJhbnNhY3Rpb25SZXNvdXJj ZU93bmVyOwogCQlpZiAoZW50cnktPmlkeF9yZWwpCiAJCQlpbmRleF9jbG9zZShlbnRyeS0+aWR4 X3JlbCwgTm9Mb2NrKTsKIAkJaWYgKGVudHJ5LT5wa19yZWwpCkBAIC00MTU2LDYgKzQxNzYsNyBA QCByaV9GYXN0UGF0aFRlYXJkb3duKHZvaWQpCiAJCQlFeGVjRHJvcFNpbmdsZVR1cGxlVGFibGVT bG90KGVudHJ5LT5wa19zbG90KTsKIAkJaWYgKGVudHJ5LT5ma19zbG90KQogCQkJRXhlY0Ryb3BT aW5nbGVUdXBsZVRhYmxlU2xvdChlbnRyeS0+Zmtfc2xvdCk7CisJCUN1cnJlbnRSZXNvdXJjZU93 bmVyID0gb2xkb3duZXI7CiAJCWlmIChlbnRyeS0+Zmx1c2hfY3h0KQogCQkJTWVtb3J5Q29udGV4 dERlbGV0ZShlbnRyeS0+Zmx1c2hfY3h0KTsKIAl9CkBAIC00MjcxLDYgKzQyOTIsNDQgQEAgcmlf RmFzdFBhdGhHZXRFbnRyeShjb25zdCBSSV9Db25zdHJhaW50SW5mbyAqcmlpbmZvLCBSZWxhdGlv biBma19yZWwpCiAJCWVudHJ5LT5ma19zbG90ID0gTWFrZVNpbmdsZVR1cGxlVGFibGVTbG90KFJl bGF0aW9uR2V0RGVzY3IoZmtfcmVsKSwKIAkJCQkJCQkJCQkJCSAgJlRUU09wc0hlYXBUdXBsZSk7 CiAKKwkJLyoKKwkJICogVHJhbnNmZXIgcmVsYXRpb24gYW5kIFR1cGxlRGVzYyByZWZlcmVuY2Vz IGZyb20gdGhlIGN1cnJlbnQKKwkJICogcmVzb3VyY2Ugb3duZXIgdG8gQ3VyVHJhbnNhY3Rpb25S ZXNvdXJjZU93bmVyIHNvIHRoZXkgc3Vydml2ZQorCQkgKiBjbGVhbnVwIG9mIGlubmVyIHJlc291 cmNlIG93bmVycyAoZS5nLiwgU1BJIHBvcnRhbHMgZnJvbSBDLWxhbmd1YWdlCisJCSAqIGZ1bmN0 aW9ucykuICBUaGUgYmF0Y2ggY2FsbGJhY2sgdGhhdCBjbG9zZXMgdGhlbQorCQkgKiAocmlfRmFz dFBhdGhUZWFyZG93bikgZmlyZXMgYXQgcXVlcnlfZGVwdGggPT0gMCwgd2hpY2ggbWF5IGJlIGxv bmcKKwkJICogYWZ0ZXIgdGhlIHJlc291cmNlIG93bmVyIHRoYXQgd2FzIGN1cnJlbnQgd2hlbiB0 aGUgdHJpZ2dlciBmaXJlZAorCQkgKiBoYXMgYmVlbiByZWxlYXNlZC4KKwkJICoKKwkJICogV2Ug b3BlbiByZWxhdGlvbnMgYW5kIGNyZWF0ZSBzbG90cyB1bmRlciB0aGUgY3VycmVudCByZXNvdXJj ZSBvd25lcgorCQkgKiAodG8gYXZvaWQgYWZmZWN0aW5nIHRyYW5zaWVudCBidWZmZXIgcGlucyBm cm9tIGNhdGFsb2cgbG9va3VwcyksCisJCSAqIHRoZW4gdHJhbnNmZXIgdGhlIHJlbGF0aW9uIHJl ZnMgYW5kIFR1cGxlRGVzYyBwaW5zIGJ5IGluY3JlbWVudGluZworCQkgKiB1bmRlciB0aGUgdGFy Z2V0IG93bmVyIGFuZCBkZWNyZW1lbnRpbmcgdW5kZXIgdGhlIG9yaWdpbmFsLgorCQkgKgorCQkg KiBSZWxhdGlvbiBUdXBsZURlc2NzIChyZF9hdHQpIGFyZSByZWZlcmVuY2UtY291bnRlZCAodGRy ZWZjb3VudCA+PQorCQkgKiAxKSwgc28gUGluVHVwbGVEZXNjIGluc2lkZSB0YWJsZV9zbG90X2Ny ZWF0ZSAvCisJCSAqIE1ha2VTaW5nbGVUdXBsZVRhYmxlU2xvdCByZWdpc3RlcnMgdGhlbSB3aXRo IHRoZSByZXNvdXJjZSBvd25lci4KKwkJICogVGhlc2UgbXVzdCBhbHNvIGJlIHRyYW5zZmVycmVk LgorCQkgKi8KKwkJaWYgKEN1cnJlbnRSZXNvdXJjZU93bmVyICE9IEN1clRyYW5zYWN0aW9uUmVz b3VyY2VPd25lcikKKwkJeworCQkJUmVzb3VyY2VPd25lciBzYXZlZCA9IEN1cnJlbnRSZXNvdXJj ZU93bmVyOworCisJCQkvKiBBZGQgcmVmcyB1bmRlciBDdXJUcmFuc2FjdGlvblJlc291cmNlT3du ZXIgKi8KKwkJCUN1cnJlbnRSZXNvdXJjZU93bmVyID0gQ3VyVHJhbnNhY3Rpb25SZXNvdXJjZU93 bmVyOworCQkJUmVsYXRpb25JbmNyZW1lbnRSZWZlcmVuY2VDb3VudChlbnRyeS0+cGtfcmVsKTsK KwkJCVJlbGF0aW9uSW5jcmVtZW50UmVmZXJlbmNlQ291bnQoZW50cnktPmlkeF9yZWwpOworCQkJ UGluVHVwbGVEZXNjKGVudHJ5LT5wa19zbG90LT50dHNfdHVwbGVEZXNjcmlwdG9yKTsKKwkJCVBp blR1cGxlRGVzYyhlbnRyeS0+Zmtfc2xvdC0+dHRzX3R1cGxlRGVzY3JpcHRvcik7CisKKwkJCS8q IFJlbW92ZSByZWZzIGZyb20gdGhlIG9yaWdpbmFsIHJlc291cmNlIG93bmVyICovCisJCQlDdXJy ZW50UmVzb3VyY2VPd25lciA9IHNhdmVkOworCQkJUmVsYXRpb25EZWNyZW1lbnRSZWZlcmVuY2VD b3VudChlbnRyeS0+cGtfcmVsKTsKKwkJCVJlbGF0aW9uRGVjcmVtZW50UmVmZXJlbmNlQ291bnQo ZW50cnktPmlkeF9yZWwpOworCQkJUmVsZWFzZVR1cGxlRGVzYyhlbnRyeS0+cGtfc2xvdC0+dHRz X3R1cGxlRGVzY3JpcHRvcik7CisJCQlSZWxlYXNlVHVwbGVEZXNjKGVudHJ5LT5ma19zbG90LT50 dHNfdHVwbGVEZXNjcmlwdG9yKTsKKwkJfQorCiAJCWVudHJ5LT5mbHVzaF9jeHQgPSBBbGxvY1Nl dENvbnRleHRDcmVhdGUoVG9wVHJhbnNhY3Rpb25Db250ZXh0LAogCQkJCQkJCQkJCQkJICJSSSBm YXN0IHBhdGggZmx1c2ggdGVtcG9yYXJ5IGNvbnRleHQiLAogCQkJCQkJCQkJCQkJIEFMTE9DU0VU X1NNQUxMX1NJWkVTKTsKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvbWVzb24uYnVpbGQg Yi9zcmMvdGVzdC9tb2R1bGVzL21lc29uLmJ1aWxkCmluZGV4IDRiY2E0MmJiMzcwLi4zZDVkMDE2 YzQ2ZiAxMDA2NDQKLS0tIGEvc3JjL3Rlc3QvbW9kdWxlcy9tZXNvbi5idWlsZAorKysgYi9zcmMv dGVzdC9tb2R1bGVzL21lc29uLmJ1aWxkCkBAIC01Myw2ICs1Myw3IEBAIHN1YmRpcigndGVzdF9z YXNscHJlcCcpCiBzdWJkaXIoJ3Rlc3Rfc2htZW0nKQogc3ViZGlyKCd0ZXN0X3NobV9tcScpCiBz dWJkaXIoJ3Rlc3Rfc2xydScpCitzdWJkaXIoJ3Rlc3Rfc3BpX2Z1bmMnKQogc3ViZGlyKCd0ZXN0 X3RpZHN0b3JlJykKIHN1YmRpcigndHlwY2FjaGUnKQogc3ViZGlyKCd1bnNhZmVfdGVzdHMnKQpk aWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3NwaV9mdW5jL2V4cGVjdGVkL3JpX2Zh c3RwYXRoLm91dCBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9zcGlfZnVuYy9leHBlY3RlZC9yaV9m YXN0cGF0aC5vdXQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjViMmJm OWU5MzEwCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3NwaV9mdW5j L2V4cGVjdGVkL3JpX2Zhc3RwYXRoLm91dApAQCAtMCwwICsxLDc5IEBACistLQorLS0gVGVzdCBS SSBmYXN0LXBhdGggRksgY2hlY2sgdW5kZXIgQy1sZXZlbCBTUEkuCistLQorLS0gVGhlIFJJIGZh c3QtcGF0aCBjYWNoZXMgcmVsYXRpb24gcmVmZXJlbmNlcyBpbiByaV9GYXN0UGF0aEdldEVudHJ5 KCkKKy0tIHVuZGVyIHRoZSBjdXJyZW50IHJlc291cmNlIG93bmVyLiAgV2hlbiBGSyB0cmlnZ2Vy cyBmaXJlIGluc2lkZSBhCistLSBDLWxldmVsIFNQSSBjb250ZXh0IChTUElfY29ubmVjdC9TUElf ZXhlY3V0ZS9TUElfZmluaXNoKSwgdGhlIGlubmVyCistLSByZXNvdXJjZSBvd25lciBpcyByZWxl YXNlZCBiZWZvcmUgdGhlIGJhdGNoIGNhbGxiYWNrIHRoYXQgY2xvc2VzCistLSB0aG9zZSByZWxh dGlvbnMgZmlyZXMgYXQgcXVlcnlfZGVwdGggPT0gMC4gIFdpdGhvdXQgdGhlIGZpeCwgdGhpcwor LS0gY3Jhc2hlcyB3aXRoIEFzc2VydChyZWwtPnJkX3JlZmNudCA+IDApIGluIGluZGV4X2Nsb3Nl LgorLS0KKy0tIFNpbXBsZSBQTC9wZ1NRTCBkb2VzIE5PVCB0cmlnZ2VyIHRoaXMgYmVjYXVzZSBp dHMgU1BJIGNvbm5lY3Rpb24KKy0tIG91dGxpdmVzIHRoZSBiYXRjaCBjYWxsYmFjay4gIEEgQyBm dW5jdGlvbiB1c2luZyBTUEkgaXMgcmVxdWlyZWQuCistLQorQ1JFQVRFIEVYVEVOU0lPTiB0ZXN0 X3NwaV9mdW5jOworQ1JFQVRFIFRBQkxFIHJpX2ZwX3BrMSAoaWQgc2VyaWFsIFBSSU1BUlkgS0VZ KTsKK0NSRUFURSBUQUJMRSByaV9mcF9wazIgKGlkIHNlcmlhbCBQUklNQVJZIEtFWSk7CitDUkVB VEUgVEFCTEUgcmlfZnBfcGszIChpZCBzZXJpYWwgUFJJTUFSWSBLRVkpOworSU5TRVJUIElOVE8g cmlfZnBfcGsxIFZBTFVFUyAoMSk7CitJTlNFUlQgSU5UTyByaV9mcF9wazIgVkFMVUVTICgxKTsK K0lOU0VSVCBJTlRPIHJpX2ZwX3BrMyBWQUxVRVMgKDEpOworQ1JFQVRFIFRBQkxFIHJpX2ZwX2Zr ICgKKyAgICBpZCBzZXJpYWwgUFJJTUFSWSBLRVksCisgICAgYSBpbnQgUkVGRVJFTkNFUyByaV9m cF9wazEoaWQpLAorICAgIGIgaW50IFJFRkVSRU5DRVMgcmlfZnBfcGsyKGlkKSwKKyAgICBjIGlu dCBSRUZFUkVOQ0VTIHJpX2ZwX3BrMyhpZCksCisgICAgZCBpbnQgUkVGRVJFTkNFUyByaV9mcF9w azEoaWQpLAorICAgIGUgaW50IFJFRkVSRU5DRVMgcmlfZnBfcGsyKGlkKSwKKyAgICBmIGludCBS RUZFUkVOQ0VTIHJpX2ZwX3BrMyhpZCkKKyk7CistLSBDLWxldmVsIFNQSSBJTlNFUlQ6IHRoZSBj cml0aWNhbCB0ZXN0IGNhc2UuCistLSBXaXRob3V0IHRoZSBmaXggdGhpcyBjcmFzaGVzIHRoZSBz ZXJ2ZXIuCitTRUxFQ1Qgc3BpX2V4ZWMoCisgICAgJ0lOU0VSVCBJTlRPIHJpX2ZwX2ZrIChhLCBi LCBjLCBkLCBlLCBmKSBWQUxVRVMgKDEsIDEsIDEsIDEsIDEsIDEpJyk7Cisgc3BpX2V4ZWMgCist LS0tLS0tLS0tCisgCisoMSByb3cpCisKKy0tIEFkZGl0aW9uYWwgQy1sZXZlbCBTUEkgSU5TRVJU cyB0byBleGVyY2lzZSBiYXRjaCByZXVzZSBhY3Jvc3MgY2FsbHMuCistLSBVc2UgZGlmZmVyZW50 IGNvbHVtbiBvcmRlcmluZ3MgdG8gZW5zdXJlIGVhY2ggaXMgYSBkaXN0aW5jdCBzdGF0ZW1lbnQu CitTRUxFQ1Qgc3BpX2V4ZWMoCisgICAgJ0lOU0VSVCBJTlRPIHJpX2ZwX2ZrIChmLCBlLCBkLCBj LCBiLCBhKSBWQUxVRVMgKDEsIDEsIDEsIDEsIDEsIDEpJyk7Cisgc3BpX2V4ZWMgCistLS0tLS0t LS0tCisgCisoMSByb3cpCisKK1NFTEVDVCBzcGlfZXhlYygKKyAgICAnSU5TRVJUIElOVE8gcmlf ZnBfZmsgKGEsIGMsIGUsIGIsIGQsIGYpIFZBTFVFUyAoMSwgMSwgMSwgMSwgMSwgMSknKTsKKyBz cGlfZXhlYyAKKy0tLS0tLS0tLS0KKyAKKygxIHJvdykKKworLS0gQy1sZXZlbCBTUEkgd2l0aCBG SyB2aW9sYXRpb246IHNob3VsZCBlcnJvciwgbm90IGNyYXNoCitTRUxFQ1Qgc3BpX2V4ZWMoCisg ICAgJ0lOU0VSVCBJTlRPIHJpX2ZwX2ZrIChhLCBiLCBjLCBkLCBlLCBmKSBWQUxVRVMgKDk5OSwg MSwgMSwgMSwgMSwgMSknKTsKK0VSUk9SOiAgaW5zZXJ0IG9yIHVwZGF0ZSBvbiB0YWJsZSAicmlf ZnBfZmsiIHZpb2xhdGVzIGZvcmVpZ24ga2V5IGNvbnN0cmFpbnQgInJpX2ZwX2ZrX2FfZmtleSIK K0RFVEFJTDogIEtleSAoYSk9KDk5OSkgaXMgbm90IHByZXNlbnQgaW4gdGFibGUgInJpX2ZwX3Br MSIuCitDT05URVhUOiAgU1FMIHN0YXRlbWVudCAiSU5TRVJUIElOVE8gcmlfZnBfZmsgKGEsIGIs IGMsIGQsIGUsIGYpIFZBTFVFUyAoOTk5LCAxLCAxLCAxLCAxLCAxKSIKKy0tIE5lc3RlZDogUEwv cGdTUUwgY2FsbGluZyBDIFNQSSAobWltaWNzIFBvc3RHSVMgdG9Ub3BvR2VvbSBwYXR0ZXJuKQor Q1JFQVRFIEZVTkNUSU9OIHBscGdzcWxfY2FsbHNfY19zcGkoKSBSRVRVUk5TIHZvaWQgQVMgJCQK K0RFQ0xBUkUKKyAgICBpbnNfc3RtdCB0ZXh0IDo9ICdJTlNFUlQgSU5UTyByaV9mcF9mayAoYSwg YiwgYywgZCwgZSwgZikgVkFMVUVTICgxLCAxLCAxLCAxLCAxLCAxKSc7CitCRUdJTgorICAgIFBF UkZPUk0gc3BpX2V4ZWMoaW5zX3N0bXQpOworRU5EOworJCQgTEFOR1VBR0UgcGxwZ3NxbDsKK1NF TEVDVCBwbHBnc3FsX2NhbGxzX2Nfc3BpKCk7CisgcGxwZ3NxbF9jYWxsc19jX3NwaSAKKy0tLS0t LS0tLS0tLS0tLS0tLS0tLQorIAorKDEgcm93KQorCistLSBDbGVhbnVwCitEUk9QIEZVTkNUSU9O IHBscGdzcWxfY2FsbHNfY19zcGkoKTsKK0RST1AgVEFCTEUgcmlfZnBfZms7CitEUk9QIFRBQkxF IHJpX2ZwX3BrMywgcmlfZnBfcGsyLCByaV9mcF9wazE7CitEUk9QIEVYVEVOU0lPTiB0ZXN0X3Nw aV9mdW5jOwpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3NwaV9mdW5jL21lc29u LmJ1aWxkIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3NwaV9mdW5jL21lc29uLmJ1aWxkCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi45MzllZGM4OThhNAotLS0gL2Rldi9u dWxsCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9zcGlfZnVuYy9tZXNvbi5idWlsZApAQCAt MCwwICsxLDMxIEBACit0ZXN0X3NwaV9mdW5jX3NvdXJjZXMgPSBmaWxlcygKKyAgJ3Rlc3Rfc3Bp X2Z1bmMuYycsCispCisKK2lmIGhvc3Rfc3lzdGVtID09ICd3aW5kb3dzJworICB0ZXN0X3NwaV9m dW5jX3NvdXJjZXMgKz0gcmNfbGliX2dlbi5wcm9jZXNzKHdpbjMydmVyX3JjLCBleHRyYV9hcmdz OiBbCisgICAgJy0tTkFNRScsICd0ZXN0X3NwaV9mdW5jJywKKyAgICAnLS1GSUxFREVTQycsICd0 ZXN0X3NwaV9mdW5jIC0gU1FMLWNhbGxhYmxlIEMgU1BJIGZ1bmN0aW9uJyxdKQorZW5kaWYKKwor dGVzdF9zcGlfZnVuYyA9IHNoYXJlZF9tb2R1bGUoJ3Rlc3Rfc3BpX2Z1bmMnLAorICB0ZXN0X3Nw aV9mdW5jX3NvdXJjZXMsCisgIGt3YXJnczogcGdfdGVzdF9tb2RfYXJncywKKykKK3Rlc3RfaW5z dGFsbF9saWJzICs9IHRlc3Rfc3BpX2Z1bmMKKwordGVzdF9pbnN0YWxsX2RhdGEgKz0gZmlsZXMo CisgICd0ZXN0X3NwaV9mdW5jLmNvbnRyb2wnLAorICAndGVzdF9zcGlfZnVuYy0tMS4wLnNxbCcs CispCisKK3Rlc3RzICs9IHsKKyAgJ25hbWUnOiAndGVzdF9zcGlfZnVuYycsCisgICdzZCc6IG1l c29uLmN1cnJlbnRfc291cmNlX2RpcigpLAorICAnYmQnOiBtZXNvbi5jdXJyZW50X2J1aWxkX2Rp cigpLAorICAncmVncmVzcyc6IHsKKyAgICAnc3FsJzogWworICAgICAgJ3JpX2Zhc3RwYXRoJywK KyAgICBdLAorICB9LAorfQpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3NwaV9m dW5jL3NxbC9yaV9mYXN0cGF0aC5zcWwgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc3BpX2Z1bmMv c3FsL3JpX2Zhc3RwYXRoLnNxbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MC4uMDAyZjRhZDVlNTIKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rf c3BpX2Z1bmMvc3FsL3JpX2Zhc3RwYXRoLnNxbApAQCAtMCwwICsxLDY1IEBACistLQorLS0gVGVz dCBSSSBmYXN0LXBhdGggRksgY2hlY2sgdW5kZXIgQy1sZXZlbCBTUEkuCistLQorLS0gVGhlIFJJ IGZhc3QtcGF0aCBjYWNoZXMgcmVsYXRpb24gcmVmZXJlbmNlcyBpbiByaV9GYXN0UGF0aEdldEVu dHJ5KCkKKy0tIHVuZGVyIHRoZSBjdXJyZW50IHJlc291cmNlIG93bmVyLiAgV2hlbiBGSyB0cmln Z2VycyBmaXJlIGluc2lkZSBhCistLSBDLWxldmVsIFNQSSBjb250ZXh0IChTUElfY29ubmVjdC9T UElfZXhlY3V0ZS9TUElfZmluaXNoKSwgdGhlIGlubmVyCistLSByZXNvdXJjZSBvd25lciBpcyBy ZWxlYXNlZCBiZWZvcmUgdGhlIGJhdGNoIGNhbGxiYWNrIHRoYXQgY2xvc2VzCistLSB0aG9zZSBy ZWxhdGlvbnMgZmlyZXMgYXQgcXVlcnlfZGVwdGggPT0gMC4gIFdpdGhvdXQgdGhlIGZpeCwgdGhp cworLS0gY3Jhc2hlcyB3aXRoIEFzc2VydChyZWwtPnJkX3JlZmNudCA+IDApIGluIGluZGV4X2Ns b3NlLgorLS0KKy0tIFNpbXBsZSBQTC9wZ1NRTCBkb2VzIE5PVCB0cmlnZ2VyIHRoaXMgYmVjYXVz ZSBpdHMgU1BJIGNvbm5lY3Rpb24KKy0tIG91dGxpdmVzIHRoZSBiYXRjaCBjYWxsYmFjay4gIEEg QyBmdW5jdGlvbiB1c2luZyBTUEkgaXMgcmVxdWlyZWQuCistLQorCitDUkVBVEUgRVhURU5TSU9O IHRlc3Rfc3BpX2Z1bmM7CisKK0NSRUFURSBUQUJMRSByaV9mcF9wazEgKGlkIHNlcmlhbCBQUklN QVJZIEtFWSk7CitDUkVBVEUgVEFCTEUgcmlfZnBfcGsyIChpZCBzZXJpYWwgUFJJTUFSWSBLRVkp OworQ1JFQVRFIFRBQkxFIHJpX2ZwX3BrMyAoaWQgc2VyaWFsIFBSSU1BUlkgS0VZKTsKK0lOU0VS VCBJTlRPIHJpX2ZwX3BrMSBWQUxVRVMgKDEpOworSU5TRVJUIElOVE8gcmlfZnBfcGsyIFZBTFVF UyAoMSk7CitJTlNFUlQgSU5UTyByaV9mcF9wazMgVkFMVUVTICgxKTsKKworQ1JFQVRFIFRBQkxF IHJpX2ZwX2ZrICgKKyAgICBpZCBzZXJpYWwgUFJJTUFSWSBLRVksCisgICAgYSBpbnQgUkVGRVJF TkNFUyByaV9mcF9wazEoaWQpLAorICAgIGIgaW50IFJFRkVSRU5DRVMgcmlfZnBfcGsyKGlkKSwK KyAgICBjIGludCBSRUZFUkVOQ0VTIHJpX2ZwX3BrMyhpZCksCisgICAgZCBpbnQgUkVGRVJFTkNF UyByaV9mcF9wazEoaWQpLAorICAgIGUgaW50IFJFRkVSRU5DRVMgcmlfZnBfcGsyKGlkKSwKKyAg ICBmIGludCBSRUZFUkVOQ0VTIHJpX2ZwX3BrMyhpZCkKKyk7CisKKy0tIEMtbGV2ZWwgU1BJIElO U0VSVDogdGhlIGNyaXRpY2FsIHRlc3QgY2FzZS4KKy0tIFdpdGhvdXQgdGhlIGZpeCB0aGlzIGNy YXNoZXMgdGhlIHNlcnZlci4KK1NFTEVDVCBzcGlfZXhlYygKKyAgICAnSU5TRVJUIElOVE8gcmlf ZnBfZmsgKGEsIGIsIGMsIGQsIGUsIGYpIFZBTFVFUyAoMSwgMSwgMSwgMSwgMSwgMSknKTsKKwor LS0gQWRkaXRpb25hbCBDLWxldmVsIFNQSSBJTlNFUlRzIHRvIGV4ZXJjaXNlIGJhdGNoIHJldXNl IGFjcm9zcyBjYWxscy4KKy0tIFVzZSBkaWZmZXJlbnQgY29sdW1uIG9yZGVyaW5ncyB0byBlbnN1 cmUgZWFjaCBpcyBhIGRpc3RpbmN0IHN0YXRlbWVudC4KK1NFTEVDVCBzcGlfZXhlYygKKyAgICAn SU5TRVJUIElOVE8gcmlfZnBfZmsgKGYsIGUsIGQsIGMsIGIsIGEpIFZBTFVFUyAoMSwgMSwgMSwg MSwgMSwgMSknKTsKK1NFTEVDVCBzcGlfZXhlYygKKyAgICAnSU5TRVJUIElOVE8gcmlfZnBfZmsg KGEsIGMsIGUsIGIsIGQsIGYpIFZBTFVFUyAoMSwgMSwgMSwgMSwgMSwgMSknKTsKKworLS0gQy1s ZXZlbCBTUEkgd2l0aCBGSyB2aW9sYXRpb246IHNob3VsZCBlcnJvciwgbm90IGNyYXNoCitTRUxF Q1Qgc3BpX2V4ZWMoCisgICAgJ0lOU0VSVCBJTlRPIHJpX2ZwX2ZrIChhLCBiLCBjLCBkLCBlLCBm KSBWQUxVRVMgKDk5OSwgMSwgMSwgMSwgMSwgMSknKTsKKworLS0gTmVzdGVkOiBQTC9wZ1NRTCBj YWxsaW5nIEMgU1BJIChtaW1pY3MgUG9zdEdJUyB0b1RvcG9HZW9tIHBhdHRlcm4pCitDUkVBVEUg RlVOQ1RJT04gcGxwZ3NxbF9jYWxsc19jX3NwaSgpIFJFVFVSTlMgdm9pZCBBUyAkJAorREVDTEFS RQorICAgIGluc19zdG10IHRleHQgOj0gJ0lOU0VSVCBJTlRPIHJpX2ZwX2ZrIChhLCBiLCBjLCBk LCBlLCBmKSBWQUxVRVMgKDEsIDEsIDEsIDEsIDEsIDEpJzsKK0JFR0lOCisgICAgUEVSRk9STSBz cGlfZXhlYyhpbnNfc3RtdCk7CitFTkQ7CiskJCBMQU5HVUFHRSBwbHBnc3FsOworCitTRUxFQ1Qg cGxwZ3NxbF9jYWxsc19jX3NwaSgpOworCistLSBDbGVhbnVwCitEUk9QIEZVTkNUSU9OIHBscGdz cWxfY2FsbHNfY19zcGkoKTsKK0RST1AgVEFCTEUgcmlfZnBfZms7CitEUk9QIFRBQkxFIHJpX2Zw X3BrMywgcmlfZnBfcGsyLCByaV9mcF9wazE7CitEUk9QIEVYVEVOU0lPTiB0ZXN0X3NwaV9mdW5j OwpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3NwaV9mdW5jL3Rlc3Rfc3BpX2Z1 bmMtLTEuMC5zcWwgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc3BpX2Z1bmMvdGVzdF9zcGlfZnVu Yy0tMS4wLnNxbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uZDVkNjc5 NzRkNWIKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc3BpX2Z1bmMv dGVzdF9zcGlfZnVuYy0tMS4wLnNxbApAQCAtMCwwICsxLDkgQEAKKy8qIHNyYy90ZXN0L21vZHVs ZXMvdGVzdF9zcGlfZnVuYy90ZXN0X3NwaV9mdW5jLS0xLjAuc3FsICovCisKKy0tIGNvbXBsYWlu IGlmIHNjcmlwdCBpcyBzb3VyY2VkIGluIHBzcWwsIHJhdGhlciB0aGFuIHZpYSBDUkVBVEUgRVhU RU5TSU9OCitcZWNobyBVc2UgIkNSRUFURSBFWFRFTlNJT04gdGVzdF9zcGlfZnVuYyIgdG8gbG9h ZCB0aGlzIGZpbGUuIFxxdWl0CisKK0NSRUFURSBGVU5DVElPTiBzcGlfZXhlYyhxdWVyeSB0ZXh0 KQorUkVUVVJOUyB2b2lkCitBUyAnTU9EVUxFX1BBVEhOQU1FJywgJ3NwaV9leGVjJworTEFOR1VB R0UgQyBTVFJJQ1Q7CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc3BpX2Z1bmMv dGVzdF9zcGlfZnVuYy5jIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3NwaV9mdW5jL3Rlc3Rfc3Bp X2Z1bmMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uNTFmNGI5YzRm NzMKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc3BpX2Z1bmMvdGVz dF9zcGlfZnVuYy5jCkBAIC0wLDAgKzEsNTEgQEAKKy8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICoKKyAq IHRlc3Rfc3BpX2Z1bmMuYworICoJCVNRTC1jYWxsYWJsZSBDIGZ1bmN0aW9uIHRoYXQgdXNlcyBT UEkgdG8gZXhlY3V0ZSBhIHF1ZXJ5LgorICoKKyAqCQlVc2VmdWwgZm9yIHRlc3RpbmcgY29kZSBw YXRocyB0aGF0IG9ubHkgdHJpZ2dlciB1bmRlciBDLWxldmVsCisgKgkJU1BJIChub3QgUEwvcGdT UUwpLCBzdWNoIGFzIHJlc291cmNlIG93bmVyIGludGVyYWN0aW9ucyB3aXRoCisgKgkJUkkgZmFz dC1wYXRoIEZLIGNoZWNrcy4KKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMjYsIFBvc3RncmVTUUwg R2xvYmFsIERldmVsb3BtZW50IEdyb3VwCisgKgorICogSURFTlRJRklDQVRJT04KKyAqCQlzcmMv dGVzdC9tb2R1bGVzL3Rlc3Rfc3BpX2Z1bmMvdGVzdF9zcGlfZnVuYy5jCisgKgorICotLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tCisgKi8KKyNpbmNsdWRlICJwb3N0Z3Jlcy5oIgorCisjaW5jbHVkZSAiZXhlY3V0 b3Ivc3BpLmgiCisjaW5jbHVkZSAidXRpbHMvYnVpbHRpbnMuaCIKKworUEdfTU9EVUxFX01BR0lD OworCitQR19GVU5DVElPTl9JTkZPX1YxKHNwaV9leGVjKTsKKworLyoKKyAqIHNwaV9leGVjKHF1 ZXJ5IHRleHQpIC0gZXhlY3V0ZSBhIFNRTCBxdWVyeSB2aWEgU1BJLgorICoKKyAqIE9wZW5zIGEg ZnJlc2ggU1BJIGNvbm5lY3Rpb24sIGV4ZWN1dGVzIHRoZSBxdWVyeSwgYW5kIGNsb3NlcyB0aGUK KyAqIGNvbm5lY3Rpb24uICBUaGlzIG1pbWljcyB0aGUgU1BJIHVzYWdlIHBhdHRlcm4gb2YgQy1s YW5ndWFnZQorICogZXh0ZW5zaW9ucyAoZS5nLiwgUG9zdEdJUyB0b3BvbG9neSBmdW5jdGlvbnMp IHdoZXJlIGVhY2ggY2FsbAorICogdG8gU1BJX2Nvbm5lY3QgLyBTUElfZXhlY3V0ZSAvIFNQSV9m aW5pc2ggY3JlYXRlcyBhbmQgZGVzdHJveXMKKyAqIGEgc2hvcnQtbGl2ZWQgU1BJIGNvbnRleHQu CisgKi8KK0RhdHVtCitzcGlfZXhlYyhQR19GVU5DVElPTl9BUkdTKQoreworCWNvbnN0IGNoYXIg KnF1ZXJ5ID0gdGV4dF90b19jc3RyaW5nKFBHX0dFVEFSR19URVhUX1BQKDApKTsKKwlpbnQJCQly ZXQ7CisKKwlTUElfY29ubmVjdCgpOworCisJcmV0ID0gU1BJX2V4ZWN1dGUocXVlcnksIGZhbHNl LCAwKTsKKworCWlmIChyZXQgPCAwKQorCQllbG9nKEVSUk9SLCAiU1BJX2V4ZWN1dGUgZmFpbGVk OiBlcnJvciBjb2RlICVkIiwgcmV0KTsKKworCVNQSV9maW5pc2goKTsKKworCVBHX1JFVFVSTl9W T0lEKCk7Cit9CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc3BpX2Z1bmMvdGVz dF9zcGlfZnVuYy5jb250cm9sIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3NwaV9mdW5jL3Rlc3Rf c3BpX2Z1bmMuY29udHJvbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4u ODdiZDlkYzk3ODIKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc3Bp X2Z1bmMvdGVzdF9zcGlfZnVuYy5jb250cm9sCkBAIC0wLDAgKzEsNCBAQAorY29tbWVudCA9ICdU ZXN0IFNRTC1jYWxsYWJsZSBDIGZ1bmN0aW9uIHRoYXQgdXNlcyBTUEknCitkZWZhdWx0X3ZlcnNp b24gPSAnMS4wJworbW9kdWxlX3BhdGhuYW1lID0gJyRsaWJkaXIvdGVzdF9zcGlfZnVuYycKK3Jl bG9jYXRhYmxlID0gdHJ1ZQotLSAKMi41MC4xIChBcHBsZSBHaXQtMTU1KQoK --0000000000001cd5bf064ede5dac--