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 1pk556-0003hs-2K for pgsql-hackers@arkaria.postgresql.org; Wed, 05 Apr 2023 15:29:52 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1pk554-0001DD-Dc for pgsql-hackers@arkaria.postgresql.org; Wed, 05 Apr 2023 15:29:50 +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 1pk553-0001D3-W1 for pgsql-hackers@lists.postgresql.org; Wed, 05 Apr 2023 15:29:50 +0000 Received: from mail-pf1-x436.google.com ([2607:f8b0:4864:20::436]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.94.2) (envelope-from ) id 1pk54z-0014Xs-2R for pgsql-hackers@postgresql.org; Wed, 05 Apr 2023 15:29:49 +0000 Received: by mail-pf1-x436.google.com with SMTP id ce4so10895219pfb.1 for ; Wed, 05 Apr 2023 08:29:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1680708582; x=1683300582; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=lkydUZQh5SUdsCvEkfdM63X53Wcs4D9fEjTUhVr26cA=; b=YBkreN53jOAZm1FyzUCqEtall7NUGYqEAIaTDWF5Y2zknorMIlugulhywu+KSpuP3R edDsm/wJG2LTGKjMvq5nWWnm7r/9vpDzqRiyj6d0oKnmFrIFKotazMAWBx1yFnSr2TgX LwJ1OLmjbkVOxfLY9iaCaWdOzX2fY2FgzX8mkM/8OpBDeCQFIzMEhaSesZ3SgwwWN3Jx AjQ7nXLoo3ZgQQHUS58IjhikO8S715nLmd/SeVzCVSvKpuWXjVq9nR5mG4/JGcTVHDGe eqv1ccukZycM2vXKz1SIjYW585S2yloDLRJKlT8N3j0l1ayH62yJmGnqYL6boAUFoq2I dSKg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1680708582; x=1683300582; 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=lkydUZQh5SUdsCvEkfdM63X53Wcs4D9fEjTUhVr26cA=; b=3G5KBHJXqksZQVcVS/8ARU0DJ2nqNyLUcgxW3TFvwLZlll41yszpEo+GrEZEsgPbaC NmKcL3OCTUYkooSnz01Vuw177QmNQ2/pJx1iSDCUPefgL7pSKX91LVmWfOAWoRGibWJ6 njib8sy6bd85LHHXCeidwI5/RV++5M3kSied2sFwrfGvou8MUu3IwszZfWORsyRDoCqW HUwNagMHiBEsuhxK5lemgP1QUsSXFfTORIU4inmgSw+Oy8prUE+JmBnNJAJLMdp0XO5/ M/BMyRRhBT5IhacD0AJBnOy6voczLwGCyTSM8OygHlYrUJV1r81MCl+ROZofv0tPtxWA 2a4g== X-Gm-Message-State: AAQBX9fIHhw3jsr5bhtnli6gVSb06Dbhes+ALNbnUmtoPmpdkW06OWuZ o+LGSCT4sKTmTr7I6XqH3zaIzwWg9o8r9RD7Uic= X-Google-Smtp-Source: AKy350YUvWFUgpIkCEZVf7+1ZWqolQ5sNSkL6si+zFqIt09uJrkzttRzH+fHTw+63kCpRnJvsImuj0B90nA9OfNMJwU= X-Received: by 2002:a65:4946:0:b0:50f:6926:ea7e with SMTP id q6-20020a654946000000b0050f6926ea7emr1210027pgs.2.1680708582181; Wed, 05 Apr 2023 08:29:42 -0700 (PDT) MIME-Version: 1.0 References: <20230329.132155.629765142788133576.horikyota.ntt@gmail.com> <20230329.173456.1185961934810139447.horikyota.ntt@gmail.com> <935191FB-083B-4060-89FC-466F61FAA391@yesql.se> <1252075.1680547394@sss.pgh.pa.us> <20230403190837.qubpnwugfe2k2g46@awork3.anarazel.de> <7E06F879-7E20-4A6A-862F-CA72CDC9A323@yesql.se> In-Reply-To: From: Melanie Plageman Date: Wed, 5 Apr 2023 11:29:30 -0400 Message-ID: Subject: Re: Should vacuum process config file reload more often To: Daniel Gustafsson Cc: Andres Freund , Tom Lane , Masahiko Sawada , Kyotaro Horiguchi , PostgreSQL Hackers , Amit Kapila Content-Type: multipart/mixed; boundary="00000000000003aa1905f89876c2" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --00000000000003aa1905f89876c2 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Thanks all for the reviews. v16 attached. I put it together rather quickly, so there might be a few spurious whitespaces or similar. There is one rather annoying pgindent outlier that I have to figure out what to do about as well. The remaining functional TODOs that I know of are: - Resolve what to do about names of GUC and vacuum variables for cost limit and cost delay (since it may affect extensions) - Figure out what to do about the logging message which accesses dboid and tableoid (lock/no lock, where to put it, etc) - I see several places in docs which reference the balancing algorithm for autovac workers. I did not read them in great detail, but we may want to review them to see if any require updates. - Consider whether or not the initial two commits should just be squashed with the third commit - Anything else reviewers are still unhappy with On Wed, Apr 5, 2023 at 1:56=E2=80=AFAM Masahiko Sawada wrote: > > On Wed, Apr 5, 2023 at 5:05=E2=80=AFAM Melanie Plageman > wrote: > > > > On Tue, Apr 4, 2023 at 4:27=E2=80=AFAM Masahiko Sawada wrote: > > > --- > > > - 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 worker= s > > > 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 i= s > > 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 wort= h > > 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()? > > Previously, we used to show the pid in the log since a worker/launcher > set other workers' delay costs. But now that the worker sets its delay > costs, we don't need to show the pid in the log. Also, I think it's > useful for debugging and investigating the system if we log it when > changing the values. The log I imagined to add was like: > > @@ -1801,6 +1801,13 @@ VacuumUpdateCosts(void) > VacuumCostDelay =3D vacuum_cost_delay; > > AutoVacuumUpdateLimit(); > + > + elog(DEBUG2, "autovacuum update costs (db=3D%u, rel=3D%u, > dobalance=3D%s, cost_limit=3D%d, cost_delay=3D%g active=3D%s failsafe=3D%= s)", > + MyWorkerInfo->wi_dboid, MyWorkerInfo->wi_tableoid, > + pg_atomic_unlocked_test_flag(&MyWorkerInfo->wi_dobalance) > ? "no" : "yes", > + VacuumCostLimit, VacuumCostDelay, > + VacuumCostDelay > 0 ? "yes" : "no", > + VacuumFailsafeActive ? "yes" : "no"); > } > else > { Makes sense. I've updated the log message to roughly what you suggested. I also realized I think it does make sense to call it in VacuumUpdateCosts() -- only for autovacuum workers of course. I've done this. I haven't taken the lock though and can't decide if I must since they access dboid and tableoid -- those are not going to change at this point, but I still don't know if I can access them lock-free... Perhaps there is a way to condition it on the log level? If I have to take a lock, then I don't know if we should put these in VacuumUpdateCosts()... On Wed, Apr 5, 2023 at 3:16=E2=80=AFAM Kyotaro Horiguchi wrote: > About 0001: > > + * 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. > + * If failsafe mode has been engaged, we will not re-enable cost-based d= elay > + * for the table until after vacuuming has completed, regardless of othe= r > + * settings. Only VACUUM code should inspect this variable and only tabl= e > + * access methods should set it. In Table AM-agnostic VACUUM code, this > + * variable controls whether or not to allow cost-based delays. Table AM= s are > + * free to use it if they desire this behavior. > + */ > +bool VacuumFailsafeActive =3D false; > > If I understand this correctly, there seems to be an issue. The > AM-agnostic VACUUM code is setting it and no table AMs actually do > that. No, it is not set in table AM-agnostic VACUUM code. I meant it is used/read from/inspected in table AM-agnostic VACUUM code. Table AMs can set it if they want to avoid cost-based delays being re-enabled. It is only set to true heap-specific code and is initialized to false and reset in table AM-agnostic code back to false in between each relation being vacuumed. I updated the comment to reflect this. Let me know if you think it is clear. > 0003: > + > + /* > + * Ensure VacuumFailsafeActive has been reset bef= ore vacuuming the > + * next relation. > + */ > + VacuumFailsafeActive =3D false; > } > } > PG_FINALLY(); > { > in_vacuum =3D false; > VacuumCostActive =3D false; > + VacuumFailsafeActive =3D false; > + VacuumCostBalance =3D 0; > > There is no need to reset VacuumFailsafeActive in the PG_TRY() block. I think that is true -- since it is initialized to false and reset to false after vacuuming every relation. However, I am leaning toward keeping it because I haven't thought through every codepath and determined if there is ever a way where it could be true here. > + /* > + * Reload the configuration file if requested. This allows change= s to > + * autovacuum_vacuum_cost_limit and autovacuum_vacuum_cost_delay = to take > + * effect while a table is being vacuumed or analyzed. > + */ > + if (ConfigReloadPending && IsAutoVacuumWorkerProcess()) > + { > + ConfigReloadPending =3D false; > + ProcessConfigFile(PGC_SIGHUP); > + VacuumUpdateCosts(); > + } > > I believe we should prevent unnecessary reloading when > VacuumFailsafeActive is true. This is in conflict with two of the other reviewers feedback: Sawada-san: > + * Reload the configuration file if requested. This allows chang= es to > + * [autovacuum_]vacuum_cost_limit and [autovacuum_]vacuum_cost_d= elay to > + * take effect while a table is being vacuumed or analyzed. > + */ > + if (ConfigReloadPending && !analyze_in_outer_xact) > + { > + ConfigReloadPending =3D false; > + ProcessConfigFile(PGC_SIGHUP); > + AutoVacuumUpdateDelay(); > + AutoVacuumUpdateLimit(); > + } > > It makes sense to me that we need to reload the config file even when > vacuum-delay is disabled. But I think it's not convenient for users > that we don't reload the configuration file once the failsafe is > triggered. I think users might want to change some GUCs such as > log_autovacuum_min_duration. and Daniel in response to this: > > It makes sense to me that we need to reload the config file even when > > vacuum-delay is disabled. But I think it's not convenient for users > > that we don't reload the configuration file once the failsafe is > > triggered. I think users might want to change some GUCs such as > > log_autovacuum_min_duration. > > I agree with this. > + AutoVacuumUpdateLimit(); > > I'm not entirely sure, but it might be better to name this > AutoVacuumUpdateCostLimit(). I have made this change. > + pg_atomic_flag wi_dobalance; > ... > + /* > + * We only expect this worker to ever set the flag, so do= n't bother > + * checking the return value. We shouldn't have to retry. > + */ > + if (tab->at_dobalance) > + pg_atomic_test_set_flag(&MyWorkerInfo->wi_dobalan= ce); > + else > + pg_atomic_clear_flag(&MyWorkerInfo->wi_dobalance)= ; > > LWLockAcquire(AutovacuumLock, LW_SHARED); > > autovac_recalculate_workers_for_balance(); > > I don't see the need for using atomic here. The code is executed > infrequently and we already take a lock while counting do_balance > workers. So sticking with the old locking method (taking LW_EXCLUSIVE > then set wi_dobalance then do balance) should be fine. We access wi_dobalance on every call to AutoVacuumUpdateLimit() which is executed in vacuum_delay_point(). I do not think we can justify take a shared lock in a function that is called so frequently. > +void > +AutoVacuumUpdateLimit(void) > ... > + if (av_relopt_cost_limit > 0) > + VacuumCostLimit =3D av_relopt_cost_limit; > + else > > I think we should use wi_dobalance to decide if we need to do balance > or not. We don't need to take a lock to do that since only the process > updates it. We do do that below in the "else" before balancing. But we for sure don't need to balance if relopt for cost limit is set. We can save an access to an atomic variable this way. I think the atomic is a relatively cheap way of avoiding this whole locking question. > /* > * Remove my info from shared memory. We could, but inte= ntionally > - * don't, clear wi_cost_limit and friends --- this is on = the > - * assumption that we probably have more to do with simil= ar cost > - * settings, so we don't want to give up our share of I/O= for a very > - * short interval and thereby thrash the global balance. > + * don't, unset wi_dobalance on the assumption that we ar= e more likely > + * than not to vacuum a table with no table options next,= so we don't > + * want to give up our share of I/O for a very short inte= rval and > + * thereby thrash the global balance. > */ > LWLockAcquire(AutovacuumScheduleLock, LW_EXCLUSIVE); > MyWorkerInfo->wi_tableoid =3D InvalidOid; > > The comment mentions wi_dobalance, but it doesn't appear here.. The point of the comment is that we don't do anything with wi_dobalance here. It is explaining why it doesn't appear. The previous comment mentioned not doing anything with wi_cost_delay and wi_cost_limit which also didn't appear here. On Wed, Apr 5, 2023 at 9:10=E2=80=AFAM Daniel Gustafsson = wrote: > > > On 4 Apr 2023, at 22:04, Melanie Plageman w= rote: > >> +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 visibi= lity. > >> Moreover, I'm not sure it's a good idea to perform this rename. This = will keep > >> VacuumCostLimit and VacuumCostDelay exported, but change their meaning= . Any > >> external code referring to these thinking they are backing the GUCs wi= ll still > >> compile, but may be broken in subtle ways. Is there a reason for not = keeping > >> 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 th= e > > 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? > > I think I wasn't clear in my comment, sorry. I don't have a problem with > introducing a new variable to split the balanced value from the GUC value= . > What I don't think we should do is repurpose an exported symbol into doin= g a > new thing. In the case at hand I think VacuumCostLimit and VacuumCostDel= ay > should remain the backing variables for the GUCs, with vacuum_cost_limit = and > vacuum_cost_delay carrying the balanced values. So the inverse of what i= s in > the patch now. > > The risk of these symbols being used in extensions might be very low but = on > principle it seems unwise to alter a symbol and risk subtle breakage. I totally see what you are saying. The only complication is that all of the other variables used in vacuum code are the camelcase and the gucs follow the snake case -- as pointed out in a previous review comment by Sawada-san: > @@ -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. This is less of a compelling argument than subtle breakage for extension code, though. I am, however, wondering if extensions expect to have access to the guc variable or the global variable -- or both? Left it as is in this version until we resolve the question. > > Oh, also I've annotated these with PGDLLIMPORT too. > > > >> + * TODO: should VacuumCostLimit and VacuumCostDelay be initialized to= valid or > >> + * invalid values? > >> + */ > >> +int VacuumCostLimit =3D 0; > >> +double VacuumCostDelay =3D -1; > >> > >> I think the important part is to make sure they are never accessed wit= hout > >> VacuumUpdateCosts having been called first. I think that's the case h= ere, but > >> it's not entirely clear. Do you see a codepath where that could happe= n? If > >> they are initialized to a sentinel value we also need to check for tha= t, 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(). > > Another question along these lines, we only call AutoVacuumUpdateLimit() = in > case there is a sleep in vacuum_delay_point(): > > + /* > + * Balance and update limit values for autovacuum workers. We mus= t > + * always do this in case the autovacuum launcher or another > + * autovacuum worker has recalculated the number of workers acros= s > + * which we must balance the limit. This is done by the launcher = when > + * launching a new worker and by workers before vacuuming each ta= ble. > + */ > + AutoVacuumUpdateLimit(); > > Shouldn't we always call that in case we had a config reload, or am I bei= ng > thick? We actually also call it from inside VacuumUpdateCosts(), which is always called in the case of a config reload. > >> +static double av_relopt_cost_delay =3D -1; > >> +static int av_relopt_cost_limit =3D 0; > > Sorry, I didn't catch this earlier, shouldn't this be -1 to match the def= ault > value of autovacuum_vacuum_cost_limit? Yea, this is a bit tricky. Initial values of -1 and 0 have the same effect when we are referencing av_relopt_vacuum_cost_limit in AutoVacuumUpdateCostLimit(). However, I was trying to initialize both av_relopt_vacuum_cost_limit and av_relopt_vacuum_cost_delay to "invalid" values which were not the default for the associated autovacuum gucs, since initializing av_relopt_cost_delay to the default for autovacuum_vacuum_cost_delay (2 ms) would cause it to be used even if storage params were not set for the relation. I have updated the initial value to -1, as you suggested -- but I don't know if it is more or less confusing the explain what I just explained in the comment above it. > >> These need a comment IMO, ideally one that explain why they are initia= lized to > >> those values. > > > > I've added a comment. > > + * Variables to save the cost-related table options for the current rela= tion > > The "table options" nomenclature is right now only used for FDW foreign t= able > options, I think we should use "storage parameters" or "relation options"= here. I've updated these to "storage parameters" to match the docs. I poked around looking for other places I referred to them as table options and tried to fix those as well. I've also changed all relevant variable names. > >> + /* 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 thi= s should > >> 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. > > Thinking more on this I'm tempted to recommend that we promote this to an > elog(), mainly due to the latter. An accidental call to VacuumUpdateCost= s() > doesn't seem entirely unlikely to happen Makes sense. I've added a trivial elog ERROR, but I didn't spend quite enough time thinking about what (if any) other context to include in it. - Melanie --00000000000003aa1905f89876c2 Content-Type: text/x-patch; charset="US-ASCII"; name="v16-0001-Make-vacuum-s-failsafe_active-a-global.patch" Content-Disposition: attachment; filename="v16-0001-Make-vacuum-s-failsafe_active-a-global.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg3u9xtc0 RnJvbSA4ZTg3Yzk1NTIyZDU0ZmRhY2Q3N2FjZjFjNWIzMTQ5NjhkM2M3ZTY4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBGcmksIDMxIE1hciAyMDIzIDEwOjM4OjM5IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTYgMS8zXSBNYWtlIHZhY3V1bSdzIGZhaWxzYWZlX2FjdGl2ZSBhIGdsb2JhbAoKV2hp bGUgdmFjdXVtaW5nIGEgdGFibGUgaW4gZmFpbHNhZmUgbW9kZSwgVmFjdXVtQ29zdEFjdGl2ZSBz aG91bGQgbm90IGJlCnJlLWVuYWJsZWQuIFRoaXMgY3VycmVudGx5IGlzbid0IGEgcHJvYmxlbSBi ZWNhdXNlIHZhY3V1bSBjb3N0CnBhcmFtZXRlcnMgYXJlIG9ubHkgcmVmcmVzaGVkIGluIGJldHdl ZW4gdmFjdXVtaW5nIHRhYmxlcyBhbmQgZmFpbHNhZmUKc3RhdHVzIGlzIHJlc2V0IGZvciBldmVy eSB0YWJsZS4gSW4gcHJlcGFyYXRpb24gZm9yIGFsbG93aW5nIHZhY3V1bSBjb3N0CnBhcmFtZXRl cnMgdG8gYmUgdXBkYXRlZCBtb3JlIGZyZXF1ZW50bHksIGVsZXZhdGUKTFZSZWxTdGF0ZS0+ZmFp bHNhZmVfYWN0aXZlIHRvIGEgZ2xvYmFsLCBWYWN1dW1GYWlsc2FmZUFjdGl2ZSwgd2hpY2gKd2ls bCBiZSBjaGVja2VkIHdoZW4gZGV0ZXJtaW5pbmcgd2hldGhlciBvciBub3QgdG8gcmUtZW5hYmxl IHZhY3V1bQpjb3N0LXJlbGF0ZWQgZGVsYXlzLgoKUmV2aWV3ZWQtYnk6IE1hc2FoaWtvIFNhd2Fk YSA8c2F3YWRhLm1zaGtAZ21haWwuY29tPgpSZXZpZXdlZC1ieTogRGFuaWVsIEd1c3RhZnNzb24g PGRhbmllbEB5ZXNxbC5zZT4KUmV2aWV3ZWQtYnk6IEt5b3Rhcm8gSG9yaWd1Y2hpIDxob3Jpa3lv dGEubnR0QGdtYWlsLmNvbT4KRGlzY3Vzc2lvbjogaHR0cHM6Ly93d3cucG9zdGdyZXNxbC5vcmcv bWVzc2FnZS1pZC9mbGF0L0NBQUtSdV9abmd6cW5FT0RjN0xtUzFOSDA0S3Q2WTlodVNqejVwcDcl MkJEWGhyakRBMGd3JTQwbWFpbC5nbWFpbC5jb20KLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVh cC92YWN1dW1sYXp5LmMgfCAxNiArKysrKysrLS0tLS0tLS0tCiBzcmMvYmFja2VuZC9jb21tYW5k cy92YWN1dW0uYyAgICAgICAgfCAxNSArKysrKysrKysrKysrKysKIHNyYy9pbmNsdWRlL2NvbW1h bmRzL3ZhY3V1bS5oICAgICAgICB8ICAxICsKIDMgZmlsZXMgY2hhbmdlZCwgMjMgaW5zZXJ0aW9u cygrKSwgOSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVh cC92YWN1dW1sYXp5LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKaW5k ZXggNjM5MTc5YWE0Ni4uMmJhODViZDNkNiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNz L2hlYXAvdmFjdXVtbGF6eS5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxh enkuYwpAQCAtMTUzLDggKzE1Myw2IEBAIHR5cGVkZWYgc3RydWN0IExWUmVsU3RhdGUKIAlib29s CQlhZ2dyZXNzaXZlOwogCS8qIFVzZSB2aXNpYmlsaXR5IG1hcCB0byBza2lwPyAoZGlzYWJsZWQg YnkgRElTQUJMRV9QQUdFX1NLSVBQSU5HKSAqLwogCWJvb2wJCXNraXB3aXRodm07Ci0JLyogV3Jh cGFyb3VuZCBmYWlsc2FmZSBoYXMgYmVlbiB0cmlnZ2VyZWQ/ICovCi0JYm9vbAkJZmFpbHNhZmVf YWN0aXZlOwogCS8qIENvbnNpZGVyIGluZGV4IHZhY3V1bWluZyBieXBhc3Mgb3B0aW1pemF0aW9u PyAqLwogCWJvb2wJCWNvbnNpZGVyX2J5cGFzc19vcHRpbWl6YXRpb247CiAKQEAgLTM5MSw3ICsz ODksNyBAQCBoZWFwX3ZhY3V1bV9yZWwoUmVsYXRpb24gcmVsLCBWYWN1dW1QYXJhbXMgKnBhcmFt cywKIAlBc3NlcnQocGFyYW1zLT5pbmRleF9jbGVhbnVwICE9IFZBQ09QVFZBTFVFX1VOU1BFQ0lG SUVEKTsKIAlBc3NlcnQocGFyYW1zLT50cnVuY2F0ZSAhPSBWQUNPUFRWQUxVRV9VTlNQRUNJRklF RCAmJgogCQkgICBwYXJhbXMtPnRydW5jYXRlICE9IFZBQ09QVFZBTFVFX0FVVE8pOwotCXZhY3Jl bC0+ZmFpbHNhZmVfYWN0aXZlID0gZmFsc2U7CisJVmFjdXVtRmFpbHNhZmVBY3RpdmUgPSBmYWxz ZTsKIAl2YWNyZWwtPmNvbnNpZGVyX2J5cGFzc19vcHRpbWl6YXRpb24gPSB0cnVlOwogCXZhY3Jl bC0+ZG9faW5kZXhfdmFjdXVtaW5nID0gdHJ1ZTsKIAl2YWNyZWwtPmRvX2luZGV4X2NsZWFudXAg PSB0cnVlOwpAQCAtNzA5LDcgKzcwNyw3IEBAIGhlYXBfdmFjdXVtX3JlbChSZWxhdGlvbiByZWws IFZhY3V1bVBhcmFtcyAqcGFyYW1zLAogCQkJfQogCQkJZWxzZQogCQkJewotCQkJCWlmICghdmFj cmVsLT5mYWlsc2FmZV9hY3RpdmUpCisJCQkJaWYgKCFWYWN1dW1GYWlsc2FmZUFjdGl2ZSkKIAkJ CQkJYXBwZW5kU3RyaW5nSW5mb1N0cmluZygmYnVmLCBfKCJpbmRleCBzY2FuIGJ5cGFzc2VkOiAi KSk7CiAJCQkJZWxzZQogCQkJCQlhcHBlbmRTdHJpbmdJbmZvU3RyaW5nKCZidWYsIF8oImluZGV4 IHNjYW4gYnlwYXNzZWQgYnkgZmFpbHNhZmU6ICIpKTsKQEAgLTIyOTMsNyArMjI5MSw3IEBAIGxh enlfdmFjdXVtKExWUmVsU3RhdGUgKnZhY3JlbCkKIAkJICogdmFjdXVtaW5nIG9yIGhlYXAgdmFj dXVtaW5nLiAgVGhpcyBWQUNVVU0gb3BlcmF0aW9uIHdvbid0IGVuZCB1cAogCQkgKiBiYWNrIGhl cmUgYWdhaW4uCiAJCSAqLwotCQlBc3NlcnQodmFjcmVsLT5mYWlsc2FmZV9hY3RpdmUpOworCQlB c3NlcnQoVmFjdXVtRmFpbHNhZmVBY3RpdmUpOwogCX0KIAogCS8qCkBAIC0yMzc0LDcgKzIzNzIs NyBAQCBsYXp5X3ZhY3V1bV9hbGxfaW5kZXhlcyhMVlJlbFN0YXRlICp2YWNyZWwpCiAJICovCiAJ QXNzZXJ0KHZhY3JlbC0+bnVtX2luZGV4X3NjYW5zID4gMCB8fAogCQkgICB2YWNyZWwtPmRlYWRf aXRlbXMtPm51bV9pdGVtcyA9PSB2YWNyZWwtPmxwZGVhZF9pdGVtcyk7Ci0JQXNzZXJ0KGFsbGlu ZGV4ZXMgfHwgdmFjcmVsLT5mYWlsc2FmZV9hY3RpdmUpOworCUFzc2VydChhbGxpbmRleGVzIHx8 IFZhY3V1bUZhaWxzYWZlQWN0aXZlKTsKIAogCS8qCiAJICogSW5jcmVhc2UgYW5kIHJlcG9ydCB0 aGUgbnVtYmVyIG9mIGluZGV4IHNjYW5zLgpAQCAtMjYxNiwxMiArMjYxNCwxMiBAQCBzdGF0aWMg Ym9vbAogbGF6eV9jaGVja193cmFwYXJvdW5kX2ZhaWxzYWZlKExWUmVsU3RhdGUgKnZhY3JlbCkK IHsKIAkvKiBEb24ndCB3YXJuIG1vcmUgdGhhbiBvbmNlIHBlciBWQUNVVU0gKi8KLQlpZiAodmFj cmVsLT5mYWlsc2FmZV9hY3RpdmUpCisJaWYgKFZhY3V1bUZhaWxzYWZlQWN0aXZlKQogCQlyZXR1 cm4gdHJ1ZTsKIAogCWlmICh1bmxpa2VseSh2YWN1dW1feGlkX2ZhaWxzYWZlX2NoZWNrKCZ2YWNy ZWwtPmN1dG9mZnMpKSkKIAl7Ci0JCXZhY3JlbC0+ZmFpbHNhZmVfYWN0aXZlID0gdHJ1ZTsKKwkJ VmFjdXVtRmFpbHNhZmVBY3RpdmUgPSB0cnVlOwogCiAJCS8qCiAJCSAqIEFiYW5kb24gdXNlIG9m IGEgYnVmZmVyIGFjY2VzcyBzdHJhdGVneSB0byBhbGxvdyB1c2Ugb2YgYWxsIG9mCkBAIC0yODIw LDcgKzI4MTgsNyBAQCBzaG91bGRfYXR0ZW1wdF90cnVuY2F0aW9uKExWUmVsU3RhdGUgKnZhY3Jl bCkKIHsKIAlCbG9ja051bWJlciBwb3NzaWJseV9mcmVlYWJsZTsKIAotCWlmICghdmFjcmVsLT5k b19yZWxfdHJ1bmNhdGUgfHwgdmFjcmVsLT5mYWlsc2FmZV9hY3RpdmUgfHwKKwlpZiAoIXZhY3Jl bC0+ZG9fcmVsX3RydW5jYXRlIHx8IFZhY3V1bUZhaWxzYWZlQWN0aXZlIHx8CiAJCW9sZF9zbmFw c2hvdF90aHJlc2hvbGQgPj0gMCkKIAkJcmV0dXJuIGZhbHNlOwogCmRpZmYgLS1naXQgYS9zcmMv YmFja2VuZC9jb21tYW5kcy92YWN1dW0uYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5j CmluZGV4IGRhODUzMzBlZjQuLmM3NGIyMWZjZTkgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2Nv bW1hbmRzL3ZhY3V1bS5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCkBAIC03 Miw2ICs3MiwyMSBAQCBpbnQJCQl2YWN1dW1fbXVsdGl4YWN0X2ZyZWV6ZV90YWJsZV9hZ2U7CiBp bnQJCQl2YWN1dW1fZmFpbHNhZmVfYWdlOwogaW50CQkJdmFjdXVtX211bHRpeGFjdF9mYWlsc2Fm ZV9hZ2U7CiAKKy8qCisgKiBWYWN1dW1GYWlsc2FmZUFjdGl2ZSBpcyBhIGRlZmluZWQgYXMgYSBn bG9iYWwgc28gdGhhdCB3ZSBjYW4gZGV0ZXJtaW5lCisgKiB3aGV0aGVyIG9yIG5vdCB0byByZS1l bmFibGUgY29zdC1iYXNlZCB2YWN1dW0gZGVsYXkgd2hlbiB2YWN1dW1pbmcgYSB0YWJsZS4KKyAq IElmIGZhaWxzYWZlIG1vZGUgaGFzIGJlZW4gZW5nYWdlZCwgd2Ugd2lsbCBub3QgcmUtZW5hYmxl IGNvc3QtYmFzZWQgZGVsYXkKKyAqIGZvciB0aGUgdGFibGUgdW50aWwgYWZ0ZXIgdmFjdXVtaW5n IGhhcyBjb21wbGV0ZWQsIHJlZ2FyZGxlc3Mgb2Ygb3RoZXIKKyAqIHNldHRpbmdzLgorICoKKyAq IE9ubHkgVkFDVVVNIGNvZGUgc2hvdWxkIGluc3BlY3QgdGhpcyB2YXJpYWJsZSBhbmQgb25seSB0 YWJsZSBhY2Nlc3MgbWV0aG9kcworICogc2hvdWxkIHNldCBpdCB0byB0cnVlLiBJbiBUYWJsZSBB TS1hZ25vc3RpYyBWQUNVVU0gY29kZSwgdGhpcyB2YXJpYWJsZSBpcworICogaW5zcGVjdGVkIHRv IGRldGVybWluZSB3aGV0aGVyIG9yIG5vdCB0byBhbGxvdyBjb3N0LWJhc2VkIGRlbGF5cy4gVGFi bGUgQU1zCisgKiBhcmUgZnJlZSB0byBzZXQgaXQgaWYgdGhleSBkZXNpcmUgdGhpcyBiZWhhdmlv ciwgYnV0IGl0IGlzIGZhbHNlIGJ5IGRlZmF1bHQKKyAqIGFuZCByZXNldCB0byBmYWxzZSBpbiBi ZXR3ZWVuIHZhY3V1bWluZyBlYWNoIHJlbGF0aW9uLgorICovCitib29sCQlWYWN1dW1GYWlsc2Fm ZUFjdGl2ZSA9IGZhbHNlOworCiAvKgogICogVmFyaWFibGVzIGZvciBjb3N0LWJhc2VkIHBhcmFs bGVsIHZhY3V1bS4gIFNlZSBjb21tZW50cyBhdG9wCiAgKiBjb21wdXRlX3BhcmFsbGVsX2RlbGF5 IHRvIHVuZGVyc3RhbmQgaG93IGl0IHdvcmtzLgpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvY29t bWFuZHMvdmFjdXVtLmggYi9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaAppbmRleCBiZGZk OTZjZmVjLi43MjE5YzZiYTljIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1 dW0uaAorKysgYi9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaApAQCAtMzA2LDYgKzMwNiw3 IEBAIGV4dGVybiBQR0RMTElNUE9SVCBwZ19hdG9taWNfdWludDMyICpWYWN1dW1TaGFyZWRDb3N0 QmFsYW5jZTsKIGV4dGVybiBQR0RMTElNUE9SVCBwZ19hdG9taWNfdWludDMyICpWYWN1dW1BY3Rp dmVOV29ya2VyczsKIGV4dGVybiBQR0RMTElNUE9SVCBpbnQgVmFjdXVtQ29zdEJhbGFuY2VMb2Nh bDsKIAorZXh0ZXJuIFBHRExMSU1QT1JUIGJvb2wgVmFjdXVtRmFpbHNhZmVBY3RpdmU7CiAKIC8q IGluIGNvbW1hbmRzL3ZhY3V1bS5jICovCiBleHRlcm4gdm9pZCBFeGVjVmFjdXVtKFBhcnNlU3Rh dGUgKnBzdGF0ZSwgVmFjdXVtU3RtdCAqdmFjc3RtdCwgYm9vbCBpc1RvcExldmVsKTsKLS0gCjIu MzcuMgoK --00000000000003aa1905f89876c2 Content-Type: text/x-patch; charset="US-ASCII"; name="v16-0002-Separate-vacuum-cost-variables-from-gucs.patch" Content-Disposition: attachment; filename="v16-0002-Separate-vacuum-cost-variables-from-gucs.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg3u9xtg1 RnJvbSBlNmY3Y2ViOTU2MDAxNDkyNjhiYTg3YzNmNjJjOWY1NDlkOWUyY2ExIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBNb24sIDMgQXByIDIwMjMgMTE6MjI6MTggLTA0MDAKU3ViamVjdDogW1BB VENIIHYxNiAyLzNdIFNlcGFyYXRlIHZhY3V1bSBjb3N0IHZhcmlhYmxlcyBmcm9tIGd1Y3MKClZh Y3V1bSBjb2RlIHJ1biBib3RoIGJ5IGF1dG92YWN1dW0gd29ya2VycyBhbmQgYSBiYWNrZW5kIGRv aW5nClZBQ1VVTS9BTkFMWVpFIHByZXZpb3VzbHkgdXNlZCBWYWN1dW1Db3N0TGltaXQgYW5kIFZh Y3V1bUNvc3REZWxheSB3aGljaAp3ZXJlIHRoZSBnbG9iYWwgdmFyaWFibGVzIGZvciB0aGUgZ3Vj cyB2YWN1dW1fY29zdF9saW1pdCBhbmQKdmFjdXVtX2Nvc3RfZGVsYXkuIEF1dG92YWN1dW0gd29y a2VycyBuZWVkZWQgdG8gb3ZlcnJpZGUgdGhlc2UgdmFyaWFibGVzCndpdGggdGhlaXIgb3duIHZh bHVlcywgZGVyaXZlZCBmcm9tIGF1dG92YWN1dW1fdmFjdXVtX2Nvc3RfbGltaXQgYW5kCmF1dG92 YWN1dW1fdmFjdXVtX2Nvc3RfZGVsYXkgYW5kIHdvcmtlciBjb3N0IGxpbWl0IGJhbGFuY2luZyBs b2dpYy4gVGhpcwpsZWQgdG8gY29uZnVzaW5nIGNvZGUgd2hpY2gsIGluIHNvbWUgY2FzZXMsIGJv dGggZGVyaXZlZCBhbmQgc2V0IGEgbmV3CnZhbHVlIG9mIFZhY3V1bUNvc3RMaW1pdCBmcm9tIFZh Y3V1bUNvc3RMaW1pdC4KCkluIHByZXBhcmF0aW9uIGZvciByZWZyZXNoaW5nIHRoZXNlIGd1YyB2 YWx1ZXMgbW9yZSBvZnRlbiwgc2VwYXJhdGUKdGhlc2UgdmFyaWFibGVzIGZyb20gdGhlIGd1Y3Mg dGhlbXNlbHZlcyBhbmQgYWRkIGEgZnVuY3Rpb24gdG8gdXBkYXRlCnRoZSBnbG9iYWwgdmFyaWFi bGVzIHVzaW5nIHRoZSBndWNzIGFuZCBleGlzdGluZyBsb2dpYy4KClBlciBzdWdnZXN0aW9uIGJ5 IEt5b3Rhcm8gSG9yaWd1Y2hpCgpSZXZpZXdlZC1ieTogTWFzYWhpa28gU2F3YWRhIDxzYXdhZGEu bXNoa0BnbWFpbC5jb20+ClJldmlld2VkLWJ5OiBEYW5pZWwgR3VzdGFmc3NvbiA8ZGFuaWVsQHll c3FsLnNlPgpSZXZpZXdlZC1ieTogS3lvdGFybyBIb3JpZ3VjaGkgPGhvcmlreW90YS5udHRAZ21h aWwuY29tPgpEaXNjdXNzaW9uOiBodHRwczovL3d3dy5wb3N0Z3Jlc3FsLm9yZy9tZXNzYWdlLWlk L2ZsYXQvQ0FBS1J1X1puZ3pxbkVPRGM3TG1TMU5IMDRLdDZZOWh1U2p6NXBwNyUyQkRYaHJqREEw Z3clNDBtYWlsLmdtYWlsLmNvbQotLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jICAg ICAgICAgfCAxNSArKysrKysrKystLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxs ZWwuYyB8ICAxICsKIHNyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jICAgfCAzOCAr KysrKysrKysrKy0tLS0tLS0tLS0tLS0tLS0KIHNyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFs cy5jICAgICAgfCAgMiAtLQogc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWNfdGFibGVzLmMgICB8 ICA0ICstLQogc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmggICAgICAgICB8ICA3ICsrKysr CiBzcmMvaW5jbHVkZS9taXNjYWRtaW4uaCAgICAgICAgICAgICAgIHwgIDIgLS0KIHNyYy9pbmNs dWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oICAgfCAgMyAtLS0KIDggZmlsZXMgY2hhbmdlZCwg MzkgaW5zZXJ0aW9ucygrKSwgMzMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvY29tbWFuZHMvdmFjdXVtLmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYwppbmRl eCBjNzRiMjFmY2U5Li5jODQyZDhmMWU5IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5k cy92YWN1dW0uYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYwpAQCAtNzEsNiAr NzEsMTcgQEAgaW50CQkJdmFjdXVtX211bHRpeGFjdF9mcmVlemVfbWluX2FnZTsKIGludAkJCXZh Y3V1bV9tdWx0aXhhY3RfZnJlZXplX3RhYmxlX2FnZTsKIGludAkJCXZhY3V1bV9mYWlsc2FmZV9h Z2U7CiBpbnQJCQl2YWN1dW1fbXVsdGl4YWN0X2ZhaWxzYWZlX2FnZTsKK2RvdWJsZQkJdmFjdXVt X2Nvc3RfZGVsYXk7CitpbnQJCQl2YWN1dW1fY29zdF9saW1pdDsKKworLyoKKyAqIFZhcmlhYmxl cyBmb3IgY29zdC1iYXNlZCB2YWN1dW0gZGVsYXkuIFRoZSBkZWZhdWx0cyBkaWZmZXIgYmV0d2Vl bgorICogYXV0b3ZhY3V1bSBhbmQgdmFjdXVtLiBUaGVzZSBzaG91bGQgYmUgb3ZlcnJpZGRlbiB3 aXRoIHRoZSBhcHByb3ByaWF0ZSBHVUMKKyAqIHZhbHVlIGluIHZhY3V1bSBjb2RlLiBUaGVzZSBh cmUgaW5pdGlhbGl6ZWQgaGVyZSB0byB0aGUgZGVmYXVsdHMgZm9yIGNsaWVudAorICogYmFja2Vu ZHMgZXhlY3V0aW5nIFZBQ1VVTSBvciBBTkFMWVpFLgorICovCitpbnQJCQlWYWN1dW1Db3N0TGlt aXQgPSAyMDA7Citkb3VibGUJCVZhY3V1bUNvc3REZWxheSA9IDA7CiAKIC8qCiAgKiBWYWN1dW1G YWlsc2FmZUFjdGl2ZSBpcyBhIGRlZmluZWQgYXMgYSBnbG9iYWwgc28gdGhhdCB3ZSBjYW4gZGV0 ZXJtaW5lCkBAIC01MDQsNiArNTE1LDcgQEAgdmFjdXVtKExpc3QgKnJlbGF0aW9ucywgVmFjdXVt UGFyYW1zICpwYXJhbXMsCiAJewogCQlMaXN0Q2VsbCAgICpjdXI7CiAKKwkJVmFjdXVtVXBkYXRl Q29zdHMoKTsKIAkJaW5fdmFjdXVtID0gdHJ1ZTsKIAkJVmFjdXVtQ29zdEFjdGl2ZSA9IChWYWN1 dW1Db3N0RGVsYXkgPiAwKTsKIAkJVmFjdXVtQ29zdEJhbGFuY2UgPSAwOwpAQCAtMjI2NCw4ICsy Mjc2LDcgQEAgdmFjdXVtX2RlbGF5X3BvaW50KHZvaWQpCiAKIAkJVmFjdXVtQ29zdEJhbGFuY2Ug PSAwOwogCi0JCS8qIHVwZGF0ZSBiYWxhbmNlIHZhbHVlcyBmb3Igd29ya2VycyAqLwotCQlBdXRv VmFjdXVtVXBkYXRlRGVsYXkoKTsKKwkJVmFjdXVtVXBkYXRlQ29zdHMoKTsKIAogCQkvKiBNaWdo dCBoYXZlIGdvdHRlbiBhbiBpbnRlcnJ1cHQgd2hpbGUgc2xlZXBpbmcgKi8KIAkJQ0hFQ0tfRk9S X0lOVEVSUlVQVFMoKTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBh cmFsbGVsLmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCmluZGV4IDU2 MzExN2E4ZjYuLjBiNTljOTIyZTQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3Zh Y3V1bXBhcmFsbGVsLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwu YwpAQCAtOTk2LDYgKzk5Niw3IEBAIHBhcmFsbGVsX3ZhY3V1bV9tYWluKGRzbV9zZWdtZW50ICpz ZWcsIHNobV90b2MgKnRvYykKIAogCS8qIFNldCBjb3N0LWJhc2VkIHZhY3V1bSBkZWxheSAqLwog CVZhY3V1bUNvc3RBY3RpdmUgPSAoVmFjdXVtQ29zdERlbGF5ID4gMCk7CisJVmFjdXVtVXBkYXRl Q29zdHMoKTsKIAlWYWN1dW1Db3N0QmFsYW5jZSA9IDA7CiAJVmFjdXVtUGFnZUhpdCA9IDA7CiAJ VmFjdXVtUGFnZU1pc3MgPSAwOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9h dXRvdmFjdXVtLmMgYi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwppbmRleCA1 ODVkMjgxNDhjLi5jZTdlMDA5NTc2IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVy L2F1dG92YWN1dW0uYworKysgYi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwpA QCAtMTc3NCwxNyArMTc3NCwyNSBAQCBGcmVlV29ya2VySW5mbyhpbnQgY29kZSwgRGF0dW0gYXJn KQogfQogCiAvKgotICogVXBkYXRlIHRoZSBjb3N0LWJhc2VkIGRlbGF5IHBhcmFtZXRlcnMsIHNv IHRoYXQgbXVsdGlwbGUgd29ya2VycyBjb25zdW1lCi0gKiBlYWNoIGEgZnJhY3Rpb24gb2YgdGhl IHRvdGFsIGF2YWlsYWJsZSBJL08uCisgKiBVcGRhdGUgdmFjdXVtIGNvc3QtYmFzZWQgZGVsYXkt cmVsYXRlZCBwYXJhbWV0ZXJzIGZvciBhdXRvdmFjdXVtIHdvcmtlcnMgYW5kCisgKiBiYWNrZW5k cyBleGVjdXRpbmcgVkFDVVVNIG9yIEFOQUxZWkUgdXNpbmcgdGhlIHZhbHVlIG9mIHJlbGV2YW50 IGd1Y3MgYW5kCisgKiBnbG9iYWwgc3RhdGUuIFRoaXMgbXVzdCBiZSBjYWxsZWQgZHVyaW5nIHNl dHVwIGZvciB2YWN1dW0gYW5kIGFmdGVyIGV2ZXJ5CisgKiBjb25maWcgcmVsb2FkIHRvIGVuc3Vy ZSB1cC10by1kYXRlIHZhbHVlcy4KICAqLwogdm9pZAotQXV0b1ZhY3V1bVVwZGF0ZURlbGF5KHZv aWQpCitWYWN1dW1VcGRhdGVDb3N0cyh2b2lkKQogewogCWlmIChNeVdvcmtlckluZm8pCiAJewog CQlWYWN1dW1Db3N0RGVsYXkgPSBNeVdvcmtlckluZm8tPndpX2Nvc3RfZGVsYXk7CiAJCVZhY3V1 bUNvc3RMaW1pdCA9IE15V29ya2VySW5mby0+d2lfY29zdF9saW1pdDsKIAl9CisJZWxzZQorCXsK KwkJLyogTXVzdCBiZSBleHBsaWNpdCBWQUNVVU0gb3IgQU5BTFlaRSAqLworCQlWYWN1dW1Db3N0 TGltaXQgPSB2YWN1dW1fY29zdF9saW1pdDsKKwkJVmFjdXVtQ29zdERlbGF5ID0gdmFjdXVtX2Nv c3RfZGVsYXk7CisJfQogfQogCiAvKgpAQCAtMTgwNSw5ICsxODEzLDkgQEAgYXV0b3ZhY19iYWxh bmNlX2Nvc3Qodm9pZCkKIAkgKiB6ZXJvIGlzIG5vdCBhIHZhbGlkIHZhbHVlLgogCSAqLwogCWlu dAkJCXZhY19jb3N0X2xpbWl0ID0gKGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQgPiAwID8KLQkJ CQkJCQkJICBhdXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0IDogVmFjdXVtQ29zdExpbWl0KTsKKwkJ CQkJCQkJICBhdXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0IDogdmFjdXVtX2Nvc3RfbGltaXQpOwog CWRvdWJsZQkJdmFjX2Nvc3RfZGVsYXkgPSAoYXV0b3ZhY3V1bV92YWNfY29zdF9kZWxheSA+PSAw ID8KLQkJCQkJCQkJICBhdXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5IDogVmFjdXVtQ29zdERlbGF5 KTsKKwkJCQkJCQkJICBhdXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5IDogdmFjdXVtX2Nvc3RfZGVs YXkpOwogCWRvdWJsZQkJY29zdF90b3RhbDsKIAlkb3VibGUJCWNvc3RfYXZhaWw7CiAJZGxpc3Rf aXRlcglpdGVyOwpAQCAtMjMxMiw4ICsyMzIwLDYgQEAgZG9fYXV0b3ZhY3V1bSh2b2lkKQogCQlh dXRvdmFjX3RhYmxlICp0YWI7CiAJCWJvb2wJCWlzc2hhcmVkOwogCQlib29sCQlza2lwaXQ7Ci0J CWRvdWJsZQkJc3RkVmFjdXVtQ29zdERlbGF5OwotCQlpbnQJCQlzdGRWYWN1dW1Db3N0TGltaXQ7 CiAJCWRsaXN0X2l0ZXIJaXRlcjsKIAogCQlDSEVDS19GT1JfSU5URVJSVVBUUygpOwpAQCAtMjQx NiwxNCArMjQyMiw2IEBAIGRvX2F1dG92YWN1dW0odm9pZCkKIAkJCWNvbnRpbnVlOwogCQl9CiAK LQkJLyoKLQkJICogUmVtZW1iZXIgdGhlIHByZXZhaWxpbmcgdmFsdWVzIG9mIHRoZSB2YWN1dW0g Y29zdCBHVUNzLiAgV2UgaGF2ZSB0bwotCQkgKiByZXN0b3JlIHRoZXNlIGF0IHRoZSBib3R0b20g b2YgdGhlIGxvb3AsIGVsc2Ugd2UnbGwgY29tcHV0ZSB3cm9uZwotCQkgKiB2YWx1ZXMgaW4gdGhl IG5leHQgaXRlcmF0aW9uIG9mIGF1dG92YWNfYmFsYW5jZV9jb3N0KCkuCi0JCSAqLwotCQlzdGRW YWN1dW1Db3N0RGVsYXkgPSBWYWN1dW1Db3N0RGVsYXk7Ci0JCXN0ZFZhY3V1bUNvc3RMaW1pdCA9 IFZhY3V1bUNvc3RMaW1pdDsKLQogCQkvKiBNdXN0IGhvbGQgQXV0b3ZhY3V1bUxvY2sgd2hpbGUg bXVja2luZyB3aXRoIGNvc3QgYmFsYW5jZSBpbmZvICovCiAJCUxXTG9ja0FjcXVpcmUoQXV0b3Zh Y3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7CiAKQEAgLTI0MzcsNyArMjQzNSw3IEBAIGRvX2F1dG92 YWN1dW0odm9pZCkKIAkJYXV0b3ZhY19iYWxhbmNlX2Nvc3QoKTsKIAogCQkvKiBzZXQgdGhlIGFj dGl2ZSBjb3N0IHBhcmFtZXRlcnMgZnJvbSB0aGUgcmVzdWx0IG9mIHRoYXQgKi8KLQkJQXV0b1Zh Y3V1bVVwZGF0ZURlbGF5KCk7CisJCVZhY3V1bVVwZGF0ZUNvc3RzKCk7CiAKIAkJLyogZG9uZSAq LwogCQlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKQEAgLTI1MzQsMTAgKzI1MzIsNiBA QCBkZWxldGVkOgogCQlNeVdvcmtlckluZm8tPndpX3RhYmxlb2lkID0gSW52YWxpZE9pZDsKIAkJ TXlXb3JrZXJJbmZvLT53aV9zaGFyZWRyZWwgPSBmYWxzZTsKIAkJTFdMb2NrUmVsZWFzZShBdXRv dmFjdXVtU2NoZWR1bGVMb2NrKTsKLQotCQkvKiByZXN0b3JlIHZhY3V1bSBjb3N0IEdVQ3MgZm9y IHRoZSBuZXh0IGl0ZXJhdGlvbiAqLwotCQlWYWN1dW1Db3N0RGVsYXkgPSBzdGRWYWN1dW1Db3N0 RGVsYXk7Ci0JCVZhY3V1bUNvc3RMaW1pdCA9IHN0ZFZhY3V1bUNvc3RMaW1pdDsKIAl9CiAKIAkv KgpAQCAtMjgyMCwxNCArMjgxNCwxNCBAQCB0YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlk LCBIVEFCICp0YWJsZV90b2FzdF9tYXAsCiAJCQk/IGF2b3B0cy0+dmFjdXVtX2Nvc3RfZGVsYXkK IAkJCTogKGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkgPj0gMCkKIAkJCT8gYXV0b3ZhY3V1bV92 YWNfY29zdF9kZWxheQotCQkJOiBWYWN1dW1Db3N0RGVsYXk7CisJCQk6IHZhY3V1bV9jb3N0X2Rl bGF5OwogCiAJCS8qIDAgb3IgLTEgaW4gYXV0b3ZhYyBzZXR0aW5nIG1lYW5zIHVzZSBwbGFpbiB2 YWN1dW1fY29zdF9saW1pdCAqLwogCQl2YWNfY29zdF9saW1pdCA9IChhdm9wdHMgJiYgYXZvcHRz LT52YWN1dW1fY29zdF9saW1pdCA+IDApCiAJCQk/IGF2b3B0cy0+dmFjdXVtX2Nvc3RfbGltaXQK IAkJCTogKGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQgPiAwKQogCQkJPyBhdXRvdmFjdXVtX3Zh Y19jb3N0X2xpbWl0Ci0JCQk6IFZhY3V1bUNvc3RMaW1pdDsKKwkJCTogdmFjdXVtX2Nvc3RfbGlt aXQ7CiAKIAkJLyogLTEgaW4gYXV0b3ZhYyBzZXR0aW5nIG1lYW5zIHVzZSBsb2dfYXV0b3ZhY3V1 bV9taW5fZHVyYXRpb24gKi8KIAkJbG9nX21pbl9kdXJhdGlvbiA9IChhdm9wdHMgJiYgYXZvcHRz LT5sb2dfbWluX2R1cmF0aW9uID49IDApCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9p bml0L2dsb2JhbHMuYyBiL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jCmluZGV4IDFi MWQ4MTQyNTQuLjhlNWIwNjVlOGYgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQv Z2xvYmFscy5jCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jCkBAIC0xNDIs OCArMTQyLDYgQEAgaW50CQkJTWF4QmFja2VuZHMgPSAwOwogaW50CQkJVmFjdXVtQ29zdFBhZ2VI aXQgPSAxOwkvKiBHVUMgcGFyYW1ldGVycyBmb3IgdmFjdXVtICovCiBpbnQJCQlWYWN1dW1Db3N0 UGFnZU1pc3MgPSAyOwogaW50CQkJVmFjdXVtQ29zdFBhZ2VEaXJ0eSA9IDIwOwotaW50CQkJVmFj dXVtQ29zdExpbWl0ID0gMjAwOwotZG91YmxlCQlWYWN1dW1Db3N0RGVsYXkgPSAwOwogCiBpbnQ2 NAkJVmFjdXVtUGFnZUhpdCA9IDA7CiBpbnQ2NAkJVmFjdXVtUGFnZU1pc3MgPSAwOwpkaWZmIC0t Z2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWNfdGFibGVzLmMgYi9zcmMvYmFja2VuZC91 dGlscy9taXNjL2d1Y190YWJsZXMuYwppbmRleCA4MDYyNTg5ZWZkLi43N2RiMWExNDZjIDEwMDY0 NAotLS0gYS9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Y190YWJsZXMuYworKysgYi9zcmMvYmFj a2VuZC91dGlscy9taXNjL2d1Y190YWJsZXMuYwpAQCAtMjQwOSw3ICsyNDA5LDcgQEAgc3RydWN0 IGNvbmZpZ19pbnQgQ29uZmlndXJlTmFtZXNJbnRbXSA9CiAJCQlnZXR0ZXh0X25vb3AoIlZhY3V1 bSBjb3N0IGFtb3VudCBhdmFpbGFibGUgYmVmb3JlIG5hcHBpbmcuIiksCiAJCQlOVUxMCiAJCX0s Ci0JCSZWYWN1dW1Db3N0TGltaXQsCisJCSZ2YWN1dW1fY29zdF9saW1pdCwKIAkJMjAwLCAxLCAx MDAwMCwKIAkJTlVMTCwgTlVMTCwgTlVMTAogCX0sCkBAIC0zNzAxLDcgKzM3MDEsNyBAQCBzdHJ1 Y3QgY29uZmlnX3JlYWwgQ29uZmlndXJlTmFtZXNSZWFsW10gPQogCQkJTlVMTCwKIAkJCUdVQ19V TklUX01TCiAJCX0sCi0JCSZWYWN1dW1Db3N0RGVsYXksCisJCSZ2YWN1dW1fY29zdF9kZWxheSwK IAkJMCwgMCwgMTAwLAogCQlOVUxMLCBOVUxMLCBOVUxMCiAJfSwKZGlmZiAtLWdpdCBhL3NyYy9p bmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgK aW5kZXggNzIxOWM2YmE5Yy4uZDA0OGJiNmUwZCAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvY29t bWFuZHMvdmFjdXVtLmgKKysrIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKQEAgLTMw MCw2ICszMDAsOCBAQCBleHRlcm4gUEdETExJTVBPUlQgaW50IHZhY3V1bV9tdWx0aXhhY3RfZnJl ZXplX21pbl9hZ2U7CiBleHRlcm4gUEdETExJTVBPUlQgaW50IHZhY3V1bV9tdWx0aXhhY3RfZnJl ZXplX3RhYmxlX2FnZTsKIGV4dGVybiBQR0RMTElNUE9SVCBpbnQgdmFjdXVtX2ZhaWxzYWZlX2Fn ZTsKIGV4dGVybiBQR0RMTElNUE9SVCBpbnQgdmFjdXVtX211bHRpeGFjdF9mYWlsc2FmZV9hZ2U7 CitleHRlcm4gUEdETExJTVBPUlQgZG91YmxlIHZhY3V1bV9jb3N0X2RlbGF5OworZXh0ZXJuIFBH RExMSU1QT1JUIGludCB2YWN1dW1fY29zdF9saW1pdDsKIAogLyogVmFyaWFibGVzIGZvciBjb3N0 LWJhc2VkIHBhcmFsbGVsIHZhY3V1bSAqLwogZXh0ZXJuIFBHRExMSU1QT1JUIHBnX2F0b21pY191 aW50MzIgKlZhY3V1bVNoYXJlZENvc3RCYWxhbmNlOwpAQCAtMzA3LDYgKzMwOSw4IEBAIGV4dGVy biBQR0RMTElNUE9SVCBwZ19hdG9taWNfdWludDMyICpWYWN1dW1BY3RpdmVOV29ya2VyczsKIGV4 dGVybiBQR0RMTElNUE9SVCBpbnQgVmFjdXVtQ29zdEJhbGFuY2VMb2NhbDsKIAogZXh0ZXJuIFBH RExMSU1QT1JUIGJvb2wgVmFjdXVtRmFpbHNhZmVBY3RpdmU7CitleHRlcm4gUEdETExJTVBPUlQg aW50IFZhY3V1bUNvc3RMaW1pdDsKK2V4dGVybiBQR0RMTElNUE9SVCBkb3VibGUgVmFjdXVtQ29z dERlbGF5OwogCiAvKiBpbiBjb21tYW5kcy92YWN1dW0uYyAqLwogZXh0ZXJuIHZvaWQgRXhlY1Zh Y3V1bShQYXJzZVN0YXRlICpwc3RhdGUsIFZhY3V1bVN0bXQgKnZhY3N0bXQsIGJvb2wgaXNUb3BM ZXZlbCk7CkBAIC0zNDYsNiArMzUwLDkgQEAgZXh0ZXJuIEluZGV4QnVsa0RlbGV0ZVJlc3VsdCAq dmFjX2NsZWFudXBfb25lX2luZGV4KEluZGV4VmFjdXVtSW5mbyAqaXZpbmZvLAogCQkJCQkJCQkJ CQkJCUluZGV4QnVsa0RlbGV0ZVJlc3VsdCAqaXN0YXQpOwogZXh0ZXJuIFNpemUgdmFjX21heF9p dGVtc190b19hbGxvY19zaXplKGludCBtYXhfaXRlbXMpOwogCisvKiBJbiBwb3N0bWFzdGVyL2F1 dG92YWN1dW0uYyAqLworZXh0ZXJuIHZvaWQgVmFjdXVtVXBkYXRlQ29zdHModm9pZCk7CisKIC8q IGluIGNvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMgKi8KIGV4dGVybiBQYXJhbGxlbFZhY3V1bVN0 YXRlICpwYXJhbGxlbF92YWN1dW1faW5pdChSZWxhdGlvbiByZWwsIFJlbGF0aW9uICppbmRyZWxz LAogCQkJCQkJCQkJCQkJIGludCBuaW5kZXhlcywgaW50IG5yZXF1ZXN0ZWRfd29ya2VycywKZGlm ZiAtLWdpdCBhL3NyYy9pbmNsdWRlL21pc2NhZG1pbi5oIGIvc3JjL2luY2x1ZGUvbWlzY2FkbWlu LmgKaW5kZXggMDZhODZmOWFjMS4uNjZkYjFiMmM2OSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUv bWlzY2FkbWluLmgKKysrIGIvc3JjL2luY2x1ZGUvbWlzY2FkbWluLmgKQEAgLTI2Niw4ICsyNjYs NiBAQCBleHRlcm4gUEdETExJTVBPUlQgaW50IG1heF9wYXJhbGxlbF9tYWludGVuYW5jZV93b3Jr ZXJzOwogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBWYWN1dW1Db3N0UGFnZUhpdDsKIGV4dGVybiBQ R0RMTElNUE9SVCBpbnQgVmFjdXVtQ29zdFBhZ2VNaXNzOwogZXh0ZXJuIFBHRExMSU1QT1JUIGlu dCBWYWN1dW1Db3N0UGFnZURpcnR5OwotZXh0ZXJuIFBHRExMSU1QT1JUIGludCBWYWN1dW1Db3N0 TGltaXQ7Ci1leHRlcm4gUEdETExJTVBPUlQgZG91YmxlIFZhY3V1bUNvc3REZWxheTsKIAogZXh0 ZXJuIFBHRExMSU1QT1JUIGludDY0IFZhY3V1bVBhZ2VIaXQ7CiBleHRlcm4gUEdETExJTVBPUlQg aW50NjQgVmFjdXVtUGFnZU1pc3M7CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9wb3N0bWFzdGVy L2F1dG92YWN1dW0uaCBiL3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oCmluZGV4 IGMxNDAzNzFiNTEuLjY1YWZkMWVhMWUgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3Bvc3RtYXN0 ZXIvYXV0b3ZhY3V1bS5oCisrKyBiL3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5o CkBAIC02Myw5ICs2Myw2IEBAIGV4dGVybiBpbnQJU3RhcnRBdXRvVmFjV29ya2VyKHZvaWQpOwog LyogY2FsbGVkIGZyb20gcG9zdG1hc3RlciB3aGVuIGEgd29ya2VyIGNvdWxkIG5vdCBiZSBmb3Jr ZWQgKi8KIGV4dGVybiB2b2lkIEF1dG9WYWNXb3JrZXJGYWlsZWQodm9pZCk7CiAKLS8qIGF1dG92 YWN1dW0gY29zdC1kZWxheSBiYWxhbmNlciAqLwotZXh0ZXJuIHZvaWQgQXV0b1ZhY3V1bVVwZGF0 ZURlbGF5KHZvaWQpOwotCiAjaWZkZWYgRVhFQ19CQUNLRU5ECiBleHRlcm4gdm9pZCBBdXRvVmFj TGF1bmNoZXJNYWluKGludCBhcmdjLCBjaGFyICphcmd2W10pIHBnX2F0dHJpYnV0ZV9ub3JldHVy bigpOwogZXh0ZXJuIHZvaWQgQXV0b1ZhY1dvcmtlck1haW4oaW50IGFyZ2MsIGNoYXIgKmFyZ3Zb XSkgcGdfYXR0cmlidXRlX25vcmV0dXJuKCk7Ci0tIAoyLjM3LjIKCg== --00000000000003aa1905f89876c2 Content-Type: text/x-patch; charset="US-ASCII"; name="v16-0003-Autovacuum-refreshes-cost-based-delay-params-mor.patch" Content-Disposition: attachment; filename="v16-0003-Autovacuum-refreshes-cost-based-delay-params-mor.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg3u9xtg2 RnJvbSBlMmE1MjMxOGEzNWZiZTcyMzZiNjc1ZjVhN2MyMTBkMDI1NjhhYWRmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBTYXQsIDI1IE1hciAyMDIzIDE0OjE0OjU1IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTYgMy8zXSBBdXRvdmFjdXVtIHJlZnJlc2hlcyBjb3N0LWJhc2VkIGRlbGF5IHBhcmFt cyBtb3JlCiBvZnRlbgoKQWxsb3cgYXV0b3ZhY3V1bSB0byByZWxvYWQgdGhlIGNvbmZpZyBmaWxl IG1vcmUgb2Z0ZW4gc28gdGhhdCBjb3N0LWJhc2VkCmRlbGF5IHBhcmFtZXRlcnMgY2FuIHRha2Ug ZWZmZWN0IHdoaWxlIFZBQ1VVTWluZyBhIHJlbGF0aW9uLiBQcmV2aW91c2x5CmF1dG92YWN1dW0g d29ya2VycyBvbmx5IHJlbG9hZGVkIHRoZSBjb25maWcgZmlsZSBvbmNlIHBlciByZWxhdGlvbgp2 YWN1dW1lZCwgc28gY29uZmlnIGNoYW5nZXMgY291bGQgbm90IHRha2UgZWZmZWN0IHVudGlsIGJl Z2lubmluZyB0bwp2YWN1dW0gdGhlIG5leHQgdGFibGUuCgpOb3csIGNoZWNrIGlmIGEgcmVsb2Fk IGlzIHBlbmRpbmcgcm91Z2hseSBvbmNlIHBlciBibG9jaywgd2hlbiBjaGVja2luZwppZiB3ZSBu ZWVkIHRvIGRlbGF5LgoKSW4gb3JkZXIgZm9yIGF1dG92YWN1dW0gd29ya2VycyB0byBzYWZlbHkg dXBkYXRlIHRoZWlyIG93biBjb3N0IGRlbGF5CmFuZCBjb3N0IGxpbWl0IHBhcmFtZXRlcnMgd2l0 aG91dCBpbXBhY3RpbmcgcGVyZm9ybWFuY2UsIHdlIGhhZCB0bwpyZXRoaW5rIHdoZW4gYW5kIGhv dyB0aGVzZSB2YWx1ZXMgd2VyZSBhY2Nlc3NlZC4KClByZXZpb3VzbHksIGFuIGF1dG92YWN1dW0g d29ya2VyJ3Mgd2lfY29zdF9saW1pdCB3YXMgc2V0IG9ubHkgYXQgdGhlCmJlZ2lubmluZyBvZiB2 YWN1dW1pbmcgYSB0YWJsZSwgYWZ0ZXIgcmVsb2FkaW5nIHRoZSBjb25maWcgZmlsZS4KVGhlcmVm b3JlLCBhdCB0aGUgdGltZSB0aGF0IGF1dG92YWNfYmFsYW5jZV9jb3N0KCkgaXMgY2FsbGVkLCB3 b3JrZXJzCnZhY3V1bWluZyB0YWJsZXMgd2l0aCBubyBjb3N0LXJlbGF0ZWQgc3RvcmFnZSBwYXJh bWV0ZXJzIGNvdWxkIHN0aWxsCmhhdmUgZGlmZmVyZW50IHZhbHVlcyBmb3IgdGhlaXIgd2lfY29z dF9saW1pdF9iYXNlIGFuZCB3aV9jb3N0X2RlbGF5LgoKTm93IHRoYXQgdGhlIGNvc3QgcGFyYW1l dGVycyBjYW4gYmUgdXBkYXRlZCB3aGlsZSB2YWN1dW1pbmcgYSB0YWJsZSwKd29ya2VycyB3aWxs ICh3aXRoaW4gc29tZSBtYXJnaW4gb2YgZXJyb3IpIGhhdmUgbm8gcmVhc29uIHRvIGhhdmUKZGlm ZmVyZW50IHZhbHVlcyBmb3IgY29zdCBsaW1pdCBhbmQgY29zdCBkZWxheSAoaW4gdGhlIGFic2Vu Y2Ugb2YKY29zdC1yZWxhdGVkIHN0b3JhZ2UgcGFyYW1ldGVycykuIFRoaXMgcmVtb3ZlcyB0aGUg cmF0aW9uYWxlIGZvciBrZWVwaW5nCmNvc3QgbGltaXQgYW5kIGNvc3QgZGVsYXkgaW4gc2hhcmVk IG1lbW9yeS4gQmFsYW5jaW5nIHRoZSBjb3N0IGxpbWl0CnJlcXVpcmVzIG9ubHkgdGhlIG51bWJl ciBvZiBhY3RpdmUgYXV0b3ZhY3V1bSB3b3JrZXJzIHZhY3V1bWluZyBhIHRhYmxlCndpdGggbm8g Y29zdC1iYXNlZCBzdG9yYWdlIHBhcmFtZXRlcnMuCgpSZXZpZXdlZC1ieTogTWFzYWhpa28gU2F3 YWRhIDxzYXdhZGEubXNoa0BnbWFpbC5jb20+ClJldmlld2VkLWJ5OiBEYW5pZWwgR3VzdGFmc3Nv biA8ZGFuaWVsQHllc3FsLnNlPgpSZXZpZXdlZC1ieTogS3lvdGFybyBIb3JpZ3VjaGkgPGhvcmlr eW90YS5udHRAZ21haWwuY29tPgpEaXNjdXNzaW9uOiBodHRwczovL3d3dy5wb3N0Z3Jlc3FsLm9y Zy9tZXNzYWdlLWlkL2ZsYXQvQ0FBS1J1X1puZ3pxbkVPRGM3TG1TMU5IMDRLdDZZOWh1U2p6NXBw NyUyQkRYaHJqREEwZ3clNDBtYWlsLmdtYWlsLmNvbQotLS0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9o ZWFwL3ZhY3V1bWxhenkuYyAgfCAgIDIgKy0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5j ICAgICAgICAgfCAgNDQgKysrKy0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVs LmMgfCAgIDEgLQogc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMgICB8IDI3MSAr KysrKysrKysrKysrKystLS0tLS0tLS0tLQogc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgg ICAgICAgICB8ICAgMSArCiA1IGZpbGVzIGNoYW5nZWQsIDIwMCBpbnNlcnRpb25zKCspLCAxMTkg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVt bGF6eS5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jCmluZGV4IDJiYTg1 YmQzZDYuLjBhOWViZDIyYmQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3Zh Y3V1bWxhenkuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKQEAg LTM4OSw3ICszODksNyBAQCBoZWFwX3ZhY3V1bV9yZWwoUmVsYXRpb24gcmVsLCBWYWN1dW1QYXJh bXMgKnBhcmFtcywKIAlBc3NlcnQocGFyYW1zLT5pbmRleF9jbGVhbnVwICE9IFZBQ09QVFZBTFVF X1VOU1BFQ0lGSUVEKTsKIAlBc3NlcnQocGFyYW1zLT50cnVuY2F0ZSAhPSBWQUNPUFRWQUxVRV9V TlNQRUNJRklFRCAmJgogCQkgICBwYXJhbXMtPnRydW5jYXRlICE9IFZBQ09QVFZBTFVFX0FVVE8p OwotCVZhY3V1bUZhaWxzYWZlQWN0aXZlID0gZmFsc2U7CisJQXNzZXJ0KCFWYWN1dW1GYWlsc2Fm ZUFjdGl2ZSk7CiAJdmFjcmVsLT5jb25zaWRlcl9ieXBhc3Nfb3B0aW1pemF0aW9uID0gdHJ1ZTsK IAl2YWNyZWwtPmRvX2luZGV4X3ZhY3V1bWluZyA9IHRydWU7CiAJdmFjcmVsLT5kb19pbmRleF9j bGVhbnVwID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5j IGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKaW5kZXggYzg0MmQ4ZjFlOS4uMzdmYmJl MDA4YyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKKysrIGIvc3Jj L2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKQEAgLTQ4LDYgKzQ4LDcgQEAKICNpbmNsdWRlICJw Z3N0YXQuaCIKICNpbmNsdWRlICJwb3N0bWFzdGVyL2F1dG92YWN1dW0uaCIKICNpbmNsdWRlICJw b3N0bWFzdGVyL2Jnd29ya2VyX2ludGVybmFscy5oIgorI2luY2x1ZGUgInBvc3RtYXN0ZXIvaW50 ZXJydXB0LmgiCiAjaW5jbHVkZSAic3RvcmFnZS9idWZtZ3IuaCIKICNpbmNsdWRlICJzdG9yYWdl L2xtZ3IuaCIKICNpbmNsdWRlICJzdG9yYWdlL3Btc2lnbmFsLmgiCkBAIC01MTUsOSArNTE2LDkg QEAgdmFjdXVtKExpc3QgKnJlbGF0aW9ucywgVmFjdXVtUGFyYW1zICpwYXJhbXMsCiAJewogCQlM aXN0Q2VsbCAgICpjdXI7CiAKLQkJVmFjdXVtVXBkYXRlQ29zdHMoKTsKIAkJaW5fdmFjdXVtID0g dHJ1ZTsKLQkJVmFjdXVtQ29zdEFjdGl2ZSA9IChWYWN1dW1Db3N0RGVsYXkgPiAwKTsKKwkJVmFj dXVtRmFpbHNhZmVBY3RpdmUgPSBmYWxzZTsKKwkJVmFjdXVtVXBkYXRlQ29zdHMoKTsKIAkJVmFj dXVtQ29zdEJhbGFuY2UgPSAwOwogCQlWYWN1dW1QYWdlSGl0ID0gMDsKIAkJVmFjdXVtUGFnZU1p c3MgPSAwOwpAQCAtNTcxLDEyICs1NzIsMjAgQEAgdmFjdXVtKExpc3QgKnJlbGF0aW9ucywgVmFj dXVtUGFyYW1zICpwYXJhbXMsCiAJCQkJCUNvbW1hbmRDb3VudGVySW5jcmVtZW50KCk7CiAJCQkJ fQogCQkJfQorCisJCQkvKgorCQkJICogRW5zdXJlIFZhY3V1bUZhaWxzYWZlQWN0aXZlIGhhcyBi ZWVuIHJlc2V0IGJlZm9yZSB2YWN1dW1pbmcgdGhlCisJCQkgKiBuZXh0IHJlbGF0aW9uLgorCQkJ ICovCisJCQlWYWN1dW1GYWlsc2FmZUFjdGl2ZSA9IGZhbHNlOwogCQl9CiAJfQogCVBHX0ZJTkFM TFkoKTsKIAl7CiAJCWluX3ZhY3V1bSA9IGZhbHNlOwogCQlWYWN1dW1Db3N0QWN0aXZlID0gZmFs c2U7CisJCVZhY3V1bUZhaWxzYWZlQWN0aXZlID0gZmFsc2U7CisJCVZhY3V1bUNvc3RCYWxhbmNl ID0gMDsKIAl9CiAJUEdfRU5EX1RSWSgpOwogCkBAIC0yMjQzLDcgKzIyNTIsMjcgQEAgdmFjdXVt X2RlbGF5X3BvaW50KHZvaWQpCiAJLyogQWx3YXlzIGNoZWNrIGZvciBpbnRlcnJ1cHRzICovCiAJ Q0hFQ0tfRk9SX0lOVEVSUlVQVFMoKTsKIAotCWlmICghVmFjdXVtQ29zdEFjdGl2ZSB8fCBJbnRl cnJ1cHRQZW5kaW5nKQorCWlmIChJbnRlcnJ1cHRQZW5kaW5nIHx8CisJCSghVmFjdXVtQ29zdEFj dGl2ZSAmJiAhQ29uZmlnUmVsb2FkUGVuZGluZykpCisJCXJldHVybjsKKworCS8qCisJICogUmVs b2FkIHRoZSBjb25maWd1cmF0aW9uIGZpbGUgaWYgcmVxdWVzdGVkLiBUaGlzIGFsbG93cyBjaGFu Z2VzIHRvCisJICogYXV0b3ZhY3V1bV92YWN1dW1fY29zdF9saW1pdCBhbmQgYXV0b3ZhY3V1bV92 YWN1dW1fY29zdF9kZWxheSB0byB0YWtlCisJICogZWZmZWN0IHdoaWxlIGEgdGFibGUgaXMgYmVp bmcgdmFjdXVtZWQgb3IgYW5hbHl6ZWQuCisJICovCisJaWYgKENvbmZpZ1JlbG9hZFBlbmRpbmcg JiYgSXNBdXRvVmFjdXVtV29ya2VyUHJvY2VzcygpKQorCXsKKwkJQ29uZmlnUmVsb2FkUGVuZGlu ZyA9IGZhbHNlOworCQlQcm9jZXNzQ29uZmlnRmlsZShQR0NfU0lHSFVQKTsKKwkJVmFjdXVtVXBk YXRlQ29zdHMoKTsKKwl9CisKKwkvKgorCSAqIElmIHdlIGRpc2FibGVkIGNvc3QtYmFzZWQgZGVs YXlzIGFmdGVyIHJlbG9hZGluZyB0aGUgY29uZmlnIGZpbGUsCisJICogcmV0dXJuLgorCSAqLwor CWlmICghVmFjdXVtQ29zdEFjdGl2ZSkKIAkJcmV0dXJuOwogCiAJLyoKQEAgLTIyNzYsNyArMjMw NSwxNCBAQCB2YWN1dW1fZGVsYXlfcG9pbnQodm9pZCkKIAogCQlWYWN1dW1Db3N0QmFsYW5jZSA9 IDA7CiAKLQkJVmFjdXVtVXBkYXRlQ29zdHMoKTsKKwkJLyoKKwkJICogQmFsYW5jZSBhbmQgdXBk YXRlIGxpbWl0IHZhbHVlcyBmb3IgYXV0b3ZhY3V1bSB3b3JrZXJzLiBXZSBtdXN0CisJCSAqIGFs d2F5cyBkbyB0aGlzIGluIGNhc2UgdGhlIGF1dG92YWN1dW0gbGF1bmNoZXIgb3IgYW5vdGhlcgor CQkgKiBhdXRvdmFjdXVtIHdvcmtlciBoYXMgcmVjYWxjdWxhdGVkIHRoZSBudW1iZXIgb2Ygd29y a2VycyBhY3Jvc3MKKwkJICogd2hpY2ggd2UgbXVzdCBiYWxhbmNlIHRoZSBsaW1pdC4gVGhpcyBp cyBkb25lIGJ5IHRoZSBsYXVuY2hlciB3aGVuCisJCSAqIGxhdW5jaGluZyBhIG5ldyB3b3JrZXIg YW5kIGJ5IHdvcmtlcnMgYmVmb3JlIHZhY3V1bWluZyBlYWNoIHRhYmxlLgorCQkgKi8KKwkJQXV0 b1ZhY3V1bVVwZGF0ZUNvc3RMaW1pdCgpOwogCiAJCS8qIE1pZ2h0IGhhdmUgZ290dGVuIGFuIGlu dGVycnVwdCB3aGlsZSBzbGVlcGluZyAqLwogCQlDSEVDS19GT1JfSU5URVJSVVBUUygpOwpkaWZm IC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyBiL3NyYy9iYWNr ZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKaW5kZXggMGI1OWM5MjJlNC4uZTIwMGQ1Y2Fm OCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYworKysg Yi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC05OTUsNyArOTk1LDYg QEAgcGFyYWxsZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQog CQkJCQkJCQkJCQkJIGZhbHNlKTsKIAogCS8qIFNldCBjb3N0LWJhc2VkIHZhY3V1bSBkZWxheSAq LwotCVZhY3V1bUNvc3RBY3RpdmUgPSAoVmFjdXVtQ29zdERlbGF5ID4gMCk7CiAJVmFjdXVtVXBk YXRlQ29zdHMoKTsKIAlWYWN1dW1Db3N0QmFsYW5jZSA9IDA7CiAJVmFjdXVtUGFnZUhpdCA9IDA7 CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYyBiL3NyYy9i YWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCmluZGV4IGNlN2UwMDk1NzYuLjE1YWQyZjNk ZjcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCisrKyBi L3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCkBAIC0xMzksNiArMTM5LDE4IEBA IGludAkJCUxvZ19hdXRvdmFjdXVtX21pbl9kdXJhdGlvbiA9IDYwMDAwMDsKIHN0YXRpYyBib29s IGFtX2F1dG92YWN1dW1fbGF1bmNoZXIgPSBmYWxzZTsKIHN0YXRpYyBib29sIGFtX2F1dG92YWN1 dW1fd29ya2VyID0gZmFsc2U7CiAKKy8qCisgKiBWYXJpYWJsZXMgdG8gc2F2ZSB0aGUgY29zdC1y ZWxhdGVkIHN0b3JhZ2UgcGFyYW1ldGVycyBmb3IgdGhlIGN1cnJlbnQKKyAqIHJlbGF0aW9uIGJl aW5nIHZhY3V1bWVkIGJ5IHRoaXMgYXV0b3ZhY3V1bSB3b3JrZXIuIFVzaW5nIHRoZXNlLCB3ZSBj YW4KKyAqIGVuc3VyZSB3ZSBkb24ndCBvdmVyd3JpdGUgdGhlIHZhbHVlcyBvZiBWYWN1dW1Db3N0 RGVsYXkgYW5kIFZhY3V1bUNvc3RMaW1pdAorICogYWZ0ZXIgcmVsb2FkaW5nIHRoZSBjb25maWd1 cmF0aW9uIGZpbGUuIFRoZXkgYXJlIGluaXRpYWxpemVkIHRvICJpbnZhbGlkIgorICogdmFsdWVz IHRvIGluZGljYXRlIG5vIGNvc3QtcmVsYXRlZCBzdG9yYWdlIHBhcmFtZXRlcnMgd2VyZSBzcGVj aWZpZWQgYW5kCisgKiB3aWxsIGJlIHNldCBpbiBkb19hdXRvdmFjdXVtKCkgYWZ0ZXIgY2hlY2tp bmcgdGhlIHN0b3JhZ2UgcGFyYW1ldGVycyBpbgorICogdGFibGVfcmVjaGVja19hdXRvdmFjKCku CisgKi8KK3N0YXRpYyBkb3VibGUgYXZfc3RvcmFnZV9wYXJhbV9jb3N0X2RlbGF5ID0gLTE7Citz dGF0aWMgaW50CWF2X3N0b3JhZ2VfcGFyYW1fY29zdF9saW1pdCA9IC0xOworCiAvKiBGbGFncyBz ZXQgYnkgc2lnbmFsIGhhbmRsZXJzICovCiBzdGF0aWMgdm9sYXRpbGUgc2lnX2F0b21pY190IGdv dF9TSUdVU1IyID0gZmFsc2U7CiAKQEAgLTE4OSw4ICsyMDEsOCBAQCB0eXBlZGVmIHN0cnVjdCBh dXRvdmFjX3RhYmxlCiB7CiAJT2lkCQkJYXRfcmVsaWQ7CiAJVmFjdXVtUGFyYW1zIGF0X3BhcmFt czsKLQlkb3VibGUJCWF0X3ZhY3V1bV9jb3N0X2RlbGF5OwotCWludAkJCWF0X3ZhY3V1bV9jb3N0 X2xpbWl0OworCWRvdWJsZQkJYXRfc3RvcmFnZV9wYXJhbV92YWNfY29zdF9kZWxheTsKKwlpbnQJ CQlhdF9zdG9yYWdlX3BhcmFtX3ZhY19jb3N0X2xpbWl0OwogCWJvb2wJCWF0X2RvYmFsYW5jZTsK IAlib29sCQlhdF9zaGFyZWRyZWw7CiAJY2hhcgkgICAqYXRfcmVsbmFtZTsKQEAgLTIwOSw3ICsy MjEsNyBAQCB0eXBlZGVmIHN0cnVjdCBhdXRvdmFjX3RhYmxlCiAgKiB3aV9zaGFyZWRyZWwgZmxh ZyBpbmRpY2F0aW5nIHdoZXRoZXIgdGFibGUgaXMgbWFya2VkIHJlbGlzc2hhcmVkCiAgKiB3aV9w cm9jCQlwb2ludGVyIHRvIFBHUFJPQyBvZiB0aGUgcnVubmluZyB3b3JrZXIsIE5VTEwgaWYgbm90 IHN0YXJ0ZWQKICAqIHdpX2xhdW5jaHRpbWUgVGltZSBhdCB3aGljaCB0aGlzIHdvcmtlciB3YXMg bGF1bmNoZWQKLSAqIHdpX2Nvc3RfKglWYWN1dW0gY29zdC1iYXNlZCBkZWxheSBwYXJhbWV0ZXJz IGN1cnJlbnQgaW4gdGhpcyB3b3JrZXIKKyAqIHdpX2RvYmFsYW5jZSBXaGV0aGVyIHRoaXMgd29y a2VyIHNob3VsZCBiZSBpbmNsdWRlZCBpbiBiYWxhbmNlIGNhbGN1bGF0aW9ucwogICoKICAqIEFs bCBmaWVsZHMgYXJlIHByb3RlY3RlZCBieSBBdXRvdmFjdXVtTG9jaywgZXhjZXB0IGZvciB3aV90 YWJsZW9pZCBhbmQKICAqIHdpX3NoYXJlZHJlbCB3aGljaCBhcmUgcHJvdGVjdGVkIGJ5IEF1dG92 YWN1dW1TY2hlZHVsZUxvY2sgKG5vdGUgdGhlc2UKQEAgLTIyMywxMSArMjM1LDggQEAgdHlwZWRl ZiBzdHJ1Y3QgV29ya2VySW5mb0RhdGEKIAlPaWQJCQl3aV90YWJsZW9pZDsKIAlQR1BST0MJICAg KndpX3Byb2M7CiAJVGltZXN0YW1wVHogd2lfbGF1bmNodGltZTsKLQlib29sCQl3aV9kb2JhbGFu Y2U7CisJcGdfYXRvbWljX2ZsYWcgd2lfZG9iYWxhbmNlOwogCWJvb2wJCXdpX3NoYXJlZHJlbDsK LQlkb3VibGUJCXdpX2Nvc3RfZGVsYXk7Ci0JaW50CQkJd2lfY29zdF9saW1pdDsKLQlpbnQJCQl3 aV9jb3N0X2xpbWl0X2Jhc2U7CiB9IFdvcmtlckluZm9EYXRhOwogCiB0eXBlZGVmIHN0cnVjdCBX b3JrZXJJbmZvRGF0YSAqV29ya2VySW5mbzsKQEAgLTI3Myw2ICsyODIsOCBAQCB0eXBlZGVmIHN0 cnVjdCBBdXRvVmFjdXVtV29ya0l0ZW0KICAqIGF2X3N0YXJ0aW5nV29ya2VyIHBvaW50ZXIgdG8g V29ya2VySW5mbyBjdXJyZW50bHkgYmVpbmcgc3RhcnRlZCAoY2xlYXJlZCBieQogICoJCQkJCXRo ZSB3b3JrZXIgaXRzZWxmIGFzIHNvb24gYXMgaXQncyB1cCBhbmQgcnVubmluZykKICAqIGF2X3dv cmtJdGVtcwkJd29yayBpdGVtIGFycmF5CisgKiBhdl9ud29ya2Vyc0ZvckJhbGFuY2UgdGhlIG51 bWJlciBvZiBhdXRvdmFjdXVtIHdvcmtlcnMgdG8gdXNlIHdoZW4KKyAqIAkJCQkJY2FsY3VsYXRp bmcgdGhlIHBlciB3b3JrZXIgY29zdCBsaW1pdAogICoKICAqIFRoaXMgc3RydWN0IGlzIHByb3Rl Y3RlZCBieSBBdXRvdmFjdXVtTG9jaywgZXhjZXB0IGZvciBhdl9zaWduYWwgYW5kIHBhcnRzCiAg KiBvZiB0aGUgd29ya2VyIGxpc3QgKHNlZSBhYm92ZSkuCkBAIC0yODYsNiArMjk3LDcgQEAgdHlw ZWRlZiBzdHJ1Y3QKIAlkbGlzdF9oZWFkCWF2X3J1bm5pbmdXb3JrZXJzOwogCVdvcmtlckluZm8J YXZfc3RhcnRpbmdXb3JrZXI7CiAJQXV0b1ZhY3V1bVdvcmtJdGVtIGF2X3dvcmtJdGVtc1tOVU1f V09SS0lURU1TXTsKKwlwZ19hdG9taWNfdWludDMyIGF2X253b3JrZXJzRm9yQmFsYW5jZTsKIH0g QXV0b1ZhY3V1bVNobWVtU3RydWN0OwogCiBzdGF0aWMgQXV0b1ZhY3V1bVNobWVtU3RydWN0ICpB dXRvVmFjdXVtU2htZW07CkBAIC0zMTksNyArMzMxLDcgQEAgc3RhdGljIHZvaWQgbGF1bmNoX3dv cmtlcihUaW1lc3RhbXBUeiBub3cpOwogc3RhdGljIExpc3QgKmdldF9kYXRhYmFzZV9saXN0KHZv aWQpOwogc3RhdGljIHZvaWQgcmVidWlsZF9kYXRhYmFzZV9saXN0KE9pZCBuZXdkYik7CiBzdGF0 aWMgaW50CWRiX2NvbXBhcmF0b3IoY29uc3Qgdm9pZCAqYSwgY29uc3Qgdm9pZCAqYik7Ci1zdGF0 aWMgdm9pZCBhdXRvdmFjX2JhbGFuY2VfY29zdCh2b2lkKTsKK3N0YXRpYyB2b2lkIGF1dG92YWNf cmVjYWxjdWxhdGVfd29ya2Vyc19mb3JfYmFsYW5jZSh2b2lkKTsKIAogc3RhdGljIHZvaWQgZG9f YXV0b3ZhY3V1bSh2b2lkKTsKIHN0YXRpYyB2b2lkIEZyZWVXb3JrZXJJbmZvKGludCBjb2RlLCBE YXR1bSBhcmcpOwpAQCAtNjcwLDcgKzY4Miw3IEBAIEF1dG9WYWNMYXVuY2hlck1haW4oaW50IGFy Z2MsIGNoYXIgKmFyZ3ZbXSkKIAkJCXsKIAkJCQlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2Nr LCBMV19FWENMVVNJVkUpOwogCQkJCUF1dG9WYWN1dW1TaG1lbS0+YXZfc2lnbmFsW0F1dG9WYWNS ZWJhbGFuY2VdID0gZmFsc2U7Ci0JCQkJYXV0b3ZhY19iYWxhbmNlX2Nvc3QoKTsKKwkJCQlhdXRv dmFjX3JlY2FsY3VsYXRlX3dvcmtlcnNfZm9yX2JhbGFuY2UoKTsKIAkJCQlMV0xvY2tSZWxlYXNl KEF1dG92YWN1dW1Mb2NrKTsKIAkJCX0KIApAQCAtODIwLDggKzgzMiw4IEBAIEhhbmRsZUF1dG9W YWNMYXVuY2hlckludGVycnVwdHModm9pZCkKIAkJCUF1dG9WYWNMYXVuY2hlclNodXRkb3duKCk7 CiAKIAkJLyogcmViYWxhbmNlIGluIGNhc2UgdGhlIGRlZmF1bHQgY29zdCBwYXJhbWV0ZXJzIGNo YW5nZWQgKi8KLQkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZFKTsK LQkJYXV0b3ZhY19iYWxhbmNlX2Nvc3QoKTsKKwkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9j aywgTFdfU0hBUkVEKTsKKwkJYXV0b3ZhY19yZWNhbGN1bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNl KCk7CiAJCUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1bUxvY2spOwogCiAJCS8qIHJlYnVpbGQgdGhl IGxpc3QgaW4gY2FzZSB0aGUgbmFwdGltZSBjaGFuZ2VkICovCkBAIC0xNzU1LDEwICsxNzY3LDcg QEAgRnJlZVdvcmtlckluZm8oaW50IGNvZGUsIERhdHVtIGFyZykKIAkJTXlXb3JrZXJJbmZvLT53 aV9zaGFyZWRyZWwgPSBmYWxzZTsKIAkJTXlXb3JrZXJJbmZvLT53aV9wcm9jID0gTlVMTDsKIAkJ TXlXb3JrZXJJbmZvLT53aV9sYXVuY2h0aW1lID0gMDsKLQkJTXlXb3JrZXJJbmZvLT53aV9kb2Jh bGFuY2UgPSBmYWxzZTsKLQkJTXlXb3JrZXJJbmZvLT53aV9jb3N0X2RlbGF5ID0gMDsKLQkJTXlX b3JrZXJJbmZvLT53aV9jb3N0X2xpbWl0ID0gMDsKLQkJTXlXb3JrZXJJbmZvLT53aV9jb3N0X2xp bWl0X2Jhc2UgPSAwOworCQlwZ19hdG9taWNfY2xlYXJfZmxhZygmTXlXb3JrZXJJbmZvLT53aV9k b2JhbGFuY2UpOwogCQlkbGlzdF9wdXNoX2hlYWQoJkF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVdv cmtlcnMsCiAJCQkJCQkmTXlXb3JrZXJJbmZvLT53aV9saW5rcyk7CiAJCS8qIG5vdCBtaW5lIGFu eW1vcmUgKi8KQEAgLTE3ODQsOTcgKzE3OTMsMTI3IEBAIFZhY3V1bVVwZGF0ZUNvc3RzKHZvaWQp CiB7CiAJaWYgKE15V29ya2VySW5mbykKIAl7Ci0JCVZhY3V1bUNvc3REZWxheSA9IE15V29ya2Vy SW5mby0+d2lfY29zdF9kZWxheTsKLQkJVmFjdXVtQ29zdExpbWl0ID0gTXlXb3JrZXJJbmZvLT53 aV9jb3N0X2xpbWl0OworCQlpZiAoYXZfc3RvcmFnZV9wYXJhbV9jb3N0X2RlbGF5ID49IDApCisJ CQlWYWN1dW1Db3N0RGVsYXkgPSBhdl9zdG9yYWdlX3BhcmFtX2Nvc3RfZGVsYXk7CisJCWVsc2Ug aWYgKGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkgPj0gMCkKKwkJCVZhY3V1bUNvc3REZWxheSA9 IGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXk7CisJCWVsc2UKKwkJCS8qIGZhbGwgYmFjayB0byB2 YWN1dW1fY29zdF9kZWxheSAqLworCQkJVmFjdXVtQ29zdERlbGF5ID0gdmFjdXVtX2Nvc3RfZGVs YXk7CisKKwkJQXV0b1ZhY3V1bVVwZGF0ZUNvc3RMaW1pdCgpOwogCX0KIAllbHNlCiAJewogCQkv KiBNdXN0IGJlIGV4cGxpY2l0IFZBQ1VVTSBvciBBTkFMWVpFICovCi0JCVZhY3V1bUNvc3RMaW1p dCA9IHZhY3V1bV9jb3N0X2xpbWl0OwogCQlWYWN1dW1Db3N0RGVsYXkgPSB2YWN1dW1fY29zdF9k ZWxheTsKKwkJVmFjdXVtQ29zdExpbWl0ID0gdmFjdXVtX2Nvc3RfbGltaXQ7CisJfQorCisJLyoK KwkgKiBJZiBjb25maWd1cmF0aW9uIGNoYW5nZXMgYXJlIGFsbG93ZWQgdG8gaW1wYWN0IFZhY3V1 bUNvc3RBY3RpdmUsIG1ha2UKKwkgKiBzdXJlIGl0IGlzIHVwZGF0ZWQuCisJICovCisJaWYgKFZh Y3V1bUZhaWxzYWZlQWN0aXZlKQorCQlBc3NlcnQoIVZhY3V1bUNvc3RBY3RpdmUpOworCWVsc2Ug aWYgKFZhY3V1bUNvc3REZWxheSA+IDApCisJCVZhY3V1bUNvc3RBY3RpdmUgPSB0cnVlOworCWVs c2UKKwl7CisJCVZhY3V1bUNvc3RBY3RpdmUgPSBmYWxzZTsKKwkJVmFjdXVtQ29zdEJhbGFuY2Ug PSAwOworCX0KKworCWlmIChNeVdvcmtlckluZm8pCisJeworCQllbG9nKERFQlVHMiwKKwkJCSAi QXV0b3ZhY3V1bSBWYWN1dW1VcGRhdGVDb3N0cyhkYj0ldSwgcmVsPSV1LCBkb2JhbGFuY2U9JXMs IGNvc3RfbGltaXQ9JWQsIGNvc3RfZGVsYXk9JWcgYWN0aXZlPSVzIGZhaWxzYWZlPSVzKSIsCisJ CQkgTXlXb3JrZXJJbmZvLT53aV9kYm9pZCwgTXlXb3JrZXJJbmZvLT53aV90YWJsZW9pZCwKKwkJ CSBwZ19hdG9taWNfdW5sb2NrZWRfdGVzdF9mbGFnKCZNeVdvcmtlckluZm8tPndpX2RvYmFsYW5j ZSkgPyAibm8iIDogInllcyIsCisJCQkgVmFjdXVtQ29zdExpbWl0LCBWYWN1dW1Db3N0RGVsYXks CisJCQkgVmFjdXVtQ29zdERlbGF5ID4gMCA/ICJ5ZXMiIDogIm5vIiwKKwkJCSBWYWN1dW1GYWls c2FmZUFjdGl2ZSA/ICJ5ZXMiIDogIm5vIik7CiAJfQogfQogCiAvKgotICogYXV0b3ZhY19iYWxh bmNlX2Nvc3QKLSAqCQlSZWNhbGN1bGF0ZSB0aGUgY29zdCBsaW1pdCBzZXR0aW5nIGZvciBlYWNo IGFjdGl2ZSB3b3JrZXIuCi0gKgotICogQ2FsbGVyIG11c3QgaG9sZCB0aGUgQXV0b3ZhY3V1bUxv Y2sgaW4gZXhjbHVzaXZlIG1vZGUuCisgKiBVcGRhdGUgVmFjdXVtQ29zdExpbWl0IHdpdGggdGhl IGNvcnJlY3QgdmFsdWUgZm9yIGFuIGF1dG92YWN1dW0gd29ya2VyLCBnaXZlbgorICogdGhlIHZh bHVlIG9mIG90aGVyIHJlbGV2YW50IGNvc3QgbGltaXQgcGFyYW1ldGVycyBhbmQgdGhlIG51bWJl ciBvZiB3b3JrZXJzCisgKiBhY3Jvc3Mgd2hpY2ggdGhlIGxpbWl0IG11c3QgYmUgYmFsYW5jZWQu IEF1dG92YWN1dW0gd29ya2VycyBtdXN0IGNhbGwgdGhpcworICogcmVndWxhcmx5IGluIGNhc2Ug YXZfbndvcmtlcnNfZm9yX2JhbGFuY2UgaGFzIGJlZW4gdXBkYXRlZCBieSBhbm90aGVyIHdvcmtl cgorICogb3IgYnkgdGhlIGF1dG92YWN1dW0gbGF1bmNoZXIuIFRoZXkgbXVzdCBhbHNvIGNhbGwg aXQgYWZ0ZXIgYSBjb25maWcgcmVsb2FkLgogICovCi1zdGF0aWMgdm9pZAotYXV0b3ZhY19iYWxh bmNlX2Nvc3Qodm9pZCkKK3ZvaWQKK0F1dG9WYWN1dW1VcGRhdGVDb3N0TGltaXQodm9pZCkKIHsK KwlpZiAoIU15V29ya2VySW5mbykKKwkJcmV0dXJuOworCiAJLyoKLQkgKiBUaGUgaWRlYSBoZXJl IGlzIHRoYXQgd2UgcmF0aW9uIG91dCBJL08gZXF1YWxseS4gIFRoZSBhbW91bnQgb2YgSS9PCi0J ICogdGhhdCBhIHdvcmtlciBjYW4gY29uc3VtZSBpcyBkZXRlcm1pbmVkIGJ5IGNvc3RfbGltaXQv Y29zdF9kZWxheSwgc28gd2UKLQkgKiB0cnkgdG8gZXF1YWxpemUgdGhvc2UgcmF0aW9zIHJhdGhl ciB0aGFuIHRoZSByYXcgbGltaXQgc2V0dGluZ3MuCi0JICoKIAkgKiBub3RlOiBpbiBjb3N0X2xp bWl0LCB6ZXJvIGFsc28gbWVhbnMgdXNlIHZhbHVlIGZyb20gZWxzZXdoZXJlLCBiZWNhdXNlCiAJ ICogemVybyBpcyBub3QgYSB2YWxpZCB2YWx1ZS4KIAkgKi8KLQlpbnQJCQl2YWNfY29zdF9saW1p dCA9IChhdXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0ID4gMCA/Ci0JCQkJCQkJCSAgYXV0b3ZhY3V1 bV92YWNfY29zdF9saW1pdCA6IHZhY3V1bV9jb3N0X2xpbWl0KTsKLQlkb3VibGUJCXZhY19jb3N0 X2RlbGF5ID0gKGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkgPj0gMCA/Ci0JCQkJCQkJCSAgYXV0 b3ZhY3V1bV92YWNfY29zdF9kZWxheSA6IHZhY3V1bV9jb3N0X2RlbGF5KTsKLQlkb3VibGUJCWNv c3RfdG90YWw7Ci0JZG91YmxlCQljb3N0X2F2YWlsOwotCWRsaXN0X2l0ZXIJaXRlcjsKIAotCS8q IG5vdCBzZXQ/IG5vdGhpbmcgdG8gZG8gKi8KLQlpZiAodmFjX2Nvc3RfbGltaXQgPD0gMCB8fCB2 YWNfY29zdF9kZWxheSA8PSAwKQotCQlyZXR1cm47Ci0KLQkvKiBjYWxjdWxhdGUgdGhlIHRvdGFs IGJhc2UgY29zdCBsaW1pdCBvZiBwYXJ0aWNpcGF0aW5nIGFjdGl2ZSB3b3JrZXJzICovCi0JY29z dF90b3RhbCA9IDAuMDsKLQlkbGlzdF9mb3JlYWNoKGl0ZXIsICZBdXRvVmFjdXVtU2htZW0tPmF2 X3J1bm5pbmdXb3JrZXJzKQorCWlmIChhdl9zdG9yYWdlX3BhcmFtX2Nvc3RfbGltaXQgPiAwKQor CQlWYWN1dW1Db3N0TGltaXQgPSBhdl9zdG9yYWdlX3BhcmFtX2Nvc3RfbGltaXQ7CisJZWxzZQog CXsKLQkJV29ya2VySW5mbwl3b3JrZXIgPSBkbGlzdF9jb250YWluZXIoV29ya2VySW5mb0RhdGEs IHdpX2xpbmtzLCBpdGVyLmN1cik7CisJCWludAkJCW53b3JrZXJzX2Zvcl9iYWxhbmNlOworCisJ CWlmIChhdXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0ID4gMCkKKwkJCVZhY3V1bUNvc3RMaW1pdCA9 IGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQ7CisJCWVsc2UKKwkJCVZhY3V1bUNvc3RMaW1pdCA9 IHZhY3V1bV9jb3N0X2xpbWl0OworCisJCS8qIE9ubHkgYmFsYW5jZSBsaW1pdCBpZiBubyBjb3N0 LXJlbGF0ZWQgc3RvcmFnZSBwYXJhbWV0ZXJzIHNwZWNpZmllZCAqLworCQlpZiAocGdfYXRvbWlj X3VubG9ja2VkX3Rlc3RfZmxhZygmTXlXb3JrZXJJbmZvLT53aV9kb2JhbGFuY2UpKQorCQkJcmV0 dXJuOwogCi0JCWlmICh3b3JrZXItPndpX3Byb2MgIT0gTlVMTCAmJgotCQkJd29ya2VyLT53aV9k b2JhbGFuY2UgJiYKLQkJCXdvcmtlci0+d2lfY29zdF9saW1pdF9iYXNlID4gMCAmJiB3b3JrZXIt PndpX2Nvc3RfZGVsYXkgPiAwKQotCQkJY29zdF90b3RhbCArPQotCQkJCShkb3VibGUpIHdvcmtl ci0+d2lfY29zdF9saW1pdF9iYXNlIC8gd29ya2VyLT53aV9jb3N0X2RlbGF5OworCQlBc3NlcnQo VmFjdXVtQ29zdExpbWl0ID4gMCk7CisKKwkJbndvcmtlcnNfZm9yX2JhbGFuY2UgPSBwZ19hdG9t aWNfcmVhZF91MzIoCisJCQkJCQkJCSZBdXRvVmFjdXVtU2htZW0tPmF2X253b3JrZXJzRm9yQmFs YW5jZSk7CisKKwkJLyogVGhlcmUgaXMgYXQgbGVhc3QgMSBhdXRvdmFjIHdvcmtlciAodGhpcyB3 b3JrZXIpLiAqLworCQlpZiAobndvcmtlcnNfZm9yX2JhbGFuY2UgPD0gMCkKKwkJCWVsb2coRVJS T1IsICJud29ya2Vyc19mb3JfYmFsYW5jZSBtdXN0IGJlID4gMCIpOworCisJCVZhY3V1bUNvc3RM aW1pdCA9IE1heChWYWN1dW1Db3N0TGltaXQgLyBud29ya2Vyc19mb3JfYmFsYW5jZSwgMSk7CiAJ fQorfQogCi0JLyogdGhlcmUgYXJlIG5vIGNvc3QgbGltaXRzIC0tIG5vdGhpbmcgdG8gZG8gKi8K LQlpZiAoY29zdF90b3RhbCA8PSAwKQotCQlyZXR1cm47CisvKgorICogYXV0b3ZhY19yZWNhbGN1 bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNlCisgKgkJUmVjYWxjdWxhdGUgdGhlIG51bWJlciBvZiB3 b3JrZXJzIHRvIGNvbnNpZGVyLCBnaXZlbiBjb3N0LXJlbGF0ZWQKKyAqCQlzdG9yYWdlIHBhcmFt ZXRlcnMgYW5kIHRoZSBjdXJyZW50IG51bWJlciBvZiBhY3RpdmUgd29ya2Vycy4KKyAqCisgKiBD YWxsZXIgbXVzdCBob2xkIHRoZSBBdXRvdmFjdXVtTG9jayBpbiBhdCBsZWFzdCBzaGFyZWQgbW9k ZSB0byBhY2Nlc3MKKyAqIHdvcmtlci0+d2lfcHJvYy4KKyAqLworc3RhdGljIHZvaWQKK2F1dG92 YWNfcmVjYWxjdWxhdGVfd29ya2Vyc19mb3JfYmFsYW5jZSh2b2lkKQoreworCWRsaXN0X2l0ZXIJ aXRlcjsKKwlpbnQJCQlvcmlnX253b3JrZXJzX2Zvcl9iYWxhbmNlOworCWludAkJCW53b3JrZXJz X2Zvcl9iYWxhbmNlID0gMDsKKworCW9yaWdfbndvcmtlcnNfZm9yX2JhbGFuY2UgPQorCQlwZ19h dG9taWNfcmVhZF91MzIoJkF1dG9WYWN1dW1TaG1lbS0+YXZfbndvcmtlcnNGb3JCYWxhbmNlKTsK IAotCS8qCi0JICogQWRqdXN0IGNvc3QgbGltaXQgb2YgZWFjaCBhY3RpdmUgd29ya2VyIHRvIGJh bGFuY2UgdGhlIHRvdGFsIG9mIGNvc3QKLQkgKiBsaW1pdCB0byBhdXRvdmFjdXVtX3ZhY3V1bV9j b3N0X2xpbWl0LgotCSAqLwotCWNvc3RfYXZhaWwgPSAoZG91YmxlKSB2YWNfY29zdF9saW1pdCAv IHZhY19jb3N0X2RlbGF5OwogCWRsaXN0X2ZvcmVhY2goaXRlciwgJkF1dG9WYWN1dW1TaG1lbS0+ YXZfcnVubmluZ1dvcmtlcnMpCiAJewogCQlXb3JrZXJJbmZvCXdvcmtlciA9IGRsaXN0X2NvbnRh aW5lcihXb3JrZXJJbmZvRGF0YSwgd2lfbGlua3MsIGl0ZXIuY3VyKTsKIAotCQlpZiAod29ya2Vy LT53aV9wcm9jICE9IE5VTEwgJiYKLQkJCXdvcmtlci0+d2lfZG9iYWxhbmNlICYmCi0JCQl3b3Jr ZXItPndpX2Nvc3RfbGltaXRfYmFzZSA+IDAgJiYgd29ya2VyLT53aV9jb3N0X2RlbGF5ID4gMCkK LQkJewotCQkJaW50CQkJbGltaXQgPSAoaW50KQotCQkJKGNvc3RfYXZhaWwgKiB3b3JrZXItPndp X2Nvc3RfbGltaXRfYmFzZSAvIGNvc3RfdG90YWwpOwotCi0JCQkvKgotCQkJICogV2UgcHV0IGEg bG93ZXIgYm91bmQgb2YgMSBvbiB0aGUgY29zdF9saW1pdCwgdG8gYXZvaWQgZGl2aXNpb24tCi0J CQkgKiBieS16ZXJvIGluIHRoZSB2YWN1dW0gY29kZS4gIEFsc28sIGluIGNhc2Ugb2Ygcm91bmRv ZmYgdHJvdWJsZQotCQkJICogaW4gdGhlc2UgY2FsY3VsYXRpb25zLCBsZXQncyBiZSBzdXJlIHdl IGRvbid0IGV2ZXIgc2V0Ci0JCQkgKiBjb3N0X2xpbWl0IHRvIG1vcmUgdGhhbiB0aGUgYmFzZSB2 YWx1ZS4KLQkJCSAqLwotCQkJd29ya2VyLT53aV9jb3N0X2xpbWl0ID0gTWF4KE1pbihsaW1pdCwK LQkJCQkJCQkJCQkJd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2UpLAotCQkJCQkJCQkJCTEpOwot CQl9CisJCWlmICh3b3JrZXItPndpX3Byb2MgPT0gTlVMTCB8fAorCQkJcGdfYXRvbWljX3VubG9j a2VkX3Rlc3RfZmxhZygmd29ya2VyLT53aV9kb2JhbGFuY2UpKQorCQkJY29udGludWU7CiAKLQkJ aWYgKHdvcmtlci0+d2lfcHJvYyAhPSBOVUxMKQotCQkJZWxvZyhERUJVRzIsICJhdXRvdmFjX2Jh bGFuY2VfY29zdChwaWQ9JWQgZGI9JXUsIHJlbD0ldSwgZG9iYWxhbmNlPSVzIGNvc3RfbGltaXQ9 JWQsIGNvc3RfbGltaXRfYmFzZT0lZCwgY29zdF9kZWxheT0lZykiLAotCQkJCSB3b3JrZXItPndp X3Byb2MtPnBpZCwgd29ya2VyLT53aV9kYm9pZCwgd29ya2VyLT53aV90YWJsZW9pZCwKLQkJCQkg d29ya2VyLT53aV9kb2JhbGFuY2UgPyAieWVzIiA6ICJubyIsCi0JCQkJIHdvcmtlci0+d2lfY29z dF9saW1pdCwgd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2UsCi0JCQkJIHdvcmtlci0+d2lfY29z dF9kZWxheSk7CisJCW53b3JrZXJzX2Zvcl9iYWxhbmNlKys7CiAJfQorCisJaWYgKG53b3JrZXJz X2Zvcl9iYWxhbmNlICE9IG9yaWdfbndvcmtlcnNfZm9yX2JhbGFuY2UpCisJCXBnX2F0b21pY193 cml0ZV91MzIoJkF1dG9WYWN1dW1TaG1lbS0+YXZfbndvcmtlcnNGb3JCYWxhbmNlLAorCQkJCQkJ CW53b3JrZXJzX2Zvcl9iYWxhbmNlKTsKIH0KIAogLyoKQEAgLTI0MjIsMjMgKzI0NjEsMzQgQEAg ZG9fYXV0b3ZhY3V1bSh2b2lkKQogCQkJY29udGludWU7CiAJCX0KIAotCQkvKiBNdXN0IGhvbGQg QXV0b3ZhY3V1bUxvY2sgd2hpbGUgbXVja2luZyB3aXRoIGNvc3QgYmFsYW5jZSBpbmZvICovCi0J CUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7CisJCS8qCisJCSAq IFNhdmUgdGhlIGNvc3QtcmVsYXRlZCBzdG9yYWdlIHBhcmFtZXRlciB2YWx1ZXMgaW4gZ2xvYmFs IHZhcmlhYmxlcworCQkgKiBmb3IgcmVmZXJlbmNlIHdoZW4gdXBkYXRpbmcgVmFjdXVtQ29zdExp bWl0IGFuZCBWYWN1dW1Db3N0RGVsYXkKKwkJICogZHVyaW5nIHZhY3V1bWluZyB0aGlzIHRhYmxl LgorCQkgKi8KKwkJYXZfc3RvcmFnZV9wYXJhbV9jb3N0X2xpbWl0ID0gdGFiLT5hdF9zdG9yYWdl X3BhcmFtX3ZhY19jb3N0X2xpbWl0OworCQlhdl9zdG9yYWdlX3BhcmFtX2Nvc3RfZGVsYXkgPSB0 YWItPmF0X3N0b3JhZ2VfcGFyYW1fdmFjX2Nvc3RfZGVsYXk7CiAKLQkJLyogYWR2ZXJ0aXNlIG15 IGNvc3QgZGVsYXkgcGFyYW1ldGVycyBmb3IgdGhlIGJhbGFuY2luZyBhbGdvcml0aG0gKi8KLQkJ TXlXb3JrZXJJbmZvLT53aV9kb2JhbGFuY2UgPSB0YWItPmF0X2RvYmFsYW5jZTsKLQkJTXlXb3Jr ZXJJbmZvLT53aV9jb3N0X2RlbGF5ID0gdGFiLT5hdF92YWN1dW1fY29zdF9kZWxheTsKLQkJTXlX b3JrZXJJbmZvLT53aV9jb3N0X2xpbWl0ID0gdGFiLT5hdF92YWN1dW1fY29zdF9saW1pdDsKLQkJ TXlXb3JrZXJJbmZvLT53aV9jb3N0X2xpbWl0X2Jhc2UgPSB0YWItPmF0X3ZhY3V1bV9jb3N0X2xp bWl0OworCQkvKgorCQkgKiBXZSBvbmx5IGV4cGVjdCB0aGlzIHdvcmtlciB0byBldmVyIHNldCB0 aGUgZmxhZywgc28gZG9uJ3QgYm90aGVyCisJCSAqIGNoZWNraW5nIHRoZSByZXR1cm4gdmFsdWUu IFdlIHNob3VsZG4ndCBoYXZlIHRvIHJldHJ5LgorCQkgKi8KKwkJaWYgKHRhYi0+YXRfZG9iYWxh bmNlKQorCQkJcGdfYXRvbWljX3Rlc3Rfc2V0X2ZsYWcoJk15V29ya2VySW5mby0+d2lfZG9iYWxh bmNlKTsKKwkJZWxzZQorCQkJcGdfYXRvbWljX2NsZWFyX2ZsYWcoJk15V29ya2VySW5mby0+d2lf ZG9iYWxhbmNlKTsKIAotCQkvKiBkbyBhIGJhbGFuY2UgKi8KLQkJYXV0b3ZhY19iYWxhbmNlX2Nv c3QoKTsKKwkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfU0hBUkVEKTsKKwkJYXV0 b3ZhY19yZWNhbGN1bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNlKCk7CisJCUxXTG9ja1JlbGVhc2Uo QXV0b3ZhY3V1bUxvY2spOwogCi0JCS8qIHNldCB0aGUgYWN0aXZlIGNvc3QgcGFyYW1ldGVycyBm cm9tIHRoZSByZXN1bHQgb2YgdGhhdCAqLworCQkvKgorCQkgKiBXZSB3YWl0IHVudGlsIHRoaXMg cG9pbnQgdG8gdXBkYXRlIGNvc3QgZGVsYXkgYW5kIGNvc3QgbGltaXQKKwkJICogdmFsdWVzLCBl dmVuIHRob3VnaCB3ZSByZWxvYWRlZCB0aGUgY29uZmlndXJhdGlvbiBmaWxlIGFib3ZlLCBzbwor CQkgKiB0aGF0IHdlIGNhbiB0YWtlIGludG8gYWNjb3VudCB0aGUgY29zdC1yZWxhdGVkIHN0b3Jh Z2UgcGFyYW1ldGVycy4KKwkJICovCiAJCVZhY3V1bVVwZGF0ZUNvc3RzKCk7CiAKLQkJLyogZG9u ZSAqLwotCQlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKIAogCQkvKiBjbGVhbiB1cCBt ZW1vcnkgYmVmb3JlIGVhY2ggaXRlcmF0aW9uICovCiAJCU1lbW9yeUNvbnRleHRSZXNldEFuZERl bGV0ZUNoaWxkcmVuKFBvcnRhbENvbnRleHQpOwpAQCAtMjUyMywxMCArMjU3MywxMCBAQCBkZWxl dGVkOgogCiAJCS8qCiAJCSAqIFJlbW92ZSBteSBpbmZvIGZyb20gc2hhcmVkIG1lbW9yeS4gIFdl IGNvdWxkLCBidXQgaW50ZW50aW9uYWxseQotCQkgKiBkb24ndCwgY2xlYXIgd2lfY29zdF9saW1p dCBhbmQgZnJpZW5kcyAtLS0gdGhpcyBpcyBvbiB0aGUKLQkJICogYXNzdW1wdGlvbiB0aGF0IHdl IHByb2JhYmx5IGhhdmUgbW9yZSB0byBkbyB3aXRoIHNpbWlsYXIgY29zdAotCQkgKiBzZXR0aW5n cywgc28gd2UgZG9uJ3Qgd2FudCB0byBnaXZlIHVwIG91ciBzaGFyZSBvZiBJL08gZm9yIGEgdmVy eQotCQkgKiBzaG9ydCBpbnRlcnZhbCBhbmQgdGhlcmVieSB0aHJhc2ggdGhlIGdsb2JhbCBiYWxh bmNlLgorCQkgKiBkb24ndCwgdW5zZXQgd2lfZG9iYWxhbmNlIG9uIHRoZSBhc3N1bXB0aW9uIHRo YXQgd2UgYXJlIG1vcmUgbGlrZWx5CisJCSAqIHRoYW4gbm90IHRvIHZhY3V1bSBhIHRhYmxlIHdp dGggbm8gY29zdC1yZWxhdGVkIHN0b3JhZ2UgcGFyYW1ldGVycworCQkgKiBuZXh0LCBzbyB3ZSBk b24ndCB3YW50IHRvIGdpdmUgdXAgb3VyIHNoYXJlIG9mIEkvTyBmb3IgYSB2ZXJ5IHNob3J0CisJ CSAqIGludGVydmFsIGFuZCB0aGVyZWJ5IHRocmFzaCB0aGUgZ2xvYmFsIGJhbGFuY2UuCiAJCSAq LwogCQlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1TY2hlZHVsZUxvY2ssIExXX0VYQ0xVU0lWRSk7 CiAJCU15V29ya2VySW5mby0+d2lfdGFibGVvaWQgPSBJbnZhbGlkT2lkOwpAQCAtMjU2Myw2ICsy NjEzLDcgQEAgZGVsZXRlZDoKIAkJewogCQkJQ29uZmlnUmVsb2FkUGVuZGluZyA9IGZhbHNlOwog CQkJUHJvY2Vzc0NvbmZpZ0ZpbGUoUEdDX1NJR0hVUCk7CisJCQlWYWN1dW1VcGRhdGVDb3N0cygp OwogCQl9CiAKIAkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZFKTsK QEAgLTI3OTgsOCArMjg0OSw2IEBAIHRhYmxlX3JlY2hlY2tfYXV0b3ZhYyhPaWQgcmVsaWQsIEhU QUIgKnRhYmxlX3RvYXN0X21hcCwKIAkJaW50CQkJZnJlZXplX3RhYmxlX2FnZTsKIAkJaW50CQkJ bXVsdGl4YWN0X2ZyZWV6ZV9taW5fYWdlOwogCQlpbnQJCQltdWx0aXhhY3RfZnJlZXplX3RhYmxl X2FnZTsKLQkJaW50CQkJdmFjX2Nvc3RfbGltaXQ7Ci0JCWRvdWJsZQkJdmFjX2Nvc3RfZGVsYXk7 CiAJCWludAkJCWxvZ19taW5fZHVyYXRpb247CiAKIAkJLyoKQEAgLTI4MDksMjAgKzI4NTgsNiBA QCB0YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJsZV90b2FzdF9tYXAs CiAJCSAqIGRlZmF1bHRzLCBhdXRvdmFjdXVtJ3Mgb3duIGZpcnN0IGFuZCBwbGFpbiB2YWN1dW0g c2Vjb25kLgogCQkgKi8KIAotCQkvKiAtMSBpbiBhdXRvdmFjIHNldHRpbmcgbWVhbnMgdXNlIHBs YWluIHZhY3V1bV9jb3N0X2RlbGF5ICovCi0JCXZhY19jb3N0X2RlbGF5ID0gKGF2b3B0cyAmJiBh dm9wdHMtPnZhY3V1bV9jb3N0X2RlbGF5ID49IDApCi0JCQk/IGF2b3B0cy0+dmFjdXVtX2Nvc3Rf ZGVsYXkKLQkJCTogKGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkgPj0gMCkKLQkJCT8gYXV0b3Zh Y3V1bV92YWNfY29zdF9kZWxheQotCQkJOiB2YWN1dW1fY29zdF9kZWxheTsKLQotCQkvKiAwIG9y IC0xIGluIGF1dG92YWMgc2V0dGluZyBtZWFucyB1c2UgcGxhaW4gdmFjdXVtX2Nvc3RfbGltaXQg Ki8KLQkJdmFjX2Nvc3RfbGltaXQgPSAoYXZvcHRzICYmIGF2b3B0cy0+dmFjdXVtX2Nvc3RfbGlt aXQgPiAwKQotCQkJPyBhdm9wdHMtPnZhY3V1bV9jb3N0X2xpbWl0Ci0JCQk6IChhdXRvdmFjdXVt X3ZhY19jb3N0X2xpbWl0ID4gMCkKLQkJCT8gYXV0b3ZhY3V1bV92YWNfY29zdF9saW1pdAotCQkJ OiB2YWN1dW1fY29zdF9saW1pdDsKLQogCQkvKiAtMSBpbiBhdXRvdmFjIHNldHRpbmcgbWVhbnMg dXNlIGxvZ19hdXRvdmFjdXVtX21pbl9kdXJhdGlvbiAqLwogCQlsb2dfbWluX2R1cmF0aW9uID0g KGF2b3B0cyAmJiBhdm9wdHMtPmxvZ19taW5fZHVyYXRpb24gPj0gMCkKIAkJCT8gYXZvcHRzLT5s b2dfbWluX2R1cmF0aW9uCkBAIC0yODc4LDggKzI5MTMsMTAgQEAgdGFibGVfcmVjaGVja19hdXRv dmFjKE9pZCByZWxpZCwgSFRBQiAqdGFibGVfdG9hc3RfbWFwLAogCQl0YWItPmF0X3BhcmFtcy5t dWx0aXhhY3RfZnJlZXplX3RhYmxlX2FnZSA9IG11bHRpeGFjdF9mcmVlemVfdGFibGVfYWdlOwog CQl0YWItPmF0X3BhcmFtcy5pc193cmFwYXJvdW5kID0gd3JhcGFyb3VuZDsKIAkJdGFiLT5hdF9w YXJhbXMubG9nX21pbl9kdXJhdGlvbiA9IGxvZ19taW5fZHVyYXRpb247Ci0JCXRhYi0+YXRfdmFj dXVtX2Nvc3RfbGltaXQgPSB2YWNfY29zdF9saW1pdDsKLQkJdGFiLT5hdF92YWN1dW1fY29zdF9k ZWxheSA9IHZhY19jb3N0X2RlbGF5OworCQl0YWItPmF0X3N0b3JhZ2VfcGFyYW1fdmFjX2Nvc3Rf bGltaXQgPSBhdm9wdHMgPworCQkJYXZvcHRzLT52YWN1dW1fY29zdF9saW1pdCA6IDA7CisJCXRh Yi0+YXRfc3RvcmFnZV9wYXJhbV92YWNfY29zdF9kZWxheSA9IGF2b3B0cyA/CisJCQlhdm9wdHMt PnZhY3V1bV9jb3N0X2RlbGF5IDogLTE7CiAJCXRhYi0+YXRfcmVsbmFtZSA9IE5VTEw7CiAJCXRh Yi0+YXRfbnNwbmFtZSA9IE5VTEw7CiAJCXRhYi0+YXRfZGF0bmFtZSA9IE5VTEw7CkBAIC0zMzcx LDEwICszNDA4LDE4IEBAIEF1dG9WYWN1dW1TaG1lbUluaXQodm9pZCkKIAkJd29ya2VyID0gKFdv cmtlckluZm8pICgoY2hhciAqKSBBdXRvVmFjdXVtU2htZW0gKwogCQkJCQkJCSAgIE1BWEFMSUdO KHNpemVvZihBdXRvVmFjdXVtU2htZW1TdHJ1Y3QpKSk7CiAKKwogCQkvKiBpbml0aWFsaXplIHRo ZSBXb3JrZXJJbmZvIGZyZWUgbGlzdCAqLwogCQlmb3IgKGkgPSAwOyBpIDwgYXV0b3ZhY3V1bV9t YXhfd29ya2VyczsgaSsrKQorCQl7CiAJCQlkbGlzdF9wdXNoX2hlYWQoJkF1dG9WYWN1dW1TaG1l bS0+YXZfZnJlZVdvcmtlcnMsCiAJCQkJCQkJJndvcmtlcltpXS53aV9saW5rcyk7CisKKwkJCXBn X2F0b21pY19pbml0X2ZsYWcoJndvcmtlcltpXS53aV9kb2JhbGFuY2UpOworCQl9CisKKwkJcGdf YXRvbWljX2luaXRfdTMyKCZBdXRvVmFjdXVtU2htZW0tPmF2X253b3JrZXJzRm9yQmFsYW5jZSwg MCk7CisKIAl9CiAJZWxzZQogCQlBc3NlcnQoZm91bmQpOwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1 ZGUvY29tbWFuZHMvdmFjdXVtLmggYi9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaAppbmRl eCBkMDQ4YmI2ZTBkLi4zOGM4YmRmMGZjIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jb21tYW5k cy92YWN1dW0uaAorKysgYi9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaApAQCAtMzUxLDYg KzM1MSw3IEBAIGV4dGVybiBJbmRleEJ1bGtEZWxldGVSZXN1bHQgKnZhY19jbGVhbnVwX29uZV9p bmRleChJbmRleFZhY3V1bUluZm8gKml2aW5mbywKIGV4dGVybiBTaXplIHZhY19tYXhfaXRlbXNf dG9fYWxsb2Nfc2l6ZShpbnQgbWF4X2l0ZW1zKTsKIAogLyogSW4gcG9zdG1hc3Rlci9hdXRvdmFj dXVtLmMgKi8KK2V4dGVybiB2b2lkIEF1dG9WYWN1dW1VcGRhdGVDb3N0TGltaXQodm9pZCk7CiBl eHRlcm4gdm9pZCBWYWN1dW1VcGRhdGVDb3N0cyh2b2lkKTsKIAogLyogaW4gY29tbWFuZHMvdmFj dXVtcGFyYWxsZWwuYyAqLwotLSAKMi4zNy4yCgo= --00000000000003aa1905f89876c2--