Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1pjNF0-0006br-Dq for pgsql-hackers@arkaria.postgresql.org; Mon, 03 Apr 2023 16:41:10 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1pjNEz-0000dY-7o for pgsql-hackers@arkaria.postgresql.org; Mon, 03 Apr 2023 16:41:09 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1pjNEy-0000dO-QA for pgsql-hackers@lists.postgresql.org; Mon, 03 Apr 2023 16:41:08 +0000 Received: from mail-pj1-x102e.google.com ([2607:f8b0:4864:20::102e]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.94.2) (envelope-from ) id 1pjNEu-000fPL-9b for pgsql-hackers@postgresql.org; Mon, 03 Apr 2023 16:41:08 +0000 Received: by mail-pj1-x102e.google.com with SMTP id r7-20020a17090b050700b002404be7920aso29163318pjz.5 for ; Mon, 03 Apr 2023 09:41:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1680540062; x=1683132062; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=0+gpBGPeW73CTWqX+gw/as8mCnseLO8TPDVFbUTa9Jk=; b=DWI2yDe4ONWK0JZRZgVgHPND18/15e5EOmAZg+iUc1bamLmVHMPEMMnz7P9VLuyQkw /Y13b8Id6xC43OxAf1I8hB9a9alB8gmEuUA/Gxz7nGDlXYzLFqtrWofzHJke1Ny3sxGT YD8VDLXAl9M4zdRRCNOCXSgcDYEaeeJnDqFwP37X9TR5f1Qd5L1fmXYX3pxUjPMNeiM6 sT70tgvLDu8V5LBOEna2Zod+HsX0K/FOEJonmHpFM6Chtux69xB5wSJ25a4SsUF0130P 3bB/AyIUMvmseYuPwhvm0OL2BXxBns9RHfIpNWDyW7MqFRZpGOuu94hcDK/9tW8psysx DNUQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1680540062; x=1683132062; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=0+gpBGPeW73CTWqX+gw/as8mCnseLO8TPDVFbUTa9Jk=; b=VjhtjQ83yjRqPj5n43eX6KW6dU5+m7sfWVoTv7BuMyVW/zzJ3JWT5JRoL2pLYg3n0i ghf8OYo3YN9F4AhFkZ4quV4qYwiVlmU9hScszG/dB/VLWuLdQzD7RE6+akFcy+FkmQck gRQC7BdCs5/OgDP+7vUQnNVpPB4U7gsUAzleAoAUyOJFGQHw/d39z2lvoG8904lWCtKi 72Q7AL9RSWbSF3GnCzN6xoYmqOTh989JHSm39pItNIfPP22tsv5rD/ipERB691ufkjx5 K7h+/bTjGIn2KfGxAZjT93dVHNYlaD8skFiWlC1HUMOqRQJvFAMtw8or6Jqiku2uviZS VAnA== X-Gm-Message-State: AAQBX9edl+gf1rkEAUFzmWmitiCSyj+Ic6epnsxTbtteQqws8ukXg/xa 6HWXAIZk5dZoQcQJ/4b2waqJS7CPI7kV9RRXJeE= X-Google-Smtp-Source: AKy350byMs+MtKuHpNn7rq3pRdpKQLgCGCgghkCKDXZ0rIrUtrsxa5KbXpyxZbdBnGlsyoCjpkQSeAcr7P7iI0TYNbg= X-Received: by 2002:a17:903:489:b0:1a2:8c7e:f325 with SMTP id jj9-20020a170903048900b001a28c7ef325mr5167895plb.11.1680540061596; Mon, 03 Apr 2023 09:41:01 -0700 (PDT) MIME-Version: 1.0 References: <20230329.120908.350115307125624430.horikyota.ntt@gmail.com> <20230329.132155.629765142788133576.horikyota.ntt@gmail.com> <20230329.173456.1185961934810139447.horikyota.ntt@gmail.com> <935191FB-083B-4060-89FC-466F61FAA391@yesql.se> In-Reply-To: From: Melanie Plageman Date: Mon, 3 Apr 2023 12:40:49 -0400 Message-ID: Subject: Re: Should vacuum process config file reload more often To: Masahiko Sawada Cc: Daniel Gustafsson , Kyotaro Horiguchi , PostgreSQL Hackers , Andres Freund , amit.kapila16@gmail.com Content-Type: multipart/mixed; boundary="00000000000067bc5205f8713969" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --00000000000067bc5205f8713969 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable On Sun, Apr 2, 2023 at 10:28=E2=80=AFPM Masahiko Sawada wrote: > Thank you for updating the patches. Here are comments for 0001, 0002, > and 0003 patches: Thanks for the review! v13 attached with requested updates. > 0001: > > @@ -391,7 +389,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params, > Assert(params->index_cleanup !=3D VACOPTVALUE_UNSPECIFIED); > Assert(params->truncate !=3D VACOPTVALUE_UNSPECIFIED && > params->truncate !=3D VACOPTVALUE_AUTO); > - vacrel->failsafe_active =3D false; > + VacuumFailsafeActive =3D false; > > If we go with the idea of using VacuumCostActive + > VacuumFailsafeActive, we need to make sure that both are cleared at > the end of the vacuum per table. Since the patch clears it only here, > it remains true even after vacuum() if we trigger the failsafe mode > for the last table in the table list. > > In addition to that, to ensure that also in an error case, I think we > need to clear it also in PG_FINALLY() block in vacuum(). So, in 0001, I tried to keep it exactly the same as LVRelState->failsafe_active except for it being a global. We don't actually use VacuumFailsafeActive in this commit except in vacuumlazy.c, which does its own management of the value (it resets it to false at the top of heap_vacuum_rel()). In the later commit which references VacuumFailsafeActive outside of vacuumlazy.c, I had reset it in PG_FINALLY(). I hadn't reset it in the relation list loop in vacuum(). Autovacuum calls vacuum() for each relation. However, you are right that for VACUUM with a list of relations for a table access method other than heap, once set to true, if the table AM forgets to reset the value to false at the end of vacuuming the relation, it would stay true. I've set it to false now at the bottom of the loop through relations in vacuum(). > --- > @@ -306,6 +306,7 @@ extern PGDLLIMPORT pg_atomic_uint32 > *VacuumSharedCostBalance; > extern PGDLLIMPORT pg_atomic_uint32 *VacuumActiveNWorkers; > extern PGDLLIMPORT int VacuumCostBalanceLocal; > > +extern bool VacuumFailsafeActive; > > Do we need PGDLLIMPORT for VacuumFailSafeActive? I didn't add one because I thought extensions and other code probably shouldn't access this variable. I thought PGDLLIMPORT was only needed for extensions built on windows to access variables. > 0002: > > @@ -2388,6 +2398,7 @@ vac_max_items_to_alloc_size(int max_items) > return offsetof(VacDeadItems, items) + > sizeof(ItemPointerData) * max_items; > } > > + > /* > * vac_tid_reaped() -- is a particular tid deletable? > * > > Unnecessary new line. There are some other unnecessary new lines in this = patch. Thanks! I think I got them all. > --- > @@ -307,6 +309,8 @@ extern PGDLLIMPORT pg_atomic_uint32 *VacuumActiveNWor= kers; > extern PGDLLIMPORT int VacuumCostBalanceLocal; > > extern bool VacuumFailsafeActive; > +extern int VacuumCostLimit; > +extern double VacuumCostDelay; > > and > > @@ -266,8 +266,6 @@ extern PGDLLIMPORT int max_parallel_maintenance_worke= rs; > extern PGDLLIMPORT int VacuumCostPageHit; > extern PGDLLIMPORT int VacuumCostPageMiss; > extern PGDLLIMPORT int VacuumCostPageDirty; > -extern PGDLLIMPORT int VacuumCostLimit; > -extern PGDLLIMPORT double VacuumCostDelay; > > Do we need PGDLLIMPORT too? I was on the fence about this. I annotated the new guc variables vacuum_cost_delay and vacuum_cost_limit with PGDLLIMPORT, but I did not annotate the variables used in vacuum code (VacuumCostLimit/Delay). I think whether or not this is the right choice depends on two things: whether or not my understanding of PGDLLIMPORT is correct and, if it is, whether or not we want extensions to be able to access VacuumCostLimit/Delay or if just access to the guc variables is sufficient/desirable. > --- > @@ -1773,20 +1773,33 @@ FreeWorkerInfo(int code, Datum arg) > } > } > > + > /* > - * Update the cost-based delay parameters, so that multiple workers cons= ume > - * each a fraction of the total available I/O. > + * Update vacuum cost-based delay-related parameters for autovacuum work= ers and > + * backends executing VACUUM or ANALYZE using the value of relevant gucs= and > + * global state. This must be called during setup for vacuum and after e= very > + * config reload to ensure up-to-date values. > */ > void > -AutoVacuumUpdateDelay(void) > +VacuumUpdateCosts(void > > Isn't it better to define VacuumUpdateCosts() in vacuum.c rather than > autovacuum.c as this is now a common code for both vacuum and > autovacuum? We can't access members of WorkerInfoData from inside vacuum.c > 0003: > > @@ -501,9 +502,9 @@ vacuum(List *relations, VacuumParams *params, > { > ListCell *cur; > > - VacuumUpdateCosts(); > in_vacuum =3D true; > - VacuumCostActive =3D (VacuumCostDelay > 0); > + VacuumFailsafeActive =3D false; > + VacuumUpdateCosts(); > > Hmm, if we initialize VacuumFailsafeActive here, should it be included > in 0001 patch? See comment above. This is the first patch where we use or reference it outside of vacuumlazy.c > --- > + if (VacuumCostDelay > 0) > + VacuumCostActive =3D true; > + else > + { > + VacuumCostActive =3D false; > + VacuumCostBalance =3D 0; > + } > > I agree to update VacuumCostActive in VacuumUpdateCosts(). But if we > do that I think this change should be included in 0002 patch. I'm a bit hesitant to do this because in 0002 VacuumCostActive cannot change status while vacuuming a table or even between tables for VACUUM when a list of relations is specified (except for being disabled by failsafe mode) Adding it to VacuumUpdateCosts() in 0003 makes it clear that it could change while vacuuming a table, so we must update it. I previously had 0002 introduce AutoVacuumUpdateLimit(), which only updated VacuumCostLimit with wi_cost_limit for autovacuum workers and then called that in vacuum_delay_point() (instead of AutoVacuumUpdateDelay() or VacuumUpdateCosts()). I abandoned that idea in favor of the simplicity of having VacuumUpdateCosts() just update those variables for everyone, since it could be reused in 0003. Now, I'm thinking the previous method might be more clear? Or is what I have okay? > --- > + if (ConfigReloadPending && !analyze_in_outer_xact) > + { > + ConfigReloadPending =3D false; > + ProcessConfigFile(PGC_SIGHUP); > + VacuumUpdateCosts(); > + } > > Since analyze_in_outer_xact is false by default, we reload the config > file in vacuum_delay_point() by default. We need to note that > vacuum_delay_point() could be called via other paths, for example > gin_cleanup_pending_list() and ambulkdelete() called by > validate_index(). So it seems to me that we should do the opposite; we > have another global variable, say vacuum_can_reload_config, which is > false by default, and is set to true only when vacuum() allows it. In > vacuum_delay_point(), we reload the config file iff > (ConfigReloadPending && vacuum_can_reload_config). Wow, great point. Thanks for catching this. I've made the update you suggested. I also set vacuum_can_reload_config to false in PG_FINALLY() in vacuum(). - Melanie --00000000000067bc5205f8713969 Content-Type: text/x-patch; charset="US-ASCII"; name="v13-0004-Autovacuum-refreshes-cost-based-delay-params-mor.patch" Content-Disposition: attachment; filename="v13-0004-Autovacuum-refreshes-cost-based-delay-params-mor.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg1222ab3 RnJvbSBlNzU3YTRhZTA4MjY5YmRkOGZkY2Y3N2I2ZWVmZjRhMjkyZDFhOGVjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBTYXQsIDI1IE1hciAyMDIzIDE0OjE0OjU1IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTMgNC80XSBBdXRvdmFjdXVtIHJlZnJlc2hlcyBjb3N0LWJhc2VkIGRlbGF5IHBhcmFt cyBtb3JlCiBvZnRlbgoKVGhlIHByZXZpb3VzIGNvbW1pdCBhbGxvd2VkIFZBQ1VVTSB0byByZWxv YWQgdGhlIGNvbmZpZyBmaWxlIG1vcmUgb2Z0ZW4Kc28gdGhhdCBjb3N0LWJhc2VkIGRlbGF5IHBh cmFtZXRlcnMgY291bGQgdGFrZSBlZmZlY3Qgd2hpbGUgVkFDVVVNaW5nIGEKcmVsYXRpb24uIEF1 dG92YWN1dW0sIGhvd2V2ZXIgZGlkIG5vdCBiZW5lZml0IGZyb20gdGhpcyBjaGFuZ2UuCgpJbiBv cmRlciBmb3IgYXV0b3ZhY3V1bSB3b3JrZXJzIHRvIHNhZmVseSB1cGRhdGUgdGhlaXIgb3duIGNv c3QgZGVsYXkKYW5kIGNvc3QgbGltaXQgcGFyYW1ldGVycyB3aXRob3V0IGltcGFjdGluZyBwZXJm b3JtYW5jZSwgd2UgaGFkIHRvCnJldGhpbmsgd2hlbiBhbmQgaG93IHRoZXNlIHZhbHVlcyB3ZXJl IGFjY2Vzc2VkLgoKUHJldmlvdXNseSwgYW4gYXV0b3ZhY3V1bSB3b3JrZXIncyB3aV9jb3N0X2xp bWl0IHdhcyBzZXQgb25seSBhdCB0aGUKYmVnaW5uaW5nIG9mIHZhY3V1bWluZyBhIHRhYmxlLCBh ZnRlciByZWxvYWRpbmcgdGhlIGNvbmZpZyBmaWxlLgpUaGVyZWZvcmUsIGF0IHRoZSB0aW1lIHRo YXQgYXV0b3ZhY19iYWxhbmNlX2Nvc3QoKSBpcyBjYWxsZWQsIHdvcmtlcnMKdmFjdXVtaW5nIHRh YmxlcyB3aXRoIG5vIHRhYmxlIG9wdGlvbnMgY291bGQgc3RpbGwgaGF2ZSBkaWZmZXJlbnQgdmFs dWVzCmZvciB0aGVpciB3aV9jb3N0X2xpbWl0X2Jhc2UgYW5kIHdpX2Nvc3RfZGVsYXkuCgpOb3cg dGhhdCB0aGUgY29zdCBwYXJhbWV0ZXJzIGNhbiBiZSB1cGRhdGVkIHdoaWxlIHZhY3V1bWluZyBh IHRhYmxlLAp3b3JrZXJzIHdpbGwgKHdpdGhpbiBzb21lIG1hcmdpbiBvZiBlcnJvcikgaGF2ZSBu byByZWFzb24gdG8gaGF2ZQpkaWZmZXJlbnQgdmFsdWVzIGZvciBjb3N0IGxpbWl0IGFuZCBjb3N0 IGRlbGF5IChpbiB0aGUgYWJzZW5jZSBvZiB0YWJsZQpvcHRpb25zKS4gVGhpcyByZW1vdmVzIHRo ZSByYXRpb25hbGUgZm9yIGtlZXBpbmcgY29zdCBsaW1pdCBhbmQgY29zdApkZWxheSBpbiBzaGFy ZWQgbWVtb3J5LiBCYWxhbmNpbmcgdGhlIGNvc3QgbGltaXQgcmVxdWlyZXMgb25seSB0aGUKbnVt YmVyIG9mIGFjdGl2ZSBhdXRvdmFjdXVtIHdvcmtlcnMgdmFjdXVtaW5nIGEgdGFibGUgd2l0aCBu byBjb3N0LWJhc2VkCnRhYmxlIG9wdGlvbnMuCgpSZXZpZXdlZC1ieTogTWFzYWhpa28gU2F3YWRh IDxzYXdhZGEubXNoa0BnbWFpbC5jb20+ClJldmlld2VkLWJ5OiBLeW90YXJvIEhvcmlndWNoaSA8 aG9yaWt5b3RhLm50dEBnbWFpbC5jb20+ClJldmlld2VkLWJ5OiBEYW5pZWwgR3VzdGFmc3NvbiA8 ZGFuaWVsQHllc3FsLnNlPgpEaXNjdXNzaW9uOiBodHRwczovL3d3dy5wb3N0Z3Jlc3FsLm9yZy9t ZXNzYWdlLWlkL2ZsYXQvQ0FBS1J1X1puZ3pxbkVPRGM3TG1TMU5IMDRLdDZZOWh1U2p6NXBwNyUy QkRYaHJqREEwZ3clNDBtYWlsLmdtYWlsLmNvbQotLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3Zh Y3V1bS5jICAgICAgIHwgIDE3ICstCiBzcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0u YyB8IDIzNSArKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tCiBzcmMvaW5jbHVkZS9jb21tYW5k cy92YWN1dW0uaCAgICAgICB8ICAgMSArCiAzIGZpbGVzIGNoYW5nZWQsIDEzNCBpbnNlcnRpb25z KCspLCAxMTkgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMv dmFjdXVtLmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYwppbmRleCA4ODhlYjAyMmNj Li4zZTM0MzI0NjQ1IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYwor KysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYwpAQCAtMjI1NywxMCArMjI1NywxMCBA QCB2YWN1dW1fZGVsYXlfcG9pbnQodm9pZCkKIAogCS8qCiAJICogUmVsb2FkIHRoZSBjb25maWd1 cmF0aW9uIGZpbGUgaWYgcmVxdWVzdGVkLiBUaGlzIGFsbG93cyBjaGFuZ2VzIHRvCi0JICogdmFj dXVtX2Nvc3RfbGltaXQgYW5kIHZhY3V1bV9jb3N0X2RlbGF5IHRvIHRha2UgZWZmZWN0IHdoaWxl IGEgdGFibGUgaXMKLQkgKiBiZWluZyB2YWN1dW1lZCBvciBhbmFseXplZC4gQW5hbHl6ZSBzaG91 bGQgbm90IHJlbG9hZCBjb25maWd1cmF0aW9uCi0JICogZmlsZSBpZiBpdCBpcyBpbiBhbiBvdXRl ciB0cmFuc2FjdGlvbiwgYXMgd2UgY3VycmVudGx5IG9ubHkgYWxsb3cKLQkgKiBjb25maWd1cmF0 aW9uIHJlbG9hZCB3aGVuIGluIHRvcC1sZXZlbCBzdGF0ZW1lbnRzLgorCSAqIFthdXRvdmFjdXVt X112YWN1dW1fY29zdF9saW1pdCBhbmQgW2F1dG92YWN1dW1fXXZhY3V1bV9jb3N0X2RlbGF5IHRv CisJICogdGFrZSBlZmZlY3Qgd2hpbGUgYSB0YWJsZSBpcyBiZWluZyB2YWN1dW1lZCBvciBhbmFs eXplZC4gQW5hbHl6ZSBzaG91bGQKKwkgKiBub3QgcmVsb2FkIGNvbmZpZ3VyYXRpb24gZmlsZSBp ZiBpdCBpcyBpbiBhbiBvdXRlciB0cmFuc2FjdGlvbiwgYXMgd2UKKwkgKiBjdXJyZW50bHkgb25s eSBhbGxvdyBjb25maWd1cmF0aW9uIHJlbG9hZCB3aGVuIGluIHRvcC1sZXZlbCBzdGF0ZW1lbnRz LgogCSAqLwogCWlmIChDb25maWdSZWxvYWRQZW5kaW5nICYmIHZhY3V1bV9jYW5fcmVsb2FkX2Nv bmZpZykKIAl7CkBAIC0yMzA2LDcgKzIzMDYsMTQgQEAgdmFjdXVtX2RlbGF5X3BvaW50KHZvaWQp CiAKIAkJVmFjdXVtQ29zdEJhbGFuY2UgPSAwOwogCi0JCVZhY3V1bVVwZGF0ZUNvc3RzKCk7CisJ CS8qCisJCSAqIEJhbGFuY2UgYW5kIHVwZGF0ZSBsaW1pdCB2YWx1ZXMgZm9yIGF1dG92YWN1dW0g d29ya2Vycy4gV2UgbXVzdAorCQkgKiBhbHdheXMgZG8gdGhpcyBpbiBjYXNlIHRoZSBhdXRvdmFj dXVtIGxhdW5jaGVyIG9yIGFub3RoZXIKKwkJICogYXV0b3ZhY3V1bSB3b3JrZXIgaGFzIHJlY2Fs Y3VsYXRlZCB0aGUgbnVtYmVyIG9mIHdvcmtlcnMgYWNyb3NzCisJCSAqIHdoaWNoIHdlIG11c3Qg YmFsYW5jZSB0aGUgbGltaXQuIFRoaXMgaXMgZG9uZSBieSB0aGUgbGF1bmNoZXIgd2hlbgorCQkg KiBsYXVuY2hpbmcgYSBuZXcgd29ya2VyIGFuZCBieSB3b3JrZXJzIGJlZm9yZSB2YWN1dW1pbmcg ZWFjaCB0YWJsZS4KKwkJICovCisJCUF1dG9WYWN1dW1VcGRhdGVMaW1pdCgpOwogCiAJCS8qIE1p Z2h0IGhhdmUgZ290dGVuIGFuIGludGVycnVwdCB3aGlsZSBzbGVlcGluZyAqLwogCQlDSEVDS19G T1JfSU5URVJSVVBUUygpOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRv dmFjdXVtLmMgYi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwppbmRleCA3YTk3 MzgyMDJmLi44Y2I5YmVlNGViIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1 dG92YWN1dW0uYworKysgYi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwpAQCAt MTM5LDYgKzEzOSw5IEBAIGludAkJCUxvZ19hdXRvdmFjdXVtX21pbl9kdXJhdGlvbiA9IDYwMDAw MDsKIHN0YXRpYyBib29sIGFtX2F1dG92YWN1dW1fbGF1bmNoZXIgPSBmYWxzZTsKIHN0YXRpYyBi b29sIGFtX2F1dG92YWN1dW1fd29ya2VyID0gZmFsc2U7CiAKK3N0YXRpYyBkb3VibGUgYXZfcmVs b3B0X2Nvc3RfZGVsYXkgPSAtMTsKK3N0YXRpYyBpbnQJYXZfcmVsb3B0X2Nvc3RfbGltaXQgPSAw OworCiAvKiBGbGFncyBzZXQgYnkgc2lnbmFsIGhhbmRsZXJzICovCiBzdGF0aWMgdm9sYXRpbGUg c2lnX2F0b21pY190IGdvdF9TSUdVU1IyID0gZmFsc2U7CiAKQEAgLTE4OSw4ICsxOTIsOCBAQCB0 eXBlZGVmIHN0cnVjdCBhdXRvdmFjX3RhYmxlCiB7CiAJT2lkCQkJYXRfcmVsaWQ7CiAJVmFjdXVt UGFyYW1zIGF0X3BhcmFtczsKLQlkb3VibGUJCWF0X3ZhY3V1bV9jb3N0X2RlbGF5OwotCWludAkJ CWF0X3ZhY3V1bV9jb3N0X2xpbWl0OworCWRvdWJsZQkJYXRfcmVsb3B0X3ZhY19jb3N0X2RlbGF5 OworCWludAkJCWF0X3JlbG9wdF92YWNfY29zdF9saW1pdDsKIAlib29sCQlhdF9kb2JhbGFuY2U7 CiAJYm9vbAkJYXRfc2hhcmVkcmVsOwogCWNoYXIJICAgKmF0X3JlbG5hbWU7CkBAIC0yMDksNyAr MjEyLDcgQEAgdHlwZWRlZiBzdHJ1Y3QgYXV0b3ZhY190YWJsZQogICogd2lfc2hhcmVkcmVsIGZs YWcgaW5kaWNhdGluZyB3aGV0aGVyIHRhYmxlIGlzIG1hcmtlZCByZWxpc3NoYXJlZAogICogd2lf cHJvYwkJcG9pbnRlciB0byBQR1BST0Mgb2YgdGhlIHJ1bm5pbmcgd29ya2VyLCBOVUxMIGlmIG5v dCBzdGFydGVkCiAgKiB3aV9sYXVuY2h0aW1lIFRpbWUgYXQgd2hpY2ggdGhpcyB3b3JrZXIgd2Fz IGxhdW5jaGVkCi0gKiB3aV9jb3N0XyoJVmFjdXVtIGNvc3QtYmFzZWQgZGVsYXkgcGFyYW1ldGVy cyBjdXJyZW50IGluIHRoaXMgd29ya2VyCisgKiB3aV9kb2JhbGFuY2UgV2hldGhlciB0aGlzIHdv cmtlciBzaG91bGQgYmUgaW5jbHVkZWQgaW4gYmFsYW5jZSBjYWxjdWxhdGlvbnMKICAqCiAgKiBB bGwgZmllbGRzIGFyZSBwcm90ZWN0ZWQgYnkgQXV0b3ZhY3V1bUxvY2ssIGV4Y2VwdCBmb3Igd2lf dGFibGVvaWQgYW5kCiAgKiB3aV9zaGFyZWRyZWwgd2hpY2ggYXJlIHByb3RlY3RlZCBieSBBdXRv dmFjdXVtU2NoZWR1bGVMb2NrIChub3RlIHRoZXNlCkBAIC0yMjMsMTEgKzIyNiw4IEBAIHR5cGVk ZWYgc3RydWN0IFdvcmtlckluZm9EYXRhCiAJT2lkCQkJd2lfdGFibGVvaWQ7CiAJUEdQUk9DCSAg ICp3aV9wcm9jOwogCVRpbWVzdGFtcFR6IHdpX2xhdW5jaHRpbWU7Ci0JYm9vbAkJd2lfZG9iYWxh bmNlOworCXBnX2F0b21pY19mbGFnIHdpX2RvYmFsYW5jZTsKIAlib29sCQl3aV9zaGFyZWRyZWw7 Ci0JZG91YmxlCQl3aV9jb3N0X2RlbGF5OwotCWludAkJCXdpX2Nvc3RfbGltaXQ7Ci0JaW50CQkJ d2lfY29zdF9saW1pdF9iYXNlOwogfSBXb3JrZXJJbmZvRGF0YTsKIAogdHlwZWRlZiBzdHJ1Y3Qg V29ya2VySW5mb0RhdGEgKldvcmtlckluZm87CkBAIC0yNzMsNiArMjczLDggQEAgdHlwZWRlZiBz dHJ1Y3QgQXV0b1ZhY3V1bVdvcmtJdGVtCiAgKiBhdl9zdGFydGluZ1dvcmtlciBwb2ludGVyIHRv IFdvcmtlckluZm8gY3VycmVudGx5IGJlaW5nIHN0YXJ0ZWQgKGNsZWFyZWQgYnkKICAqCQkJCQl0 aGUgd29ya2VyIGl0c2VsZiBhcyBzb29uIGFzIGl0J3MgdXAgYW5kIHJ1bm5pbmcpCiAgKiBhdl93 b3JrSXRlbXMJCXdvcmsgaXRlbSBhcnJheQorICogYXZfbndvcmtlcnNGb3JCYWxhbmNlIHRoZSBu dW1iZXIgb2YgYXV0b3ZhY3V1bSB3b3JrZXJzIHRvIHVzZSB3aGVuCisgKiAJCQkJCWNhbGN1bGF0 aW5nIHRoZSBwZXIgd29ya2VyIGNvc3QgbGltaXQKICAqCiAgKiBUaGlzIHN0cnVjdCBpcyBwcm90 ZWN0ZWQgYnkgQXV0b3ZhY3V1bUxvY2ssIGV4Y2VwdCBmb3IgYXZfc2lnbmFsIGFuZCBwYXJ0cwog ICogb2YgdGhlIHdvcmtlciBsaXN0IChzZWUgYWJvdmUpLgpAQCAtMjg2LDYgKzI4OCw3IEBAIHR5 cGVkZWYgc3RydWN0CiAJZGxpc3RfaGVhZAlhdl9ydW5uaW5nV29ya2VyczsKIAlXb3JrZXJJbmZv CWF2X3N0YXJ0aW5nV29ya2VyOwogCUF1dG9WYWN1dW1Xb3JrSXRlbSBhdl93b3JrSXRlbXNbTlVN X1dPUktJVEVNU107CisJcGdfYXRvbWljX3VpbnQzMiBhdl9ud29ya2Vyc0ZvckJhbGFuY2U7CiB9 IEF1dG9WYWN1dW1TaG1lbVN0cnVjdDsKIAogc3RhdGljIEF1dG9WYWN1dW1TaG1lbVN0cnVjdCAq QXV0b1ZhY3V1bVNobWVtOwpAQCAtMzE5LDcgKzMyMiw3IEBAIHN0YXRpYyB2b2lkIGxhdW5jaF93 b3JrZXIoVGltZXN0YW1wVHogbm93KTsKIHN0YXRpYyBMaXN0ICpnZXRfZGF0YWJhc2VfbGlzdCh2 b2lkKTsKIHN0YXRpYyB2b2lkIHJlYnVpbGRfZGF0YWJhc2VfbGlzdChPaWQgbmV3ZGIpOwogc3Rh dGljIGludAlkYl9jb21wYXJhdG9yKGNvbnN0IHZvaWQgKmEsIGNvbnN0IHZvaWQgKmIpOwotc3Rh dGljIHZvaWQgYXV0b3ZhY19iYWxhbmNlX2Nvc3Qodm9pZCk7CitzdGF0aWMgdm9pZCBhdXRvdmFj X3JlY2FsY3VsYXRlX3dvcmtlcnNfZm9yX2JhbGFuY2Uodm9pZCk7CiAKIHN0YXRpYyB2b2lkIGRv X2F1dG92YWN1dW0odm9pZCk7CiBzdGF0aWMgdm9pZCBGcmVlV29ya2VySW5mbyhpbnQgY29kZSwg RGF0dW0gYXJnKTsKQEAgLTY3MCw3ICs2NzMsNyBAQCBBdXRvVmFjTGF1bmNoZXJNYWluKGludCBh cmdjLCBjaGFyICphcmd2W10pCiAJCQl7CiAJCQkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9j aywgTFdfRVhDTFVTSVZFKTsKIAkJCQlBdXRvVmFjdXVtU2htZW0tPmF2X3NpZ25hbFtBdXRvVmFj UmViYWxhbmNlXSA9IGZhbHNlOwotCQkJCWF1dG92YWNfYmFsYW5jZV9jb3N0KCk7CisJCQkJYXV0 b3ZhY19yZWNhbGN1bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNlKCk7CiAJCQkJTFdMb2NrUmVsZWFz ZShBdXRvdmFjdXVtTG9jayk7CiAJCQl9CiAKQEAgLTgyMCw4ICs4MjMsOCBAQCBIYW5kbGVBdXRv VmFjTGF1bmNoZXJJbnRlcnJ1cHRzKHZvaWQpCiAJCQlBdXRvVmFjTGF1bmNoZXJTaHV0ZG93bigp OwogCiAJCS8qIHJlYmFsYW5jZSBpbiBjYXNlIHRoZSBkZWZhdWx0IGNvc3QgcGFyYW1ldGVycyBj aGFuZ2VkICovCi0JCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7 Ci0JCWF1dG92YWNfYmFsYW5jZV9jb3N0KCk7CisJCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxv Y2ssIExXX1NIQVJFRCk7CisJCWF1dG92YWNfcmVjYWxjdWxhdGVfd29ya2Vyc19mb3JfYmFsYW5j ZSgpOwogCQlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKIAogCQkvKiByZWJ1aWxkIHRo ZSBsaXN0IGluIGNhc2UgdGhlIG5hcHRpbWUgY2hhbmdlZCAqLwpAQCAtMTc1NSwxMCArMTc1OCw3 IEBAIEZyZWVXb3JrZXJJbmZvKGludCBjb2RlLCBEYXR1bSBhcmcpCiAJCU15V29ya2VySW5mby0+ d2lfc2hhcmVkcmVsID0gZmFsc2U7CiAJCU15V29ya2VySW5mby0+d2lfcHJvYyA9IE5VTEw7CiAJ CU15V29ya2VySW5mby0+d2lfbGF1bmNodGltZSA9IDA7Ci0JCU15V29ya2VySW5mby0+d2lfZG9i YWxhbmNlID0gZmFsc2U7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9kZWxheSA9IDA7Ci0JCU15 V29ya2VySW5mby0+d2lfY29zdF9saW1pdCA9IDA7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9s aW1pdF9iYXNlID0gMDsKKwkJcGdfYXRvbWljX2NsZWFyX2ZsYWcoJk15V29ya2VySW5mby0+d2lf ZG9iYWxhbmNlKTsKIAkJZGxpc3RfcHVzaF9oZWFkKCZBdXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVX b3JrZXJzLAogCQkJCQkJJk15V29ya2VySW5mby0+d2lfbGlua3MpOwogCQkvKiBub3QgbWluZSBh bnltb3JlICovCkBAIC0xNzg3LDE0ICsxNzg3LDIxIEBAIFZhY3V1bVVwZGF0ZUNvc3RzKHZvaWQp CiAKIAlpZiAoYW1fYXV0b3ZhY3V1bV93b3JrZXIpCiAJewotCQlWYWN1dW1Db3N0TGltaXQgPSBN eVdvcmtlckluZm8tPndpX2Nvc3RfbGltaXQ7Ci0JCVZhY3V1bUNvc3REZWxheSA9IE15V29ya2Vy SW5mby0+d2lfY29zdF9kZWxheTsKKwkJaWYgKGF2X3JlbG9wdF9jb3N0X2RlbGF5ID49IDApCisJ CQlWYWN1dW1Db3N0RGVsYXkgPSBhdl9yZWxvcHRfY29zdF9kZWxheTsKKwkJZWxzZSBpZiAoYXV0 b3ZhY3V1bV92YWNfY29zdF9kZWxheSA+PSAwKQorCQkJVmFjdXVtQ29zdERlbGF5ID0gYXV0b3Zh Y3V1bV92YWNfY29zdF9kZWxheTsKKwkJZWxzZQorCQkJLyogZmFsbCBiYWNrIHRvIHZhY3V1bV9j b3N0X2RlbGF5ICovCisJCQlWYWN1dW1Db3N0RGVsYXkgPSB2YWN1dW1fY29zdF9kZWxheTsKKwor CQlBdXRvVmFjdXVtVXBkYXRlTGltaXQoKTsKIAl9CiAJZWxzZQogCXsKIAkJLyogTXVzdCBiZSBl eHBsaWNpdCBWQUNVVU0gb3IgQU5BTFlaRSAqLwotCQlWYWN1dW1Db3N0TGltaXQgPSB2YWN1dW1f Y29zdF9saW1pdDsKIAkJVmFjdXVtQ29zdERlbGF5ID0gdmFjdXVtX2Nvc3RfZGVsYXk7CisJCVZh Y3V1bUNvc3RMaW1pdCA9IHZhY3V1bV9jb3N0X2xpbWl0OwogCX0KIAogCS8qCkBAIC0xODE3LDg1 ICsxODI0LDgyIEBAIFZhY3V1bVVwZGF0ZUNvc3RzKHZvaWQpCiB9CiAKIC8qCi0gKiBhdXRvdmFj X2JhbGFuY2VfY29zdAotICoJCVJlY2FsY3VsYXRlIHRoZSBjb3N0IGxpbWl0IHNldHRpbmcgZm9y IGVhY2ggYWN0aXZlIHdvcmtlci4KLSAqCi0gKiBDYWxsZXIgbXVzdCBob2xkIHRoZSBBdXRvdmFj dXVtTG9jayBpbiBleGNsdXNpdmUgbW9kZS4KLSAqLwotc3RhdGljIHZvaWQKLWF1dG92YWNfYmFs YW5jZV9jb3N0KHZvaWQpCisqIFVwZGF0ZSBWYWN1dW1Db3N0TGltaXQgd2l0aCB0aGUgY29ycmVj dCB2YWx1ZSBmb3IgYW4gYXV0b3ZhY3V1bSB3b3JrZXIsIGdpdmVuCisqIHRoZSB2YWx1ZSBvZiBv dGhlciByZWxldmFudCBjb3N0IGxpbWl0IHBhcmFtZXRlcnMgYW5kIHRoZSBudW1iZXIgb2Ygd29y a2VycworKiBhY3Jvc3Mgd2hpY2ggdGhlIGxpbWl0IG11c3QgYmUgYmFsYW5jZWQuIEF1dG92YWN1 dW0gd29ya2VycyBtdXN0IGNhbGwgdGhpcworKiByZWd1bGFybHkgaW4gY2FzZSBhdl9ud29ya2Vy c19mb3JfYmFsYW5jZSBoYXMgYmVlbiB1cGRhdGVkIGJ5IGFub3RoZXIgd29ya2VyCisqIG9yIGJ5 IHRoZSBhdXRvdmFjdXVtIGxhdW5jaGVyLiBUaGV5IG11c3QgYWxzbyBjYWxsIGl0IGFmdGVyIGEg Y29uZmlnIHJlbG9hZC4KKyovCit2b2lkCitBdXRvVmFjdXVtVXBkYXRlTGltaXQodm9pZCkKIHsK KwlpZiAoIWFtX2F1dG92YWN1dW1fd29ya2VyKQorCQlyZXR1cm47CisKIAkvKgotCSAqIFRoZSBp ZGVhIGhlcmUgaXMgdGhhdCB3ZSByYXRpb24gb3V0IEkvTyBlcXVhbGx5LiAgVGhlIGFtb3VudCBv ZiBJL08KLQkgKiB0aGF0IGEgd29ya2VyIGNhbiBjb25zdW1lIGlzIGRldGVybWluZWQgYnkgY29z dF9saW1pdC9jb3N0X2RlbGF5LCBzbyB3ZQotCSAqIHRyeSB0byBlcXVhbGl6ZSB0aG9zZSByYXRp b3MgcmF0aGVyIHRoYW4gdGhlIHJhdyBsaW1pdCBzZXR0aW5ncy4KLQkgKgogCSAqIG5vdGU6IGlu IGNvc3RfbGltaXQsIHplcm8gYWxzbyBtZWFucyB1c2UgdmFsdWUgZnJvbSBlbHNld2hlcmUsIGJl Y2F1c2UKIAkgKiB6ZXJvIGlzIG5vdCBhIHZhbGlkIHZhbHVlLgogCSAqLwotCWludAkJCXZhY19j b3N0X2xpbWl0ID0gKGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQgPiAwID8KLQkJCQkJCQkJICBh dXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0IDogdmFjdXVtX2Nvc3RfbGltaXQpOwotCWRvdWJsZQkJ dmFjX2Nvc3RfZGVsYXkgPSAoYXV0b3ZhY3V1bV92YWNfY29zdF9kZWxheSA+PSAwID8KLQkJCQkJ CQkJICBhdXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5IDogdmFjdXVtX2Nvc3RfZGVsYXkpOwotCWRv dWJsZQkJY29zdF90b3RhbDsKLQlkb3VibGUJCWNvc3RfYXZhaWw7Ci0JZGxpc3RfaXRlcglpdGVy OwotCi0JLyogbm90IHNldD8gbm90aGluZyB0byBkbyAqLwotCWlmICh2YWNfY29zdF9saW1pdCA8 PSAwIHx8IHZhY19jb3N0X2RlbGF5IDw9IDApCi0JCXJldHVybjsKIAotCS8qIGNhbGN1bGF0ZSB0 aGUgdG90YWwgYmFzZSBjb3N0IGxpbWl0IG9mIHBhcnRpY2lwYXRpbmcgYWN0aXZlIHdvcmtlcnMg Ki8KLQljb3N0X3RvdGFsID0gMC4wOwotCWRsaXN0X2ZvcmVhY2goaXRlciwgJkF1dG9WYWN1dW1T aG1lbS0+YXZfcnVubmluZ1dvcmtlcnMpCisJaWYgKGF2X3JlbG9wdF9jb3N0X2xpbWl0ID4gMCkK KwkJVmFjdXVtQ29zdExpbWl0ID0gYXZfcmVsb3B0X2Nvc3RfbGltaXQ7CisJZWxzZQogCXsKLQkJ V29ya2VySW5mbwl3b3JrZXIgPSBkbGlzdF9jb250YWluZXIoV29ya2VySW5mb0RhdGEsIHdpX2xp bmtzLCBpdGVyLmN1cik7CisJCWludAkJCW53b3JrZXJzX2Zvcl9iYWxhbmNlOworCisJCWlmIChh dXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0ID4gMCkKKwkJCVZhY3V1bUNvc3RMaW1pdCA9IGF1dG92 YWN1dW1fdmFjX2Nvc3RfbGltaXQ7CisJCWVsc2UKKwkJCVZhY3V1bUNvc3RMaW1pdCA9IHZhY3V1 bV9jb3N0X2xpbWl0OworCisJCS8qIE9ubHkgYmFsYW5jZSBsaW1pdCBpZiBubyB0YWJsZSBvcHRp b25zIHNwZWNpZmllZCAqLworCQlpZiAocGdfYXRvbWljX3VubG9ja2VkX3Rlc3RfZmxhZygmTXlX b3JrZXJJbmZvLT53aV9kb2JhbGFuY2UpKQorCQkJcmV0dXJuOworCisJCUFzc2VydChWYWN1dW1D b3N0TGltaXQgPiAwKTsKIAotCQlpZiAod29ya2VyLT53aV9wcm9jICE9IE5VTEwgJiYKLQkJCXdv cmtlci0+d2lfZG9iYWxhbmNlICYmCi0JCQl3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSA+IDAg JiYgd29ya2VyLT53aV9jb3N0X2RlbGF5ID4gMCkKLQkJCWNvc3RfdG90YWwgKz0KLQkJCQkoZG91 YmxlKSB3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSAvIHdvcmtlci0+d2lfY29zdF9kZWxheTsK KwkJbndvcmtlcnNfZm9yX2JhbGFuY2UgPSBwZ19hdG9taWNfcmVhZF91MzIoCisJCQkJCQkJCSZB dXRvVmFjdXVtU2htZW0tPmF2X253b3JrZXJzRm9yQmFsYW5jZSk7CisKKwkJLyogVGhlcmUgaXMg YXQgbGVhc3QgMSBhdXRvdmFjIHdvcmtlciAodGhpcyB3b3JrZXIpLiAqLworCQlBc3NlcnQobndv cmtlcnNfZm9yX2JhbGFuY2UgPiAwKTsKKworCQlWYWN1dW1Db3N0TGltaXQgPSBNYXgoVmFjdXVt Q29zdExpbWl0IC8gbndvcmtlcnNfZm9yX2JhbGFuY2UsIDEpOwogCX0KK30KIAotCS8qIHRoZXJl IGFyZSBubyBjb3N0IGxpbWl0cyAtLSBub3RoaW5nIHRvIGRvICovCi0JaWYgKGNvc3RfdG90YWwg PD0gMCkKLQkJcmV0dXJuOworLyoKKyAqIGF1dG92YWNfcmVjYWxjdWxhdGVfd29ya2Vyc19mb3Jf YmFsYW5jZQorICoJCVJlY2FsY3VsYXRlIHRoZSBudW1iZXIgb2Ygd29ya2VycyB0byBjb25zaWRl ciwgZ2l2ZW4gdGFibGUgb3B0aW9ucyBhbmQKKyAqCQl0aGUgY3VycmVudCBudW1iZXIgb2YgYWN0 aXZlIHdvcmtlcnMuCisgKgorICogQ2FsbGVyIG11c3QgaG9sZCB0aGUgQXV0b3ZhY3V1bUxvY2sg aW4gYXQgbGVhc3Qgc2hhcmVkIG1vZGUgdG8gYWNjZXNzCisgKiB3b3JrZXItPndpX3Byb2MuCisg Ki8KK3N0YXRpYyB2b2lkCithdXRvdmFjX3JlY2FsY3VsYXRlX3dvcmtlcnNfZm9yX2JhbGFuY2Uo dm9pZCkKK3sKKwlkbGlzdF9pdGVyCWl0ZXI7CisJaW50CQkJb3JpZ19ud29ya2Vyc19mb3JfYmFs YW5jZTsKKwlpbnQJCQlud29ya2Vyc19mb3JfYmFsYW5jZSA9IDA7CisKKwlvcmlnX253b3JrZXJz X2Zvcl9iYWxhbmNlID0KKwkJcGdfYXRvbWljX3JlYWRfdTMyKCZBdXRvVmFjdXVtU2htZW0tPmF2 X253b3JrZXJzRm9yQmFsYW5jZSk7CiAKLQkvKgotCSAqIEFkanVzdCBjb3N0IGxpbWl0IG9mIGVh Y2ggYWN0aXZlIHdvcmtlciB0byBiYWxhbmNlIHRoZSB0b3RhbCBvZiBjb3N0Ci0JICogbGltaXQg dG8gYXV0b3ZhY3V1bV92YWN1dW1fY29zdF9saW1pdC4KLQkgKi8KLQljb3N0X2F2YWlsID0gKGRv dWJsZSkgdmFjX2Nvc3RfbGltaXQgLyB2YWNfY29zdF9kZWxheTsKIAlkbGlzdF9mb3JlYWNoKGl0 ZXIsICZBdXRvVmFjdXVtU2htZW0tPmF2X3J1bm5pbmdXb3JrZXJzKQogCXsKIAkJV29ya2VySW5m bwl3b3JrZXIgPSBkbGlzdF9jb250YWluZXIoV29ya2VySW5mb0RhdGEsIHdpX2xpbmtzLCBpdGVy LmN1cik7CiAKLQkJaWYgKHdvcmtlci0+d2lfcHJvYyAhPSBOVUxMICYmCi0JCQl3b3JrZXItPndp X2RvYmFsYW5jZSAmJgotCQkJd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2UgPiAwICYmIHdvcmtl ci0+d2lfY29zdF9kZWxheSA+IDApCi0JCXsKLQkJCWludAkJCWxpbWl0ID0gKGludCkKLQkJCShj b3N0X2F2YWlsICogd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2UgLyBjb3N0X3RvdGFsKTsKLQot CQkJLyoKLQkJCSAqIFdlIHB1dCBhIGxvd2VyIGJvdW5kIG9mIDEgb24gdGhlIGNvc3RfbGltaXQs IHRvIGF2b2lkIGRpdmlzaW9uLQotCQkJICogYnktemVybyBpbiB0aGUgdmFjdXVtIGNvZGUuICBB bHNvLCBpbiBjYXNlIG9mIHJvdW5kb2ZmIHRyb3VibGUKLQkJCSAqIGluIHRoZXNlIGNhbGN1bGF0 aW9ucywgbGV0J3MgYmUgc3VyZSB3ZSBkb24ndCBldmVyIHNldAotCQkJICogY29zdF9saW1pdCB0 byBtb3JlIHRoYW4gdGhlIGJhc2UgdmFsdWUuCi0JCQkgKi8KLQkJCXdvcmtlci0+d2lfY29zdF9s aW1pdCA9IE1heChNaW4obGltaXQsCi0JCQkJCQkJCQkJCXdvcmtlci0+d2lfY29zdF9saW1pdF9i YXNlKSwKLQkJCQkJCQkJCQkxKTsKLQkJfQorCQlpZiAod29ya2VyLT53aV9wcm9jID09IE5VTEwg fHwKKwkJCXBnX2F0b21pY191bmxvY2tlZF90ZXN0X2ZsYWcoJndvcmtlci0+d2lfZG9iYWxhbmNl KSkKKwkJCWNvbnRpbnVlOwogCi0JCWlmICh3b3JrZXItPndpX3Byb2MgIT0gTlVMTCkKLQkJCWVs b2coREVCVUcyLCAiYXV0b3ZhY19iYWxhbmNlX2Nvc3QocGlkPSVkIGRiPSV1LCByZWw9JXUsIGRv YmFsYW5jZT0lcyBjb3N0X2xpbWl0PSVkLCBjb3N0X2xpbWl0X2Jhc2U9JWQsIGNvc3RfZGVsYXk9 JWcpIiwKLQkJCQkgd29ya2VyLT53aV9wcm9jLT5waWQsIHdvcmtlci0+d2lfZGJvaWQsIHdvcmtl ci0+d2lfdGFibGVvaWQsCi0JCQkJIHdvcmtlci0+d2lfZG9iYWxhbmNlID8gInllcyIgOiAibm8i LAotCQkJCSB3b3JrZXItPndpX2Nvc3RfbGltaXQsIHdvcmtlci0+d2lfY29zdF9saW1pdF9iYXNl LAotCQkJCSB3b3JrZXItPndpX2Nvc3RfZGVsYXkpOworCQlud29ya2Vyc19mb3JfYmFsYW5jZSsr OwogCX0KKworCWlmIChud29ya2Vyc19mb3JfYmFsYW5jZSAhPSBvcmlnX253b3JrZXJzX2Zvcl9i YWxhbmNlKQorCQlwZ19hdG9taWNfd3JpdGVfdTMyKCZBdXRvVmFjdXVtU2htZW0tPmF2X253b3Jr ZXJzRm9yQmFsYW5jZSwKKwkJCQkJCQlud29ya2Vyc19mb3JfYmFsYW5jZSk7CiB9CiAKIC8qCkBA IC0yNDQzLDIzICsyNDQ3LDMxIEBAIGRvX2F1dG92YWN1dW0odm9pZCkKIAkJCWNvbnRpbnVlOwog CQl9CiAKLQkJLyogTXVzdCBob2xkIEF1dG92YWN1dW1Mb2NrIHdoaWxlIG11Y2tpbmcgd2l0aCBj b3N0IGJhbGFuY2UgaW5mbyAqLwotCQlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2NrLCBMV19F WENMVVNJVkUpOwogCi0JCS8qIGFkdmVydGlzZSBteSBjb3N0IGRlbGF5IHBhcmFtZXRlcnMgZm9y IHRoZSBiYWxhbmNpbmcgYWxnb3JpdGhtICovCi0JCU15V29ya2VySW5mby0+d2lfZG9iYWxhbmNl ID0gdGFiLT5hdF9kb2JhbGFuY2U7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9kZWxheSA9IHRh Yi0+YXRfdmFjdXVtX2Nvc3RfZGVsYXk7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9saW1pdCA9 IHRhYi0+YXRfdmFjdXVtX2Nvc3RfbGltaXQ7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9saW1p dF9iYXNlID0gdGFiLT5hdF92YWN1dW1fY29zdF9saW1pdDsKKwkJLyoKKwkJICogU2F2ZSB0aGUg Y29zdC1yZWxhdGVkIHRhYmxlIG9wdGlvbnMgaW4gZ2xvYmFsIHZhcmlhYmxlcyBmb3IKKwkJICog cmVmZXJlbmNlIHdoZW4gdXBkYXRpbmcgVmFjdXVtQ29zdExpbWl0IGFuZCBWYWN1dW1Db3N0RGVs YXkgZHVyaW5nCisJCSAqIHZhY3V1bWluZyB0aGlzIHRhYmxlLgorCQkgKi8KKwkJYXZfcmVsb3B0 X2Nvc3RfbGltaXQgPSB0YWItPmF0X3JlbG9wdF92YWNfY29zdF9saW1pdDsKKwkJYXZfcmVsb3B0 X2Nvc3RfZGVsYXkgPSB0YWItPmF0X3JlbG9wdF92YWNfY29zdF9kZWxheTsKIAotCQkvKiBkbyBh IGJhbGFuY2UgKi8KLQkJYXV0b3ZhY19iYWxhbmNlX2Nvc3QoKTsKKwkJaWYgKHRhYi0+YXRfZG9i YWxhbmNlKQorCQkJcGdfYXRvbWljX3Rlc3Rfc2V0X2ZsYWcoJk15V29ya2VySW5mby0+d2lfZG9i YWxhbmNlKTsKKwkJZWxzZQorCQkJcGdfYXRvbWljX2NsZWFyX2ZsYWcoJk15V29ya2VySW5mby0+ d2lfZG9iYWxhbmNlKTsKIAotCQkvKiBzZXQgdGhlIGFjdGl2ZSBjb3N0IHBhcmFtZXRlcnMgZnJv bSB0aGUgcmVzdWx0IG9mIHRoYXQgKi8KKwkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywg TFdfU0hBUkVEKTsKKwkJYXV0b3ZhY19yZWNhbGN1bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNlKCk7 CisJCUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1bUxvY2spOworCisJCS8qCisJCSAqIFdlIHdhaXQg dW50aWwgdGhpcyBwb2ludCB0byB1cGRhdGUgY29zdCBkZWxheSBhbmQgY29zdCBsaW1pdAorCQkg KiB2YWx1ZXMsIGV2ZW4gdGhvdWdoIHdlIHJlbG9hZGVkIHRoZSBjb25maWd1cmF0aW9uIGZpbGUg YWJvdmUsIHNvCisJCSAqIHRoYXQgd2UgY2FuIHRha2UgaW50byBhY2NvdW50IHRoZSBjb3N0LXJl bGF0ZWQgdGFibGUgb3B0aW9ucy4KKwkJICovCiAJCVZhY3V1bVVwZGF0ZUNvc3RzKCk7CiAKLQkJ LyogZG9uZSAqLwotCQlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKIAogCQkvKiBjbGVh biB1cCBtZW1vcnkgYmVmb3JlIGVhY2ggaXRlcmF0aW9uICovCiAJCU1lbW9yeUNvbnRleHRSZXNl dEFuZERlbGV0ZUNoaWxkcmVuKFBvcnRhbENvbnRleHQpOwpAQCAtMjU0NCwxMCArMjU1NiwxMCBA QCBkZWxldGVkOgogCiAJCS8qCiAJCSAqIFJlbW92ZSBteSBpbmZvIGZyb20gc2hhcmVkIG1lbW9y eS4gIFdlIGNvdWxkLCBidXQgaW50ZW50aW9uYWxseQotCQkgKiBkb24ndCwgY2xlYXIgd2lfY29z dF9saW1pdCBhbmQgZnJpZW5kcyAtLS0gdGhpcyBpcyBvbiB0aGUKLQkJICogYXNzdW1wdGlvbiB0 aGF0IHdlIHByb2JhYmx5IGhhdmUgbW9yZSB0byBkbyB3aXRoIHNpbWlsYXIgY29zdAotCQkgKiBz ZXR0aW5ncywgc28gd2UgZG9uJ3Qgd2FudCB0byBnaXZlIHVwIG91ciBzaGFyZSBvZiBJL08gZm9y IGEgdmVyeQotCQkgKiBzaG9ydCBpbnRlcnZhbCBhbmQgdGhlcmVieSB0aHJhc2ggdGhlIGdsb2Jh bCBiYWxhbmNlLgorCQkgKiBkb24ndCwgdW5zZXQgd2lfZG9iYWxhbmNlIG9uIHRoZSBhc3N1bXB0 aW9uIHRoYXQgd2UgYXJlIG1vcmUgbGlrZWx5CisJCSAqIHRoYW4gbm90IHRvIHZhY3V1bSBhIHRh YmxlIHdpdGggbm8gdGFibGUgb3B0aW9ucyBuZXh0LCBzbyB3ZSBkb24ndAorCQkgKiB3YW50IHRv IGdpdmUgdXAgb3VyIHNoYXJlIG9mIEkvTyBmb3IgYSB2ZXJ5IHNob3J0IGludGVydmFsIGFuZAor CQkgKiB0aGVyZWJ5IHRocmFzaCB0aGUgZ2xvYmFsIGJhbGFuY2UuCiAJCSAqLwogCQlMV0xvY2tB Y3F1aXJlKEF1dG92YWN1dW1TY2hlZHVsZUxvY2ssIExXX0VYQ0xVU0lWRSk7CiAJCU15V29ya2Vy SW5mby0+d2lfdGFibGVvaWQgPSBJbnZhbGlkT2lkOwpAQCAtMjU4NCw2ICsyNTk2LDcgQEAgZGVs ZXRlZDoKIAkJewogCQkJQ29uZmlnUmVsb2FkUGVuZGluZyA9IGZhbHNlOwogCQkJUHJvY2Vzc0Nv bmZpZ0ZpbGUoUEdDX1NJR0hVUCk7CisJCQlWYWN1dW1VcGRhdGVDb3N0cygpOwogCQl9CiAKIAkJ TFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZFKTsKQEAgLTI4MTksOCAr MjgzMiw2IEBAIHRhYmxlX3JlY2hlY2tfYXV0b3ZhYyhPaWQgcmVsaWQsIEhUQUIgKnRhYmxlX3Rv YXN0X21hcCwKIAkJaW50CQkJZnJlZXplX3RhYmxlX2FnZTsKIAkJaW50CQkJbXVsdGl4YWN0X2Zy ZWV6ZV9taW5fYWdlOwogCQlpbnQJCQltdWx0aXhhY3RfZnJlZXplX3RhYmxlX2FnZTsKLQkJaW50 CQkJdmFjX2Nvc3RfbGltaXQ7Ci0JCWRvdWJsZQkJdmFjX2Nvc3RfZGVsYXk7CiAJCWludAkJCWxv Z19taW5fZHVyYXRpb247CiAKIAkJLyoKQEAgLTI4MzAsMjAgKzI4NDEsNiBAQCB0YWJsZV9yZWNo ZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJsZV90b2FzdF9tYXAsCiAJCSAqIGRlZmF1 bHRzLCBhdXRvdmFjdXVtJ3Mgb3duIGZpcnN0IGFuZCBwbGFpbiB2YWN1dW0gc2Vjb25kLgogCQkg Ki8KIAotCQkvKiAtMSBpbiBhdXRvdmFjIHNldHRpbmcgbWVhbnMgdXNlIHBsYWluIHZhY3V1bV9j b3N0X2RlbGF5ICovCi0JCXZhY19jb3N0X2RlbGF5ID0gKGF2b3B0cyAmJiBhdm9wdHMtPnZhY3V1 bV9jb3N0X2RlbGF5ID49IDApCi0JCQk/IGF2b3B0cy0+dmFjdXVtX2Nvc3RfZGVsYXkKLQkJCTog KGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkgPj0gMCkKLQkJCT8gYXV0b3ZhY3V1bV92YWNfY29z dF9kZWxheQotCQkJOiB2YWN1dW1fY29zdF9kZWxheTsKLQotCQkvKiAwIG9yIC0xIGluIGF1dG92 YWMgc2V0dGluZyBtZWFucyB1c2UgcGxhaW4gdmFjdXVtX2Nvc3RfbGltaXQgKi8KLQkJdmFjX2Nv c3RfbGltaXQgPSAoYXZvcHRzICYmIGF2b3B0cy0+dmFjdXVtX2Nvc3RfbGltaXQgPiAwKQotCQkJ PyBhdm9wdHMtPnZhY3V1bV9jb3N0X2xpbWl0Ci0JCQk6IChhdXRvdmFjdXVtX3ZhY19jb3N0X2xp bWl0ID4gMCkKLQkJCT8gYXV0b3ZhY3V1bV92YWNfY29zdF9saW1pdAotCQkJOiB2YWN1dW1fY29z dF9saW1pdDsKLQogCQkvKiAtMSBpbiBhdXRvdmFjIHNldHRpbmcgbWVhbnMgdXNlIGxvZ19hdXRv dmFjdXVtX21pbl9kdXJhdGlvbiAqLwogCQlsb2dfbWluX2R1cmF0aW9uID0gKGF2b3B0cyAmJiBh dm9wdHMtPmxvZ19taW5fZHVyYXRpb24gPj0gMCkKIAkJCT8gYXZvcHRzLT5sb2dfbWluX2R1cmF0 aW9uCkBAIC0yODk5LDggKzI4OTYsMTAgQEAgdGFibGVfcmVjaGVja19hdXRvdmFjKE9pZCByZWxp ZCwgSFRBQiAqdGFibGVfdG9hc3RfbWFwLAogCQl0YWItPmF0X3BhcmFtcy5tdWx0aXhhY3RfZnJl ZXplX3RhYmxlX2FnZSA9IG11bHRpeGFjdF9mcmVlemVfdGFibGVfYWdlOwogCQl0YWItPmF0X3Bh cmFtcy5pc193cmFwYXJvdW5kID0gd3JhcGFyb3VuZDsKIAkJdGFiLT5hdF9wYXJhbXMubG9nX21p bl9kdXJhdGlvbiA9IGxvZ19taW5fZHVyYXRpb247Ci0JCXRhYi0+YXRfdmFjdXVtX2Nvc3RfbGlt aXQgPSB2YWNfY29zdF9saW1pdDsKLQkJdGFiLT5hdF92YWN1dW1fY29zdF9kZWxheSA9IHZhY19j b3N0X2RlbGF5OworCQl0YWItPmF0X3JlbG9wdF92YWNfY29zdF9saW1pdCA9IGF2b3B0cyA/CisJ CQlhdm9wdHMtPnZhY3V1bV9jb3N0X2xpbWl0IDogMDsKKwkJdGFiLT5hdF9yZWxvcHRfdmFjX2Nv c3RfZGVsYXkgPSBhdm9wdHMgPworCQkJYXZvcHRzLT52YWN1dW1fY29zdF9kZWxheSA6IC0xOwog CQl0YWItPmF0X3JlbG5hbWUgPSBOVUxMOwogCQl0YWItPmF0X25zcG5hbWUgPSBOVUxMOwogCQl0 YWItPmF0X2RhdG5hbWUgPSBOVUxMOwpAQCAtMzM5MiwxMCArMzM5MSwxOCBAQCBBdXRvVmFjdXVt U2htZW1Jbml0KHZvaWQpCiAJCXdvcmtlciA9IChXb3JrZXJJbmZvKSAoKGNoYXIgKikgQXV0b1Zh Y3V1bVNobWVtICsKIAkJCQkJCQkgICBNQVhBTElHTihzaXplb2YoQXV0b1ZhY3V1bVNobWVtU3Ry dWN0KSkpOwogCisKIAkJLyogaW5pdGlhbGl6ZSB0aGUgV29ya2VySW5mbyBmcmVlIGxpc3QgKi8K IAkJZm9yIChpID0gMDsgaSA8IGF1dG92YWN1dW1fbWF4X3dvcmtlcnM7IGkrKykKKwkJewogCQkJ ZGxpc3RfcHVzaF9oZWFkKCZBdXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVXb3JrZXJzLAogCQkJCQkJ CSZ3b3JrZXJbaV0ud2lfbGlua3MpOworCisJCQlwZ19hdG9taWNfaW5pdF9mbGFnKCZ3b3JrZXJb aV0ud2lfZG9iYWxhbmNlKTsKKwkJfQorCisJCXBnX2F0b21pY19pbml0X3UzMigmQXV0b1ZhY3V1 bVNobWVtLT5hdl9ud29ya2Vyc0ZvckJhbGFuY2UsIDApOworCiAJfQogCWVsc2UKIAkJQXNzZXJ0 KGZvdW5kKTsKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oIGIvc3Jj L2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKaW5kZXggYTYyZGQyZTc4MS4uNmIyODYwMzdjYSAx MDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKKysrIGIvc3JjL2luY2x1 ZGUvY29tbWFuZHMvdmFjdXVtLmgKQEAgLTM1MSw2ICszNTEsNyBAQCBleHRlcm4gSW5kZXhCdWxr RGVsZXRlUmVzdWx0ICp2YWNfY2xlYW51cF9vbmVfaW5kZXgoSW5kZXhWYWN1dW1JbmZvICppdmlu Zm8sCiBleHRlcm4gU2l6ZSB2YWNfbWF4X2l0ZW1zX3RvX2FsbG9jX3NpemUoaW50IG1heF9pdGVt cyk7CiAKIC8qIEluIHBvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jICovCitleHRlcm4gdm9pZCBBdXRv VmFjdXVtVXBkYXRlTGltaXQodm9pZCk7CiBleHRlcm4gdm9pZCBWYWN1dW1VcGRhdGVDb3N0cyh2 b2lkKTsKIAogLyogaW4gY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyAqLwotLSAKMi4zNy4yCgo= --00000000000067bc5205f8713969 Content-Type: text/x-patch; charset="US-ASCII"; name="v13-0002-Separate-vacuum-cost-variables-from-gucs.patch" Content-Disposition: attachment; filename="v13-0002-Separate-vacuum-cost-variables-from-gucs.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg1222a91 RnJvbSA2ZjQwZjRiZTNhZThiYWI1NTUxYTI5OGVlNjE2M2Y2N2MwNjg2MWU5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBNb24sIDMgQXByIDIwMjMgMTE6MjI6MTggLTA0MDAKU3ViamVjdDogW1BB VENIIHYxMyAyLzRdIFNlcGFyYXRlIHZhY3V1bSBjb3N0IHZhcmlhYmxlcyBmcm9tIGd1Y3MKClZh Y3V1bSBjb2RlIHJ1biBib3RoIGJ5IGF1dG92YWN1dW0gd29ya2VycyBhbmQgYSBiYWNrZW5kIGRv aW5nClZBQ1VVTS9BTkFMWVpFIHByZXZpb3VzbHkgdXNlZCBWYWN1dW1Db3N0TGltaXQgYW5kIFZh Y3V1bUNvc3REZWxheSB3aGljaAp3ZXJlIHRoZSBnbG9iYWwgdmFyaWFibGVzIGZvciB0aGUgZ3Vj cyB2YWN1dW1fY29zdF9saW1pdCBhbmQKdmFjdXVtX2Nvc3RfZGVsYXkuIEF1dG92YWN1dW0gd29y a2VycyBuZWVkZWQgdG8gb3ZlcnJpZGUgdGhlc2UgdmFyaWFibGVzCndpdGggdGhlaXIgb3duIHZh bHVlcywgZGVyaXZlZCBmcm9tIGF1dG92YWN1dW1fdmFjdXVtX2Nvc3RfbGltaXQgYW5kCmF1dG92 YWN1dW1fdmFjdXVtX2Nvc3RfZGVsYXkgYW5kIHdvcmtlciBjb3N0IGxpbWl0IGJhbGFuY2luZyBs b2dpYy4gVGhpcwpsZWQgdG8gY29uZnVzaW5nIGNvZGUgd2hpY2gsIGluIHNvbWUgY2FzZXMsIGJv dGggZGVyaXZlZCBhbmQgc2V0IGEgbmV3CnZhbHVlIG9mIFZhY3V1bUNvc3RMaW1pdCBmcm9tIFZh Y3V1bUNvc3RMaW1pdC4KCkluIHByZXBhcmF0aW9uIGZvciByZWZyZXNoaW5nIHRoZXNlIGd1YyB2 YWx1ZXMgbW9yZSBvZnRlbiwgc2VwYXJhdGUKdGhlc2UgdmFyaWFibGVzIGZyb20gdGhlIGd1Y3Mg dGhlbXNlbHZlcyBhbmQgYWRkIGEgZnVuY3Rpb24gdG8gdXBkYXRlCnRoZSBnbG9iYWwgdmFyaWFi bGVzIHVzaW5nIHRoZSBndWNzIGFuZCBleGlzdGluZyBsb2dpYy4KClJldmlld2VkLWJ5OiBNYXNh aGlrbyBTYXdhZGEgPHNhd2FkYS5tc2hrQGdtYWlsLmNvbT4KRGlzY3Vzc2lvbjogaHR0cHM6Ly93 d3cucG9zdGdyZXNxbC5vcmcvbWVzc2FnZS1pZC9mbGF0L0NBQUtSdV9abmd6cW5FT0RjN0xtUzFO SDA0S3Q2WTlodVNqejVwcDclMkJEWGhyakRBMGd3JTQwbWFpbC5nbWFpbC5jb20KLS0tCiBzcmMv YmFja2VuZC9jb21tYW5kcy92YWN1dW0uYyAgICAgICAgIHwgMTYgKysrKysrKystLQogc3JjL2Jh Y2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyB8ICAxICsKIHNyYy9iYWNrZW5kL3Bvc3Rt YXN0ZXIvYXV0b3ZhY3V1bS5jICAgfCA0NSArKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0KIHNy Yy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jICAgICAgfCAgMiAtLQogc3JjL2JhY2tlbmQv dXRpbHMvbWlzYy9ndWNfdGFibGVzLmMgICB8ICA0ICstLQogc3JjL2luY2x1ZGUvY29tbWFuZHMv dmFjdXVtLmggICAgICAgICB8ICA3ICsrKysrCiBzcmMvaW5jbHVkZS9taXNjYWRtaW4uaCAgICAg ICAgICAgICAgIHwgIDIgLS0KIHNyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oICAg fCAgMyAtLQogOCBmaWxlcyBjaGFuZ2VkLCA0NSBpbnNlcnRpb25zKCspLCAzNSBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYyBiL3NyYy9iYWNr ZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCmluZGV4IDk3MjRmYmNlNDYuLjk2ZGY1ZTI5MjAgMTAwNjQ0 Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCisrKyBiL3NyYy9iYWNrZW5kL2Nv bW1hbmRzL3ZhY3V1bS5jCkBAIC03MSw2ICs3MSwxOCBAQCBpbnQJCQl2YWN1dW1fbXVsdGl4YWN0 X2ZyZWV6ZV9taW5fYWdlOwogaW50CQkJdmFjdXVtX211bHRpeGFjdF9mcmVlemVfdGFibGVfYWdl OwogaW50CQkJdmFjdXVtX2ZhaWxzYWZlX2FnZTsKIGludAkJCXZhY3V1bV9tdWx0aXhhY3RfZmFp bHNhZmVfYWdlOworZG91YmxlCQl2YWN1dW1fY29zdF9kZWxheTsKK2ludAkJCXZhY3V1bV9jb3N0 X2xpbWl0OworCisvKgorICogVmFyaWFibGVzIGZvciBjb3N0LWJhc2VkIHZhY3V1bSBkZWxheS4g VGhlIGRlZmF1bHRzIGRpZmZlciBiZXR3ZWVuCisgKiBhdXRvdmFjdXVtIGFuZCB2YWN1dW0uIFRo ZXNlIHNob3VsZCBiZSBvdmVycmlkZGVuIHdpdGggdGhlIGFwcHJvcHJpYXRlIEdVQworICogdmFs dWUgaW4gdmFjdXVtIGNvZGUuCisgKiBUT0RPOiBzaG91bGQgVmFjdXVtQ29zdExpbWl0IGFuZCBW YWN1dW1Db3N0RGVsYXkgYmUgaW5pdGlhbGl6ZWQgdG8gdmFsaWQgb3IKKyAqIGludmFsaWQgdmFs dWVzPworICovCitpbnQJCQlWYWN1dW1Db3N0TGltaXQgPSAwOworZG91YmxlCQlWYWN1dW1Db3N0 RGVsYXkgPSAtMTsKIAogLyoKICAqIFZhY3V1bUZhaWxzYWZlQWN0aXZlIGlzIGEgZGVmaW5lZCBh cyBhIGdsb2JhbCBzbyB0aGF0IHdlIGNhbiBkZXRlcm1pbmUKQEAgLTQ5OCw2ICs1MTAsNyBAQCB2 YWN1dW0oTGlzdCAqcmVsYXRpb25zLCBWYWN1dW1QYXJhbXMgKnBhcmFtcywKIAl7CiAJCUxpc3RD ZWxsICAgKmN1cjsKIAorCQlWYWN1dW1VcGRhdGVDb3N0cygpOwogCQlpbl92YWN1dW0gPSB0cnVl OwogCQlWYWN1dW1Db3N0QWN0aXZlID0gKFZhY3V1bUNvc3REZWxheSA+IDApOwogCQlWYWN1dW1D b3N0QmFsYW5jZSA9IDA7CkBAIC0yMjU4LDggKzIyNzEsNyBAQCB2YWN1dW1fZGVsYXlfcG9pbnQo dm9pZCkKIAogCQlWYWN1dW1Db3N0QmFsYW5jZSA9IDA7CiAKLQkJLyogdXBkYXRlIGJhbGFuY2Ug dmFsdWVzIGZvciB3b3JrZXJzICovCi0JCUF1dG9WYWN1dW1VcGRhdGVEZWxheSgpOworCQlWYWN1 dW1VcGRhdGVDb3N0cygpOwogCiAJCS8qIE1pZ2h0IGhhdmUgZ290dGVuIGFuIGludGVycnVwdCB3 aGlsZSBzbGVlcGluZyAqLwogCQlDSEVDS19GT1JfSU5URVJSVVBUUygpOwpkaWZmIC0tZ2l0IGEv c3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyBiL3NyYy9iYWNrZW5kL2NvbW1h bmRzL3ZhY3V1bXBhcmFsbGVsLmMKaW5kZXggZmY3ZWQwZjU2MS4uY2Y4Y2Y4OTkyNyAxMDA2NDQK LS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYworKysgYi9zcmMvYmFj a2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC05OTYsNiArOTk2LDcgQEAgcGFyYWxs ZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQogCiAJLyogU2V0 IGNvc3QtYmFzZWQgdmFjdXVtIGRlbGF5ICovCiAJVmFjdXVtRmFpbHNhZmVBY3RpdmUgPSBmYWxz ZTsKKwlWYWN1dW1VcGRhdGVDb3N0cygpOwogCVZhY3V1bUNvc3RBY3RpdmUgPSAoVmFjdXVtQ29z dERlbGF5ID4gMCk7CiAJVmFjdXVtQ29zdEJhbGFuY2UgPSAwOwogCVZhY3V1bVBhZ2VIaXQgPSAw OwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMgYi9zcmMv YmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwppbmRleCA1ODVkMjgxNDhjLi4yN2QwZDVm OWUyIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYworKysg Yi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwpAQCAtMTc3NCwxNiArMTc3NCwy NyBAQCBGcmVlV29ya2VySW5mbyhpbnQgY29kZSwgRGF0dW0gYXJnKQogfQogCiAvKgotICogVXBk YXRlIHRoZSBjb3N0LWJhc2VkIGRlbGF5IHBhcmFtZXRlcnMsIHNvIHRoYXQgbXVsdGlwbGUgd29y a2VycyBjb25zdW1lCi0gKiBlYWNoIGEgZnJhY3Rpb24gb2YgdGhlIHRvdGFsIGF2YWlsYWJsZSBJ L08uCisgKiBVcGRhdGUgdmFjdXVtIGNvc3QtYmFzZWQgZGVsYXktcmVsYXRlZCBwYXJhbWV0ZXJz IGZvciBhdXRvdmFjdXVtIHdvcmtlcnMgYW5kCisgKiBiYWNrZW5kcyBleGVjdXRpbmcgVkFDVVVN IG9yIEFOQUxZWkUgdXNpbmcgdGhlIHZhbHVlIG9mIHJlbGV2YW50IGd1Y3MgYW5kCisgKiBnbG9i YWwgc3RhdGUuIFRoaXMgbXVzdCBiZSBjYWxsZWQgZHVyaW5nIHNldHVwIGZvciB2YWN1dW0gYW5k IGFmdGVyIGV2ZXJ5CisgKiBjb25maWcgcmVsb2FkIHRvIGVuc3VyZSB1cC10by1kYXRlIHZhbHVl cy4KICAqLwogdm9pZAotQXV0b1ZhY3V1bVVwZGF0ZURlbGF5KHZvaWQpCitWYWN1dW1VcGRhdGVD b3N0cyh2b2lkKQogewotCWlmIChNeVdvcmtlckluZm8pCisJaWYgKGFtX2F1dG92YWN1dW1fbGF1 bmNoZXIpCisJCXJldHVybjsKKworCWlmIChhbV9hdXRvdmFjdXVtX3dvcmtlcikKIAl7Ci0JCVZh Y3V1bUNvc3REZWxheSA9IE15V29ya2VySW5mby0+d2lfY29zdF9kZWxheTsKIAkJVmFjdXVtQ29z dExpbWl0ID0gTXlXb3JrZXJJbmZvLT53aV9jb3N0X2xpbWl0OworCQlWYWN1dW1Db3N0RGVsYXkg PSBNeVdvcmtlckluZm8tPndpX2Nvc3RfZGVsYXk7CisJfQorCWVsc2UKKwl7CisJCS8qIE11c3Qg YmUgZXhwbGljaXQgVkFDVVVNIG9yIEFOQUxZWkUgKi8KKwkJVmFjdXVtQ29zdExpbWl0ID0gdmFj dXVtX2Nvc3RfbGltaXQ7CisJCVZhY3V1bUNvc3REZWxheSA9IHZhY3V1bV9jb3N0X2RlbGF5Owog CX0KIH0KIApAQCAtMTgwNSw5ICsxODE2LDkgQEAgYXV0b3ZhY19iYWxhbmNlX2Nvc3Qodm9pZCkK IAkgKiB6ZXJvIGlzIG5vdCBhIHZhbGlkIHZhbHVlLgogCSAqLwogCWludAkJCXZhY19jb3N0X2xp bWl0ID0gKGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQgPiAwID8KLQkJCQkJCQkJICBhdXRvdmFj dXVtX3ZhY19jb3N0X2xpbWl0IDogVmFjdXVtQ29zdExpbWl0KTsKKwkJCQkJCQkJICBhdXRvdmFj dXVtX3ZhY19jb3N0X2xpbWl0IDogdmFjdXVtX2Nvc3RfbGltaXQpOwogCWRvdWJsZQkJdmFjX2Nv c3RfZGVsYXkgPSAoYXV0b3ZhY3V1bV92YWNfY29zdF9kZWxheSA+PSAwID8KLQkJCQkJCQkJICBh dXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5IDogVmFjdXVtQ29zdERlbGF5KTsKKwkJCQkJCQkJICBh dXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5IDogdmFjdXVtX2Nvc3RfZGVsYXkpOwogCWRvdWJsZQkJ Y29zdF90b3RhbDsKIAlkb3VibGUJCWNvc3RfYXZhaWw7CiAJZGxpc3RfaXRlcglpdGVyOwpAQCAt MjMxMiw4ICsyMzIzLDYgQEAgZG9fYXV0b3ZhY3V1bSh2b2lkKQogCQlhdXRvdmFjX3RhYmxlICp0 YWI7CiAJCWJvb2wJCWlzc2hhcmVkOwogCQlib29sCQlza2lwaXQ7Ci0JCWRvdWJsZQkJc3RkVmFj dXVtQ29zdERlbGF5OwotCQlpbnQJCQlzdGRWYWN1dW1Db3N0TGltaXQ7CiAJCWRsaXN0X2l0ZXIJ aXRlcjsKIAogCQlDSEVDS19GT1JfSU5URVJSVVBUUygpOwpAQCAtMjQxNiwxNCArMjQyNSw2IEBA IGRvX2F1dG92YWN1dW0odm9pZCkKIAkJCWNvbnRpbnVlOwogCQl9CiAKLQkJLyoKLQkJICogUmVt ZW1iZXIgdGhlIHByZXZhaWxpbmcgdmFsdWVzIG9mIHRoZSB2YWN1dW0gY29zdCBHVUNzLiAgV2Ug aGF2ZSB0bwotCQkgKiByZXN0b3JlIHRoZXNlIGF0IHRoZSBib3R0b20gb2YgdGhlIGxvb3AsIGVs c2Ugd2UnbGwgY29tcHV0ZSB3cm9uZwotCQkgKiB2YWx1ZXMgaW4gdGhlIG5leHQgaXRlcmF0aW9u IG9mIGF1dG92YWNfYmFsYW5jZV9jb3N0KCkuCi0JCSAqLwotCQlzdGRWYWN1dW1Db3N0RGVsYXkg PSBWYWN1dW1Db3N0RGVsYXk7Ci0JCXN0ZFZhY3V1bUNvc3RMaW1pdCA9IFZhY3V1bUNvc3RMaW1p dDsKLQogCQkvKiBNdXN0IGhvbGQgQXV0b3ZhY3V1bUxvY2sgd2hpbGUgbXVja2luZyB3aXRoIGNv c3QgYmFsYW5jZSBpbmZvICovCiAJCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX0VY Q0xVU0lWRSk7CiAKQEAgLTI0MzcsNyArMjQzOCw3IEBAIGRvX2F1dG92YWN1dW0odm9pZCkKIAkJ YXV0b3ZhY19iYWxhbmNlX2Nvc3QoKTsKIAogCQkvKiBzZXQgdGhlIGFjdGl2ZSBjb3N0IHBhcmFt ZXRlcnMgZnJvbSB0aGUgcmVzdWx0IG9mIHRoYXQgKi8KLQkJQXV0b1ZhY3V1bVVwZGF0ZURlbGF5 KCk7CisJCVZhY3V1bVVwZGF0ZUNvc3RzKCk7CiAKIAkJLyogZG9uZSAqLwogCQlMV0xvY2tSZWxl YXNlKEF1dG92YWN1dW1Mb2NrKTsKQEAgLTI1MzQsMTAgKzI1MzUsNiBAQCBkZWxldGVkOgogCQlN eVdvcmtlckluZm8tPndpX3RhYmxlb2lkID0gSW52YWxpZE9pZDsKIAkJTXlXb3JrZXJJbmZvLT53 aV9zaGFyZWRyZWwgPSBmYWxzZTsKIAkJTFdMb2NrUmVsZWFzZShBdXRvdmFjdXVtU2NoZWR1bGVM b2NrKTsKLQotCQkvKiByZXN0b3JlIHZhY3V1bSBjb3N0IEdVQ3MgZm9yIHRoZSBuZXh0IGl0ZXJh dGlvbiAqLwotCQlWYWN1dW1Db3N0RGVsYXkgPSBzdGRWYWN1dW1Db3N0RGVsYXk7Ci0JCVZhY3V1 bUNvc3RMaW1pdCA9IHN0ZFZhY3V1bUNvc3RMaW1pdDsKIAl9CiAKIAkvKgpAQCAtMjgyMCwxNCAr MjgxNywxNCBAQCB0YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJsZV90 b2FzdF9tYXAsCiAJCQk/IGF2b3B0cy0+dmFjdXVtX2Nvc3RfZGVsYXkKIAkJCTogKGF1dG92YWN1 dW1fdmFjX2Nvc3RfZGVsYXkgPj0gMCkKIAkJCT8gYXV0b3ZhY3V1bV92YWNfY29zdF9kZWxheQot CQkJOiBWYWN1dW1Db3N0RGVsYXk7CisJCQk6IHZhY3V1bV9jb3N0X2RlbGF5OwogCiAJCS8qIDAg b3IgLTEgaW4gYXV0b3ZhYyBzZXR0aW5nIG1lYW5zIHVzZSBwbGFpbiB2YWN1dW1fY29zdF9saW1p dCAqLwogCQl2YWNfY29zdF9saW1pdCA9IChhdm9wdHMgJiYgYXZvcHRzLT52YWN1dW1fY29zdF9s aW1pdCA+IDApCiAJCQk/IGF2b3B0cy0+dmFjdXVtX2Nvc3RfbGltaXQKIAkJCTogKGF1dG92YWN1 dW1fdmFjX2Nvc3RfbGltaXQgPiAwKQogCQkJPyBhdXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0Ci0J CQk6IFZhY3V1bUNvc3RMaW1pdDsKKwkJCTogdmFjdXVtX2Nvc3RfbGltaXQ7CiAKIAkJLyogLTEg aW4gYXV0b3ZhYyBzZXR0aW5nIG1lYW5zIHVzZSBsb2dfYXV0b3ZhY3V1bV9taW5fZHVyYXRpb24g Ki8KIAkJbG9nX21pbl9kdXJhdGlvbiA9IChhdm9wdHMgJiYgYXZvcHRzLT5sb2dfbWluX2R1cmF0 aW9uID49IDApCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9pbml0L2dsb2JhbHMuYyBi L3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jCmluZGV4IDFiMWQ4MTQyNTQuLjhlNWIw NjVlOGYgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jCisrKyBi L3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jCkBAIC0xNDIsOCArMTQyLDYgQEAgaW50 CQkJTWF4QmFja2VuZHMgPSAwOwogaW50CQkJVmFjdXVtQ29zdFBhZ2VIaXQgPSAxOwkvKiBHVUMg cGFyYW1ldGVycyBmb3IgdmFjdXVtICovCiBpbnQJCQlWYWN1dW1Db3N0UGFnZU1pc3MgPSAyOwog aW50CQkJVmFjdXVtQ29zdFBhZ2VEaXJ0eSA9IDIwOwotaW50CQkJVmFjdXVtQ29zdExpbWl0ID0g MjAwOwotZG91YmxlCQlWYWN1dW1Db3N0RGVsYXkgPSAwOwogCiBpbnQ2NAkJVmFjdXVtUGFnZUhp dCA9IDA7CiBpbnQ2NAkJVmFjdXVtUGFnZU1pc3MgPSAwOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvdXRpbHMvbWlzYy9ndWNfdGFibGVzLmMgYi9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Y190 YWJsZXMuYwppbmRleCA4MDYyNTg5ZWZkLi43N2RiMWExNDZjIDEwMDY0NAotLS0gYS9zcmMvYmFj a2VuZC91dGlscy9taXNjL2d1Y190YWJsZXMuYworKysgYi9zcmMvYmFja2VuZC91dGlscy9taXNj L2d1Y190YWJsZXMuYwpAQCAtMjQwOSw3ICsyNDA5LDcgQEAgc3RydWN0IGNvbmZpZ19pbnQgQ29u ZmlndXJlTmFtZXNJbnRbXSA9CiAJCQlnZXR0ZXh0X25vb3AoIlZhY3V1bSBjb3N0IGFtb3VudCBh dmFpbGFibGUgYmVmb3JlIG5hcHBpbmcuIiksCiAJCQlOVUxMCiAJCX0sCi0JCSZWYWN1dW1Db3N0 TGltaXQsCisJCSZ2YWN1dW1fY29zdF9saW1pdCwKIAkJMjAwLCAxLCAxMDAwMCwKIAkJTlVMTCwg TlVMTCwgTlVMTAogCX0sCkBAIC0zNzAxLDcgKzM3MDEsNyBAQCBzdHJ1Y3QgY29uZmlnX3JlYWwg Q29uZmlndXJlTmFtZXNSZWFsW10gPQogCQkJTlVMTCwKIAkJCUdVQ19VTklUX01TCiAJCX0sCi0J CSZWYWN1dW1Db3N0RGVsYXksCisJCSZ2YWN1dW1fY29zdF9kZWxheSwKIAkJMCwgMCwgMTAwLAog CQlOVUxMLCBOVUxMLCBOVUxMCiAJfSwKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2NvbW1hbmRz L3ZhY3V1bS5oIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKaW5kZXggN2I4ZWUyMTc4 OC4uYTYyZGQyZTc4MSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgK KysrIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKQEAgLTMwMCw2ICszMDAsOCBAQCBl eHRlcm4gUEdETExJTVBPUlQgaW50IHZhY3V1bV9tdWx0aXhhY3RfZnJlZXplX21pbl9hZ2U7CiBl eHRlcm4gUEdETExJTVBPUlQgaW50IHZhY3V1bV9tdWx0aXhhY3RfZnJlZXplX3RhYmxlX2FnZTsK IGV4dGVybiBQR0RMTElNUE9SVCBpbnQgdmFjdXVtX2ZhaWxzYWZlX2FnZTsKIGV4dGVybiBQR0RM TElNUE9SVCBpbnQgdmFjdXVtX211bHRpeGFjdF9mYWlsc2FmZV9hZ2U7CitleHRlcm4gUEdETExJ TVBPUlQgZG91YmxlIHZhY3V1bV9jb3N0X2RlbGF5OworZXh0ZXJuIFBHRExMSU1QT1JUIGludCB2 YWN1dW1fY29zdF9saW1pdDsKIAogLyogVmFyaWFibGVzIGZvciBjb3N0LWJhc2VkIHBhcmFsbGVs IHZhY3V1bSAqLwogZXh0ZXJuIFBHRExMSU1QT1JUIHBnX2F0b21pY191aW50MzIgKlZhY3V1bVNo YXJlZENvc3RCYWxhbmNlOwpAQCAtMzA3LDYgKzMwOSw4IEBAIGV4dGVybiBQR0RMTElNUE9SVCBw Z19hdG9taWNfdWludDMyICpWYWN1dW1BY3RpdmVOV29ya2VyczsKIGV4dGVybiBQR0RMTElNUE9S VCBpbnQgVmFjdXVtQ29zdEJhbGFuY2VMb2NhbDsKIAogZXh0ZXJuIGJvb2wgVmFjdXVtRmFpbHNh ZmVBY3RpdmU7CitleHRlcm4gaW50CVZhY3V1bUNvc3RMaW1pdDsKK2V4dGVybiBkb3VibGUgVmFj dXVtQ29zdERlbGF5OwogCiAvKiBpbiBjb21tYW5kcy92YWN1dW0uYyAqLwogZXh0ZXJuIHZvaWQg RXhlY1ZhY3V1bShQYXJzZVN0YXRlICpwc3RhdGUsIFZhY3V1bVN0bXQgKnZhY3N0bXQsIGJvb2wg aXNUb3BMZXZlbCk7CkBAIC0zNDYsNiArMzUwLDkgQEAgZXh0ZXJuIEluZGV4QnVsa0RlbGV0ZVJl c3VsdCAqdmFjX2NsZWFudXBfb25lX2luZGV4KEluZGV4VmFjdXVtSW5mbyAqaXZpbmZvLAogCQkJ CQkJCQkJCQkJCUluZGV4QnVsa0RlbGV0ZVJlc3VsdCAqaXN0YXQpOwogZXh0ZXJuIFNpemUgdmFj X21heF9pdGVtc190b19hbGxvY19zaXplKGludCBtYXhfaXRlbXMpOwogCisvKiBJbiBwb3N0bWFz dGVyL2F1dG92YWN1dW0uYyAqLworZXh0ZXJuIHZvaWQgVmFjdXVtVXBkYXRlQ29zdHModm9pZCk7 CisKIC8qIGluIGNvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMgKi8KIGV4dGVybiBQYXJhbGxlbFZh Y3V1bVN0YXRlICpwYXJhbGxlbF92YWN1dW1faW5pdChSZWxhdGlvbiByZWwsIFJlbGF0aW9uICpp bmRyZWxzLAogCQkJCQkJCQkJCQkJIGludCBuaW5kZXhlcywgaW50IG5yZXF1ZXN0ZWRfd29ya2Vy cywKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL21pc2NhZG1pbi5oIGIvc3JjL2luY2x1ZGUvbWlz Y2FkbWluLmgKaW5kZXggMDZhODZmOWFjMS4uNjZkYjFiMmM2OSAxMDA2NDQKLS0tIGEvc3JjL2lu Y2x1ZGUvbWlzY2FkbWluLmgKKysrIGIvc3JjL2luY2x1ZGUvbWlzY2FkbWluLmgKQEAgLTI2Niw4 ICsyNjYsNiBAQCBleHRlcm4gUEdETExJTVBPUlQgaW50IG1heF9wYXJhbGxlbF9tYWludGVuYW5j ZV93b3JrZXJzOwogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBWYWN1dW1Db3N0UGFnZUhpdDsKIGV4 dGVybiBQR0RMTElNUE9SVCBpbnQgVmFjdXVtQ29zdFBhZ2VNaXNzOwogZXh0ZXJuIFBHRExMSU1Q T1JUIGludCBWYWN1dW1Db3N0UGFnZURpcnR5OwotZXh0ZXJuIFBHRExMSU1QT1JUIGludCBWYWN1 dW1Db3N0TGltaXQ7Ci1leHRlcm4gUEdETExJTVBPUlQgZG91YmxlIFZhY3V1bUNvc3REZWxheTsK IAogZXh0ZXJuIFBHRExMSU1QT1JUIGludDY0IFZhY3V1bVBhZ2VIaXQ7CiBleHRlcm4gUEdETExJ TVBPUlQgaW50NjQgVmFjdXVtUGFnZU1pc3M7CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9wb3N0 bWFzdGVyL2F1dG92YWN1dW0uaCBiL3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5o CmluZGV4IGMxNDAzNzFiNTEuLjY1YWZkMWVhMWUgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3Bv c3RtYXN0ZXIvYXV0b3ZhY3V1bS5oCisrKyBiL3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3Zh Y3V1bS5oCkBAIC02Myw5ICs2Myw2IEBAIGV4dGVybiBpbnQJU3RhcnRBdXRvVmFjV29ya2VyKHZv aWQpOwogLyogY2FsbGVkIGZyb20gcG9zdG1hc3RlciB3aGVuIGEgd29ya2VyIGNvdWxkIG5vdCBi ZSBmb3JrZWQgKi8KIGV4dGVybiB2b2lkIEF1dG9WYWNXb3JrZXJGYWlsZWQodm9pZCk7CiAKLS8q IGF1dG92YWN1dW0gY29zdC1kZWxheSBiYWxhbmNlciAqLwotZXh0ZXJuIHZvaWQgQXV0b1ZhY3V1 bVVwZGF0ZURlbGF5KHZvaWQpOwotCiAjaWZkZWYgRVhFQ19CQUNLRU5ECiBleHRlcm4gdm9pZCBB dXRvVmFjTGF1bmNoZXJNYWluKGludCBhcmdjLCBjaGFyICphcmd2W10pIHBnX2F0dHJpYnV0ZV9u b3JldHVybigpOwogZXh0ZXJuIHZvaWQgQXV0b1ZhY1dvcmtlck1haW4oaW50IGFyZ2MsIGNoYXIg KmFyZ3ZbXSkgcGdfYXR0cmlidXRlX25vcmV0dXJuKCk7Ci0tIAoyLjM3LjIKCg== --00000000000067bc5205f8713969 Content-Type: text/x-patch; charset="US-ASCII"; name="v13-0003-VACUUM-reloads-config-file-more-often.patch" Content-Disposition: attachment; filename="v13-0003-VACUUM-reloads-config-file-more-often.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg1222aa2 RnJvbSBmYWJlMDNhMWUzY2NhNzAxZTM1ZTYzOTRjODJlMjE4MzY5Y2Q2M2ExIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBNb24sIDMgQXByIDIwMjMgMTI6MzY6MzUgLTA0MDAKU3ViamVjdDogW1BB VENIIHYxMyAzLzRdIFZBQ1VVTSByZWxvYWRzIGNvbmZpZyBmaWxlIG1vcmUgb2Z0ZW4KClByZXZp b3VzbHksIFZBQ1VVTSB3b3VsZCBub3QgcmVsb2FkIHRoZSBjb25maWd1cmF0aW9uIGZpbGUsIHNv IGNoYW5nZXMKdG8gY29zdC1iYXNlZCBkZWxheSBwYXJhbWV0ZXJzIGNvdWxkIG9ubHkgdGFrZSBl ZmZlY3Qgb24gdGhlIG5leHQKaW52b2NhdGlvbiBvZiBWQUNVVU0uCgpOb3csIGNoZWNrIGlmIGEg cmVsb2FkIGlzIHBlbmRpbmcgcm91Z2hseSBvbmNlIHBlciBibG9jaywgd2hlbiBjaGVja2luZwpp ZiB3ZSBuZWVkIHRvIGRlbGF5LgoKTm90ZSB0aGF0IGF1dG92YWN1dW0gaXMgdW5hZmZlY3RlZCBi eSB0aGlzIGNoYW5nZS4gQXV0b3ZhY3V1bSB3b3JrZXJzCm92ZXJ3cml0ZSB0aGUgdmFsdWUgb2Yg VmFjdXVtQ29zdExpbWl0IGFuZCBWYWN1dW1Db3N0RGVsYXkgd2l0aCB0aGVpcgpvd24gV29ya2Vy SW5mby0+d2lfY29zdF9saW1pdCBhbmQgd2lfY29zdF9kZWxheSBpbnN0ZWFkIG9mIHVzaW5nCnBv dGVudGlhbGx5IHJlZnJlc2hlZCB2YWx1ZXMgb2YgYXV0b3ZhY3V1bV92YWN1dW1fY29zdF9saW1p dCBhbmQKYXV0b3ZhY3V1bV92YWN1dW1fY29zdF9kZWxheS4gTG9ja2luZyBjb25zaWRlcmF0aW9u cyBhbmQgbmVlZGVkIHVwZGF0ZXMKdG8gdGhlIHdvcmtlciBiYWxhbmNpbmcgbG9naWMgbWFrZSBl bmFibGluZyB0aGlzIGZlYXR1cmUgZm9yIGF1dG92YWN1dW0Kd29ydGh5IG9mIGFuIGluZGVwZW5k ZW50IGNvbW1pdC4KClJldmlld2VkLWJ5OiBNYXNhaGlrbyBTYXdhZGEgPHNhd2FkYS5tc2hrQGdt YWlsLmNvbT4KUmV2aWV3ZWQtYnk6IEt5b3Rhcm8gSG9yaWd1Y2hpIDxob3Jpa3lvdGEubnR0QGdt YWlsLmNvbT4KUmV2aWV3ZWQtYnk6IERhbmllbCBHdXN0YWZzc29uIDxkYW5pZWxAeWVzcWwuc2U+ CkRpc2N1c3Npb246IGh0dHBzOi8vd3d3LnBvc3RncmVzcWwub3JnL21lc3NhZ2UtaWQvZmxhdC9D QUFLUnVfWm5nenFuRU9EYzdMbVMxTkgwNEt0Nlk5aHVTano1cHA3JTJCRFhocmpEQTBndyU0MG1h aWwuZ21haWwuY29tCi0tLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMgICAgICAgICB8 IDQxICsrKysrKysrKysrKysrKysrKysrKysrKystLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFj dXVtcGFyYWxsZWwuYyB8ICA1ICsrLS0KIHNyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1 bS5jICAgfCAxOCArKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgNTggaW5zZXJ0aW9ucygr KSwgNiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1 dW0uYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCmluZGV4IDk2ZGY1ZTI5MjAuLjg4 OGViMDIyY2MgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCisrKyBi L3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCkBAIC00OCw2ICs0OCw3IEBACiAjaW5jbHVk ZSAicGdzdGF0LmgiCiAjaW5jbHVkZSAicG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgiCiAjaW5jbHVk ZSAicG9zdG1hc3Rlci9iZ3dvcmtlcl9pbnRlcm5hbHMuaCIKKyNpbmNsdWRlICJwb3N0bWFzdGVy L2ludGVycnVwdC5oIgogI2luY2x1ZGUgInN0b3JhZ2UvYnVmbWdyLmgiCiAjaW5jbHVkZSAic3Rv cmFnZS9sbWdyLmgiCiAjaW5jbHVkZSAic3RvcmFnZS9wbXNpZ25hbC5oIgpAQCAtODMsNiArODQs NyBAQCBpbnQJCQl2YWN1dW1fY29zdF9saW1pdDsKICAqLwogaW50CQkJVmFjdXVtQ29zdExpbWl0 ID0gMDsKIGRvdWJsZQkJVmFjdXVtQ29zdERlbGF5ID0gLTE7CitzdGF0aWMgYm9vbCB2YWN1dW1f Y2FuX3JlbG9hZF9jb25maWcgPSBmYWxzZTsKIAogLyoKICAqIFZhY3V1bUZhaWxzYWZlQWN0aXZl IGlzIGEgZGVmaW5lZCBhcyBhIGdsb2JhbCBzbyB0aGF0IHdlIGNhbiBkZXRlcm1pbmUKQEAgLTM1 NCw2ICszNTYsOCBAQCB2YWN1dW0oTGlzdCAqcmVsYXRpb25zLCBWYWN1dW1QYXJhbXMgKnBhcmFt cywKIAllbHNlCiAJCWluX291dGVyX3hhY3QgPSBJc0luVHJhbnNhY3Rpb25CbG9jayhpc1RvcExl dmVsKTsKIAorCXZhY3V1bV9jYW5fcmVsb2FkX2NvbmZpZyA9ICFpbl9vdXRlcl94YWN0OworCiAJ LyoKIAkgKiBDaGVjayBmb3IgYW5kIGRpc2FsbG93IHJlY3Vyc2l2ZSBjYWxscy4gIFRoaXMgY291 bGQgaGFwcGVuIHdoZW4gVkFDVVVNCiAJICogRlVMTCBvciBBTkFMWVpFIGNhbGxzIGEgaG9zdGls ZSBpbmRleCBleHByZXNzaW9uIHRoYXQgaXRzZWxmIGNhbGxzCkBAIC01MTAsOSArNTE0LDkgQEAg dmFjdXVtKExpc3QgKnJlbGF0aW9ucywgVmFjdXVtUGFyYW1zICpwYXJhbXMsCiAJewogCQlMaXN0 Q2VsbCAgICpjdXI7CiAKLQkJVmFjdXVtVXBkYXRlQ29zdHMoKTsKIAkJaW5fdmFjdXVtID0gdHJ1 ZTsKLQkJVmFjdXVtQ29zdEFjdGl2ZSA9IChWYWN1dW1Db3N0RGVsYXkgPiAwKTsKKwkJVmFjdXVt RmFpbHNhZmVBY3RpdmUgPSBmYWxzZTsKKwkJVmFjdXVtVXBkYXRlQ29zdHMoKTsKIAkJVmFjdXVt Q29zdEJhbGFuY2UgPSAwOwogCQlWYWN1dW1QYWdlSGl0ID0gMDsKIAkJVmFjdXVtUGFnZU1pc3Mg PSAwOwpAQCAtNTY2LDEyICs1NzAsMjEgQEAgdmFjdXVtKExpc3QgKnJlbGF0aW9ucywgVmFjdXVt UGFyYW1zICpwYXJhbXMsCiAJCQkJCUNvbW1hbmRDb3VudGVySW5jcmVtZW50KCk7CiAJCQkJfQog CQkJfQorCisJCQkvKgorCQkJICogRW5zdXJlIFZhY3V1bUZhaWxzYWZlQWN0aXZlIGhhcyBiZWVu IHJlc2V0IGJlZm9yZSB2YWN1dW1pbmcgdGhlCisJCQkgKiBuZXh0IHJlbGF0aW9uIHJlbGF0aW9u LgorCQkJICovCisJCQlWYWN1dW1GYWlsc2FmZUFjdGl2ZSA9IGZhbHNlOwogCQl9CiAJfQogCVBH X0ZJTkFMTFkoKTsKIAl7CiAJCWluX3ZhY3V1bSA9IGZhbHNlOwogCQlWYWN1dW1Db3N0QWN0aXZl ID0gZmFsc2U7CisJCVZhY3V1bUZhaWxzYWZlQWN0aXZlID0gZmFsc2U7CisJCVZhY3V1bUNvc3RC YWxhbmNlID0gMDsKKwkJdmFjdXVtX2Nhbl9yZWxvYWRfY29uZmlnID0gZmFsc2U7CiAJfQogCVBH X0VORF9UUlkoKTsKIApAQCAtMjIzOCw3ICsyMjUxLDI5IEBAIHZhY3V1bV9kZWxheV9wb2ludCh2 b2lkKQogCS8qIEFsd2F5cyBjaGVjayBmb3IgaW50ZXJydXB0cyAqLwogCUNIRUNLX0ZPUl9JTlRF UlJVUFRTKCk7CiAKLQlpZiAoIVZhY3V1bUNvc3RBY3RpdmUgfHwgSW50ZXJydXB0UGVuZGluZykK KwlpZiAoSW50ZXJydXB0UGVuZGluZyB8fAorCQkoIVZhY3V1bUNvc3RBY3RpdmUgJiYgIUNvbmZp Z1JlbG9hZFBlbmRpbmcpKQorCQlyZXR1cm47CisKKwkvKgorCSAqIFJlbG9hZCB0aGUgY29uZmln dXJhdGlvbiBmaWxlIGlmIHJlcXVlc3RlZC4gVGhpcyBhbGxvd3MgY2hhbmdlcyB0bworCSAqIHZh Y3V1bV9jb3N0X2xpbWl0IGFuZCB2YWN1dW1fY29zdF9kZWxheSB0byB0YWtlIGVmZmVjdCB3aGls ZSBhIHRhYmxlIGlzCisJICogYmVpbmcgdmFjdXVtZWQgb3IgYW5hbHl6ZWQuIEFuYWx5emUgc2hv dWxkIG5vdCByZWxvYWQgY29uZmlndXJhdGlvbgorCSAqIGZpbGUgaWYgaXQgaXMgaW4gYW4gb3V0 ZXIgdHJhbnNhY3Rpb24sIGFzIHdlIGN1cnJlbnRseSBvbmx5IGFsbG93CisJICogY29uZmlndXJh dGlvbiByZWxvYWQgd2hlbiBpbiB0b3AtbGV2ZWwgc3RhdGVtZW50cy4KKwkgKi8KKwlpZiAoQ29u ZmlnUmVsb2FkUGVuZGluZyAmJiB2YWN1dW1fY2FuX3JlbG9hZF9jb25maWcpCisJeworCQlDb25m aWdSZWxvYWRQZW5kaW5nID0gZmFsc2U7CisJCVByb2Nlc3NDb25maWdGaWxlKFBHQ19TSUdIVVAp OworCQlWYWN1dW1VcGRhdGVDb3N0cygpOworCX0KKworCS8qCisJICogSWYgd2UgZGlzYWJsZWQg Y29zdC1iYXNlZCBkZWxheXMgYWZ0ZXIgcmVsb2FkaW5nIHRoZSBjb25maWcgZmlsZSwKKwkgKiBy ZXR1cm4uCisJICovCisJaWYgKCFWYWN1dW1Db3N0QWN0aXZlKQogCQlyZXR1cm47CiAKIAkvKgpk aWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyBiL3NyYy9i YWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKaW5kZXggY2Y4Y2Y4OTkyNy4uNGJjMWMx NGRmZiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYwor KysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC05OTUsMTAgKzk5 NSw5IEBAIHBhcmFsbGVsX3ZhY3V1bV9tYWluKGRzbV9zZWdtZW50ICpzZWcsIHNobV90b2MgKnRv YykKIAkJCQkJCQkJCQkJCSBmYWxzZSk7CiAKIAkvKiBTZXQgY29zdC1iYXNlZCB2YWN1dW0gZGVs YXkgKi8KLQlWYWN1dW1GYWlsc2FmZUFjdGl2ZSA9IGZhbHNlOwotCVZhY3V1bVVwZGF0ZUNvc3Rz KCk7Ci0JVmFjdXVtQ29zdEFjdGl2ZSA9IChWYWN1dW1Db3N0RGVsYXkgPiAwKTsKKwlBc3NlcnQo IVZhY3V1bUZhaWxzYWZlQWN0aXZlKTsKIAlWYWN1dW1Db3N0QmFsYW5jZSA9IDA7CisJVmFjdXVt VXBkYXRlQ29zdHMoKTsKIAlWYWN1dW1QYWdlSGl0ID0gMDsKIAlWYWN1dW1QYWdlTWlzcyA9IDA7 CiAJVmFjdXVtUGFnZURpcnR5ID0gMDsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0 ZXIvYXV0b3ZhY3V1bS5jIGIvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKaW5k ZXggMjdkMGQ1ZjllMi4uN2E5NzM4MjAyZiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcG9zdG1h c3Rlci9hdXRvdmFjdXVtLmMKKysrIGIvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVt LmMKQEAgLTE3OTYsNiArMTc5NiwyNCBAQCBWYWN1dW1VcGRhdGVDb3N0cyh2b2lkKQogCQlWYWN1 dW1Db3N0TGltaXQgPSB2YWN1dW1fY29zdF9saW1pdDsKIAkJVmFjdXVtQ29zdERlbGF5ID0gdmFj dXVtX2Nvc3RfZGVsYXk7CiAJfQorCisJLyoKKwkgKiBJZiBjb25maWd1cmF0aW9uIGNoYW5nZXMg YXJlIGFsbG93ZWQgdG8gaW1wYWN0IFZhY3V1bUNvc3RBY3RpdmUsIG1ha2UKKwkgKiBzdXJlIGl0 IGlzIHVwZGF0ZWQuCisJICovCisJaWYgKFZhY3V1bUZhaWxzYWZlQWN0aXZlKQorCXsKKwkJQXNz ZXJ0KCFWYWN1dW1Db3N0QWN0aXZlKTsKKwkJcmV0dXJuOworCX0KKworCWlmIChWYWN1dW1Db3N0 RGVsYXkgPiAwKQorCQlWYWN1dW1Db3N0QWN0aXZlID0gdHJ1ZTsKKwllbHNlCisJeworCQlWYWN1 dW1Db3N0QWN0aXZlID0gZmFsc2U7CisJCVZhY3V1bUNvc3RCYWxhbmNlID0gMDsKKwl9CiB9CiAK IC8qCi0tIAoyLjM3LjIKCg== --00000000000067bc5205f8713969 Content-Type: text/x-patch; charset="US-ASCII"; name="v13-0001-Make-vacuum-s-failsafe_active-a-global.patch" Content-Disposition: attachment; filename="v13-0001-Make-vacuum-s-failsafe_active-a-global.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg1222a40 RnJvbSBiODY0MjgxYjk5ZWNjNThkNTNlMDgyOGEzZWQxODIzNjA5ZjVhN2JjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBGcmksIDMxIE1hciAyMDIzIDEwOjM4OjM5IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTMgMS80XSBNYWtlIHZhY3V1bSdzIGZhaWxzYWZlX2FjdGl2ZSBhIGdsb2JhbAoKV2hp bGUgdmFjdXVtaW5nIGEgdGFibGUgaW4gZmFpbHNhZmUgbW9kZSwgVmFjdXVtQ29zdEFjdGl2ZSBz aG91bGQgbm90IGJlCnJlLWVuYWJsZWQuIFRoaXMgY3VycmVudGx5IGlzbid0IGEgcHJvYmxlbSBi ZWNhdXNlIHZhY3V1bSBjb3N0CnBhcmFtZXRlcnMgYXJlIG9ubHkgcmVmcmVzaGVkIGluIGJldHdl ZW4gdmFjdXVtaW5nIHRhYmxlcyBhbmQgZmFpbHNhZmUKc3RhdHVzIGlzIHJlc2V0IGZvciBldmVy eSB0YWJsZS4gSW4gcHJlcGFyYXRpb24gZm9yIGFsbG93aW5nIHZhY3V1bSBjb3N0CnBhcmFtZXRl cnMgdG8gYmUgdXBkYXRlZCBtb3JlIGZyZXF1ZW50bHksIGVsZXZhdGUKTFZSZWxTdGF0ZS0+ZmFp bHNhZmVfYWN0aXZlIHRvIGEgZ2xvYmFsLCBWYWN1dW1GYWlsc2FmZUFjdGl2ZSwgd2hpY2gKd2ls bCBiZSBjaGVja2VkIHdoZW4gZGV0ZXJtaW5pbmcgd2hldGhlciBvciBub3QgdG8gcmUtZW5hYmxl IHZhY3V1bQpjb3N0LXJlbGF0ZWQgZGVsYXlzLgoKUmV2aWV3ZWQtYnk6IE1hc2FoaWtvIFNhd2Fk YSA8c2F3YWRhLm1zaGtAZ21haWwuY29tPgpEaXNjdXNzaW9uOiBodHRwczovL3d3dy5wb3N0Z3Jl c3FsLm9yZy9tZXNzYWdlLWlkL2ZsYXQvQ0FBS1J1X1puZ3pxbkVPRGM3TG1TMU5IMDRLdDZZOWh1 U2p6NXBwNyUyQkRYaHJqREEwZ3clNDBtYWlsLmdtYWlsLmNvbQotLS0KIHNyYy9iYWNrZW5kL2Fj Y2Vzcy9oZWFwL3ZhY3V1bWxhenkuYyAgfCAxNiArKysrKysrLS0tLS0tLS0tCiBzcmMvYmFja2Vu ZC9jb21tYW5kcy92YWN1dW0uYyAgICAgICAgIHwgIDkgKysrKysrKysrCiBzcmMvYmFja2VuZC9j b21tYW5kcy92YWN1dW1wYXJhbGxlbC5jIHwgIDEgKwogc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFj dXVtLmggICAgICAgICB8ICAxICsKIDQgZmlsZXMgY2hhbmdlZCwgMTggaW5zZXJ0aW9ucygrKSwg OSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1 dW1sYXp5LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKaW5kZXggM2U1 ZDM5ODJjNy4uNmQ3NjFlNmQwZSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAv dmFjdXVtbGF6eS5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYwpA QCAtMTUzLDggKzE1Myw2IEBAIHR5cGVkZWYgc3RydWN0IExWUmVsU3RhdGUKIAlib29sCQlhZ2dy ZXNzaXZlOwogCS8qIFVzZSB2aXNpYmlsaXR5IG1hcCB0byBza2lwPyAoZGlzYWJsZWQgYnkgRElT QUJMRV9QQUdFX1NLSVBQSU5HKSAqLwogCWJvb2wJCXNraXB3aXRodm07Ci0JLyogV3JhcGFyb3Vu ZCBmYWlsc2FmZSBoYXMgYmVlbiB0cmlnZ2VyZWQ/ICovCi0JYm9vbAkJZmFpbHNhZmVfYWN0aXZl OwogCS8qIENvbnNpZGVyIGluZGV4IHZhY3V1bWluZyBieXBhc3Mgb3B0aW1pemF0aW9uPyAqLwog CWJvb2wJCWNvbnNpZGVyX2J5cGFzc19vcHRpbWl6YXRpb247CiAKQEAgLTM5MSw3ICszODksNyBA QCBoZWFwX3ZhY3V1bV9yZWwoUmVsYXRpb24gcmVsLCBWYWN1dW1QYXJhbXMgKnBhcmFtcywKIAlB c3NlcnQocGFyYW1zLT5pbmRleF9jbGVhbnVwICE9IFZBQ09QVFZBTFVFX1VOU1BFQ0lGSUVEKTsK IAlBc3NlcnQocGFyYW1zLT50cnVuY2F0ZSAhPSBWQUNPUFRWQUxVRV9VTlNQRUNJRklFRCAmJgog CQkgICBwYXJhbXMtPnRydW5jYXRlICE9IFZBQ09QVFZBTFVFX0FVVE8pOwotCXZhY3JlbC0+ZmFp bHNhZmVfYWN0aXZlID0gZmFsc2U7CisJVmFjdXVtRmFpbHNhZmVBY3RpdmUgPSBmYWxzZTsKIAl2 YWNyZWwtPmNvbnNpZGVyX2J5cGFzc19vcHRpbWl6YXRpb24gPSB0cnVlOwogCXZhY3JlbC0+ZG9f aW5kZXhfdmFjdXVtaW5nID0gdHJ1ZTsKIAl2YWNyZWwtPmRvX2luZGV4X2NsZWFudXAgPSB0cnVl OwpAQCAtNzA5LDcgKzcwNyw3IEBAIGhlYXBfdmFjdXVtX3JlbChSZWxhdGlvbiByZWwsIFZhY3V1 bVBhcmFtcyAqcGFyYW1zLAogCQkJfQogCQkJZWxzZQogCQkJewotCQkJCWlmICghdmFjcmVsLT5m YWlsc2FmZV9hY3RpdmUpCisJCQkJaWYgKCFWYWN1dW1GYWlsc2FmZUFjdGl2ZSkKIAkJCQkJYXBw ZW5kU3RyaW5nSW5mb1N0cmluZygmYnVmLCBfKCJpbmRleCBzY2FuIGJ5cGFzc2VkOiAiKSk7CiAJ CQkJZWxzZQogCQkJCQlhcHBlbmRTdHJpbmdJbmZvU3RyaW5nKCZidWYsIF8oImluZGV4IHNjYW4g YnlwYXNzZWQgYnkgZmFpbHNhZmU6ICIpKTsKQEAgLTIyOTMsNyArMjI5MSw3IEBAIGxhenlfdmFj dXVtKExWUmVsU3RhdGUgKnZhY3JlbCkKIAkJICogdmFjdXVtaW5nIG9yIGhlYXAgdmFjdXVtaW5n LiAgVGhpcyBWQUNVVU0gb3BlcmF0aW9uIHdvbid0IGVuZCB1cAogCQkgKiBiYWNrIGhlcmUgYWdh aW4uCiAJCSAqLwotCQlBc3NlcnQodmFjcmVsLT5mYWlsc2FmZV9hY3RpdmUpOworCQlBc3NlcnQo VmFjdXVtRmFpbHNhZmVBY3RpdmUpOwogCX0KIAogCS8qCkBAIC0yMzc0LDcgKzIzNzIsNyBAQCBs YXp5X3ZhY3V1bV9hbGxfaW5kZXhlcyhMVlJlbFN0YXRlICp2YWNyZWwpCiAJICovCiAJQXNzZXJ0 KHZhY3JlbC0+bnVtX2luZGV4X3NjYW5zID4gMCB8fAogCQkgICB2YWNyZWwtPmRlYWRfaXRlbXMt Pm51bV9pdGVtcyA9PSB2YWNyZWwtPmxwZGVhZF9pdGVtcyk7Ci0JQXNzZXJ0KGFsbGluZGV4ZXMg fHwgdmFjcmVsLT5mYWlsc2FmZV9hY3RpdmUpOworCUFzc2VydChhbGxpbmRleGVzIHx8IFZhY3V1 bUZhaWxzYWZlQWN0aXZlKTsKIAogCS8qCiAJICogSW5jcmVhc2UgYW5kIHJlcG9ydCB0aGUgbnVt YmVyIG9mIGluZGV4IHNjYW5zLgpAQCAtMjYxNiwxMiArMjYxNCwxMiBAQCBzdGF0aWMgYm9vbAog bGF6eV9jaGVja193cmFwYXJvdW5kX2ZhaWxzYWZlKExWUmVsU3RhdGUgKnZhY3JlbCkKIHsKIAkv KiBEb24ndCB3YXJuIG1vcmUgdGhhbiBvbmNlIHBlciBWQUNVVU0gKi8KLQlpZiAodmFjcmVsLT5m YWlsc2FmZV9hY3RpdmUpCisJaWYgKFZhY3V1bUZhaWxzYWZlQWN0aXZlKQogCQlyZXR1cm4gdHJ1 ZTsKIAogCWlmICh1bmxpa2VseSh2YWN1dW1feGlkX2ZhaWxzYWZlX2NoZWNrKCZ2YWNyZWwtPmN1 dG9mZnMpKSkKIAl7Ci0JCXZhY3JlbC0+ZmFpbHNhZmVfYWN0aXZlID0gdHJ1ZTsKKwkJVmFjdXVt RmFpbHNhZmVBY3RpdmUgPSB0cnVlOwogCiAJCS8qCiAJCSAqIEFiYW5kb24gdXNlIG9mIGEgYnVm ZmVyIGFjY2VzcyBzdHJhdGVneSB0byBhbGxvdyB1c2Ugb2YgYWxsIG9mCkBAIC0yODIwLDcgKzI4 MTgsNyBAQCBzaG91bGRfYXR0ZW1wdF90cnVuY2F0aW9uKExWUmVsU3RhdGUgKnZhY3JlbCkKIHsK IAlCbG9ja051bWJlciBwb3NzaWJseV9mcmVlYWJsZTsKIAotCWlmICghdmFjcmVsLT5kb19yZWxf dHJ1bmNhdGUgfHwgdmFjcmVsLT5mYWlsc2FmZV9hY3RpdmUgfHwKKwlpZiAoIXZhY3JlbC0+ZG9f cmVsX3RydW5jYXRlIHx8IFZhY3V1bUZhaWxzYWZlQWN0aXZlIHx8CiAJCW9sZF9zbmFwc2hvdF90 aHJlc2hvbGQgPj0gMCkKIAkJcmV0dXJuIGZhbHNlOwogCmRpZmYgLS1naXQgYS9zcmMvYmFja2Vu ZC9jb21tYW5kcy92YWN1dW0uYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCmluZGV4 IGRhODUzMzBlZjQuLjk3MjRmYmNlNDYgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRz L3ZhY3V1bS5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCkBAIC03Miw2ICs3 MiwxNSBAQCBpbnQJCQl2YWN1dW1fbXVsdGl4YWN0X2ZyZWV6ZV90YWJsZV9hZ2U7CiBpbnQJCQl2 YWN1dW1fZmFpbHNhZmVfYWdlOwogaW50CQkJdmFjdXVtX211bHRpeGFjdF9mYWlsc2FmZV9hZ2U7 CiAKKy8qCisgKiBWYWN1dW1GYWlsc2FmZUFjdGl2ZSBpcyBhIGRlZmluZWQgYXMgYSBnbG9iYWwg c28gdGhhdCB3ZSBjYW4gZGV0ZXJtaW5lCisgKiB3aGV0aGVyIG9yIG5vdCB0byByZS1lbmFibGUg Y29zdC1iYXNlZCB2YWN1dW0gZGVsYXkgd2hlbiB2YWN1dW1pbmcgYSB0YWJsZS4KKyAqIElmIGZh aWxzYWZlIG1vZGUgaGFzIGJlZW4gZW5nYWdlZCwgd2Ugd2lsbCBub3QgcmUtZW5hYmxlIGNvc3Qt YmFzZWQgZGVsYXkKKyAqIGZvciB0aGUgdGFibGUgdW50aWwgYWZ0ZXIgdmFjdXVtaW5nIGhhcyBj b21wbGV0ZWQsIHJlZ2FyZGxlc3Mgb2Ygb3RoZXIKKyAqIHNldHRpbmdzLgorICovCitib29sCQlW YWN1dW1GYWlsc2FmZUFjdGl2ZSA9IGZhbHNlOworCiAvKgogICogVmFyaWFibGVzIGZvciBjb3N0 LWJhc2VkIHBhcmFsbGVsIHZhY3V1bS4gIFNlZSBjb21tZW50cyBhdG9wCiAgKiBjb21wdXRlX3Bh cmFsbGVsX2RlbGF5IHRvIHVuZGVyc3RhbmQgaG93IGl0IHdvcmtzLgpkaWZmIC0tZ2l0IGEvc3Jj L2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRz L3ZhY3V1bXBhcmFsbGVsLmMKaW5kZXggMmNkYmQxODJiNi4uZmY3ZWQwZjU2MSAxMDA2NDQKLS0t IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYworKysgYi9zcmMvYmFja2Vu ZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC05OTUsNiArOTk1LDcgQEAgcGFyYWxsZWxf dmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQogCQkJCQkJCQkJCQkJ IGZhbHNlKTsKIAogCS8qIFNldCBjb3N0LWJhc2VkIHZhY3V1bSBkZWxheSAqLworCVZhY3V1bUZh aWxzYWZlQWN0aXZlID0gZmFsc2U7CiAJVmFjdXVtQ29zdEFjdGl2ZSA9IChWYWN1dW1Db3N0RGVs YXkgPiAwKTsKIAlWYWN1dW1Db3N0QmFsYW5jZSA9IDA7CiAJVmFjdXVtUGFnZUhpdCA9IDA7CmRp ZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaCBiL3NyYy9pbmNsdWRlL2Nv bW1hbmRzL3ZhY3V1bS5oCmluZGV4IGJkZmQ5NmNmZWMuLjdiOGVlMjE3ODggMTAwNjQ0Ci0tLSBh L3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oCisrKyBiL3NyYy9pbmNsdWRlL2NvbW1hbmRz L3ZhY3V1bS5oCkBAIC0zMDYsNiArMzA2LDcgQEAgZXh0ZXJuIFBHRExMSU1QT1JUIHBnX2F0b21p Y191aW50MzIgKlZhY3V1bVNoYXJlZENvc3RCYWxhbmNlOwogZXh0ZXJuIFBHRExMSU1QT1JUIHBn X2F0b21pY191aW50MzIgKlZhY3V1bUFjdGl2ZU5Xb3JrZXJzOwogZXh0ZXJuIFBHRExMSU1QT1JU IGludCBWYWN1dW1Db3N0QmFsYW5jZUxvY2FsOwogCitleHRlcm4gYm9vbCBWYWN1dW1GYWlsc2Fm ZUFjdGl2ZTsKIAogLyogaW4gY29tbWFuZHMvdmFjdXVtLmMgKi8KIGV4dGVybiB2b2lkIEV4ZWNW YWN1dW0oUGFyc2VTdGF0ZSAqcHN0YXRlLCBWYWN1dW1TdG10ICp2YWNzdG10LCBib29sIGlzVG9w TGV2ZWwpOwotLSAKMi4zNy4yCgo= --00000000000067bc5205f8713969--