MIME-Version: 1.0
References: <20230329.132155.629765142788133576.horikyota.ntt@gmail.com>
 <20230329.173456.1185961934810139447.horikyota.ntt@gmail.com>
 <CAAKRu_Yg4-kWH_EN7wtpm3z9B+H27UTmOxzzYv1Vg=YdZ6v_rw@mail.gmail.com>
 <CAD21AoCGdxYAJHmE_nXw_MFw1+Qtn3vcThRu5FiadukgQnpWeQ@mail.gmail.com>
 <935191FB-083B-4060-89FC-466F61FAA391@yesql.se> <CAAKRu_aoa0YT36q2n3xa9MZYdepeH4Jyf2EVJj=7YdC_1c974Q@mail.gmail.com>
 <CAAKRu_bSsChKsyEy1ZV2XJQ22FoDdA56efjNr9==m2TO94557w@mail.gmail.com>
 <CAD21AoDi4i4tj1Cf9BG0q2iyVhHisQ2xxVBZajEqExX6t6_b3g@mail.gmail.com>
 <CAAKRu_bkg+0WAGTxsy0HP75RzFbPwqz3ctYq1kThjFhSL69upw@mail.gmail.com>
 <1252075.1680547394@sss.pgh.pa.us> <20230403190837.qubpnwugfe2k2g46@awork3.anarazel.de>
 <CAAKRu_ap7nhmqtKQ1TRo3LzHG3FK=YpGO=O0019M3BbN7ysm3A@mail.gmail.com> <7E06F879-7E20-4A6A-862F-CA72CDC9A323@yesql.se>
In-Reply-To: <7E06F879-7E20-4A6A-862F-CA72CDC9A323@yesql.se>
From: Melanie Plageman <melanieplageman@gmail.com>
Date: Tue, 4 Apr 2023 16:04:52 -0400
Message-ID: <CAAKRu_b1HjGCTsFpUnmwLNS8NeXJ+JnrDLhT1osP+Gq9HCU+Rw@mail.gmail.com>
Subject: Re: Should vacuum process config file reload more often
To: Daniel Gustafsson <daniel@yesql.se>
Cc: Andres Freund <andres@anarazel.de>, Tom Lane <tgl@sss.pgh.pa.us>, 
	Masahiko Sawada <sawada.mshk@gmail.com>, Kyotaro Horiguchi <horikyota.ntt@gmail.com>, 
	PostgreSQL Hackers <pgsql-hackers@postgresql.org>, Amit Kapila <amit.kapila16@gmail.com>
Content-Type: multipart/mixed; boundary="000000000000f8e86e05f88830c2"
Archived-At: <https://www.postgresql.org/message-id/CAAKRu_b1HjGCTsFpUnmwLNS8NeXJ%2BJnrDLhT1osP%2BGq9HCU%2BRw%40mail.gmail.com>
Precedence: bulk

--000000000000f8e86e05f88830c2
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Tue, Apr 4, 2023 at 4:27=E2=80=AFAM Masahiko Sawada <sawada.mshk@gmail.c=
om> wrote:
> The 0001 patch mostly looks good to me except for one
> point:
>
> @@ -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;
>          vacrel->consider_bypass_optimization =3D true;
>          vacrel->do_index_vacuuming =3D true;
>
> Looking at the 0003 patch, we set VacuumFailsafeActive to false per table=
:
>
> +                        /*
> +                         * Ensure VacuumFailsafeActive has been reset
> before vacuuming the
> +                         * next relation relation.
> +                         */
> +                        VacuumFailsafeActive =3D false;
>
> Given that we ensure it's reset before vacuuming the next table, do we
> need to reset it in heap_vacuum_rel?

I've changed the one in heap_vacuum_rel() to an assert.

> (there is a typo; s/relation relation/relation/)

Thanks! fixed.

> > > 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 t=
his patch.
> >
> > Thanks! I think I got them all.
> >
> > > ---
> > > @@ -307,6 +309,8 @@ extern PGDLLIMPORT pg_atomic_uint32 *VacuumActive=
NWorkers;
> > >  extern PGDLLIMPORT int VacuumCostBalanceLocal;
> > >
> > >  extern bool VacuumFailsafeActive;
> > > +extern int     VacuumCostLimit;
> > > +extern double VacuumCostDelay;
> > >
> > > and
> > >
> > > @@ -266,8 +266,6 @@ extern PGDLLIMPORT int max_parallel_maintenance_w=
orkers;
> > >  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.
>
> I guess it would be better to keep both accessible for backward
> compatibility. Extensions are able to access both GUC values and
> values that are actually used for vacuum delays (as we used to use the
> same variables).

> Here are some review comments for 0002-0004 patches:
>
> 0002:
> -        if (MyWorkerInfo)
> +        if (am_autovacuum_launcher)
> +                return;
> +
> +        if (am_autovacuum_worker)
>          {
> -                VacuumCostDelay =3D MyWorkerInfo->wi_cost_delay;
>                  VacuumCostLimit =3D MyWorkerInfo->wi_cost_limit;
> +                VacuumCostDelay =3D MyWorkerInfo->wi_cost_delay;
> +        }
>
> Isn't it a bit safer to check MyWorkerInfo instead of
> am_autovacuum_worker?

Ah, since we access it. I've made the change.

> Also, I don't think there is any reason why we want to exclude only
> the autovacuum launcher.

My rationale is that the launcher is the only other process type which
might reasonably be executing this code besides autovac workers, client
backends doing VACUUM/ANALYZE, and parallel vacuum workers. Is it
confusing to have the launcher have VacuumCostLimt and VacuumCostDelay
set to the guc values for explicit VACUUM and ANALYZE -- even if the
launcher doesn't use these variables?

I've removed the check, because I do agree with you that it may be
unnecessarily confusing in the code.

> ---
> + * TODO: should VacuumCostLimit and VacuumCostDelay be initialized to va=
lid or
> + * invalid values?
>
> How about using the default value of normal backends, 200 and 0?

I've gone with this suggestion

> 0003:
>
> @@ -83,6 +84,7 @@ int                   vacuum_cost_limit;
>   */
>  int                    VacuumCostLimit =3D 0;
>  double         VacuumCostDelay =3D -1;
> +static bool vacuum_can_reload_config =3D false;
>
> In vacuum.c, we use snake case for GUC parameters and camel case for
> other global variables, so it seems better to rename it
> VacuumCanReloadConfig. Sorry, that's my fault.

I have renamed it.

> 0004:
>
> +                if (tab->at_dobalance)
> +                        pg_atomic_test_set_flag(&MyWorkerInfo->wi_dobala=
nce);
> +                else
>
> The comment of pg_atomic_test_set_flag() says that it returns false if
> the flag has not successfully been set:
>
>  * pg_atomic_test_set_flag - TAS()
>  *
>  * Returns true if the flag has successfully been set, false otherwise.
>  *
>  * Acquire (including read barrier) semantics.
>
> But IIUC we don't need to worry about that as only one process updates
> the flag, right? It might be a good idea to add some comments why we
> don't need to check the return value.

I have added this comment.

> ---
> -                if (worker->wi_proc !=3D NULL)
> -                        elog(DEBUG2, "autovac_balance_cost(pid=3D%d
> db=3D%u, rel=3D%u, dobalance=3D%s cost_limit=3D%d, cost_limit_base=3D%d,
> cost_delay=3D%g)",
> -                                 worker->wi_proc->pid,
> worker->wi_dboid, worker->wi_tableoid,
> -                                 worker->wi_dobalance ? "yes" : "no",
> -                                 worker->wi_cost_limit,
> worker->wi_cost_limit_base,
> -                                 worker->wi_cost_delay);
>
> I think it's better to keep this kind of log in some form for
> debugging. For example, we can show these values of autovacuum workers
> in VacuumUpdateCosts().

I added a message to do_autovacuum() after calling VacuumUpdateCosts()
in the loop vacuuming each table. That means it will happen once per
table. It's not ideal that I had to move the call to VacuumUpdateCosts()
behind the shared lock in that loop so that we could access the pid and
such in the logging message after updating the cost and delay, but it is
probably okay. Though noone is going to be changing those at this
point, it still seemed better to access them under the lock.

This does mean we won't log anything when we do change the values of
VacuumCostDelay and VacuumCostLimit while vacuuming a table. Is it worth
adding some code to do that in VacuumUpdateCosts() (only when the value
has changed not on every call to VacuumUpdateCosts())? Or perhaps we
could add it in the config reload branch that is already in
vacuum_delay_point()?


On Tue, Apr 4, 2023 at 9:36=E2=80=AFAM Daniel Gustafsson <daniel@yesql.se> =
wrote:
>

Thanks for the review!

> > On 4 Apr 2023, at 00:35, Melanie Plageman <melanieplageman@gmail.com> w=
rote:
> >
> > On Mon, Apr 3, 2023 at 3:08=E2=80=AFPM Andres Freund <andres@anarazel.d=
e> wrote:
> >> On 2023-04-03 14:43:14 -0400, Tom Lane wrote:
> >>> Melanie Plageman <melanieplageman@gmail.com> writes:
> >>>> v13 attached with requested updates.
> >>>
> >>> I'm afraid I'd not been paying any attention to this discussion,
> >>> but better late than never.  I'm okay with letting autovacuum
> >>> processes reload config files more often than now.  However,
> >>> I object to allowing ProcessConfigFile to be called from within
> >>> commands in a normal user backend.  The existing semantics are
> >>> that user backends respond to SIGHUP only at the start of processing
> >>> a user command, and I'm uncomfortable with suddenly deciding that
> >>> that can work differently if the command happens to be VACUUM.
> >>> It seems unprincipled and perhaps actively unsafe.
> >>
> >> I think it should be ok in commands like VACUUM that already internall=
y start
> >> their own transactions, and thus require to be run outside of a transa=
ction
> >> and at the toplevel. I share your concerns about allowing config reloa=
d in
> >> arbitrary places. While we might want to go there, it would require a =
lot more
> >> analysis.
>
> Thinking more on this I'm leaning towards going with allowing more freque=
nt
> reloads in autovacuum, and saving the same for VACUUM for more careful st=
udy.
> The general case is probably fine but I'm not convinced that there aren't=
 error
> cases which can present unpleasant scenarios.

In attached v15, I've dropped support for VACUUM and non-nested ANALYZE.
It is like a 5 line change and could be added back at any time.

> > As an alternative for your consideration, attached v14 set implements
> > the config file reload for autovacuum only (in 0003) and then enables i=
t
> > for VACUUM and ANALYZE not in a nested transaction command (in 0004).
> >
> > Previously I had the commits in the reverse order for ease of review (t=
o
> > separate changes to worker limit balancing logic from config reload
> > code).
>
> A few comments on top of already submitted reviews, will do another pass =
over
> this later today.
>
> + * VacuumFailsafeActive is a defined as a global so that we can determin=
e
> + * whether or not to re-enable cost-based vacuum delay when vacuuming a =
table.
>
> This comment should be expanded to document who we expect to inspect this
> variable in order to decide on cost-based vacuum.
>
> Moving the failsafe switch into a global context means we face the risk o=
f an
> extension changing it independently of the GUCs that control it (or the c=
ode
> relying on it) such that these are out of sync.  External code messing up
> internal state is not new and of course outside of our control, but it's =
worth
> at least considering.  There isn't too much we can do here, but perhaps e=
xpand
> this comment to include a "do not change this" note?

I've updated the comment to mention how table AM-agnostic VACUUM code
uses it and to say that table AMs can set it if they want that behavior.

> +extern bool VacuumFailsafeActive;
>
> While I agree with upthread review comments that extensions shoulnd't pok=
e at
> this, not decorating it with PGDLLEXPORT adds little protection and only =
cause
> inconsistencies in symbol exports across platforms.  We only explicitly h=
ide
> symbols in shared libraries IIRC.

I've updated this.

> +extern int VacuumCostLimit;
> +extern double VacuumCostDelay;
>  ...
> -extern PGDLLIMPORT int VacuumCostLimit;
> -extern PGDLLIMPORT double VacuumCostDelay;
>
> Same with these, I don't think this is according to our default visibilit=
y.
> Moreover, I'm not sure it's a good idea to perform this rename.  This wil=
l keep
> VacuumCostLimit and VacuumCostDelay exported, but change their meaning.  =
Any
> external code referring to these thinking they are backing the GUCs will =
still
> compile, but may be broken in subtle ways.  Is there a reason for not kee=
ping
> the current GUC variables and instead add net new ones?

When VacuumCostLimit was the same variable in the code and for the GUC
vacuum_cost_limit, everytime we reload the config file, VacuumCostLimit
is overwritten. Autovacuum workers have to overwrite this value with the
appropriate one for themselves given the balancing logic and the value
of autovacuum_vacuum_cost_limit. However, the problem is, because you
can specify -1 for autovacuum_vacuum_cost_limit to indicate it should
fall back to vacuum_cost_limit, we have to reference the value of
VacuumCostLimit when calculating the new autovacuum worker's cost limit
after a config reload.

But, you have to be sure you *only* do this after a config reload when
the value of VacuumCostLimit is fresh and unmodified or you risk
dividing the value of VacuumCostLimit over and over. That means it is
unsafe to call functions updating the cost limit more than once.

This orchestration wasn't as difficult when we only reloaded the config
file once every table. We were careful about it and also kept the
original "base" cost limit around from table_recheck_autovac(). However,
once we started reloading the config file more often, this no longer
works.

By separating the variables modified when the gucs are set and the ones
used the code, we can make sure we always have the original value the
guc was set to in vacuum_cost_limit and autovacuum_vacuum_cost_limit,
whenever we need to reference it.

That being said, perhaps we should document what extensions should do?
Do you think they will want to use the variables backing the gucs or to
be able to overwrite the variables being used in the code?

Oh, also I've annotated these with PGDLLIMPORT too.

> + * TODO: should VacuumCostLimit and VacuumCostDelay be initialized to va=
lid or
> + * invalid values?
> + */
> +int                    VacuumCostLimit =3D 0;
> +double         VacuumCostDelay =3D -1;
>
> I think the important part is to make sure they are never accessed withou=
t
> VacuumUpdateCosts having been called first.  I think that's the case here=
, but
> it's not entirely clear.  Do you see a codepath where that could happen? =
 If
> they are initialized to a sentinel value we also need to check for that, =
so
> initializing to the defaults from the corresponding GUCs seems better.

I don't see a case where autovacuum could access these without calling
VacuumUpdateCosts() first. I think the other callers of
vacuum_delay_point() are the issue (gist/gin/hash/etc).

It might need a bit more thought.

My concern was that these variables correspond to multiple GUCs each
depending on the backend type, and those backends have different
defaults (e.g. autovac workers default cost delay is different than
client backend doing vacuum cost delay).

However, what I have done in this version is initialize them to the
defaults for a client backend executing VACUUM or ANALYZE, since I am
fairly confident that autovacuum will not use them without calling
VacuumUpdateCosts().

>
> +* Update VacuumCostLimit with the correct value for an autovacuum worker=
, given
>
> Trivial whitespace error in function comment.

Fixed.

> +static double av_relopt_cost_delay =3D -1;
> +static int av_relopt_cost_limit =3D 0;
>
> These need a comment IMO, ideally one that explain why they are initializ=
ed to
> those values.

I've added a comment.

> +       /* There is at least 1 autovac worker (this worker). */
> +       Assert(nworkers_for_balance > 0);
>
> Is there a scenario where this is expected to fail?  If so I think this s=
hould
> be handled and not just an Assert.

No, this isn't expected to happen because an autovacuum worker would
have called autovac_recalculate_workers_for_balance() before calling
VacuumUpdateCosts() (which calls AutoVacuumUpdateLimit()) in
do_autovacuum(). But, if someone were to move around or add a call to
VacuumUpdateCosts() there is a chance it could happen.

- Melanie

--000000000000f8e86e05f88830c2
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v15-0001-Make-vacuum-s-failsafe_active-a-global.patch"
Content-Disposition: attachment; 
	filename="v15-0001-Make-vacuum-s-failsafe_active-a-global.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_lg2op1mj0>
X-Attachment-Id: f_lg2op1mj0
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==
--000000000000f8e86e05f88830c2
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v15-0003-Autovacuum-refreshes-cost-based-delay-params-mor.patch"
Content-Disposition: attachment; 
	filename="v15-0003-Autovacuum-refreshes-cost-based-delay-params-mor.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_lg2op1mp2>
X-Attachment-Id: f_lg2op1mp2

RnJvbSAwMTAxMzZiNWFkODQ4NTkwZTZkZmMxMzliNDVhMDAwOGUxZDJhZmI4IE1vbiBTZXAgMTcg
MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h
aWwuY29tPgpEYXRlOiBTYXQsIDI1IE1hciAyMDIzIDE0OjE0OjU1IC0wNDAwClN1YmplY3Q6IFtQ
QVRDSCB2MTUgMy8zXSBBdXRvdmFjdXVtIHJlZnJlc2hlcyBjb3N0LWJhc2VkIGRlbGF5IHBhcmFt
cyBtb3JlCiBvZnRlbgoKQWxsb3cgYXV0b3ZhY3V1bSB0byByZWxvYWQgdGhlIGNvbmZpZyBmaWxl
IG1vcmUgb2Z0ZW4gc28gdGhhdCBjb3N0LWJhc2VkCmRlbGF5IHBhcmFtZXRlcnMgY2FuIHRha2Ug
ZWZmZWN0IHdoaWxlIFZBQ1VVTWluZyBhIHJlbGF0aW9uLiBQcmV2aW91c2x5CmF1dG92YWN1dW0g
d29ya2VycyBvbmx5IHJlbG9hZGVkIHRoZSBjb25maWcgZmlsZSBvbmNlIHBlciByZWxhdGlvbgp2
YWN1dW1lZCwgc28gY29uZmlnIGNoYW5nZXMgY291bGQgbm90IHRha2UgZWZmZWN0IHVudGlsIGJl
Z2lubmluZyB0bwp2YWN1dW0gdGhlIG5leHQgdGFibGUuCgpOb3csIGNoZWNrIGlmIGEgcmVsb2Fk
IGlzIHBlbmRpbmcgcm91Z2hseSBvbmNlIHBlciBibG9jaywgd2hlbiBjaGVja2luZwppZiB3ZSBu
ZWVkIHRvIGRlbGF5LgoKSW4gb3JkZXIgZm9yIGF1dG92YWN1dW0gd29ya2VycyB0byBzYWZlbHkg
dXBkYXRlIHRoZWlyIG93biBjb3N0IGRlbGF5CmFuZCBjb3N0IGxpbWl0IHBhcmFtZXRlcnMgd2l0
aG91dCBpbXBhY3RpbmcgcGVyZm9ybWFuY2UsIHdlIGhhZCB0bwpyZXRoaW5rIHdoZW4gYW5kIGhv
dyB0aGVzZSB2YWx1ZXMgd2VyZSBhY2Nlc3NlZC4KClByZXZpb3VzbHksIGFuIGF1dG92YWN1dW0g
d29ya2VyJ3Mgd2lfY29zdF9saW1pdCB3YXMgc2V0IG9ubHkgYXQgdGhlCmJlZ2lubmluZyBvZiB2
YWN1dW1pbmcgYSB0YWJsZSwgYWZ0ZXIgcmVsb2FkaW5nIHRoZSBjb25maWcgZmlsZS4KVGhlcmVm
b3JlLCBhdCB0aGUgdGltZSB0aGF0IGF1dG92YWNfYmFsYW5jZV9jb3N0KCkgaXMgY2FsbGVkLCB3
b3JrZXJzCnZhY3V1bWluZyB0YWJsZXMgd2l0aCBubyB0YWJsZSBvcHRpb25zIGNvdWxkIHN0aWxs
IGhhdmUgZGlmZmVyZW50IHZhbHVlcwpmb3IgdGhlaXIgd2lfY29zdF9saW1pdF9iYXNlIGFuZCB3
aV9jb3N0X2RlbGF5LgoKTm93IHRoYXQgdGhlIGNvc3QgcGFyYW1ldGVycyBjYW4gYmUgdXBkYXRl
ZCB3aGlsZSB2YWN1dW1pbmcgYSB0YWJsZSwKd29ya2VycyB3aWxsICh3aXRoaW4gc29tZSBtYXJn
aW4gb2YgZXJyb3IpIGhhdmUgbm8gcmVhc29uIHRvIGhhdmUKZGlmZmVyZW50IHZhbHVlcyBmb3Ig
Y29zdCBsaW1pdCBhbmQgY29zdCBkZWxheSAoaW4gdGhlIGFic2VuY2Ugb2YgdGFibGUKb3B0aW9u
cykuIFRoaXMgcmVtb3ZlcyB0aGUgcmF0aW9uYWxlIGZvciBrZWVwaW5nIGNvc3QgbGltaXQgYW5k
IGNvc3QKZGVsYXkgaW4gc2hhcmVkIG1lbW9yeS4gQmFsYW5jaW5nIHRoZSBjb3N0IGxpbWl0IHJl
cXVpcmVzIG9ubHkgdGhlCm51bWJlciBvZiBhY3RpdmUgYXV0b3ZhY3V1bSB3b3JrZXJzIHZhY3V1
bWluZyBhIHRhYmxlIHdpdGggbm8gY29zdC1iYXNlZAp0YWJsZSBvcHRpb25zLgoKUmV2aWV3ZWQt
Ynk6IE1hc2FoaWtvIFNhd2FkYSA8c2F3YWRhLm1zaGtAZ21haWwuY29tPgpSZXZpZXdlZC1ieTog
S3lvdGFybyBIb3JpZ3VjaGkgPGhvcmlreW90YS5udHRAZ21haWwuY29tPgpSZXZpZXdlZC1ieTog
RGFuaWVsIEd1c3RhZnNzb24gPGRhbmllbEB5ZXNxbC5zZT4KRGlzY3Vzc2lvbjogaHR0cHM6Ly93
d3cucG9zdGdyZXNxbC5vcmcvbWVzc2FnZS1pZC9mbGF0L0NBQUtSdV9abmd6cW5FT0RjN0xtUzFO
SDA0S3Q2WTlodVNqejVwcDclMkJEWGhyakRBMGd3JTQwbWFpbC5nbWFpbC5jb20KLS0tCiBzcmMv
YmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgIHwgICAyICstCiBzcmMvYmFja2VuZC9j
b21tYW5kcy92YWN1dW0uYyAgICAgICAgIHwgIDQ0ICsrKystCiBzcmMvYmFja2VuZC9jb21tYW5k
cy92YWN1dW1wYXJhbGxlbC5jIHwgICAxIC0KIHNyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3Zh
Y3V1bS5jICAgfCAyNjYgKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0KIHNyYy9pbmNsdWRlL2Nv
bW1hbmRzL3ZhY3V1bS5oICAgICAgICAgfCAgIDEgKwogNSBmaWxlcyBjaGFuZ2VkLCAxOTYgaW5z
ZXJ0aW9ucygrKSwgMTE4IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2Fj
Y2Vzcy9oZWFwL3ZhY3V1bWxhenkuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxh
enkuYwppbmRleCAyYmE4NWJkM2Q2Li4wYTllYmQyMmJkIDEwMDY0NAotLS0gYS9zcmMvYmFja2Vu
ZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAv
dmFjdXVtbGF6eS5jCkBAIC0zODksNyArMzg5LDcgQEAgaGVhcF92YWN1dW1fcmVsKFJlbGF0aW9u
IHJlbCwgVmFjdXVtUGFyYW1zICpwYXJhbXMsCiAJQXNzZXJ0KHBhcmFtcy0+aW5kZXhfY2xlYW51
cCAhPSBWQUNPUFRWQUxVRV9VTlNQRUNJRklFRCk7CiAJQXNzZXJ0KHBhcmFtcy0+dHJ1bmNhdGUg
IT0gVkFDT1BUVkFMVUVfVU5TUEVDSUZJRUQgJiYKIAkJICAgcGFyYW1zLT50cnVuY2F0ZSAhPSBW
QUNPUFRWQUxVRV9BVVRPKTsKLQlWYWN1dW1GYWlsc2FmZUFjdGl2ZSA9IGZhbHNlOworCUFzc2Vy
dCghVmFjdXVtRmFpbHNhZmVBY3RpdmUpOwogCXZhY3JlbC0+Y29uc2lkZXJfYnlwYXNzX29wdGlt
aXphdGlvbiA9IHRydWU7CiAJdmFjcmVsLT5kb19pbmRleF92YWN1dW1pbmcgPSB0cnVlOwogCXZh
Y3JlbC0+ZG9faW5kZXhfY2xlYW51cCA9IHRydWU7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9j
b21tYW5kcy92YWN1dW0uYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCmluZGV4IGIx
ZmM3YTBlZmMuLjk5NjRjOWVhNGQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3Zh
Y3V1bS5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCkBAIC00OCw2ICs0OCw3
IEBACiAjaW5jbHVkZSAicGdzdGF0LmgiCiAjaW5jbHVkZSAicG9zdG1hc3Rlci9hdXRvdmFjdXVt
LmgiCiAjaW5jbHVkZSAicG9zdG1hc3Rlci9iZ3dvcmtlcl9pbnRlcm5hbHMuaCIKKyNpbmNsdWRl
ICJwb3N0bWFzdGVyL2ludGVycnVwdC5oIgogI2luY2x1ZGUgInN0b3JhZ2UvYnVmbWdyLmgiCiAj
aW5jbHVkZSAic3RvcmFnZS9sbWdyLmgiCiAjaW5jbHVkZSAic3RvcmFnZS9wbXNpZ25hbC5oIgpA
QCAtNTEyLDkgKzUxMyw5IEBAIHZhY3V1bShMaXN0ICpyZWxhdGlvbnMsIFZhY3V1bVBhcmFtcyAq
cGFyYW1zLAogCXsKIAkJTGlzdENlbGwgICAqY3VyOwogCi0JCVZhY3V1bVVwZGF0ZUNvc3RzKCk7
CiAJCWluX3ZhY3V1bSA9IHRydWU7Ci0JCVZhY3V1bUNvc3RBY3RpdmUgPSAoVmFjdXVtQ29zdERl
bGF5ID4gMCk7CisJCVZhY3V1bUZhaWxzYWZlQWN0aXZlID0gZmFsc2U7CisJCVZhY3V1bVVwZGF0
ZUNvc3RzKCk7CiAJCVZhY3V1bUNvc3RCYWxhbmNlID0gMDsKIAkJVmFjdXVtUGFnZUhpdCA9IDA7
CiAJCVZhY3V1bVBhZ2VNaXNzID0gMDsKQEAgLTU2OCwxMiArNTY5LDIwIEBAIHZhY3V1bShMaXN0
ICpyZWxhdGlvbnMsIFZhY3V1bVBhcmFtcyAqcGFyYW1zLAogCQkJCQlDb21tYW5kQ291bnRlcklu
Y3JlbWVudCgpOwogCQkJCX0KIAkJCX0KKworCQkJLyoKKwkJCSAqIEVuc3VyZSBWYWN1dW1GYWls
c2FmZUFjdGl2ZSBoYXMgYmVlbiByZXNldCBiZWZvcmUgdmFjdXVtaW5nIHRoZQorCQkJICogbmV4
dCByZWxhdGlvbi4KKwkJCSAqLworCQkJVmFjdXVtRmFpbHNhZmVBY3RpdmUgPSBmYWxzZTsKIAkJ
fQogCX0KIAlQR19GSU5BTExZKCk7CiAJewogCQlpbl92YWN1dW0gPSBmYWxzZTsKIAkJVmFjdXVt
Q29zdEFjdGl2ZSA9IGZhbHNlOworCQlWYWN1dW1GYWlsc2FmZUFjdGl2ZSA9IGZhbHNlOworCQlW
YWN1dW1Db3N0QmFsYW5jZSA9IDA7CiAJfQogCVBHX0VORF9UUlkoKTsKIApAQCAtMjI0MCw3ICsy
MjQ5LDI3IEBAIHZhY3V1bV9kZWxheV9wb2ludCh2b2lkKQogCS8qIEFsd2F5cyBjaGVjayBmb3Ig
aW50ZXJydXB0cyAqLwogCUNIRUNLX0ZPUl9JTlRFUlJVUFRTKCk7CiAKLQlpZiAoIVZhY3V1bUNv
c3RBY3RpdmUgfHwgSW50ZXJydXB0UGVuZGluZykKKwlpZiAoSW50ZXJydXB0UGVuZGluZyB8fAor
CQkoIVZhY3V1bUNvc3RBY3RpdmUgJiYgIUNvbmZpZ1JlbG9hZFBlbmRpbmcpKQorCQlyZXR1cm47
CisKKwkvKgorCSAqIFJlbG9hZCB0aGUgY29uZmlndXJhdGlvbiBmaWxlIGlmIHJlcXVlc3RlZC4g
VGhpcyBhbGxvd3MgY2hhbmdlcyB0bworCSAqIGF1dG92YWN1dW1fdmFjdXVtX2Nvc3RfbGltaXQg
YW5kIGF1dG92YWN1dW1fdmFjdXVtX2Nvc3RfZGVsYXkgdG8gdGFrZQorCSAqIGVmZmVjdCB3aGls
ZSBhIHRhYmxlIGlzIGJlaW5nIHZhY3V1bWVkIG9yIGFuYWx5emVkLgorCSAqLworCWlmIChDb25m
aWdSZWxvYWRQZW5kaW5nICYmIElzQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSkKKwl7CisJCUNv
bmZpZ1JlbG9hZFBlbmRpbmcgPSBmYWxzZTsKKwkJUHJvY2Vzc0NvbmZpZ0ZpbGUoUEdDX1NJR0hV
UCk7CisJCVZhY3V1bVVwZGF0ZUNvc3RzKCk7CisJfQorCisJLyoKKwkgKiBJZiB3ZSBkaXNhYmxl
ZCBjb3N0LWJhc2VkIGRlbGF5cyBhZnRlciByZWxvYWRpbmcgdGhlIGNvbmZpZyBmaWxlLAorCSAq
IHJldHVybi4KKwkgKi8KKwlpZiAoIVZhY3V1bUNvc3RBY3RpdmUpCiAJCXJldHVybjsKIAogCS8q
CkBAIC0yMjczLDcgKzIzMDIsMTQgQEAgdmFjdXVtX2RlbGF5X3BvaW50KHZvaWQpCiAKIAkJVmFj
dXVtQ29zdEJhbGFuY2UgPSAwOwogCi0JCVZhY3V1bVVwZGF0ZUNvc3RzKCk7CisJCS8qCisJCSAq
IEJhbGFuY2UgYW5kIHVwZGF0ZSBsaW1pdCB2YWx1ZXMgZm9yIGF1dG92YWN1dW0gd29ya2Vycy4g
V2UgbXVzdAorCQkgKiBhbHdheXMgZG8gdGhpcyBpbiBjYXNlIHRoZSBhdXRvdmFjdXVtIGxhdW5j
aGVyIG9yIGFub3RoZXIKKwkJICogYXV0b3ZhY3V1bSB3b3JrZXIgaGFzIHJlY2FsY3VsYXRlZCB0
aGUgbnVtYmVyIG9mIHdvcmtlcnMgYWNyb3NzCisJCSAqIHdoaWNoIHdlIG11c3QgYmFsYW5jZSB0
aGUgbGltaXQuIFRoaXMgaXMgZG9uZSBieSB0aGUgbGF1bmNoZXIgd2hlbgorCQkgKiBsYXVuY2hp
bmcgYSBuZXcgd29ya2VyIGFuZCBieSB3b3JrZXJzIGJlZm9yZSB2YWN1dW1pbmcgZWFjaCB0YWJs
ZS4KKwkJICovCisJCUF1dG9WYWN1dW1VcGRhdGVMaW1pdCgpOwogCiAJCS8qIE1pZ2h0IGhhdmUg
Z290dGVuIGFuIGludGVycnVwdCB3aGlsZSBzbGVlcGluZyAqLwogCQlDSEVDS19GT1JfSU5URVJS
VVBUUygpOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwu
YyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKaW5kZXggMGI1OWM5MjJl
NC4uZTIwMGQ1Y2FmOCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFy
YWxsZWwuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC05
OTUsNyArOTk1LDYgQEAgcGFyYWxsZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2ht
X3RvYyAqdG9jKQogCQkJCQkJCQkJCQkJIGZhbHNlKTsKIAogCS8qIFNldCBjb3N0LWJhc2VkIHZh
Y3V1bSBkZWxheSAqLwotCVZhY3V1bUNvc3RBY3RpdmUgPSAoVmFjdXVtQ29zdERlbGF5ID4gMCk7
CiAJVmFjdXVtVXBkYXRlQ29zdHMoKTsKIAlWYWN1dW1Db3N0QmFsYW5jZSA9IDA7CiAJVmFjdXVt
UGFnZUhpdCA9IDA7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1
dW0uYyBiL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCmluZGV4IGNlN2UwMDk1
NzYuLjBjMWU0NjUyZmIgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3Zh
Y3V1bS5jCisrKyBiL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCkBAIC0xMzks
NiArMTM5LDE3IEBAIGludAkJCUxvZ19hdXRvdmFjdXVtX21pbl9kdXJhdGlvbiA9IDYwMDAwMDsK
IHN0YXRpYyBib29sIGFtX2F1dG92YWN1dW1fbGF1bmNoZXIgPSBmYWxzZTsKIHN0YXRpYyBib29s
IGFtX2F1dG92YWN1dW1fd29ya2VyID0gZmFsc2U7CiAKKy8qCisgKiBWYXJpYWJsZXMgdG8gc2F2
ZSB0aGUgY29zdC1yZWxhdGVkIHRhYmxlIG9wdGlvbnMgZm9yIHRoZSBjdXJyZW50IHJlbGF0aW9u
CisgKiBiZWluZyB2YWN1dW1lZCBieSB0aGlzIGF1dG92YWN1dW0gd29ya2VyLiBVc2luZyB0aGVz
ZSwgd2UgY2FuIGVuc3VyZSB3ZQorICogZG9uJ3Qgb3ZlcndyaXRlIHRoZSB2YWx1ZXMgb2YgVmFj
dXVtQ29zdERlbGF5IGFuZCBWYWN1dW1Db3N0TGltaXQgYWZ0ZXIKKyAqIHJlbG9hZGluZyB0aGUg
Y29uZmlndXJhdGlvbiBmaWxlLiBUaGV5IGFyZSBpbml0aWFsaXplZCB0byAiaW52YWxpZCIgdmFs
dWVzCisgKiB0byBpbmRpY2F0ZSBubyB0YWJsZSBvcHRpb25zIHdlcmUgc3BlY2lmaWVkIGFuZCB3
aWxsIGJlIHNldCBpbgorICogZG9fYXV0b3ZhY3V1bSgpIGFmdGVyIGNoZWNraW5nIHRoZSB0YWJs
ZSBvcHRpb25zIGluIHRhYmxlX3JlY2hlY2tfYXV0b3ZhYygpLgorICovCitzdGF0aWMgZG91Ymxl
IGF2X3JlbG9wdF9jb3N0X2RlbGF5ID0gLTE7CitzdGF0aWMgaW50CWF2X3JlbG9wdF9jb3N0X2xp
bWl0ID0gMDsKKwogLyogRmxhZ3Mgc2V0IGJ5IHNpZ25hbCBoYW5kbGVycyAqLwogc3RhdGljIHZv
bGF0aWxlIHNpZ19hdG9taWNfdCBnb3RfU0lHVVNSMiA9IGZhbHNlOwogCkBAIC0xODksOCArMjAw
LDggQEAgdHlwZWRlZiBzdHJ1Y3QgYXV0b3ZhY190YWJsZQogewogCU9pZAkJCWF0X3JlbGlkOwog
CVZhY3V1bVBhcmFtcyBhdF9wYXJhbXM7Ci0JZG91YmxlCQlhdF92YWN1dW1fY29zdF9kZWxheTsK
LQlpbnQJCQlhdF92YWN1dW1fY29zdF9saW1pdDsKKwlkb3VibGUJCWF0X3JlbG9wdF92YWNfY29z
dF9kZWxheTsKKwlpbnQJCQlhdF9yZWxvcHRfdmFjX2Nvc3RfbGltaXQ7CiAJYm9vbAkJYXRfZG9i
YWxhbmNlOwogCWJvb2wJCWF0X3NoYXJlZHJlbDsKIAljaGFyCSAgICphdF9yZWxuYW1lOwpAQCAt
MjA5LDcgKzIyMCw3IEBAIHR5cGVkZWYgc3RydWN0IGF1dG92YWNfdGFibGUKICAqIHdpX3NoYXJl
ZHJlbCBmbGFnIGluZGljYXRpbmcgd2hldGhlciB0YWJsZSBpcyBtYXJrZWQgcmVsaXNzaGFyZWQK
ICAqIHdpX3Byb2MJCXBvaW50ZXIgdG8gUEdQUk9DIG9mIHRoZSBydW5uaW5nIHdvcmtlciwgTlVM
TCBpZiBub3Qgc3RhcnRlZAogICogd2lfbGF1bmNodGltZSBUaW1lIGF0IHdoaWNoIHRoaXMgd29y
a2VyIHdhcyBsYXVuY2hlZAotICogd2lfY29zdF8qCVZhY3V1bSBjb3N0LWJhc2VkIGRlbGF5IHBh
cmFtZXRlcnMgY3VycmVudCBpbiB0aGlzIHdvcmtlcgorICogd2lfZG9iYWxhbmNlIFdoZXRoZXIg
dGhpcyB3b3JrZXIgc2hvdWxkIGJlIGluY2x1ZGVkIGluIGJhbGFuY2UgY2FsY3VsYXRpb25zCiAg
KgogICogQWxsIGZpZWxkcyBhcmUgcHJvdGVjdGVkIGJ5IEF1dG92YWN1dW1Mb2NrLCBleGNlcHQg
Zm9yIHdpX3RhYmxlb2lkIGFuZAogICogd2lfc2hhcmVkcmVsIHdoaWNoIGFyZSBwcm90ZWN0ZWQg
YnkgQXV0b3ZhY3V1bVNjaGVkdWxlTG9jayAobm90ZSB0aGVzZQpAQCAtMjIzLDExICsyMzQsOCBA
QCB0eXBlZGVmIHN0cnVjdCBXb3JrZXJJbmZvRGF0YQogCU9pZAkJCXdpX3RhYmxlb2lkOwogCVBH
UFJPQwkgICAqd2lfcHJvYzsKIAlUaW1lc3RhbXBUeiB3aV9sYXVuY2h0aW1lOwotCWJvb2wJCXdp
X2RvYmFsYW5jZTsKKwlwZ19hdG9taWNfZmxhZyB3aV9kb2JhbGFuY2U7CiAJYm9vbAkJd2lfc2hh
cmVkcmVsOwotCWRvdWJsZQkJd2lfY29zdF9kZWxheTsKLQlpbnQJCQl3aV9jb3N0X2xpbWl0Owot
CWludAkJCXdpX2Nvc3RfbGltaXRfYmFzZTsKIH0gV29ya2VySW5mb0RhdGE7CiAKIHR5cGVkZWYg
c3RydWN0IFdvcmtlckluZm9EYXRhICpXb3JrZXJJbmZvOwpAQCAtMjczLDYgKzI4MSw4IEBAIHR5
cGVkZWYgc3RydWN0IEF1dG9WYWN1dW1Xb3JrSXRlbQogICogYXZfc3RhcnRpbmdXb3JrZXIgcG9p
bnRlciB0byBXb3JrZXJJbmZvIGN1cnJlbnRseSBiZWluZyBzdGFydGVkIChjbGVhcmVkIGJ5CiAg
KgkJCQkJdGhlIHdvcmtlciBpdHNlbGYgYXMgc29vbiBhcyBpdCdzIHVwIGFuZCBydW5uaW5nKQog
ICogYXZfd29ya0l0ZW1zCQl3b3JrIGl0ZW0gYXJyYXkKKyAqIGF2X253b3JrZXJzRm9yQmFsYW5j
ZSB0aGUgbnVtYmVyIG9mIGF1dG92YWN1dW0gd29ya2VycyB0byB1c2Ugd2hlbgorICogCQkJCQlj
YWxjdWxhdGluZyB0aGUgcGVyIHdvcmtlciBjb3N0IGxpbWl0CiAgKgogICogVGhpcyBzdHJ1Y3Qg
aXMgcHJvdGVjdGVkIGJ5IEF1dG92YWN1dW1Mb2NrLCBleGNlcHQgZm9yIGF2X3NpZ25hbCBhbmQg
cGFydHMKICAqIG9mIHRoZSB3b3JrZXIgbGlzdCAoc2VlIGFib3ZlKS4KQEAgLTI4Niw2ICsyOTYs
NyBAQCB0eXBlZGVmIHN0cnVjdAogCWRsaXN0X2hlYWQJYXZfcnVubmluZ1dvcmtlcnM7CiAJV29y
a2VySW5mbwlhdl9zdGFydGluZ1dvcmtlcjsKIAlBdXRvVmFjdXVtV29ya0l0ZW0gYXZfd29ya0l0
ZW1zW05VTV9XT1JLSVRFTVNdOworCXBnX2F0b21pY191aW50MzIgYXZfbndvcmtlcnNGb3JCYWxh
bmNlOwogfSBBdXRvVmFjdXVtU2htZW1TdHJ1Y3Q7CiAKIHN0YXRpYyBBdXRvVmFjdXVtU2htZW1T
dHJ1Y3QgKkF1dG9WYWN1dW1TaG1lbTsKQEAgLTMxOSw3ICszMzAsNyBAQCBzdGF0aWMgdm9pZCBs
YXVuY2hfd29ya2VyKFRpbWVzdGFtcFR6IG5vdyk7CiBzdGF0aWMgTGlzdCAqZ2V0X2RhdGFiYXNl
X2xpc3Qodm9pZCk7CiBzdGF0aWMgdm9pZCByZWJ1aWxkX2RhdGFiYXNlX2xpc3QoT2lkIG5ld2Ri
KTsKIHN0YXRpYyBpbnQJZGJfY29tcGFyYXRvcihjb25zdCB2b2lkICphLCBjb25zdCB2b2lkICpi
KTsKLXN0YXRpYyB2b2lkIGF1dG92YWNfYmFsYW5jZV9jb3N0KHZvaWQpOworc3RhdGljIHZvaWQg
YXV0b3ZhY19yZWNhbGN1bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNlKHZvaWQpOwogCiBzdGF0aWMg
dm9pZCBkb19hdXRvdmFjdXVtKHZvaWQpOwogc3RhdGljIHZvaWQgRnJlZVdvcmtlckluZm8oaW50
IGNvZGUsIERhdHVtIGFyZyk7CkBAIC02NzAsNyArNjgxLDcgQEAgQXV0b1ZhY0xhdW5jaGVyTWFp
bihpbnQgYXJnYywgY2hhciAqYXJndltdKQogCQkJewogCQkJCUxXTG9ja0FjcXVpcmUoQXV0b3Zh
Y3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7CiAJCQkJQXV0b1ZhY3V1bVNobWVtLT5hdl9zaWduYWxb
QXV0b1ZhY1JlYmFsYW5jZV0gPSBmYWxzZTsKLQkJCQlhdXRvdmFjX2JhbGFuY2VfY29zdCgpOwor
CQkJCWF1dG92YWNfcmVjYWxjdWxhdGVfd29ya2Vyc19mb3JfYmFsYW5jZSgpOwogCQkJCUxXTG9j
a1JlbGVhc2UoQXV0b3ZhY3V1bUxvY2spOwogCQkJfQogCkBAIC04MjAsOCArODMxLDggQEAgSGFu
ZGxlQXV0b1ZhY0xhdW5jaGVySW50ZXJydXB0cyh2b2lkKQogCQkJQXV0b1ZhY0xhdW5jaGVyU2h1
dGRvd24oKTsKIAogCQkvKiByZWJhbGFuY2UgaW4gY2FzZSB0aGUgZGVmYXVsdCBjb3N0IHBhcmFt
ZXRlcnMgY2hhbmdlZCAqLwotCQlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2NrLCBMV19FWENM
VVNJVkUpOwotCQlhdXRvdmFjX2JhbGFuY2VfY29zdCgpOworCQlMV0xvY2tBY3F1aXJlKEF1dG92
YWN1dW1Mb2NrLCBMV19TSEFSRUQpOworCQlhdXRvdmFjX3JlY2FsY3VsYXRlX3dvcmtlcnNfZm9y
X2JhbGFuY2UoKTsKIAkJTFdMb2NrUmVsZWFzZShBdXRvdmFjdXVtTG9jayk7CiAKIAkJLyogcmVi
dWlsZCB0aGUgbGlzdCBpbiBjYXNlIHRoZSBuYXB0aW1lIGNoYW5nZWQgKi8KQEAgLTE3NTUsMTAg
KzE3NjYsNyBAQCBGcmVlV29ya2VySW5mbyhpbnQgY29kZSwgRGF0dW0gYXJnKQogCQlNeVdvcmtl
ckluZm8tPndpX3NoYXJlZHJlbCA9IGZhbHNlOwogCQlNeVdvcmtlckluZm8tPndpX3Byb2MgPSBO
VUxMOwogCQlNeVdvcmtlckluZm8tPndpX2xhdW5jaHRpbWUgPSAwOwotCQlNeVdvcmtlckluZm8t
PndpX2RvYmFsYW5jZSA9IGZhbHNlOwotCQlNeVdvcmtlckluZm8tPndpX2Nvc3RfZGVsYXkgPSAw
OwotCQlNeVdvcmtlckluZm8tPndpX2Nvc3RfbGltaXQgPSAwOwotCQlNeVdvcmtlckluZm8tPndp
X2Nvc3RfbGltaXRfYmFzZSA9IDA7CisJCXBnX2F0b21pY19jbGVhcl9mbGFnKCZNeVdvcmtlcklu
Zm8tPndpX2RvYmFsYW5jZSk7CiAJCWRsaXN0X3B1c2hfaGVhZCgmQXV0b1ZhY3V1bVNobWVtLT5h
dl9mcmVlV29ya2VycywKIAkJCQkJCSZNeVdvcmtlckluZm8tPndpX2xpbmtzKTsKIAkJLyogbm90
IG1pbmUgYW55bW9yZSAqLwpAQCAtMTc4NCw5NyArMTc5MiwxMTkgQEAgVmFjdXVtVXBkYXRlQ29z
dHModm9pZCkKIHsKIAlpZiAoTXlXb3JrZXJJbmZvKQogCXsKLQkJVmFjdXVtQ29zdERlbGF5ID0g
TXlXb3JrZXJJbmZvLT53aV9jb3N0X2RlbGF5OwotCQlWYWN1dW1Db3N0TGltaXQgPSBNeVdvcmtl
ckluZm8tPndpX2Nvc3RfbGltaXQ7CisJCWlmIChhdl9yZWxvcHRfY29zdF9kZWxheSA+PSAwKQor
CQkJVmFjdXVtQ29zdERlbGF5ID0gYXZfcmVsb3B0X2Nvc3RfZGVsYXk7CisJCWVsc2UgaWYgKGF1
dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkgPj0gMCkKKwkJCVZhY3V1bUNvc3REZWxheSA9IGF1dG92
YWN1dW1fdmFjX2Nvc3RfZGVsYXk7CisJCWVsc2UKKwkJCS8qIGZhbGwgYmFjayB0byB2YWN1dW1f
Y29zdF9kZWxheSAqLworCQkJVmFjdXVtQ29zdERlbGF5ID0gdmFjdXVtX2Nvc3RfZGVsYXk7CisK
KwkJQXV0b1ZhY3V1bVVwZGF0ZUxpbWl0KCk7CiAJfQogCWVsc2UKIAl7CiAJCS8qIE11c3QgYmUg
ZXhwbGljaXQgVkFDVVVNIG9yIEFOQUxZWkUgKi8KLQkJVmFjdXVtQ29zdExpbWl0ID0gdmFjdXVt
X2Nvc3RfbGltaXQ7CiAJCVZhY3V1bUNvc3REZWxheSA9IHZhY3V1bV9jb3N0X2RlbGF5OworCQlW
YWN1dW1Db3N0TGltaXQgPSB2YWN1dW1fY29zdF9saW1pdDsKKwl9CisKKwkvKgorCSAqIElmIGNv
bmZpZ3VyYXRpb24gY2hhbmdlcyBhcmUgYWxsb3dlZCB0byBpbXBhY3QgVmFjdXVtQ29zdEFjdGl2
ZSwgbWFrZQorCSAqIHN1cmUgaXQgaXMgdXBkYXRlZC4KKwkgKi8KKwlpZiAoVmFjdXVtRmFpbHNh
ZmVBY3RpdmUpCisJeworCQlBc3NlcnQoIVZhY3V1bUNvc3RBY3RpdmUpOworCQlyZXR1cm47CisJ
fQorCisJaWYgKFZhY3V1bUNvc3REZWxheSA+IDApCisJCVZhY3V1bUNvc3RBY3RpdmUgPSB0cnVl
OworCWVsc2UKKwl7CisJCVZhY3V1bUNvc3RBY3RpdmUgPSBmYWxzZTsKKwkJVmFjdXVtQ29zdEJh
bGFuY2UgPSAwOwogCX0KIH0KIAogLyoKLSAqIGF1dG92YWNfYmFsYW5jZV9jb3N0Ci0gKgkJUmVj
YWxjdWxhdGUgdGhlIGNvc3QgbGltaXQgc2V0dGluZyBmb3IgZWFjaCBhY3RpdmUgd29ya2VyLgot
ICoKLSAqIENhbGxlciBtdXN0IGhvbGQgdGhlIEF1dG92YWN1dW1Mb2NrIGluIGV4Y2x1c2l2ZSBt
b2RlLgorICogVXBkYXRlIFZhY3V1bUNvc3RMaW1pdCB3aXRoIHRoZSBjb3JyZWN0IHZhbHVlIGZv
ciBhbiBhdXRvdmFjdXVtIHdvcmtlciwgZ2l2ZW4KKyAqIHRoZSB2YWx1ZSBvZiBvdGhlciByZWxl
dmFudCBjb3N0IGxpbWl0IHBhcmFtZXRlcnMgYW5kIHRoZSBudW1iZXIgb2Ygd29ya2VycworICog
YWNyb3NzIHdoaWNoIHRoZSBsaW1pdCBtdXN0IGJlIGJhbGFuY2VkLiBBdXRvdmFjdXVtIHdvcmtl
cnMgbXVzdCBjYWxsIHRoaXMKKyAqIHJlZ3VsYXJseSBpbiBjYXNlIGF2X253b3JrZXJzX2Zvcl9i
YWxhbmNlIGhhcyBiZWVuIHVwZGF0ZWQgYnkgYW5vdGhlciB3b3JrZXIKKyAqIG9yIGJ5IHRoZSBh
dXRvdmFjdXVtIGxhdW5jaGVyLiBUaGV5IG11c3QgYWxzbyBjYWxsIGl0IGFmdGVyIGEgY29uZmln
IHJlbG9hZC4KICAqLwotc3RhdGljIHZvaWQKLWF1dG92YWNfYmFsYW5jZV9jb3N0KHZvaWQpCit2
b2lkCitBdXRvVmFjdXVtVXBkYXRlTGltaXQodm9pZCkKIHsKKwlpZiAoIU15V29ya2VySW5mbykK
KwkJcmV0dXJuOworCiAJLyoKLQkgKiBUaGUgaWRlYSBoZXJlIGlzIHRoYXQgd2UgcmF0aW9uIG91
dCBJL08gZXF1YWxseS4gIFRoZSBhbW91bnQgb2YgSS9PCi0JICogdGhhdCBhIHdvcmtlciBjYW4g
Y29uc3VtZSBpcyBkZXRlcm1pbmVkIGJ5IGNvc3RfbGltaXQvY29zdF9kZWxheSwgc28gd2UKLQkg
KiB0cnkgdG8gZXF1YWxpemUgdGhvc2UgcmF0aW9zIHJhdGhlciB0aGFuIHRoZSByYXcgbGltaXQg
c2V0dGluZ3MuCi0JICoKIAkgKiBub3RlOiBpbiBjb3N0X2xpbWl0LCB6ZXJvIGFsc28gbWVhbnMg
dXNlIHZhbHVlIGZyb20gZWxzZXdoZXJlLCBiZWNhdXNlCiAJICogemVybyBpcyBub3QgYSB2YWxp
ZCB2YWx1ZS4KIAkgKi8KLQlpbnQJCQl2YWNfY29zdF9saW1pdCA9IChhdXRvdmFjdXVtX3ZhY19j
b3N0X2xpbWl0ID4gMCA/Ci0JCQkJCQkJCSAgYXV0b3ZhY3V1bV92YWNfY29zdF9saW1pdCA6IHZh
Y3V1bV9jb3N0X2xpbWl0KTsKLQlkb3VibGUJCXZhY19jb3N0X2RlbGF5ID0gKGF1dG92YWN1dW1f
dmFjX2Nvc3RfZGVsYXkgPj0gMCA/Ci0JCQkJCQkJCSAgYXV0b3ZhY3V1bV92YWNfY29zdF9kZWxh
eSA6IHZhY3V1bV9jb3N0X2RlbGF5KTsKLQlkb3VibGUJCWNvc3RfdG90YWw7Ci0JZG91YmxlCQlj
b3N0X2F2YWlsOwotCWRsaXN0X2l0ZXIJaXRlcjsKIAotCS8qIG5vdCBzZXQ/IG5vdGhpbmcgdG8g
ZG8gKi8KLQlpZiAodmFjX2Nvc3RfbGltaXQgPD0gMCB8fCB2YWNfY29zdF9kZWxheSA8PSAwKQot
CQlyZXR1cm47Ci0KLQkvKiBjYWxjdWxhdGUgdGhlIHRvdGFsIGJhc2UgY29zdCBsaW1pdCBvZiBw
YXJ0aWNpcGF0aW5nIGFjdGl2ZSB3b3JrZXJzICovCi0JY29zdF90b3RhbCA9IDAuMDsKLQlkbGlz
dF9mb3JlYWNoKGl0ZXIsICZBdXRvVmFjdXVtU2htZW0tPmF2X3J1bm5pbmdXb3JrZXJzKQorCWlm
IChhdl9yZWxvcHRfY29zdF9saW1pdCA+IDApCisJCVZhY3V1bUNvc3RMaW1pdCA9IGF2X3JlbG9w
dF9jb3N0X2xpbWl0OworCWVsc2UKIAl7Ci0JCVdvcmtlckluZm8Jd29ya2VyID0gZGxpc3RfY29u
dGFpbmVyKFdvcmtlckluZm9EYXRhLCB3aV9saW5rcywgaXRlci5jdXIpOworCQlpbnQJCQlud29y
a2Vyc19mb3JfYmFsYW5jZTsKKworCQlpZiAoYXV0b3ZhY3V1bV92YWNfY29zdF9saW1pdCA+IDAp
CisJCQlWYWN1dW1Db3N0TGltaXQgPSBhdXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0OworCQllbHNl
CisJCQlWYWN1dW1Db3N0TGltaXQgPSB2YWN1dW1fY29zdF9saW1pdDsKKworCQkvKiBPbmx5IGJh
bGFuY2UgbGltaXQgaWYgbm8gdGFibGUgb3B0aW9ucyBzcGVjaWZpZWQgKi8KKwkJaWYgKHBnX2F0
b21pY191bmxvY2tlZF90ZXN0X2ZsYWcoJk15V29ya2VySW5mby0+d2lfZG9iYWxhbmNlKSkKKwkJ
CXJldHVybjsKIAotCQlpZiAod29ya2VyLT53aV9wcm9jICE9IE5VTEwgJiYKLQkJCXdvcmtlci0+
d2lfZG9iYWxhbmNlICYmCi0JCQl3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSA+IDAgJiYgd29y
a2VyLT53aV9jb3N0X2RlbGF5ID4gMCkKLQkJCWNvc3RfdG90YWwgKz0KLQkJCQkoZG91YmxlKSB3
b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSAvIHdvcmtlci0+d2lfY29zdF9kZWxheTsKKwkJQXNz
ZXJ0KFZhY3V1bUNvc3RMaW1pdCA+IDApOworCisJCW53b3JrZXJzX2Zvcl9iYWxhbmNlID0gcGdf
YXRvbWljX3JlYWRfdTMyKAorCQkJCQkJCQkmQXV0b1ZhY3V1bVNobWVtLT5hdl9ud29ya2Vyc0Zv
ckJhbGFuY2UpOworCisJCS8qIFRoZXJlIGlzIGF0IGxlYXN0IDEgYXV0b3ZhYyB3b3JrZXIgKHRo
aXMgd29ya2VyKS4gKi8KKwkJQXNzZXJ0KG53b3JrZXJzX2Zvcl9iYWxhbmNlID4gMCk7CisKKwkJ
VmFjdXVtQ29zdExpbWl0ID0gTWF4KFZhY3V1bUNvc3RMaW1pdCAvIG53b3JrZXJzX2Zvcl9iYWxh
bmNlLCAxKTsKIAl9Cit9CiAKLQkvKiB0aGVyZSBhcmUgbm8gY29zdCBsaW1pdHMgLS0gbm90aGlu
ZyB0byBkbyAqLwotCWlmIChjb3N0X3RvdGFsIDw9IDApCi0JCXJldHVybjsKKy8qCisgKiBhdXRv
dmFjX3JlY2FsY3VsYXRlX3dvcmtlcnNfZm9yX2JhbGFuY2UKKyAqCQlSZWNhbGN1bGF0ZSB0aGUg
bnVtYmVyIG9mIHdvcmtlcnMgdG8gY29uc2lkZXIsIGdpdmVuIHRhYmxlIG9wdGlvbnMgYW5kCisg
KgkJdGhlIGN1cnJlbnQgbnVtYmVyIG9mIGFjdGl2ZSB3b3JrZXJzLgorICoKKyAqIENhbGxlciBt
dXN0IGhvbGQgdGhlIEF1dG92YWN1dW1Mb2NrIGluIGF0IGxlYXN0IHNoYXJlZCBtb2RlIHRvIGFj
Y2VzcworICogd29ya2VyLT53aV9wcm9jLgorICovCitzdGF0aWMgdm9pZAorYXV0b3ZhY19yZWNh
bGN1bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNlKHZvaWQpCit7CisJZGxpc3RfaXRlcglpdGVyOwor
CWludAkJCW9yaWdfbndvcmtlcnNfZm9yX2JhbGFuY2U7CisJaW50CQkJbndvcmtlcnNfZm9yX2Jh
bGFuY2UgPSAwOworCisJb3JpZ19ud29ya2Vyc19mb3JfYmFsYW5jZSA9CisJCXBnX2F0b21pY19y
ZWFkX3UzMigmQXV0b1ZhY3V1bVNobWVtLT5hdl9ud29ya2Vyc0ZvckJhbGFuY2UpOwogCi0JLyoK
LQkgKiBBZGp1c3QgY29zdCBsaW1pdCBvZiBlYWNoIGFjdGl2ZSB3b3JrZXIgdG8gYmFsYW5jZSB0
aGUgdG90YWwgb2YgY29zdAotCSAqIGxpbWl0IHRvIGF1dG92YWN1dW1fdmFjdXVtX2Nvc3RfbGlt
aXQuCi0JICovCi0JY29zdF9hdmFpbCA9IChkb3VibGUpIHZhY19jb3N0X2xpbWl0IC8gdmFjX2Nv
c3RfZGVsYXk7CiAJZGxpc3RfZm9yZWFjaChpdGVyLCAmQXV0b1ZhY3V1bVNobWVtLT5hdl9ydW5u
aW5nV29ya2VycykKIAl7CiAJCVdvcmtlckluZm8Jd29ya2VyID0gZGxpc3RfY29udGFpbmVyKFdv
cmtlckluZm9EYXRhLCB3aV9saW5rcywgaXRlci5jdXIpOwogCi0JCWlmICh3b3JrZXItPndpX3By
b2MgIT0gTlVMTCAmJgotCQkJd29ya2VyLT53aV9kb2JhbGFuY2UgJiYKLQkJCXdvcmtlci0+d2lf
Y29zdF9saW1pdF9iYXNlID4gMCAmJiB3b3JrZXItPndpX2Nvc3RfZGVsYXkgPiAwKQotCQl7Ci0J
CQlpbnQJCQlsaW1pdCA9IChpbnQpCi0JCQkoY29zdF9hdmFpbCAqIHdvcmtlci0+d2lfY29zdF9s
aW1pdF9iYXNlIC8gY29zdF90b3RhbCk7Ci0KLQkJCS8qCi0JCQkgKiBXZSBwdXQgYSBsb3dlciBi
b3VuZCBvZiAxIG9uIHRoZSBjb3N0X2xpbWl0LCB0byBhdm9pZCBkaXZpc2lvbi0KLQkJCSAqIGJ5
LXplcm8gaW4gdGhlIHZhY3V1bSBjb2RlLiAgQWxzbywgaW4gY2FzZSBvZiByb3VuZG9mZiB0cm91
YmxlCi0JCQkgKiBpbiB0aGVzZSBjYWxjdWxhdGlvbnMsIGxldCdzIGJlIHN1cmUgd2UgZG9uJ3Qg
ZXZlciBzZXQKLQkJCSAqIGNvc3RfbGltaXQgdG8gbW9yZSB0aGFuIHRoZSBiYXNlIHZhbHVlLgot
CQkJICovCi0JCQl3b3JrZXItPndpX2Nvc3RfbGltaXQgPSBNYXgoTWluKGxpbWl0LAotCQkJCQkJ
CQkJCQl3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSksCi0JCQkJCQkJCQkJMSk7Ci0JCX0KKwkJ
aWYgKHdvcmtlci0+d2lfcHJvYyA9PSBOVUxMIHx8CisJCQlwZ19hdG9taWNfdW5sb2NrZWRfdGVz
dF9mbGFnKCZ3b3JrZXItPndpX2RvYmFsYW5jZSkpCisJCQljb250aW51ZTsKIAotCQlpZiAod29y
a2VyLT53aV9wcm9jICE9IE5VTEwpCi0JCQllbG9nKERFQlVHMiwgImF1dG92YWNfYmFsYW5jZV9j
b3N0KHBpZD0lZCBkYj0ldSwgcmVsPSV1LCBkb2JhbGFuY2U9JXMgY29zdF9saW1pdD0lZCwgY29z
dF9saW1pdF9iYXNlPSVkLCBjb3N0X2RlbGF5PSVnKSIsCi0JCQkJIHdvcmtlci0+d2lfcHJvYy0+
cGlkLCB3b3JrZXItPndpX2Rib2lkLCB3b3JrZXItPndpX3RhYmxlb2lkLAotCQkJCSB3b3JrZXIt
PndpX2RvYmFsYW5jZSA/ICJ5ZXMiIDogIm5vIiwKLQkJCQkgd29ya2VyLT53aV9jb3N0X2xpbWl0
LCB3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSwKLQkJCQkgd29ya2VyLT53aV9jb3N0X2RlbGF5
KTsKKwkJbndvcmtlcnNfZm9yX2JhbGFuY2UrKzsKIAl9CisKKwlpZiAobndvcmtlcnNfZm9yX2Jh
bGFuY2UgIT0gb3JpZ19ud29ya2Vyc19mb3JfYmFsYW5jZSkKKwkJcGdfYXRvbWljX3dyaXRlX3Uz
MigmQXV0b1ZhY3V1bVNobWVtLT5hdl9ud29ya2Vyc0ZvckJhbGFuY2UsCisJCQkJCQkJbndvcmtl
cnNfZm9yX2JhbGFuY2UpOwogfQogCiAvKgpAQCAtMjQyMiwyMiArMjQ1MiwzOSBAQCBkb19hdXRv
dmFjdXVtKHZvaWQpCiAJCQljb250aW51ZTsKIAkJfQogCi0JCS8qIE11c3QgaG9sZCBBdXRvdmFj
dXVtTG9jayB3aGlsZSBtdWNraW5nIHdpdGggY29zdCBiYWxhbmNlIGluZm8gKi8KLQkJTFdMb2Nr
QWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZFKTsKKwkJLyoKKwkJICogU2F2ZSB0
aGUgY29zdC1yZWxhdGVkIHRhYmxlIG9wdGlvbnMgaW4gZ2xvYmFsIHZhcmlhYmxlcyBmb3IKKwkJ
ICogcmVmZXJlbmNlIHdoZW4gdXBkYXRpbmcgVmFjdXVtQ29zdExpbWl0IGFuZCBWYWN1dW1Db3N0
RGVsYXkgZHVyaW5nCisJCSAqIHZhY3V1bWluZyB0aGlzIHRhYmxlLgorCQkgKi8KKwkJYXZfcmVs
b3B0X2Nvc3RfbGltaXQgPSB0YWItPmF0X3JlbG9wdF92YWNfY29zdF9saW1pdDsKKwkJYXZfcmVs
b3B0X2Nvc3RfZGVsYXkgPSB0YWItPmF0X3JlbG9wdF92YWNfY29zdF9kZWxheTsKIAotCQkvKiBh
ZHZlcnRpc2UgbXkgY29zdCBkZWxheSBwYXJhbWV0ZXJzIGZvciB0aGUgYmFsYW5jaW5nIGFsZ29y
aXRobSAqLwotCQlNeVdvcmtlckluZm8tPndpX2RvYmFsYW5jZSA9IHRhYi0+YXRfZG9iYWxhbmNl
OwotCQlNeVdvcmtlckluZm8tPndpX2Nvc3RfZGVsYXkgPSB0YWItPmF0X3ZhY3V1bV9jb3N0X2Rl
bGF5OwotCQlNeVdvcmtlckluZm8tPndpX2Nvc3RfbGltaXQgPSB0YWItPmF0X3ZhY3V1bV9jb3N0
X2xpbWl0OwotCQlNeVdvcmtlckluZm8tPndpX2Nvc3RfbGltaXRfYmFzZSA9IHRhYi0+YXRfdmFj
dXVtX2Nvc3RfbGltaXQ7CisJCS8qCisJCSAqIFdlIG9ubHkgZXhwZWN0IHRoaXMgd29ya2VyIHRv
IGV2ZXIgc2V0IHRoZSBmbGFnLCBzbyBkb24ndCBib3RoZXIKKwkJICogY2hlY2tpbmcgdGhlIHJl
dHVybiB2YWx1ZS4gV2Ugc2hvdWxkbid0IGhhdmUgdG8gcmV0cnkuCisJCSAqLworCQlpZiAodGFi
LT5hdF9kb2JhbGFuY2UpCisJCQlwZ19hdG9taWNfdGVzdF9zZXRfZmxhZygmTXlXb3JrZXJJbmZv
LT53aV9kb2JhbGFuY2UpOworCQllbHNlCisJCQlwZ19hdG9taWNfY2xlYXJfZmxhZygmTXlXb3Jr
ZXJJbmZvLT53aV9kb2JhbGFuY2UpOwogCi0JCS8qIGRvIGEgYmFsYW5jZSAqLwotCQlhdXRvdmFj
X2JhbGFuY2VfY29zdCgpOworCQlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2NrLCBMV19TSEFS
RUQpOwogCi0JCS8qIHNldCB0aGUgYWN0aXZlIGNvc3QgcGFyYW1ldGVycyBmcm9tIHRoZSByZXN1
bHQgb2YgdGhhdCAqLworCQlhdXRvdmFjX3JlY2FsY3VsYXRlX3dvcmtlcnNfZm9yX2JhbGFuY2Uo
KTsKKworCQkvKgorCQkgKiBXZSB3YWl0IHVudGlsIHRoaXMgcG9pbnQgdG8gdXBkYXRlIGNvc3Qg
ZGVsYXkgYW5kIGNvc3QgbGltaXQKKwkJICogdmFsdWVzLCBldmVuIHRob3VnaCB3ZSByZWxvYWRl
ZCB0aGUgY29uZmlndXJhdGlvbiBmaWxlIGFib3ZlLCBzbworCQkgKiB0aGF0IHdlIGNhbiB0YWtl
IGludG8gYWNjb3VudCB0aGUgY29zdC1yZWxhdGVkIHRhYmxlIG9wdGlvbnMuCisJCSAqLwogCQlW
YWN1dW1VcGRhdGVDb3N0cygpOwogCi0JCS8qIGRvbmUgKi8KKwkJZWxvZyhERUJVRzIsICJWYWN1
dW1VcGRhdGVDb3N0cyhwaWQ9JWQgZGI9JXUsIHJlbD0ldSwgZG9iYWxhbmNlPSVzIGNvc3RfbGlt
aXQ9JWQsIGNvc3RfZGVsYXk9JWcpIiwKKwkJCSBNeVdvcmtlckluZm8tPndpX3Byb2MtPnBpZCwg
TXlXb3JrZXJJbmZvLT53aV9kYm9pZCwgTXlXb3JrZXJJbmZvLT53aV90YWJsZW9pZCwKKwkJCSBw
Z19hdG9taWNfdW5sb2NrZWRfdGVzdF9mbGFnKCZNeVdvcmtlckluZm8tPndpX2RvYmFsYW5jZSkg
PyAibm8iIDogInllcyIsCisJCQkgVmFjdXVtQ29zdExpbWl0LCBWYWN1dW1Db3N0RGVsYXkpOwor
CiAJCUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1bUxvY2spOwogCiAJCS8qIGNsZWFuIHVwIG1lbW9y
eSBiZWZvcmUgZWFjaCBpdGVyYXRpb24gKi8KQEAgLTI1MjMsMTAgKzI1NzAsMTAgQEAgZGVsZXRl
ZDoKIAogCQkvKgogCQkgKiBSZW1vdmUgbXkgaW5mbyBmcm9tIHNoYXJlZCBtZW1vcnkuICBXZSBj
b3VsZCwgYnV0IGludGVudGlvbmFsbHkKLQkJICogZG9uJ3QsIGNsZWFyIHdpX2Nvc3RfbGltaXQg
YW5kIGZyaWVuZHMgLS0tIHRoaXMgaXMgb24gdGhlCi0JCSAqIGFzc3VtcHRpb24gdGhhdCB3ZSBw
cm9iYWJseSBoYXZlIG1vcmUgdG8gZG8gd2l0aCBzaW1pbGFyIGNvc3QKLQkJICogc2V0dGluZ3Ms
IHNvIHdlIGRvbid0IHdhbnQgdG8gZ2l2ZSB1cCBvdXIgc2hhcmUgb2YgSS9PIGZvciBhIHZlcnkK
LQkJICogc2hvcnQgaW50ZXJ2YWwgYW5kIHRoZXJlYnkgdGhyYXNoIHRoZSBnbG9iYWwgYmFsYW5j
ZS4KKwkJICogZG9uJ3QsIHVuc2V0IHdpX2RvYmFsYW5jZSBvbiB0aGUgYXNzdW1wdGlvbiB0aGF0
IHdlIGFyZSBtb3JlIGxpa2VseQorCQkgKiB0aGFuIG5vdCB0byB2YWN1dW0gYSB0YWJsZSB3aXRo
IG5vIHRhYmxlIG9wdGlvbnMgbmV4dCwgc28gd2UgZG9uJ3QKKwkJICogd2FudCB0byBnaXZlIHVw
IG91ciBzaGFyZSBvZiBJL08gZm9yIGEgdmVyeSBzaG9ydCBpbnRlcnZhbCBhbmQKKwkJICogdGhl
cmVieSB0aHJhc2ggdGhlIGdsb2JhbCBiYWxhbmNlLgogCQkgKi8KIAkJTFdMb2NrQWNxdWlyZShB
dXRvdmFjdXVtU2NoZWR1bGVMb2NrLCBMV19FWENMVVNJVkUpOwogCQlNeVdvcmtlckluZm8tPndp
X3RhYmxlb2lkID0gSW52YWxpZE9pZDsKQEAgLTI1NjMsNiArMjYxMCw3IEBAIGRlbGV0ZWQ6CiAJ
CXsKIAkJCUNvbmZpZ1JlbG9hZFBlbmRpbmcgPSBmYWxzZTsKIAkJCVByb2Nlc3NDb25maWdGaWxl
KFBHQ19TSUdIVVApOworCQkJVmFjdXVtVXBkYXRlQ29zdHMoKTsKIAkJfQogCiAJCUxXTG9ja0Fj
cXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7CkBAIC0yNzk4LDggKzI4NDYsNiBA
QCB0YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJsZV90b2FzdF9tYXAs
CiAJCWludAkJCWZyZWV6ZV90YWJsZV9hZ2U7CiAJCWludAkJCW11bHRpeGFjdF9mcmVlemVfbWlu
X2FnZTsKIAkJaW50CQkJbXVsdGl4YWN0X2ZyZWV6ZV90YWJsZV9hZ2U7Ci0JCWludAkJCXZhY19j
b3N0X2xpbWl0OwotCQlkb3VibGUJCXZhY19jb3N0X2RlbGF5OwogCQlpbnQJCQlsb2dfbWluX2R1
cmF0aW9uOwogCiAJCS8qCkBAIC0yODA5LDIwICsyODU1LDYgQEAgdGFibGVfcmVjaGVja19hdXRv
dmFjKE9pZCByZWxpZCwgSFRBQiAqdGFibGVfdG9hc3RfbWFwLAogCQkgKiBkZWZhdWx0cywgYXV0
b3ZhY3V1bSdzIG93biBmaXJzdCBhbmQgcGxhaW4gdmFjdXVtIHNlY29uZC4KIAkJICovCiAKLQkJ
LyogLTEgaW4gYXV0b3ZhYyBzZXR0aW5nIG1lYW5zIHVzZSBwbGFpbiB2YWN1dW1fY29zdF9kZWxh
eSAqLwotCQl2YWNfY29zdF9kZWxheSA9IChhdm9wdHMgJiYgYXZvcHRzLT52YWN1dW1fY29zdF9k
ZWxheSA+PSAwKQotCQkJPyBhdm9wdHMtPnZhY3V1bV9jb3N0X2RlbGF5Ci0JCQk6IChhdXRvdmFj
dXVtX3ZhY19jb3N0X2RlbGF5ID49IDApCi0JCQk/IGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkK
LQkJCTogdmFjdXVtX2Nvc3RfZGVsYXk7Ci0KLQkJLyogMCBvciAtMSBpbiBhdXRvdmFjIHNldHRp
bmcgbWVhbnMgdXNlIHBsYWluIHZhY3V1bV9jb3N0X2xpbWl0ICovCi0JCXZhY19jb3N0X2xpbWl0
ID0gKGF2b3B0cyAmJiBhdm9wdHMtPnZhY3V1bV9jb3N0X2xpbWl0ID4gMCkKLQkJCT8gYXZvcHRz
LT52YWN1dW1fY29zdF9saW1pdAotCQkJOiAoYXV0b3ZhY3V1bV92YWNfY29zdF9saW1pdCA+IDAp
Ci0JCQk/IGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQKLQkJCTogdmFjdXVtX2Nvc3RfbGltaXQ7
Ci0KIAkJLyogLTEgaW4gYXV0b3ZhYyBzZXR0aW5nIG1lYW5zIHVzZSBsb2dfYXV0b3ZhY3V1bV9t
aW5fZHVyYXRpb24gKi8KIAkJbG9nX21pbl9kdXJhdGlvbiA9IChhdm9wdHMgJiYgYXZvcHRzLT5s
b2dfbWluX2R1cmF0aW9uID49IDApCiAJCQk/IGF2b3B0cy0+bG9nX21pbl9kdXJhdGlvbgpAQCAt
Mjg3OCw4ICsyOTEwLDEwIEBAIHRhYmxlX3JlY2hlY2tfYXV0b3ZhYyhPaWQgcmVsaWQsIEhUQUIg
KnRhYmxlX3RvYXN0X21hcCwKIAkJdGFiLT5hdF9wYXJhbXMubXVsdGl4YWN0X2ZyZWV6ZV90YWJs
ZV9hZ2UgPSBtdWx0aXhhY3RfZnJlZXplX3RhYmxlX2FnZTsKIAkJdGFiLT5hdF9wYXJhbXMuaXNf
d3JhcGFyb3VuZCA9IHdyYXBhcm91bmQ7CiAJCXRhYi0+YXRfcGFyYW1zLmxvZ19taW5fZHVyYXRp
b24gPSBsb2dfbWluX2R1cmF0aW9uOwotCQl0YWItPmF0X3ZhY3V1bV9jb3N0X2xpbWl0ID0gdmFj
X2Nvc3RfbGltaXQ7Ci0JCXRhYi0+YXRfdmFjdXVtX2Nvc3RfZGVsYXkgPSB2YWNfY29zdF9kZWxh
eTsKKwkJdGFiLT5hdF9yZWxvcHRfdmFjX2Nvc3RfbGltaXQgPSBhdm9wdHMgPworCQkJYXZvcHRz
LT52YWN1dW1fY29zdF9saW1pdCA6IDA7CisJCXRhYi0+YXRfcmVsb3B0X3ZhY19jb3N0X2RlbGF5
ID0gYXZvcHRzID8KKwkJCWF2b3B0cy0+dmFjdXVtX2Nvc3RfZGVsYXkgOiAtMTsKIAkJdGFiLT5h
dF9yZWxuYW1lID0gTlVMTDsKIAkJdGFiLT5hdF9uc3BuYW1lID0gTlVMTDsKIAkJdGFiLT5hdF9k
YXRuYW1lID0gTlVMTDsKQEAgLTMzNzEsMTAgKzM0MDUsMTggQEAgQXV0b1ZhY3V1bVNobWVtSW5p
dCh2b2lkKQogCQl3b3JrZXIgPSAoV29ya2VySW5mbykgKChjaGFyICopIEF1dG9WYWN1dW1TaG1l
bSArCiAJCQkJCQkJICAgTUFYQUxJR04oc2l6ZW9mKEF1dG9WYWN1dW1TaG1lbVN0cnVjdCkpKTsK
IAorCiAJCS8qIGluaXRpYWxpemUgdGhlIFdvcmtlckluZm8gZnJlZSBsaXN0ICovCiAJCWZvciAo
aSA9IDA7IGkgPCBhdXRvdmFjdXVtX21heF93b3JrZXJzOyBpKyspCisJCXsKIAkJCWRsaXN0X3B1
c2hfaGVhZCgmQXV0b1ZhY3V1bVNobWVtLT5hdl9mcmVlV29ya2VycywKIAkJCQkJCQkmd29ya2Vy
W2ldLndpX2xpbmtzKTsKKworCQkJcGdfYXRvbWljX2luaXRfZmxhZygmd29ya2VyW2ldLndpX2Rv
YmFsYW5jZSk7CisJCX0KKworCQlwZ19hdG9taWNfaW5pdF91MzIoJkF1dG9WYWN1dW1TaG1lbS0+
YXZfbndvcmtlcnNGb3JCYWxhbmNlLCAwKTsKKwogCX0KIAllbHNlCiAJCUFzc2VydChmb3VuZCk7
CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaCBiL3NyYy9pbmNsdWRl
L2NvbW1hbmRzL3ZhY3V1bS5oCmluZGV4IDE3Y2Y1ODI1NWYuLmVmOTM4ZmI2OTIgMTAwNjQ0Ci0t
LSBhL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oCisrKyBiL3NyYy9pbmNsdWRlL2NvbW1h
bmRzL3ZhY3V1bS5oCkBAIC0zNTEsNiArMzUxLDcgQEAgZXh0ZXJuIEluZGV4QnVsa0RlbGV0ZVJl
c3VsdCAqdmFjX2NsZWFudXBfb25lX2luZGV4KEluZGV4VmFjdXVtSW5mbyAqaXZpbmZvLAogZXh0
ZXJuIFNpemUgdmFjX21heF9pdGVtc190b19hbGxvY19zaXplKGludCBtYXhfaXRlbXMpOwogCiAv
KiBJbiBwb3N0bWFzdGVyL2F1dG92YWN1dW0uYyAqLworZXh0ZXJuIHZvaWQgQXV0b1ZhY3V1bVVw
ZGF0ZUxpbWl0KHZvaWQpOwogZXh0ZXJuIHZvaWQgVmFjdXVtVXBkYXRlQ29zdHModm9pZCk7CiAK
IC8qIGluIGNvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMgKi8KLS0gCjIuMzcuMgoK
--000000000000f8e86e05f88830c2
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v15-0002-Separate-vacuum-cost-variables-from-gucs.patch"
Content-Disposition: attachment; 
	filename="v15-0002-Separate-vacuum-cost-variables-from-gucs.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_lg2op1mo1>
X-Attachment-Id: f_lg2op1mo1
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--000000000000f8e86e05f88830c2--