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 1pkUzD-0000Qx-26 for pgsql-hackers@arkaria.postgresql.org; Thu, 06 Apr 2023 19:09:31 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1pkUzA-0003fz-Se for pgsql-hackers@arkaria.postgresql.org; Thu, 06 Apr 2023 19:09:28 +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 1pkUzA-0003fq-DD for pgsql-hackers@lists.postgresql.org; Thu, 06 Apr 2023 19:09:28 +0000 Received: from mail-pg1-x532.google.com ([2607:f8b0:4864:20::532]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.94.2) (envelope-from ) id 1pkUz5-001IaU-N5 for pgsql-hackers@postgresql.org; Thu, 06 Apr 2023 19:09:27 +0000 Received: by mail-pg1-x532.google.com with SMTP id y35so24276409pgl.4 for ; Thu, 06 Apr 2023 12:09:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1680808161; x=1683400161; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=rce1B6i5zV6udo1xkEu3Mzf42wRuNd1u8u+gWVeZtfk=; b=J0qfeL6Ze0zfo7zZMLF/UsUCi1OjqkN7wYEOEycS1Ymjv7jaH8/OoRFbLOCDbG+7QZ CkVFXAMfYR+QtmmHdINdvsYdlspEjjhBzv23FjrjoIlC77Z7rOpaG5pg73PanC+rLeZr 0lmmKDOOBmpyuKeNsKMhRRbmsDpTvWb7OXLwMYBoBQ3YdIlM3jJVN3ZhOYqVuljaj6ci /Bgpv0a2UITdIBEd+Z9h76JnORvhuMY3c9nP+lA+jxZHmDYZ+P1l4tqOgowJm0ho718O 7ZNj1ZaBtvsO/GHThdX5jVBvDhQHWyViXw5QPeZL7tqwt+PxUnXQ2IohRXOVxifz/r2p 8e3Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1680808161; x=1683400161; 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=rce1B6i5zV6udo1xkEu3Mzf42wRuNd1u8u+gWVeZtfk=; b=AdpcY3/vIuBrXqKnEY0pm4pRBQQtFk322HJpBqYUuubyZAjhBE8IM8HY4lcT5bSnrJ iitSimp7WaMABTYykCTDc7Axvhgeh1432IOAWsQjqqQmlfPlTzNz3p+wFpt1HFylccVt 15Je0ARfBKE8kj2xhFxwW3dxdvD1uA8EDgKTVEyaW7quKvkrvfbo0jD73SQVmCmH2CuA Khed9nUSdibsp006qc3N94XtDh0hPqFtDzTorsRbf9U5VRfzlLRsNMb6tpULRSKbPsah vkj2vkhiYAFBfuxB1sT3hlu0BR1/HYy0j2hkoAL7thx1rHrPzMlevHq8mNpSxsVVjDHM G1ew== X-Gm-Message-State: AAQBX9dvYpc/uxFeJAK+8179mFovENl1B3X5RxJQFX4VucliSBS/FVe+ L40dEhzaOrphKarBycbeauAT0nS3PCbI0ueCm4w= X-Google-Smtp-Source: AKy350a+i2v+uZqEh+gydxF69tm7ZiJlqTIMdsXKp6s1Jl+Ey/HTUvBnfWk3kBSipdveigM/5wDKJsBEpQNS++KZacs= X-Received: by 2002:a63:cd08:0:b0:513:e029:d172 with SMTP id i8-20020a63cd08000000b00513e029d172mr3497233pgg.12.1680808161125; Thu, 06 Apr 2023 12:09:21 -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: Thu, 6 Apr 2023 15:09:08 -0400 Message-ID: Subject: Re: Should vacuum process config file reload more often To: Daniel Gustafsson Cc: Robert Haas , Andres Freund , Tom Lane , Masahiko Sawada , Kyotaro Horiguchi , PostgreSQL Hackers , Amit Kapila Content-Type: multipart/mixed; boundary="00000000000061568505f8afa5eb" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --00000000000061568505f8afa5eb Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable v17 attached does not yet fix the logging problem or variable naming problem. I have not changed where AutoVacuumUpdateCostLimit() is called either. This is effectively just a round of cleanup. I hope I have managed to address all other code review feedback so far, though some may have slipped through the cracks. On Wed, Apr 5, 2023 at 2:56=E2=80=AFPM Robert Haas = wrote: > On Wed, Apr 5, 2023 at 11:29=E2=80=AFAM Melanie Plageman wrote: > + /* > + * Balance and update limit values for autovacuum workers. We must > + * always do this in case the autovacuum launcher or another > + * autovacuum worker has recalculated the number of workers across > + * which we must balance the limit. This is done by the launcher when > + * launching a new worker and by workers before vacuuming each table. > + */ > > I don't quite understand what's going on here. A big reason that I'm > worried about this whole issue in the first place is that sometimes > there's a vacuum going on a giant table and you can't get it to go > fast. You want it to absorb new settings, and to do so quickly. I > realize that this is about the number of workers, not the actual cost > limit, so that makes what I'm about to say less important. But ... is > this often enough? Like, the time before we move onto the next table > could be super long. The time before a new worker is launched should > be ~autovacuum_naptime/autovacuum_max_workers or ~20s with default > settings, so that's not horrible, but I'm kind of struggling to > understand the rationale for this particular choice. Maybe it's fine. I've at least updated this comment to be more correct/less misleading. > > + if (autovacuum_vac_cost_limit > 0) > + VacuumCostLimit =3D autovacuum_vac_cost_limit; > + else > + VacuumCostLimit =3D vacuum_cost_limit; > + > + /* Only balance limit if no cost-related storage > parameters specified */ > + if (pg_atomic_unlocked_test_flag(&MyWorkerInfo->wi_dobala= nce)) > + return; > + Assert(VacuumCostLimit > 0); > + > + nworkers_for_balance =3D pg_atomic_read_u32( > + > &AutoVacuumShmem->av_nworkersForBalance); > + > + /* There is at least 1 autovac worker (this worker). */ > + if (nworkers_for_balance <=3D 0) > + elog(ERROR, "nworkers_for_balance must be > 0"); > + > + VacuumCostLimit =3D Max(VacuumCostLimit / > nworkers_for_balance, 1); > > I think it would be better stylistically to use a temporary variable > here and only assign the final value to VacuumCostLimit. I tried that and thought it adding confusing clutter. If it is a code cleanliness issue, I am willing to change it, though. On Wed, Apr 5, 2023 at 3:04=E2=80=AFPM Daniel Gustafsson = wrote: > > > On 5 Apr 2023, at 20:55, Robert Haas wrote: > > > Again, I don't think this is something we should try to > > address right now under time pressure, but in the future, I think we > > should consider ripping this behavior out. > > I would not be opposed to that, but I wholeheartedly agree that it's not = the > job of this patch (or any patch at this point in the cycle). > > > + if (autovacuum_vac_cost_limit > 0) > > + VacuumCostLimit =3D autovacuum_vac_cost_limit; > > + else > > + VacuumCostLimit =3D vacuum_cost_limit; > > + > > + /* Only balance limit if no cost-related storage > > parameters specified */ > > + if (pg_atomic_unlocked_test_flag(&MyWorkerInfo->wi_doba= lance)) > > + return; > > + Assert(VacuumCostLimit > 0); > > + > > + nworkers_for_balance =3D pg_atomic_read_u32( > > + > > &AutoVacuumShmem->av_nworkersForBalance); > > + > > + /* There is at least 1 autovac worker (this worker). */ > > + if (nworkers_for_balance <=3D 0) > > + elog(ERROR, "nworkers_for_balance must be > 0")= ; > > + > > + VacuumCostLimit =3D Max(VacuumCostLimit / > > nworkers_for_balance, 1); > > > > I think it would be better stylistically to use a temporary variable > > here and only assign the final value to VacuumCostLimit. > > I can agree with that. Another supertiny nitpick on the above is to not = end a > single-line comment with a period. I have fixed this. On Thu, Apr 6, 2023 at 2:40=E2=80=AFAM Masahiko Sawada wrote: > > On Thu, Apr 6, 2023 at 12:29=E2=80=AFAM Melanie Plageman > wrote: > > > > 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_bas= e=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 wo= rkers > > > > > in VacuumUpdateCosts(). > > > > > > > > I added a message to do_autovacuum() after calling VacuumUpdateCost= s() > > > > in the loop vacuuming each table. That means it will happen once pe= r > > > > table. It's not ideal that I had to move the call to VacuumUpdateCo= sts() > > > > 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 o= f > > > > VacuumCostDelay and VacuumCostLimit while vacuuming a table. Is it = worth > > > > adding some code to do that in VacuumUpdateCosts() (only when the v= alue > > > > has changed not on every call to VacuumUpdateCosts())? Or perhaps w= e > > > > 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/launche= r > > > set other workers' delay costs. But now that the worker sets its dela= y > > > 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()... > > I think we don't need to acquire a lock there as both values are > updated only by workers reporting this message. I dunno. I just don't feel that comfortable saying, oh it's okay to access these without a lock probably. I propose we do one of the following: - Take a shared lock inside VacuumUpdateCosts() (it is not called on every call to vacuum_delay_point()) before reading from these variables. Pros: - We will log whenever there is a change to these parameters Cons: - This adds overhead in the common case when log level is < DEBUG2. Is there a way to check the log level before taking the lock? - Acquiring the lock inside the function is inconsistent with the pattern that some of the other autovacuum functions requiring locks use (they assume you have a lock if needed inside of the function). But, we could assert that the lock is not already he= ld. - If we later decide we don't like this choice and want to move the logging elsewhere, it will necessarily log less frequently whic= h seems like a harder change to make than logging more frequently= . - Move this logging into the loop through relations in do_autovacuum() and the config reload code and take the shared lock before doing the logging. Pros: - Seems safe and not expensive - Covers most of the times we would want the logging Cons: - duplicates logging in two places > Some minor comments on 0003: > > +/* > + * autovac_recalculate_workers_for_balance > + * Recalculate the number of workers to consider, given > cost-related > + * storage parameters and the current number of active worke= rs. > + * > + * Caller must hold the AutovacuumLock in at least shared mode to access > + * worker->wi_proc. > + */ > > Does it make sense to add Assert(LWLockHeldByMe(AutovacuumLock)) at > the beginning of this function? I've added this. It is called infrequently enough to be okay, I think. > /* rebalance in case the default cost parameters changed= */ > - LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE); > - autovac_balance_cost(); > + LWLockAcquire(AutovacuumLock, LW_SHARED); > + autovac_recalculate_workers_for_balance(); > LWLockRelease(AutovacuumLock); > > Do we really need to have the autovacuum launcher recalculate > av_nworkersForBalance after reloading the config file? Since the cost > parameters are not used inautovac_recalculate_workers_for_balance() > the comment also needs to be updated. Yep, almost certainly don't need this. I've removed this call to autovac_recalculate_workers_for_balance(). > + /* > + * Balance and update limit values for autovacuum > workers. We must > + * always do this in case the autovacuum launcher or ano= ther > + * autovacuum worker has recalculated the number of > workers across > + * which we must balance the limit. This is done by > the launcher when > + * launching a new worker and by workers before > vacuuming each table. > + */ > + AutoVacuumUpdateCostLimit(); > > I think the last sentence is not correct. IIUC recalculation of > av_nworkersForBalance is done by the launcher after a worker finished > and by workers before vacuuming each table. Yes, you are right. However, I think the comment was generally misleading and I have reworded it. > It's not a problem of this patch, but IIUC since we don't reset > wi_dobalance after vacuuming each table we use the last value of > wi_dobalance for performing autovacuum items. At end of the loop for > tables in do_autovacuum() we have the following code that explains why > we don't reset wi_dobalance: > > /* > * Remove my info from shared memory. We could, but intentionall= y > * don't, unset wi_dobalance on the assumption that we are more l= ikely > * than not to vacuum a table with no cost-related storage parame= ters > * next, so we don't want to give up our share of I/O for a very = short > * interval and thereby thrash the global balance. > */ > LWLockAcquire(AutovacuumScheduleLock, LW_EXCLUSIVE); > MyWorkerInfo->wi_tableoid =3D InvalidOid; > MyWorkerInfo->wi_sharedrel =3D false; > LWLockRelease(AutovacuumScheduleLock); > > Assuming we agree with that, probably we need to reset it to true > after vacuuming all tables? Ah, great point. I have done this. On Thu, Apr 6, 2023 at 8:29=E2=80=AFAM Daniel Gustafsson = wrote: > > > On 6 Apr 2023, at 08:39, Masahiko Sawada wrote: > > > Also I agree with > > where to put the log but I think the log message should start with > > lower cases: > > > > + elog(DEBUG2, > > + "Autovacuum VacuumUpdateCosts(db=3D%u, rel=3D= %u, > > In principle I agree, but in this case Autovacuum is a name and should IM= O in > userfacing messages start with capital A. I've left this unchanged while I agonize over what to do with the placement of the log message in general. But I am happy to keep it uppercase. > > +/* > > + * autovac_recalculate_workers_for_balance > > + * Recalculate the number of workers to consider, given > > cost-related > > + * storage parameters and the current number of active wor= kers. > > + * > > + * Caller must hold the AutovacuumLock in at least shared mode to acce= ss > > + * worker->wi_proc. > > + */ > > > > Does it make sense to add Assert(LWLockHeldByMe(AutovacuumLock)) at > > the beginning of this function? > > That's probably not a bad idea. Done. > > --- > > /* rebalance in case the default cost parameters change= d */ > > - LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE); > > - autovac_balance_cost(); > > + LWLockAcquire(AutovacuumLock, LW_SHARED); > > + autovac_recalculate_workers_for_balance(); > > LWLockRelease(AutovacuumLock); > > > > Do we really need to have the autovacuum launcher recalculate > > av_nworkersForBalance after reloading the config file? Since the cost > > parameters are not used inautovac_recalculate_workers_for_balance() > > the comment also needs to be updated. > > If I understand this comment right; there was a discussion upthread that = simply > doing it in both launcher and worker simplifies the code with little over= head. > A comment can reflect that choice though. Yes, but now that this function no longer deals with the cost limit and delay values itself, we can remove it. - Melanie --00000000000061568505f8afa5eb Content-Type: text/x-patch; charset="US-ASCII"; name="v17-0003-Autovacuum-refreshes-cost-based-delay-params-mor.patch" Content-Disposition: attachment; filename="v17-0003-Autovacuum-refreshes-cost-based-delay-params-mor.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg5hi1na2 RnJvbSA2ODRmNzEwYWY0Y2IwYmY3Y2Q3ZmY3MGJhYTBhOGE4ZmRjMTNkNDhjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBTYXQsIDI1IE1hciAyMDIzIDE0OjE0OjU1IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTcgMy8zXSBBdXRvdmFjdXVtIHJlZnJlc2hlcyBjb3N0LWJhc2VkIGRlbGF5IHBhcmFt 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 ICAgICAgICAgfCAgNDUgKysrKy0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVs LmMgfCAgIDEgLQogc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMgICB8IDI3NiAr KysrKysrKysrKysrKystLS0tLS0tLS0tLQogc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgg ICAgICAgICB8ICAgMSArCiA1IGZpbGVzIGNoYW5nZWQsIDIwMiBpbnNlcnRpb25zKCspLCAxMjMg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVt bGF6eS5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jCmluZGV4IDJiYTg1 YmQzZDYuLjBhOWViZDIyYmQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3Zh Y3V1bWxhenkuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKQEAg LTM4OSw3ICszODksNyBAQCBoZWFwX3ZhY3V1bV9yZWwoUmVsYXRpb24gcmVsLCBWYWN1dW1QYXJh bXMgKnBhcmFtcywKIAlBc3NlcnQocGFyYW1zLT5pbmRleF9jbGVhbnVwICE9IFZBQ09QVFZBTFVF X1VOU1BFQ0lGSUVEKTsKIAlBc3NlcnQocGFyYW1zLT50cnVuY2F0ZSAhPSBWQUNPUFRWQUxVRV9V TlNQRUNJRklFRCAmJgogCQkgICBwYXJhbXMtPnRydW5jYXRlICE9IFZBQ09QVFZBTFVFX0FVVE8p OwotCVZhY3V1bUZhaWxzYWZlQWN0aXZlID0gZmFsc2U7CisJQXNzZXJ0KCFWYWN1dW1GYWlsc2Fm ZUFjdGl2ZSk7CiAJdmFjcmVsLT5jb25zaWRlcl9ieXBhc3Nfb3B0aW1pemF0aW9uID0gdHJ1ZTsK IAl2YWNyZWwtPmRvX2luZGV4X3ZhY3V1bWluZyA9IHRydWU7CiAJdmFjcmVsLT5kb19pbmRleF9j bGVhbnVwID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5j IGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKaW5kZXggNWI2ZjhmNTI0NC4uOTc3ZTlj NGM3ZSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKKysrIGIvc3Jj L2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKQEAgLTQ4LDYgKzQ4LDcgQEAKICNpbmNsdWRlICJw Z3N0YXQuaCIKICNpbmNsdWRlICJwb3N0bWFzdGVyL2F1dG92YWN1dW0uaCIKICNpbmNsdWRlICJw b3N0bWFzdGVyL2Jnd29ya2VyX2ludGVybmFscy5oIgorI2luY2x1ZGUgInBvc3RtYXN0ZXIvaW50 ZXJydXB0LmgiCiAjaW5jbHVkZSAic3RvcmFnZS9idWZtZ3IuaCIKICNpbmNsdWRlICJzdG9yYWdl L2xtZ3IuaCIKICNpbmNsdWRlICJzdG9yYWdlL3Btc2lnbmFsLmgiCkBAIC01MjUsOSArNTI2LDkg QEAgdmFjdXVtKExpc3QgKnJlbGF0aW9ucywgVmFjdXVtUGFyYW1zICpwYXJhbXMsIEJ1ZmZlckFj Y2Vzc1N0cmF0ZWd5IGJzdHJhdGVneSwKIAl7CiAJCUxpc3RDZWxsICAgKmN1cjsKIAotCQlWYWN1 dW1VcGRhdGVDb3N0cygpOwogCQlpbl92YWN1dW0gPSB0cnVlOwotCQlWYWN1dW1Db3N0QWN0aXZl ID0gKFZhY3V1bUNvc3REZWxheSA+IDApOworCQlWYWN1dW1GYWlsc2FmZUFjdGl2ZSA9IGZhbHNl OworCQlWYWN1dW1VcGRhdGVDb3N0cygpOwogCQlWYWN1dW1Db3N0QmFsYW5jZSA9IDA7CiAJCVZh Y3V1bVBhZ2VIaXQgPSAwOwogCQlWYWN1dW1QYWdlTWlzcyA9IDA7CkBAIC01ODEsMTIgKzU4Miwy MCBAQCB2YWN1dW0oTGlzdCAqcmVsYXRpb25zLCBWYWN1dW1QYXJhbXMgKnBhcmFtcywgQnVmZmVy QWNjZXNzU3RyYXRlZ3kgYnN0cmF0ZWd5LAogCQkJCQlDb21tYW5kQ291bnRlckluY3JlbWVudCgp OwogCQkJCX0KIAkJCX0KKworCQkJLyoKKwkJCSAqIEVuc3VyZSBWYWN1dW1GYWlsc2FmZUFjdGl2 ZSBoYXMgYmVlbiByZXNldCBiZWZvcmUgdmFjdXVtaW5nIHRoZQorCQkJICogbmV4dCByZWxhdGlv bi4KKwkJCSAqLworCQkJVmFjdXVtRmFpbHNhZmVBY3RpdmUgPSBmYWxzZTsKIAkJfQogCX0KIAlQ R19GSU5BTExZKCk7CiAJewogCQlpbl92YWN1dW0gPSBmYWxzZTsKIAkJVmFjdXVtQ29zdEFjdGl2 ZSA9IGZhbHNlOworCQlWYWN1dW1GYWlsc2FmZUFjdGl2ZSA9IGZhbHNlOworCQlWYWN1dW1Db3N0 QmFsYW5jZSA9IDA7CiAJfQogCVBHX0VORF9UUlkoKTsKIApAQCAtMjI0Nyw3ICsyMjU2LDI3IEBA IHZhY3V1bV9kZWxheV9wb2ludCh2b2lkKQogCS8qIEFsd2F5cyBjaGVjayBmb3IgaW50ZXJydXB0 cyAqLwogCUNIRUNLX0ZPUl9JTlRFUlJVUFRTKCk7CiAKLQlpZiAoIVZhY3V1bUNvc3RBY3RpdmUg fHwgSW50ZXJydXB0UGVuZGluZykKKwlpZiAoSW50ZXJydXB0UGVuZGluZyB8fAorCQkoIVZhY3V1 bUNvc3RBY3RpdmUgJiYgIUNvbmZpZ1JlbG9hZFBlbmRpbmcpKQorCQlyZXR1cm47CisKKwkvKgor CSAqIFJlbG9hZCB0aGUgY29uZmlndXJhdGlvbiBmaWxlIGlmIHJlcXVlc3RlZC4gVGhpcyBhbGxv d3MgY2hhbmdlcyB0bworCSAqIGF1dG92YWN1dW1fdmFjdXVtX2Nvc3RfbGltaXQgYW5kIGF1dG92 YWN1dW1fdmFjdXVtX2Nvc3RfZGVsYXkgdG8gdGFrZQorCSAqIGVmZmVjdCB3aGlsZSBhIHRhYmxl IGlzIGJlaW5nIHZhY3V1bWVkIG9yIGFuYWx5emVkLgorCSAqLworCWlmIChDb25maWdSZWxvYWRQ ZW5kaW5nICYmIElzQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSkKKwl7CisJCUNvbmZpZ1JlbG9h ZFBlbmRpbmcgPSBmYWxzZTsKKwkJUHJvY2Vzc0NvbmZpZ0ZpbGUoUEdDX1NJR0hVUCk7CisJCVZh Y3V1bVVwZGF0ZUNvc3RzKCk7CisJfQorCisJLyoKKwkgKiBJZiB3ZSBkaXNhYmxlZCBjb3N0LWJh c2VkIGRlbGF5cyBhZnRlciByZWxvYWRpbmcgdGhlIGNvbmZpZyBmaWxlLAorCSAqIHJldHVybi4K KwkgKi8KKwlpZiAoIVZhY3V1bUNvc3RBY3RpdmUpCiAJCXJldHVybjsKIAogCS8qCkBAIC0yMjgw LDcgKzIzMDksMTUgQEAgdmFjdXVtX2RlbGF5X3BvaW50KHZvaWQpCiAKIAkJVmFjdXVtQ29zdEJh bGFuY2UgPSAwOwogCi0JCVZhY3V1bVVwZGF0ZUNvc3RzKCk7CisJCS8qCisJCSAqIEJhbGFuY2Ug YW5kIHVwZGF0ZSBsaW1pdCB2YWx1ZXMgZm9yIGF1dG92YWN1dW0gd29ya2Vycy4gV2UgbXVzdCBk bworCQkgKiB0aGlzIHBlcmlvZGljYWxseSBhcyB0aGUgbnVtYmVyIG9mIHdvcmtlcnMgYWNyb3Nz IHdoaWNoIHdlIGFyZQorCQkgKiBiYWxhbmNpbmcgdGhlIGxpbWl0IG1heSBoYXZlIGNoYW5nZWQu CisJCSAqCisJCSAqIFhYWDogVGhlcmUgbWF5IGJlIGJldHRlciBjcml0ZXJpYSBmb3IgZGV0ZXJt aW5pbmcgd2hlbiB0byBkbyB0aGlzCisJCSAqIGJlc2lkZXMgImNoZWNrIGFmdGVyIG5hcHBpbmci LgorCQkgKi8KKwkJQXV0b1ZhY3V1bVVwZGF0ZUNvc3RMaW1pdCgpOwogCiAJCS8qIE1pZ2h0IGhh dmUgZ290dGVuIGFuIGludGVycnVwdCB3aGlsZSBzbGVlcGluZyAqLwogCQlDSEVDS19GT1JfSU5U RVJSVVBUUygpOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxs ZWwuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKaW5kZXggMGI1OWM5 MjJlNC4uZTIwMGQ1Y2FmOCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVt cGFyYWxsZWwuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBA IC05OTUsNyArOTk1LDYgQEAgcGFyYWxsZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywg c2htX3RvYyAqdG9jKQogCQkJCQkJCQkJCQkJIGZhbHNlKTsKIAogCS8qIFNldCBjb3N0LWJhc2Vk IHZhY3V1bSBkZWxheSAqLwotCVZhY3V1bUNvc3RBY3RpdmUgPSAoVmFjdXVtQ29zdERlbGF5ID4g MCk7CiAJVmFjdXVtVXBkYXRlQ29zdHMoKTsKIAlWYWN1dW1Db3N0QmFsYW5jZSA9IDA7CiAJVmFj dXVtUGFnZUhpdCA9IDA7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92 YWN1dW0uYyBiL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCmluZGV4IDI5NmIx ODUxZTMuLmY3MjM3ZmE1ZWEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0 b3ZhY3V1bS5jCisrKyBiL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCkBAIC0x MzksNiArMTM5LDE4IEBAIGludAkJCUxvZ19hdXRvdmFjdXVtX21pbl9kdXJhdGlvbiA9IDYwMDAw MDsKIHN0YXRpYyBib29sIGFtX2F1dG92YWN1dW1fbGF1bmNoZXIgPSBmYWxzZTsKIHN0YXRpYyBi b29sIGFtX2F1dG92YWN1dW1fd29ya2VyID0gZmFsc2U7CiAKKy8qCisgKiBWYXJpYWJsZXMgdG8g c2F2ZSB0aGUgY29zdC1yZWxhdGVkIHN0b3JhZ2UgcGFyYW1ldGVycyBmb3IgdGhlIGN1cnJlbnQK KyAqIHJlbGF0aW9uIGJlaW5nIHZhY3V1bWVkIGJ5IHRoaXMgYXV0b3ZhY3V1bSB3b3JrZXIuIFVz aW5nIHRoZXNlLCB3ZSBjYW4KKyAqIGVuc3VyZSB3ZSBkb24ndCBvdmVyd3JpdGUgdGhlIHZhbHVl cyBvZiBWYWN1dW1Db3N0RGVsYXkgYW5kIFZhY3V1bUNvc3RMaW1pdAorICogYWZ0ZXIgcmVsb2Fk aW5nIHRoZSBjb25maWd1cmF0aW9uIGZpbGUuIFRoZXkgYXJlIGluaXRpYWxpemVkIHRvICJpbnZh bGlkIgorICogdmFsdWVzIHRvIGluZGljYXRlIG5vIGNvc3QtcmVsYXRlZCBzdG9yYWdlIHBhcmFt ZXRlcnMgd2VyZSBzcGVjaWZpZWQgYW5kCisgKiB3aWxsIGJlIHNldCBpbiBkb19hdXRvdmFjdXVt KCkgYWZ0ZXIgY2hlY2tpbmcgdGhlIHN0b3JhZ2UgcGFyYW1ldGVycyBpbgorICogdGFibGVfcmVj aGVja19hdXRvdmFjKCkuCisgKi8KK3N0YXRpYyBkb3VibGUgYXZfc3RvcmFnZV9wYXJhbV9jb3N0 X2RlbGF5ID0gLTE7CitzdGF0aWMgaW50CWF2X3N0b3JhZ2VfcGFyYW1fY29zdF9saW1pdCA9IC0x OworCiAvKiBGbGFncyBzZXQgYnkgc2lnbmFsIGhhbmRsZXJzICovCiBzdGF0aWMgdm9sYXRpbGUg c2lnX2F0b21pY190IGdvdF9TSUdVU1IyID0gZmFsc2U7CiAKQEAgLTE4OSw4ICsyMDEsOCBAQCB0 eXBlZGVmIHN0cnVjdCBhdXRvdmFjX3RhYmxlCiB7CiAJT2lkCQkJYXRfcmVsaWQ7CiAJVmFjdXVt UGFyYW1zIGF0X3BhcmFtczsKLQlkb3VibGUJCWF0X3ZhY3V1bV9jb3N0X2RlbGF5OwotCWludAkJ CWF0X3ZhY3V1bV9jb3N0X2xpbWl0OworCWRvdWJsZQkJYXRfc3RvcmFnZV9wYXJhbV92YWNfY29z dF9kZWxheTsKKwlpbnQJCQlhdF9zdG9yYWdlX3BhcmFtX3ZhY19jb3N0X2xpbWl0OwogCWJvb2wJ CWF0X2RvYmFsYW5jZTsKIAlib29sCQlhdF9zaGFyZWRyZWw7CiAJY2hhcgkgICAqYXRfcmVsbmFt ZTsKQEAgLTIwOSw3ICsyMjEsNyBAQCB0eXBlZGVmIHN0cnVjdCBhdXRvdmFjX3RhYmxlCiAgKiB3 aV9zaGFyZWRyZWwgZmxhZyBpbmRpY2F0aW5nIHdoZXRoZXIgdGFibGUgaXMgbWFya2VkIHJlbGlz c2hhcmVkCiAgKiB3aV9wcm9jCQlwb2ludGVyIHRvIFBHUFJPQyBvZiB0aGUgcnVubmluZyB3b3Jr ZXIsIE5VTEwgaWYgbm90IHN0YXJ0ZWQKICAqIHdpX2xhdW5jaHRpbWUgVGltZSBhdCB3aGljaCB0 aGlzIHdvcmtlciB3YXMgbGF1bmNoZWQKLSAqIHdpX2Nvc3RfKglWYWN1dW0gY29zdC1iYXNlZCBk ZWxheSBwYXJhbWV0ZXJzIGN1cnJlbnQgaW4gdGhpcyB3b3JrZXIKKyAqIHdpX2RvYmFsYW5jZSBX aGV0aGVyIHRoaXMgd29ya2VyIHNob3VsZCBiZSBpbmNsdWRlZCBpbiBiYWxhbmNlIGNhbGN1bGF0 aW9ucwogICoKICAqIEFsbCBmaWVsZHMgYXJlIHByb3RlY3RlZCBieSBBdXRvdmFjdXVtTG9jaywg ZXhjZXB0IGZvciB3aV90YWJsZW9pZCBhbmQKICAqIHdpX3NoYXJlZHJlbCB3aGljaCBhcmUgcHJv dGVjdGVkIGJ5IEF1dG92YWN1dW1TY2hlZHVsZUxvY2sgKG5vdGUgdGhlc2UKQEAgLTIyMywxMSAr MjM1LDggQEAgdHlwZWRlZiBzdHJ1Y3QgV29ya2VySW5mb0RhdGEKIAlPaWQJCQl3aV90YWJsZW9p ZDsKIAlQR1BST0MJICAgKndpX3Byb2M7CiAJVGltZXN0YW1wVHogd2lfbGF1bmNodGltZTsKLQli b29sCQl3aV9kb2JhbGFuY2U7CisJcGdfYXRvbWljX2ZsYWcgd2lfZG9iYWxhbmNlOwogCWJvb2wJ CXdpX3NoYXJlZHJlbDsKLQlkb3VibGUJCXdpX2Nvc3RfZGVsYXk7Ci0JaW50CQkJd2lfY29zdF9s aW1pdDsKLQlpbnQJCQl3aV9jb3N0X2xpbWl0X2Jhc2U7CiB9IFdvcmtlckluZm9EYXRhOwogCiB0 eXBlZGVmIHN0cnVjdCBXb3JrZXJJbmZvRGF0YSAqV29ya2VySW5mbzsKQEAgLTI3Myw2ICsyODIs OCBAQCB0eXBlZGVmIHN0cnVjdCBBdXRvVmFjdXVtV29ya0l0ZW0KICAqIGF2X3N0YXJ0aW5nV29y a2VyIHBvaW50ZXIgdG8gV29ya2VySW5mbyBjdXJyZW50bHkgYmVpbmcgc3RhcnRlZCAoY2xlYXJl ZCBieQogICoJCQkJCXRoZSB3b3JrZXIgaXRzZWxmIGFzIHNvb24gYXMgaXQncyB1cCBhbmQgcnVu bmluZykKICAqIGF2X3dvcmtJdGVtcwkJd29yayBpdGVtIGFycmF5CisgKiBhdl9ud29ya2Vyc0Zv ckJhbGFuY2UgdGhlIG51bWJlciBvZiBhdXRvdmFjdXVtIHdvcmtlcnMgdG8gdXNlIHdoZW4KKyAq IAkJCQkJY2FsY3VsYXRpbmcgdGhlIHBlciB3b3JrZXIgY29zdCBsaW1pdAogICoKICAqIFRoaXMg c3RydWN0IGlzIHByb3RlY3RlZCBieSBBdXRvdmFjdXVtTG9jaywgZXhjZXB0IGZvciBhdl9zaWdu YWwgYW5kIHBhcnRzCiAgKiBvZiB0aGUgd29ya2VyIGxpc3QgKHNlZSBhYm92ZSkuCkBAIC0yODYs NiArMjk3LDcgQEAgdHlwZWRlZiBzdHJ1Y3QKIAlkbGlzdF9oZWFkCWF2X3J1bm5pbmdXb3JrZXJz OwogCVdvcmtlckluZm8JYXZfc3RhcnRpbmdXb3JrZXI7CiAJQXV0b1ZhY3V1bVdvcmtJdGVtIGF2 X3dvcmtJdGVtc1tOVU1fV09SS0lURU1TXTsKKwlwZ19hdG9taWNfdWludDMyIGF2X253b3JrZXJz Rm9yQmFsYW5jZTsKIH0gQXV0b1ZhY3V1bVNobWVtU3RydWN0OwogCiBzdGF0aWMgQXV0b1ZhY3V1 bVNobWVtU3RydWN0ICpBdXRvVmFjdXVtU2htZW07CkBAIC0zMTksNyArMzMxLDcgQEAgc3RhdGlj IHZvaWQgbGF1bmNoX3dvcmtlcihUaW1lc3RhbXBUeiBub3cpOwogc3RhdGljIExpc3QgKmdldF9k YXRhYmFzZV9saXN0KHZvaWQpOwogc3RhdGljIHZvaWQgcmVidWlsZF9kYXRhYmFzZV9saXN0KE9p ZCBuZXdkYik7CiBzdGF0aWMgaW50CWRiX2NvbXBhcmF0b3IoY29uc3Qgdm9pZCAqYSwgY29uc3Qg dm9pZCAqYik7Ci1zdGF0aWMgdm9pZCBhdXRvdmFjX2JhbGFuY2VfY29zdCh2b2lkKTsKK3N0YXRp YyB2b2lkIGF1dG92YWNfcmVjYWxjdWxhdGVfd29ya2Vyc19mb3JfYmFsYW5jZSh2b2lkKTsKIAog c3RhdGljIHZvaWQgZG9fYXV0b3ZhY3V1bSh2b2lkKTsKIHN0YXRpYyB2b2lkIEZyZWVXb3JrZXJJ bmZvKGludCBjb2RlLCBEYXR1bSBhcmcpOwpAQCAtNjY5LDcgKzY4MSw3IEBAIEF1dG9WYWNMYXVu Y2hlck1haW4oaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKIAkJCXsKIAkJCQlMV0xvY2tBY3F1aXJl KEF1dG92YWN1dW1Mb2NrLCBMV19FWENMVVNJVkUpOwogCQkJCUF1dG9WYWN1dW1TaG1lbS0+YXZf c2lnbmFsW0F1dG9WYWNSZWJhbGFuY2VdID0gZmFsc2U7Ci0JCQkJYXV0b3ZhY19iYWxhbmNlX2Nv c3QoKTsKKwkJCQlhdXRvdmFjX3JlY2FsY3VsYXRlX3dvcmtlcnNfZm9yX2JhbGFuY2UoKTsKIAkJ CQlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKIAkJCX0KIApAQCAtODE4LDExICs4MzAs NiBAQCBIYW5kbGVBdXRvVmFjTGF1bmNoZXJJbnRlcnJ1cHRzKHZvaWQpCiAJCWlmICghQXV0b1Zh Y3V1bWluZ0FjdGl2ZSgpKQogCQkJQXV0b1ZhY0xhdW5jaGVyU2h1dGRvd24oKTsKIAotCQkvKiBy ZWJhbGFuY2UgaW4gY2FzZSB0aGUgZGVmYXVsdCBjb3N0IHBhcmFtZXRlcnMgY2hhbmdlZCAqLwot CQlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2NrLCBMV19FWENMVVNJVkUpOwotCQlhdXRvdmFj X2JhbGFuY2VfY29zdCgpOwotCQlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKLQogCQkv KiByZWJ1aWxkIHRoZSBsaXN0IGluIGNhc2UgdGhlIG5hcHRpbWUgY2hhbmdlZCAqLwogCQlyZWJ1 aWxkX2RhdGFiYXNlX2xpc3QoSW52YWxpZE9pZCk7CiAJfQpAQCAtMTc1NCwxMCArMTc2MSw3IEBA IEZyZWVXb3JrZXJJbmZvKGludCBjb2RlLCBEYXR1bSBhcmcpCiAJCU15V29ya2VySW5mby0+d2lf c2hhcmVkcmVsID0gZmFsc2U7CiAJCU15V29ya2VySW5mby0+d2lfcHJvYyA9IE5VTEw7CiAJCU15 V29ya2VySW5mby0+d2lfbGF1bmNodGltZSA9IDA7Ci0JCU15V29ya2VySW5mby0+d2lfZG9iYWxh bmNlID0gZmFsc2U7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9kZWxheSA9IDA7Ci0JCU15V29y a2VySW5mby0+d2lfY29zdF9saW1pdCA9IDA7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9saW1p dF9iYXNlID0gMDsKKwkJcGdfYXRvbWljX2NsZWFyX2ZsYWcoJk15V29ya2VySW5mby0+d2lfZG9i YWxhbmNlKTsKIAkJZGxpc3RfcHVzaF9oZWFkKCZBdXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVXb3Jr ZXJzLAogCQkJCQkJJk15V29ya2VySW5mby0+d2lfbGlua3MpOwogCQkvKiBub3QgbWluZSBhbnlt b3JlICovCkBAIC0xNzgzLDk3ICsxNzg3LDEyOCBAQCBWYWN1dW1VcGRhdGVDb3N0cyh2b2lkKQog ewogCWlmIChNeVdvcmtlckluZm8pCiAJewotCQlWYWN1dW1Db3N0RGVsYXkgPSBNeVdvcmtlcklu Zm8tPndpX2Nvc3RfZGVsYXk7Ci0JCVZhY3V1bUNvc3RMaW1pdCA9IE15V29ya2VySW5mby0+d2lf Y29zdF9saW1pdDsKKwkJaWYgKGF2X3N0b3JhZ2VfcGFyYW1fY29zdF9kZWxheSA+PSAwKQorCQkJ VmFjdXVtQ29zdERlbGF5ID0gYXZfc3RvcmFnZV9wYXJhbV9jb3N0X2RlbGF5OworCQllbHNlIGlm IChhdXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5ID49IDApCisJCQlWYWN1dW1Db3N0RGVsYXkgPSBh dXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5OworCQllbHNlCisJCQkvKiBmYWxsIGJhY2sgdG8gdmFj dXVtX2Nvc3RfZGVsYXkgKi8KKwkJCVZhY3V1bUNvc3REZWxheSA9IHZhY3V1bV9jb3N0X2RlbGF5 OworCisJCUF1dG9WYWN1dW1VcGRhdGVDb3N0TGltaXQoKTsKIAl9CiAJZWxzZQogCXsKIAkJLyog TXVzdCBiZSBleHBsaWNpdCBWQUNVVU0gb3IgQU5BTFlaRSAqLwotCQlWYWN1dW1Db3N0TGltaXQg PSB2YWN1dW1fY29zdF9saW1pdDsKIAkJVmFjdXVtQ29zdERlbGF5ID0gdmFjdXVtX2Nvc3RfZGVs YXk7CisJCVZhY3V1bUNvc3RMaW1pdCA9IHZhY3V1bV9jb3N0X2xpbWl0OworCX0KKworCS8qCisJ ICogSWYgY29uZmlndXJhdGlvbiBjaGFuZ2VzIGFyZSBhbGxvd2VkIHRvIGltcGFjdCBWYWN1dW1D b3N0QWN0aXZlLCBtYWtlCisJICogc3VyZSBpdCBpcyB1cGRhdGVkLgorCSAqLworCWlmIChWYWN1 dW1GYWlsc2FmZUFjdGl2ZSkKKwkJQXNzZXJ0KCFWYWN1dW1Db3N0QWN0aXZlKTsKKwllbHNlIGlm IChWYWN1dW1Db3N0RGVsYXkgPiAwKQorCQlWYWN1dW1Db3N0QWN0aXZlID0gdHJ1ZTsKKwllbHNl CisJeworCQlWYWN1dW1Db3N0QWN0aXZlID0gZmFsc2U7CisJCVZhY3V1bUNvc3RCYWxhbmNlID0g MDsKKwl9CisKKwlpZiAoTXlXb3JrZXJJbmZvKQorCXsKKwkJZWxvZyhERUJVRzIsCisJCQkgIkF1 dG92YWN1dW0gVmFjdXVtVXBkYXRlQ29zdHMoZGI9JXUsIHJlbD0ldSwgZG9iYWxhbmNlPSVzLCBj b3N0X2xpbWl0PSVkLCBjb3N0X2RlbGF5PSVnIGFjdGl2ZT0lcyBmYWlsc2FmZT0lcykiLAorCQkJ IE15V29ya2VySW5mby0+d2lfZGJvaWQsIE15V29ya2VySW5mby0+d2lfdGFibGVvaWQsCisJCQkg cGdfYXRvbWljX3VubG9ja2VkX3Rlc3RfZmxhZygmTXlXb3JrZXJJbmZvLT53aV9kb2JhbGFuY2Up ID8gIm5vIiA6ICJ5ZXMiLAorCQkJIFZhY3V1bUNvc3RMaW1pdCwgVmFjdXVtQ29zdERlbGF5LAor CQkJIFZhY3V1bUNvc3REZWxheSA+IDAgPyAieWVzIiA6ICJubyIsCisJCQkgVmFjdXVtRmFpbHNh ZmVBY3RpdmUgPyAieWVzIiA6ICJubyIpOwogCX0KIH0KIAogLyoKLSAqIGF1dG92YWNfYmFsYW5j ZV9jb3N0Ci0gKgkJUmVjYWxjdWxhdGUgdGhlIGNvc3QgbGltaXQgc2V0dGluZyBmb3IgZWFjaCBh Y3RpdmUgd29ya2VyLgotICoKLSAqIENhbGxlciBtdXN0IGhvbGQgdGhlIEF1dG92YWN1dW1Mb2Nr IGluIGV4Y2x1c2l2ZSBtb2RlLgorICogVXBkYXRlIFZhY3V1bUNvc3RMaW1pdCB3aXRoIHRoZSBj b3JyZWN0IHZhbHVlIGZvciBhbiBhdXRvdmFjdXVtIHdvcmtlciwgZ2l2ZW4KKyAqIHRoZSB2YWx1 ZSBvZiBvdGhlciByZWxldmFudCBjb3N0IGxpbWl0IHBhcmFtZXRlcnMgYW5kIHRoZSBudW1iZXIg b2Ygd29ya2VycworICogYWNyb3NzIHdoaWNoIHRoZSBsaW1pdCBtdXN0IGJlIGJhbGFuY2VkLiBB dXRvdmFjdXVtIHdvcmtlcnMgbXVzdCBjYWxsIHRoaXMKKyAqIHJlZ3VsYXJseSBpbiBjYXNlIGF2 X253b3JrZXJzX2Zvcl9iYWxhbmNlIGhhcyBiZWVuIHVwZGF0ZWQgYnkgYW5vdGhlciB3b3JrZXIK KyAqIG9yIGJ5IHRoZSBhdXRvdmFjdXVtIGxhdW5jaGVyLiBUaGV5IG11c3QgYWxzbyBjYWxsIGl0 IGFmdGVyIGEgY29uZmlnIHJlbG9hZC4KICAqLwotc3RhdGljIHZvaWQKLWF1dG92YWNfYmFsYW5j ZV9jb3N0KHZvaWQpCit2b2lkCitBdXRvVmFjdXVtVXBkYXRlQ29zdExpbWl0KHZvaWQpCiB7CisJ aWYgKCFNeVdvcmtlckluZm8pCisJCXJldHVybjsKKwogCS8qCi0JICogVGhlIGlkZWEgaGVyZSBp cyB0aGF0IHdlIHJhdGlvbiBvdXQgSS9PIGVxdWFsbHkuICBUaGUgYW1vdW50IG9mIEkvTwotCSAq IHRoYXQgYSB3b3JrZXIgY2FuIGNvbnN1bWUgaXMgZGV0ZXJtaW5lZCBieSBjb3N0X2xpbWl0L2Nv c3RfZGVsYXksIHNvIHdlCi0JICogdHJ5IHRvIGVxdWFsaXplIHRob3NlIHJhdGlvcyByYXRoZXIg dGhhbiB0aGUgcmF3IGxpbWl0IHNldHRpbmdzLgotCSAqCiAJICogbm90ZTogaW4gY29zdF9saW1p dCwgemVybyBhbHNvIG1lYW5zIHVzZSB2YWx1ZSBmcm9tIGVsc2V3aGVyZSwgYmVjYXVzZQogCSAq IHplcm8gaXMgbm90IGEgdmFsaWQgdmFsdWUuCiAJICovCi0JaW50CQkJdmFjX2Nvc3RfbGltaXQg PSAoYXV0b3ZhY3V1bV92YWNfY29zdF9saW1pdCA+IDAgPwotCQkJCQkJCQkgIGF1dG92YWN1dW1f dmFjX2Nvc3RfbGltaXQgOiB2YWN1dW1fY29zdF9saW1pdCk7Ci0JZG91YmxlCQl2YWNfY29zdF9k ZWxheSA9IChhdXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5ID49IDAgPwotCQkJCQkJCQkgIGF1dG92 YWN1dW1fdmFjX2Nvc3RfZGVsYXkgOiB2YWN1dW1fY29zdF9kZWxheSk7Ci0JZG91YmxlCQljb3N0 X3RvdGFsOwotCWRvdWJsZQkJY29zdF9hdmFpbDsKLQlkbGlzdF9pdGVyCWl0ZXI7CiAKLQkvKiBu b3Qgc2V0PyBub3RoaW5nIHRvIGRvICovCi0JaWYgKHZhY19jb3N0X2xpbWl0IDw9IDAgfHwgdmFj X2Nvc3RfZGVsYXkgPD0gMCkKLQkJcmV0dXJuOwotCi0JLyogY2FsY3VsYXRlIHRoZSB0b3RhbCBi YXNlIGNvc3QgbGltaXQgb2YgcGFydGljaXBhdGluZyBhY3RpdmUgd29ya2VycyAqLwotCWNvc3Rf dG90YWwgPSAwLjA7Ci0JZGxpc3RfZm9yZWFjaChpdGVyLCAmQXV0b1ZhY3V1bVNobWVtLT5hdl9y dW5uaW5nV29ya2VycykKKwlpZiAoYXZfc3RvcmFnZV9wYXJhbV9jb3N0X2xpbWl0ID4gMCkKKwkJ VmFjdXVtQ29zdExpbWl0ID0gYXZfc3RvcmFnZV9wYXJhbV9jb3N0X2xpbWl0OworCWVsc2UKIAl7 Ci0JCVdvcmtlckluZm8Jd29ya2VyID0gZGxpc3RfY29udGFpbmVyKFdvcmtlckluZm9EYXRhLCB3 aV9saW5rcywgaXRlci5jdXIpOworCQlpbnQJCQlud29ya2Vyc19mb3JfYmFsYW5jZTsKKworCQlp ZiAoYXV0b3ZhY3V1bV92YWNfY29zdF9saW1pdCA+IDApCisJCQlWYWN1dW1Db3N0TGltaXQgPSBh dXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0OworCQllbHNlCisJCQlWYWN1dW1Db3N0TGltaXQgPSB2 YWN1dW1fY29zdF9saW1pdDsKKworCQkvKiBPbmx5IGJhbGFuY2UgbGltaXQgaWYgbm8gY29zdC1y ZWxhdGVkIHN0b3JhZ2UgcGFyYW1ldGVycyBzcGVjaWZpZWQgKi8KKwkJaWYgKHBnX2F0b21pY191 bmxvY2tlZF90ZXN0X2ZsYWcoJk15V29ya2VySW5mby0+d2lfZG9iYWxhbmNlKSkKKwkJCXJldHVy bjsKIAotCQlpZiAod29ya2VyLT53aV9wcm9jICE9IE5VTEwgJiYKLQkJCXdvcmtlci0+d2lfZG9i YWxhbmNlICYmCi0JCQl3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSA+IDAgJiYgd29ya2VyLT53 aV9jb3N0X2RlbGF5ID4gMCkKLQkJCWNvc3RfdG90YWwgKz0KLQkJCQkoZG91YmxlKSB3b3JrZXIt PndpX2Nvc3RfbGltaXRfYmFzZSAvIHdvcmtlci0+d2lfY29zdF9kZWxheTsKKwkJQXNzZXJ0KFZh Y3V1bUNvc3RMaW1pdCA+IDApOworCisJCW53b3JrZXJzX2Zvcl9iYWxhbmNlID0gcGdfYXRvbWlj X3JlYWRfdTMyKCZBdXRvVmFjdXVtU2htZW0tPmF2X253b3JrZXJzRm9yQmFsYW5jZSk7CisKKwkJ LyogVGhlcmUgaXMgYXQgbGVhc3QgMSBhdXRvdmFjIHdvcmtlciAodGhpcyB3b3JrZXIpICovCisJ CWlmIChud29ya2Vyc19mb3JfYmFsYW5jZSA8PSAwKQorCQkJZWxvZyhFUlJPUiwgIm53b3JrZXJz X2Zvcl9iYWxhbmNlIG11c3QgYmUgPiAwIik7CisKKwkJVmFjdXVtQ29zdExpbWl0ID0gTWF4KFZh Y3V1bUNvc3RMaW1pdCAvIG53b3JrZXJzX2Zvcl9iYWxhbmNlLCAxKTsKIAl9Cit9CiAKLQkvKiB0 aGVyZSBhcmUgbm8gY29zdCBsaW1pdHMgLS0gbm90aGluZyB0byBkbyAqLwotCWlmIChjb3N0X3Rv dGFsIDw9IDApCi0JCXJldHVybjsKKy8qCisgKiBhdXRvdmFjX3JlY2FsY3VsYXRlX3dvcmtlcnNf Zm9yX2JhbGFuY2UKKyAqCQlSZWNhbGN1bGF0ZSB0aGUgbnVtYmVyIG9mIHdvcmtlcnMgdG8gY29u c2lkZXIsIGdpdmVuIGNvc3QtcmVsYXRlZAorICoJCXN0b3JhZ2UgcGFyYW1ldGVycyBhbmQgdGhl IGN1cnJlbnQgbnVtYmVyIG9mIGFjdGl2ZSB3b3JrZXJzLgorICoKKyAqIENhbGxlciBtdXN0IGhv bGQgdGhlIEF1dG92YWN1dW1Mb2NrIGluIGF0IGxlYXN0IHNoYXJlZCBtb2RlIHRvIGFjY2Vzcwor ICogd29ya2VyLT53aV9wcm9jLgorICovCitzdGF0aWMgdm9pZAorYXV0b3ZhY19yZWNhbGN1bGF0 ZV93b3JrZXJzX2Zvcl9iYWxhbmNlKHZvaWQpCit7CisJZGxpc3RfaXRlcglpdGVyOworCWludAkJ CW9yaWdfbndvcmtlcnNfZm9yX2JhbGFuY2U7CisJaW50CQkJbndvcmtlcnNfZm9yX2JhbGFuY2Ug PSAwOworCisJQXNzZXJ0KExXTG9ja0hlbGRCeU1lKEF1dG92YWN1dW1Mb2NrKSk7CisKKwlvcmln X253b3JrZXJzX2Zvcl9iYWxhbmNlID0KKwkJcGdfYXRvbWljX3JlYWRfdTMyKCZBdXRvVmFjdXVt U2htZW0tPmF2X253b3JrZXJzRm9yQmFsYW5jZSk7CiAKLQkvKgotCSAqIEFkanVzdCBjb3N0IGxp bWl0IG9mIGVhY2ggYWN0aXZlIHdvcmtlciB0byBiYWxhbmNlIHRoZSB0b3RhbCBvZiBjb3N0Ci0J ICogbGltaXQgdG8gYXV0b3ZhY3V1bV92YWN1dW1fY29zdF9saW1pdC4KLQkgKi8KLQljb3N0X2F2 YWlsID0gKGRvdWJsZSkgdmFjX2Nvc3RfbGltaXQgLyB2YWNfY29zdF9kZWxheTsKIAlkbGlzdF9m b3JlYWNoKGl0ZXIsICZBdXRvVmFjdXVtU2htZW0tPmF2X3J1bm5pbmdXb3JrZXJzKQogCXsKIAkJ V29ya2VySW5mbwl3b3JrZXIgPSBkbGlzdF9jb250YWluZXIoV29ya2VySW5mb0RhdGEsIHdpX2xp bmtzLCBpdGVyLmN1cik7CiAKLQkJaWYgKHdvcmtlci0+d2lfcHJvYyAhPSBOVUxMICYmCi0JCQl3 b3JrZXItPndpX2RvYmFsYW5jZSAmJgotCQkJd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2UgPiAw ICYmIHdvcmtlci0+d2lfY29zdF9kZWxheSA+IDApCi0JCXsKLQkJCWludAkJCWxpbWl0ID0gKGlu dCkKLQkJCShjb3N0X2F2YWlsICogd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2UgLyBjb3N0X3Rv dGFsKTsKLQotCQkJLyoKLQkJCSAqIFdlIHB1dCBhIGxvd2VyIGJvdW5kIG9mIDEgb24gdGhlIGNv c3RfbGltaXQsIHRvIGF2b2lkIGRpdmlzaW9uLQotCQkJICogYnktemVybyBpbiB0aGUgdmFjdXVt IGNvZGUuICBBbHNvLCBpbiBjYXNlIG9mIHJvdW5kb2ZmIHRyb3VibGUKLQkJCSAqIGluIHRoZXNl IGNhbGN1bGF0aW9ucywgbGV0J3MgYmUgc3VyZSB3ZSBkb24ndCBldmVyIHNldAotCQkJICogY29z dF9saW1pdCB0byBtb3JlIHRoYW4gdGhlIGJhc2UgdmFsdWUuCi0JCQkgKi8KLQkJCXdvcmtlci0+ d2lfY29zdF9saW1pdCA9IE1heChNaW4obGltaXQsCi0JCQkJCQkJCQkJCXdvcmtlci0+d2lfY29z dF9saW1pdF9iYXNlKSwKLQkJCQkJCQkJCQkxKTsKLQkJfQorCQlpZiAod29ya2VyLT53aV9wcm9j ID09IE5VTEwgfHwKKwkJCXBnX2F0b21pY191bmxvY2tlZF90ZXN0X2ZsYWcoJndvcmtlci0+d2lf ZG9iYWxhbmNlKSkKKwkJCWNvbnRpbnVlOwogCi0JCWlmICh3b3JrZXItPndpX3Byb2MgIT0gTlVM TCkKLQkJCWVsb2coREVCVUcyLCAiYXV0b3ZhY19iYWxhbmNlX2Nvc3QocGlkPSVkIGRiPSV1LCBy ZWw9JXUsIGRvYmFsYW5jZT0lcyBjb3N0X2xpbWl0PSVkLCBjb3N0X2xpbWl0X2Jhc2U9JWQsIGNv c3RfZGVsYXk9JWcpIiwKLQkJCQkgd29ya2VyLT53aV9wcm9jLT5waWQsIHdvcmtlci0+d2lfZGJv aWQsIHdvcmtlci0+d2lfdGFibGVvaWQsCi0JCQkJIHdvcmtlci0+d2lfZG9iYWxhbmNlID8gInll cyIgOiAibm8iLAotCQkJCSB3b3JrZXItPndpX2Nvc3RfbGltaXQsIHdvcmtlci0+d2lfY29zdF9s aW1pdF9iYXNlLAotCQkJCSB3b3JrZXItPndpX2Nvc3RfZGVsYXkpOworCQlud29ya2Vyc19mb3Jf YmFsYW5jZSsrOwogCX0KKworCWlmIChud29ya2Vyc19mb3JfYmFsYW5jZSAhPSBvcmlnX253b3Jr ZXJzX2Zvcl9iYWxhbmNlKQorCQlwZ19hdG9taWNfd3JpdGVfdTMyKCZBdXRvVmFjdXVtU2htZW0t PmF2X253b3JrZXJzRm9yQmFsYW5jZSwKKwkJCQkJCQlud29ya2Vyc19mb3JfYmFsYW5jZSk7CiB9 CiAKIC8qCkBAIC0yNDIxLDIzICsyNDU2LDM0IEBAIGRvX2F1dG92YWN1dW0odm9pZCkKIAkJCWNv bnRpbnVlOwogCQl9CiAKLQkJLyogTXVzdCBob2xkIEF1dG92YWN1dW1Mb2NrIHdoaWxlIG11Y2tp bmcgd2l0aCBjb3N0IGJhbGFuY2UgaW5mbyAqLwotCQlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1M b2NrLCBMV19FWENMVVNJVkUpOworCQkvKgorCQkgKiBTYXZlIHRoZSBjb3N0LXJlbGF0ZWQgc3Rv cmFnZSBwYXJhbWV0ZXIgdmFsdWVzIGluIGdsb2JhbCB2YXJpYWJsZXMKKwkJICogZm9yIHJlZmVy ZW5jZSB3aGVuIHVwZGF0aW5nIFZhY3V1bUNvc3RMaW1pdCBhbmQgVmFjdXVtQ29zdERlbGF5CisJ CSAqIGR1cmluZyB2YWN1dW1pbmcgdGhpcyB0YWJsZS4KKwkJICovCisJCWF2X3N0b3JhZ2VfcGFy YW1fY29zdF9saW1pdCA9IHRhYi0+YXRfc3RvcmFnZV9wYXJhbV92YWNfY29zdF9saW1pdDsKKwkJ YXZfc3RvcmFnZV9wYXJhbV9jb3N0X2RlbGF5ID0gdGFiLT5hdF9zdG9yYWdlX3BhcmFtX3ZhY19j b3N0X2RlbGF5OwogCi0JCS8qIGFkdmVydGlzZSBteSBjb3N0IGRlbGF5IHBhcmFtZXRlcnMgZm9y IHRoZSBiYWxhbmNpbmcgYWxnb3JpdGhtICovCi0JCU15V29ya2VySW5mby0+d2lfZG9iYWxhbmNl ID0gdGFiLT5hdF9kb2JhbGFuY2U7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9kZWxheSA9IHRh Yi0+YXRfdmFjdXVtX2Nvc3RfZGVsYXk7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9saW1pdCA9 IHRhYi0+YXRfdmFjdXVtX2Nvc3RfbGltaXQ7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9saW1p dF9iYXNlID0gdGFiLT5hdF92YWN1dW1fY29zdF9saW1pdDsKKwkJLyoKKwkJICogV2Ugb25seSBl eHBlY3QgdGhpcyB3b3JrZXIgdG8gZXZlciBzZXQgdGhlIGZsYWcsIHNvIGRvbid0IGJvdGhlcgor CQkgKiBjaGVja2luZyB0aGUgcmV0dXJuIHZhbHVlLiBXZSBzaG91bGRuJ3QgaGF2ZSB0byByZXRy eS4KKwkJICovCisJCWlmICh0YWItPmF0X2RvYmFsYW5jZSkKKwkJCXBnX2F0b21pY190ZXN0X3Nl dF9mbGFnKCZNeVdvcmtlckluZm8tPndpX2RvYmFsYW5jZSk7CisJCWVsc2UKKwkJCXBnX2F0b21p Y19jbGVhcl9mbGFnKCZNeVdvcmtlckluZm8tPndpX2RvYmFsYW5jZSk7CiAKLQkJLyogZG8gYSBi YWxhbmNlICovCi0JCWF1dG92YWNfYmFsYW5jZV9jb3N0KCk7CisJCUxXTG9ja0FjcXVpcmUoQXV0 b3ZhY3V1bUxvY2ssIExXX1NIQVJFRCk7CisJCWF1dG92YWNfcmVjYWxjdWxhdGVfd29ya2Vyc19m b3JfYmFsYW5jZSgpOworCQlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKIAotCQkvKiBz ZXQgdGhlIGFjdGl2ZSBjb3N0IHBhcmFtZXRlcnMgZnJvbSB0aGUgcmVzdWx0IG9mIHRoYXQgKi8K KwkJLyoKKwkJICogV2Ugd2FpdCB1bnRpbCB0aGlzIHBvaW50IHRvIHVwZGF0ZSBjb3N0IGRlbGF5 IGFuZCBjb3N0IGxpbWl0CisJCSAqIHZhbHVlcywgZXZlbiB0aG91Z2ggd2UgcmVsb2FkZWQgdGhl IGNvbmZpZ3VyYXRpb24gZmlsZSBhYm92ZSwgc28KKwkJICogdGhhdCB3ZSBjYW4gdGFrZSBpbnRv IGFjY291bnQgdGhlIGNvc3QtcmVsYXRlZCBzdG9yYWdlIHBhcmFtZXRlcnMuCisJCSAqLwogCQlW YWN1dW1VcGRhdGVDb3N0cygpOwogCi0JCS8qIGRvbmUgKi8KLQkJTFdMb2NrUmVsZWFzZShBdXRv dmFjdXVtTG9jayk7CiAKIAkJLyogY2xlYW4gdXAgbWVtb3J5IGJlZm9yZSBlYWNoIGl0ZXJhdGlv biAqLwogCQlNZW1vcnlDb250ZXh0UmVzZXRBbmREZWxldGVDaGlsZHJlbihQb3J0YWxDb250ZXh0 KTsKQEAgLTI1MjEsMTYgKzI1NjcsMTcgQEAgZGVsZXRlZDoKIAkJcGZyZWUodGFiKTsKIAogCQkv KgotCQkgKiBSZW1vdmUgbXkgaW5mbyBmcm9tIHNoYXJlZCBtZW1vcnkuICBXZSBjb3VsZCwgYnV0 IGludGVudGlvbmFsbHkKLQkJICogZG9uJ3QsIGNsZWFyIHdpX2Nvc3RfbGltaXQgYW5kIGZyaWVu ZHMgLS0tIHRoaXMgaXMgb24gdGhlCi0JCSAqIGFzc3VtcHRpb24gdGhhdCB3ZSBwcm9iYWJseSBo YXZlIG1vcmUgdG8gZG8gd2l0aCBzaW1pbGFyIGNvc3QKLQkJICogc2V0dGluZ3MsIHNvIHdlIGRv bid0IHdhbnQgdG8gZ2l2ZSB1cCBvdXIgc2hhcmUgb2YgSS9PIGZvciBhIHZlcnkKLQkJICogc2hv cnQgaW50ZXJ2YWwgYW5kIHRoZXJlYnkgdGhyYXNoIHRoZSBnbG9iYWwgYmFsYW5jZS4KKwkJICog UmVtb3ZlIG15IGluZm8gZnJvbSBzaGFyZWQgbWVtb3J5LiAgV2Ugc2V0IHdpX2RvYmFsYW5jZSBv biB0aGUKKwkJICogYXNzdW1wdGlvbiB0aGF0IHdlIGFyZSBtb3JlIGxpa2VseSB0aGFuIG5vdCB0 byB2YWN1dW0gYSB0YWJsZSB3aXRoCisJCSAqIG5vIGNvc3QtcmVsYXRlZCBzdG9yYWdlIHBhcmFt ZXRlcnMgbmV4dCwgc28gd2Ugd2FudCB0byBjbGFpbSBvdXIKKwkJICogc2hhcmUgb2YgSS9PIGFz IHNvb24gYXMgcG9zc2libGUgdG8gYXZvaWQgdGhyYXNoaW5nIHRoZSBnbG9iYWwKKwkJICogYmFs YW5jZS4KIAkJICovCiAJCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bVNjaGVkdWxlTG9jaywgTFdf RVhDTFVTSVZFKTsKIAkJTXlXb3JrZXJJbmZvLT53aV90YWJsZW9pZCA9IEludmFsaWRPaWQ7CiAJ CU15V29ya2VySW5mby0+d2lfc2hhcmVkcmVsID0gZmFsc2U7CiAJCUxXTG9ja1JlbGVhc2UoQXV0 b3ZhY3V1bVNjaGVkdWxlTG9jayk7CisJCXBnX2F0b21pY190ZXN0X3NldF9mbGFnKCZNeVdvcmtl ckluZm8tPndpX2RvYmFsYW5jZSk7CiAJfQogCiAJLyoKQEAgLTI1NjIsNiArMjYwOSw3IEBAIGRl bGV0ZWQ6CiAJCXsKIAkJCUNvbmZpZ1JlbG9hZFBlbmRpbmcgPSBmYWxzZTsKIAkJCVByb2Nlc3ND b25maWdGaWxlKFBHQ19TSUdIVVApOworCQkJVmFjdXVtVXBkYXRlQ29zdHMoKTsKIAkJfQogCiAJ CUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7CkBAIC0yNzk3LDgg KzI4NDUsNiBAQCB0YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJsZV90 b2FzdF9tYXAsCiAJCWludAkJCWZyZWV6ZV90YWJsZV9hZ2U7CiAJCWludAkJCW11bHRpeGFjdF9m cmVlemVfbWluX2FnZTsKIAkJaW50CQkJbXVsdGl4YWN0X2ZyZWV6ZV90YWJsZV9hZ2U7Ci0JCWlu dAkJCXZhY19jb3N0X2xpbWl0OwotCQlkb3VibGUJCXZhY19jb3N0X2RlbGF5OwogCQlpbnQJCQls b2dfbWluX2R1cmF0aW9uOwogCiAJCS8qCkBAIC0yODA4LDIwICsyODU0LDYgQEAgdGFibGVfcmVj aGVja19hdXRvdmFjKE9pZCByZWxpZCwgSFRBQiAqdGFibGVfdG9hc3RfbWFwLAogCQkgKiBkZWZh dWx0cywgYXV0b3ZhY3V1bSdzIG93biBmaXJzdCBhbmQgcGxhaW4gdmFjdXVtIHNlY29uZC4KIAkJ ICovCiAKLQkJLyogLTEgaW4gYXV0b3ZhYyBzZXR0aW5nIG1lYW5zIHVzZSBwbGFpbiB2YWN1dW1f Y29zdF9kZWxheSAqLwotCQl2YWNfY29zdF9kZWxheSA9IChhdm9wdHMgJiYgYXZvcHRzLT52YWN1 dW1fY29zdF9kZWxheSA+PSAwKQotCQkJPyBhdm9wdHMtPnZhY3V1bV9jb3N0X2RlbGF5Ci0JCQk6 IChhdXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5ID49IDApCi0JCQk/IGF1dG92YWN1dW1fdmFjX2Nv c3RfZGVsYXkKLQkJCTogdmFjdXVtX2Nvc3RfZGVsYXk7Ci0KLQkJLyogMCBvciAtMSBpbiBhdXRv dmFjIHNldHRpbmcgbWVhbnMgdXNlIHBsYWluIHZhY3V1bV9jb3N0X2xpbWl0ICovCi0JCXZhY19j b3N0X2xpbWl0ID0gKGF2b3B0cyAmJiBhdm9wdHMtPnZhY3V1bV9jb3N0X2xpbWl0ID4gMCkKLQkJ CT8gYXZvcHRzLT52YWN1dW1fY29zdF9saW1pdAotCQkJOiAoYXV0b3ZhY3V1bV92YWNfY29zdF9s aW1pdCA+IDApCi0JCQk/IGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQKLQkJCTogdmFjdXVtX2Nv c3RfbGltaXQ7Ci0KIAkJLyogLTEgaW4gYXV0b3ZhYyBzZXR0aW5nIG1lYW5zIHVzZSBsb2dfYXV0 b3ZhY3V1bV9taW5fZHVyYXRpb24gKi8KIAkJbG9nX21pbl9kdXJhdGlvbiA9IChhdm9wdHMgJiYg YXZvcHRzLT5sb2dfbWluX2R1cmF0aW9uID49IDApCiAJCQk/IGF2b3B0cy0+bG9nX21pbl9kdXJh dGlvbgpAQCAtMjg3Nyw4ICsyOTA5LDEwIEBAIHRhYmxlX3JlY2hlY2tfYXV0b3ZhYyhPaWQgcmVs aWQsIEhUQUIgKnRhYmxlX3RvYXN0X21hcCwKIAkJdGFiLT5hdF9wYXJhbXMubXVsdGl4YWN0X2Zy ZWV6ZV90YWJsZV9hZ2UgPSBtdWx0aXhhY3RfZnJlZXplX3RhYmxlX2FnZTsKIAkJdGFiLT5hdF9w YXJhbXMuaXNfd3JhcGFyb3VuZCA9IHdyYXBhcm91bmQ7CiAJCXRhYi0+YXRfcGFyYW1zLmxvZ19t aW5fZHVyYXRpb24gPSBsb2dfbWluX2R1cmF0aW9uOwotCQl0YWItPmF0X3ZhY3V1bV9jb3N0X2xp bWl0ID0gdmFjX2Nvc3RfbGltaXQ7Ci0JCXRhYi0+YXRfdmFjdXVtX2Nvc3RfZGVsYXkgPSB2YWNf Y29zdF9kZWxheTsKKwkJdGFiLT5hdF9zdG9yYWdlX3BhcmFtX3ZhY19jb3N0X2xpbWl0ID0gYXZv cHRzID8KKwkJCWF2b3B0cy0+dmFjdXVtX2Nvc3RfbGltaXQgOiAwOworCQl0YWItPmF0X3N0b3Jh Z2VfcGFyYW1fdmFjX2Nvc3RfZGVsYXkgPSBhdm9wdHMgPworCQkJYXZvcHRzLT52YWN1dW1fY29z dF9kZWxheSA6IC0xOwogCQl0YWItPmF0X3JlbG5hbWUgPSBOVUxMOwogCQl0YWItPmF0X25zcG5h bWUgPSBOVUxMOwogCQl0YWItPmF0X2RhdG5hbWUgPSBOVUxMOwpAQCAtMzM4MCwxMCArMzQxNCwx OCBAQCBBdXRvVmFjdXVtU2htZW1Jbml0KHZvaWQpCiAJCXdvcmtlciA9IChXb3JrZXJJbmZvKSAo KGNoYXIgKikgQXV0b1ZhY3V1bVNobWVtICsKIAkJCQkJCQkgICBNQVhBTElHTihzaXplb2YoQXV0 b1ZhY3V1bVNobWVtU3RydWN0KSkpOwogCisKIAkJLyogaW5pdGlhbGl6ZSB0aGUgV29ya2VySW5m byBmcmVlIGxpc3QgKi8KIAkJZm9yIChpID0gMDsgaSA8IGF1dG92YWN1dW1fbWF4X3dvcmtlcnM7 IGkrKykKKwkJewogCQkJZGxpc3RfcHVzaF9oZWFkKCZBdXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVX b3JrZXJzLAogCQkJCQkJCSZ3b3JrZXJbaV0ud2lfbGlua3MpOworCisJCQlwZ19hdG9taWNfaW5p dF9mbGFnKCZ3b3JrZXJbaV0ud2lfZG9iYWxhbmNlKTsKKwkJfQorCisJCXBnX2F0b21pY19pbml0 X3UzMigmQXV0b1ZhY3V1bVNobWVtLT5hdl9ud29ya2Vyc0ZvckJhbGFuY2UsIDApOworCiAJfQog CWVsc2UKIAkJQXNzZXJ0KGZvdW5kKTsKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2NvbW1hbmRz L3ZhY3V1bS5oIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKaW5kZXggNDQwZGRkMjE1 NC4uZTk3MDViYTUxZCAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgK KysrIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKQEAgLTM1Miw2ICszNTIsNyBAQCBl eHRlcm4gSW5kZXhCdWxrRGVsZXRlUmVzdWx0ICp2YWNfY2xlYW51cF9vbmVfaW5kZXgoSW5kZXhW YWN1dW1JbmZvICppdmluZm8sCiBleHRlcm4gU2l6ZSB2YWNfbWF4X2l0ZW1zX3RvX2FsbG9jX3Np emUoaW50IG1heF9pdGVtcyk7CiAKIC8qIEluIHBvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jICovCitl eHRlcm4gdm9pZCBBdXRvVmFjdXVtVXBkYXRlQ29zdExpbWl0KHZvaWQpOwogZXh0ZXJuIHZvaWQg VmFjdXVtVXBkYXRlQ29zdHModm9pZCk7CiAKIC8qIGluIGNvbW1hbmRzL3ZhY3V1bXBhcmFsbGVs LmMgKi8KLS0gCjIuMzcuMgoK --00000000000061568505f8afa5eb Content-Type: text/x-patch; charset="US-ASCII"; name="v17-0001-Make-vacuum-s-failsafe_active-a-global.patch" Content-Disposition: attachment; filename="v17-0001-Make-vacuum-s-failsafe_active-a-global.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg5hi1n50 RnJvbSA1YjMxZmYwYWY1ODEzZDJmNzc0N2VhYWJiYmY1ZTZmNGM4Mjg0YzRhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBGcmksIDMxIE1hciAyMDIzIDEwOjM4OjM5IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTcgMS8zXSBNYWtlIHZhY3V1bSdzIGZhaWxzYWZlX2FjdGl2ZSBhIGdsb2JhbAoKV2hp 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 CmluZGV4IGVhMWQ4OTYwZjQuLjdmYzVjMTllMzcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2Nv bW1hbmRzL3ZhY3V1bS5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCkBAIC03 Miw2ICs3MiwyMSBAQCBpbnQJCQl2YWN1dW1fbXVsdGl4YWN0X2ZyZWV6ZV90YWJsZV9hZ2U7CiBp bnQJCQl2YWN1dW1fZmFpbHNhZmVfYWdlOwogaW50CQkJdmFjdXVtX211bHRpeGFjdF9mYWlsc2Fm ZV9hZ2U7CiAKKy8qCisgKiBWYWN1dW1GYWlsc2FmZUFjdGl2ZSBpcyBhIGRlZmluZWQgYXMgYSBn bG9iYWwgc28gdGhhdCB3ZSBjYW4gZGV0ZXJtaW5lCisgKiB3aGV0aGVyIG9yIG5vdCB0byByZS1l bmFibGUgY29zdC1iYXNlZCB2YWN1dW0gZGVsYXkgd2hlbiB2YWN1dW1pbmcgYSB0YWJsZS4KKyAq IElmIGZhaWxzYWZlIG1vZGUgaGFzIGJlZW4gZW5nYWdlZCwgd2Ugd2lsbCBub3QgcmUtZW5hYmxl IGNvc3QtYmFzZWQgZGVsYXkKKyAqIGZvciB0aGUgdGFibGUgdW50aWwgYWZ0ZXIgdmFjdXVtaW5n IGhhcyBjb21wbGV0ZWQsIHJlZ2FyZGxlc3Mgb2Ygb3RoZXIKKyAqIHNldHRpbmdzLgorICoKKyAq IE9ubHkgVkFDVVVNIGNvZGUgc2hvdWxkIGluc3BlY3QgdGhpcyB2YXJpYWJsZSBhbmQgb25seSB0 YWJsZSBhY2Nlc3MgbWV0aG9kcworICogc2hvdWxkIHNldCBpdCB0byB0cnVlLiBJbiBUYWJsZSBB TS1hZ25vc3RpYyBWQUNVVU0gY29kZSwgdGhpcyB2YXJpYWJsZSBpcworICogaW5zcGVjdGVkIHRv IGRldGVybWluZSB3aGV0aGVyIG9yIG5vdCB0byBhbGxvdyBjb3N0LWJhc2VkIGRlbGF5cy4gVGFi bGUgQU1zCisgKiBhcmUgZnJlZSB0byBzZXQgaXQgaWYgdGhleSBkZXNpcmUgdGhpcyBiZWhhdmlv ciwgYnV0IGl0IGlzIGZhbHNlIGJ5IGRlZmF1bHQKKyAqIGFuZCByZXNldCB0byBmYWxzZSBpbiBi ZXR3ZWVuIHZhY3V1bWluZyBlYWNoIHJlbGF0aW9uLgorICovCitib29sCQlWYWN1dW1GYWlsc2Fm ZUFjdGl2ZSA9IGZhbHNlOworCiAvKgogICogVmFyaWFibGVzIGZvciBjb3N0LWJhc2VkIHBhcmFs bGVsIHZhY3V1bS4gIFNlZSBjb21tZW50cyBhdG9wCiAgKiBjb21wdXRlX3BhcmFsbGVsX2RlbGF5 IHRvIHVuZGVyc3RhbmQgaG93IGl0IHdvcmtzLgpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvY29t bWFuZHMvdmFjdXVtLmggYi9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaAppbmRleCAxOWNh ODE4ZGMyLi4xMjIzZDE1ZTBkIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1 dW0uaAorKysgYi9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaApAQCAtMzA2LDYgKzMwNiw3 IEBAIGV4dGVybiBQR0RMTElNUE9SVCBwZ19hdG9taWNfdWludDMyICpWYWN1dW1TaGFyZWRDb3N0 QmFsYW5jZTsKIGV4dGVybiBQR0RMTElNUE9SVCBwZ19hdG9taWNfdWludDMyICpWYWN1dW1BY3Rp dmVOV29ya2VyczsKIGV4dGVybiBQR0RMTElNUE9SVCBpbnQgVmFjdXVtQ29zdEJhbGFuY2VMb2Nh bDsKIAorZXh0ZXJuIFBHRExMSU1QT1JUIGJvb2wgVmFjdXVtRmFpbHNhZmVBY3RpdmU7CiAKIC8q IGluIGNvbW1hbmRzL3ZhY3V1bS5jICovCiBleHRlcm4gdm9pZCBFeGVjVmFjdXVtKFBhcnNlU3Rh dGUgKnBzdGF0ZSwgVmFjdXVtU3RtdCAqdmFjc3RtdCwgYm9vbCBpc1RvcExldmVsKTsKLS0gCjIu MzcuMgoK --00000000000061568505f8afa5eb Content-Type: text/x-patch; charset="US-ASCII"; name="v17-0002-Separate-vacuum-cost-variables-from-gucs.patch" Content-Disposition: attachment; filename="v17-0002-Separate-vacuum-cost-variables-from-gucs.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg5hi1n91 RnJvbSBjNDU2ZTBkNjk0OWU3NDIyMTY4YTNlYjViMmRjMjY4YjdhMjQzODMzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBNb24sIDMgQXByIDIwMjMgMTE6MjI6MTggLTA0MDAKU3ViamVjdDogW1BB VENIIHYxNyAyLzNdIFNlcGFyYXRlIHZhY3V1bSBjb3N0IHZhcmlhYmxlcyBmcm9tIGd1Y3MKClZh 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 eCA3ZmM1YzE5ZTM3Li41YjZmOGY1MjQ0IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5k cy92YWN1dW0uYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYwpAQCAtNzEsNiAr NzEsMTcgQEAgaW50CQkJdmFjdXVtX211bHRpeGFjdF9mcmVlemVfbWluX2FnZTsKIGludAkJCXZh Y3V1bV9tdWx0aXhhY3RfZnJlZXplX3RhYmxlX2FnZTsKIGludAkJCXZhY3V1bV9mYWlsc2FmZV9h Z2U7CiBpbnQJCQl2YWN1dW1fbXVsdGl4YWN0X2ZhaWxzYWZlX2FnZTsKK2RvdWJsZQkJdmFjdXVt X2Nvc3RfZGVsYXk7CitpbnQJCQl2YWN1dW1fY29zdF9saW1pdDsKKworLyoKKyAqIFZhcmlhYmxl cyBmb3IgY29zdC1iYXNlZCB2YWN1dW0gZGVsYXkuIFRoZSBkZWZhdWx0cyBkaWZmZXIgYmV0d2Vl bgorICogYXV0b3ZhY3V1bSBhbmQgdmFjdXVtLiBUaGVzZSBzaG91bGQgYmUgb3ZlcnJpZGRlbiB3 aXRoIHRoZSBhcHByb3ByaWF0ZSBHVUMKKyAqIHZhbHVlIGluIHZhY3V1bSBjb2RlLiBUaGVzZSBh cmUgaW5pdGlhbGl6ZWQgaGVyZSB0byB0aGUgZGVmYXVsdHMgZm9yIGNsaWVudAorICogYmFja2Vu ZHMgZXhlY3V0aW5nIFZBQ1VVTSBvciBBTkFMWVpFLgorICovCitpbnQJCQlWYWN1dW1Db3N0TGlt aXQgPSAyMDA7Citkb3VibGUJCVZhY3V1bUNvc3REZWxheSA9IDA7CiAKIC8qCiAgKiBWYWN1dW1G YWlsc2FmZUFjdGl2ZSBpcyBhIGRlZmluZWQgYXMgYSBnbG9iYWwgc28gdGhhdCB3ZSBjYW4gZGV0 ZXJtaW5lCkBAIC01MTQsNiArNTI1LDcgQEAgdmFjdXVtKExpc3QgKnJlbGF0aW9ucywgVmFjdXVt UGFyYW1zICpwYXJhbXMsIEJ1ZmZlckFjY2Vzc1N0cmF0ZWd5IGJzdHJhdGVneSwKIAl7CiAJCUxp c3RDZWxsICAgKmN1cjsKIAorCQlWYWN1dW1VcGRhdGVDb3N0cygpOwogCQlpbl92YWN1dW0gPSB0 cnVlOwogCQlWYWN1dW1Db3N0QWN0aXZlID0gKFZhY3V1bUNvc3REZWxheSA+IDApOwogCQlWYWN1 dW1Db3N0QmFsYW5jZSA9IDA7CkBAIC0yMjY4LDggKzIyODAsNyBAQCB2YWN1dW1fZGVsYXlfcG9p bnQodm9pZCkKIAogCQlWYWN1dW1Db3N0QmFsYW5jZSA9IDA7CiAKLQkJLyogdXBkYXRlIGJhbGFu Y2UgdmFsdWVzIGZvciB3b3JrZXJzICovCi0JCUF1dG9WYWN1dW1VcGRhdGVEZWxheSgpOworCQlW YWN1dW1VcGRhdGVDb3N0cygpOwogCiAJCS8qIE1pZ2h0IGhhdmUgZ290dGVuIGFuIGludGVycnVw dCB3aGlsZSBzbGVlcGluZyAqLwogCQlDSEVDS19GT1JfSU5URVJSVVBUUygpOwpkaWZmIC0tZ2l0 IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyBiL3NyYy9iYWNrZW5kL2Nv bW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKaW5kZXggNTYzMTE3YThmNi4uMGI1OWM5MjJlNCAxMDA2 NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYworKysgYi9zcmMv YmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC05OTYsNiArOTk2LDcgQEAgcGFy YWxsZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQogCiAJLyog U2V0IGNvc3QtYmFzZWQgdmFjdXVtIGRlbGF5ICovCiAJVmFjdXVtQ29zdEFjdGl2ZSA9IChWYWN1 dW1Db3N0RGVsYXkgPiAwKTsKKwlWYWN1dW1VcGRhdGVDb3N0cygpOwogCVZhY3V1bUNvc3RCYWxh bmNlID0gMDsKIAlWYWN1dW1QYWdlSGl0ID0gMDsKIAlWYWN1dW1QYWdlTWlzcyA9IDA7CmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYyBiL3NyYy9iYWNrZW5k L3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCmluZGV4IGMxZTkxMWIxYjMuLjI5NmIxODUxZTMgMTAw NjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCisrKyBiL3NyYy9i YWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCkBAIC0xNzczLDE3ICsxNzczLDI1IEBAIEZy ZWVXb3JrZXJJbmZvKGludCBjb2RlLCBEYXR1bSBhcmcpCiB9CiAKIC8qCi0gKiBVcGRhdGUgdGhl IGNvc3QtYmFzZWQgZGVsYXkgcGFyYW1ldGVycywgc28gdGhhdCBtdWx0aXBsZSB3b3JrZXJzIGNv bnN1bWUKLSAqIGVhY2ggYSBmcmFjdGlvbiBvZiB0aGUgdG90YWwgYXZhaWxhYmxlIEkvTy4KKyAq IFVwZGF0ZSB2YWN1dW0gY29zdC1iYXNlZCBkZWxheS1yZWxhdGVkIHBhcmFtZXRlcnMgZm9yIGF1 dG92YWN1dW0gd29ya2VycyBhbmQKKyAqIGJhY2tlbmRzIGV4ZWN1dGluZyBWQUNVVU0gb3IgQU5B TFlaRSB1c2luZyB0aGUgdmFsdWUgb2YgcmVsZXZhbnQgZ3VjcyBhbmQKKyAqIGdsb2JhbCBzdGF0 ZS4gVGhpcyBtdXN0IGJlIGNhbGxlZCBkdXJpbmcgc2V0dXAgZm9yIHZhY3V1bSBhbmQgYWZ0ZXIg ZXZlcnkKKyAqIGNvbmZpZyByZWxvYWQgdG8gZW5zdXJlIHVwLXRvLWRhdGUgdmFsdWVzLgogICov CiB2b2lkCi1BdXRvVmFjdXVtVXBkYXRlRGVsYXkodm9pZCkKK1ZhY3V1bVVwZGF0ZUNvc3RzKHZv aWQpCiB7CiAJaWYgKE15V29ya2VySW5mbykKIAl7CiAJCVZhY3V1bUNvc3REZWxheSA9IE15V29y a2VySW5mby0+d2lfY29zdF9kZWxheTsKIAkJVmFjdXVtQ29zdExpbWl0ID0gTXlXb3JrZXJJbmZv LT53aV9jb3N0X2xpbWl0OwogCX0KKwllbHNlCisJeworCQkvKiBNdXN0IGJlIGV4cGxpY2l0IFZB Q1VVTSBvciBBTkFMWVpFICovCisJCVZhY3V1bUNvc3RMaW1pdCA9IHZhY3V1bV9jb3N0X2xpbWl0 OworCQlWYWN1dW1Db3N0RGVsYXkgPSB2YWN1dW1fY29zdF9kZWxheTsKKwl9CiB9CiAKIC8qCkBA IC0xODA0LDkgKzE4MTIsOSBAQCBhdXRvdmFjX2JhbGFuY2VfY29zdCh2b2lkKQogCSAqIHplcm8g aXMgbm90IGEgdmFsaWQgdmFsdWUuCiAJICovCiAJaW50CQkJdmFjX2Nvc3RfbGltaXQgPSAoYXV0 b3ZhY3V1bV92YWNfY29zdF9saW1pdCA+IDAgPwotCQkJCQkJCQkgIGF1dG92YWN1dW1fdmFjX2Nv c3RfbGltaXQgOiBWYWN1dW1Db3N0TGltaXQpOworCQkJCQkJCQkgIGF1dG92YWN1dW1fdmFjX2Nv c3RfbGltaXQgOiB2YWN1dW1fY29zdF9saW1pdCk7CiAJZG91YmxlCQl2YWNfY29zdF9kZWxheSA9 IChhdXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5ID49IDAgPwotCQkJCQkJCQkgIGF1dG92YWN1dW1f dmFjX2Nvc3RfZGVsYXkgOiBWYWN1dW1Db3N0RGVsYXkpOworCQkJCQkJCQkgIGF1dG92YWN1dW1f dmFjX2Nvc3RfZGVsYXkgOiB2YWN1dW1fY29zdF9kZWxheSk7CiAJZG91YmxlCQljb3N0X3RvdGFs OwogCWRvdWJsZQkJY29zdF9hdmFpbDsKIAlkbGlzdF9pdGVyCWl0ZXI7CkBAIC0yMzExLDggKzIz MTksNiBAQCBkb19hdXRvdmFjdXVtKHZvaWQpCiAJCWF1dG92YWNfdGFibGUgKnRhYjsKIAkJYm9v bAkJaXNzaGFyZWQ7CiAJCWJvb2wJCXNraXBpdDsKLQkJZG91YmxlCQlzdGRWYWN1dW1Db3N0RGVs YXk7Ci0JCWludAkJCXN0ZFZhY3V1bUNvc3RMaW1pdDsKIAkJZGxpc3RfaXRlcglpdGVyOwogCiAJ CUNIRUNLX0ZPUl9JTlRFUlJVUFRTKCk7CkBAIC0yNDE1LDE0ICsyNDIxLDYgQEAgZG9fYXV0b3Zh Y3V1bSh2b2lkKQogCQkJY29udGludWU7CiAJCX0KIAotCQkvKgotCQkgKiBSZW1lbWJlciB0aGUg cHJldmFpbGluZyB2YWx1ZXMgb2YgdGhlIHZhY3V1bSBjb3N0IEdVQ3MuICBXZSBoYXZlIHRvCi0J CSAqIHJlc3RvcmUgdGhlc2UgYXQgdGhlIGJvdHRvbSBvZiB0aGUgbG9vcCwgZWxzZSB3ZSdsbCBj b21wdXRlIHdyb25nCi0JCSAqIHZhbHVlcyBpbiB0aGUgbmV4dCBpdGVyYXRpb24gb2YgYXV0b3Zh Y19iYWxhbmNlX2Nvc3QoKS4KLQkJICovCi0JCXN0ZFZhY3V1bUNvc3REZWxheSA9IFZhY3V1bUNv c3REZWxheTsKLQkJc3RkVmFjdXVtQ29zdExpbWl0ID0gVmFjdXVtQ29zdExpbWl0OwotCiAJCS8q IE11c3QgaG9sZCBBdXRvdmFjdXVtTG9jayB3aGlsZSBtdWNraW5nIHdpdGggY29zdCBiYWxhbmNl IGluZm8gKi8KIAkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZFKTsK IApAQCAtMjQzNiw3ICsyNDM0LDcgQEAgZG9fYXV0b3ZhY3V1bSh2b2lkKQogCQlhdXRvdmFjX2Jh bGFuY2VfY29zdCgpOwogCiAJCS8qIHNldCB0aGUgYWN0aXZlIGNvc3QgcGFyYW1ldGVycyBmcm9t IHRoZSByZXN1bHQgb2YgdGhhdCAqLwotCQlBdXRvVmFjdXVtVXBkYXRlRGVsYXkoKTsKKwkJVmFj dXVtVXBkYXRlQ29zdHMoKTsKIAogCQkvKiBkb25lICovCiAJCUxXTG9ja1JlbGVhc2UoQXV0b3Zh Y3V1bUxvY2spOwpAQCAtMjUzMywxMCArMjUzMSw2IEBAIGRlbGV0ZWQ6CiAJCU15V29ya2VySW5m by0+d2lfdGFibGVvaWQgPSBJbnZhbGlkT2lkOwogCQlNeVdvcmtlckluZm8tPndpX3NoYXJlZHJl bCA9IGZhbHNlOwogCQlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1TY2hlZHVsZUxvY2spOwotCi0J CS8qIHJlc3RvcmUgdmFjdXVtIGNvc3QgR1VDcyBmb3IgdGhlIG5leHQgaXRlcmF0aW9uICovCi0J CVZhY3V1bUNvc3REZWxheSA9IHN0ZFZhY3V1bUNvc3REZWxheTsKLQkJVmFjdXVtQ29zdExpbWl0 ID0gc3RkVmFjdXVtQ29zdExpbWl0OwogCX0KIAogCS8qCkBAIC0yODE5LDE0ICsyODEzLDE0IEBA IHRhYmxlX3JlY2hlY2tfYXV0b3ZhYyhPaWQgcmVsaWQsIEhUQUIgKnRhYmxlX3RvYXN0X21hcCwK IAkJCT8gYXZvcHRzLT52YWN1dW1fY29zdF9kZWxheQogCQkJOiAoYXV0b3ZhY3V1bV92YWNfY29z dF9kZWxheSA+PSAwKQogCQkJPyBhdXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5Ci0JCQk6IFZhY3V1 bUNvc3REZWxheTsKKwkJCTogdmFjdXVtX2Nvc3RfZGVsYXk7CiAKIAkJLyogMCBvciAtMSBpbiBh dXRvdmFjIHNldHRpbmcgbWVhbnMgdXNlIHBsYWluIHZhY3V1bV9jb3N0X2xpbWl0ICovCiAJCXZh Y19jb3N0X2xpbWl0ID0gKGF2b3B0cyAmJiBhdm9wdHMtPnZhY3V1bV9jb3N0X2xpbWl0ID4gMCkK IAkJCT8gYXZvcHRzLT52YWN1dW1fY29zdF9saW1pdAogCQkJOiAoYXV0b3ZhY3V1bV92YWNfY29z dF9saW1pdCA+IDApCiAJCQk/IGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQKLQkJCTogVmFjdXVt Q29zdExpbWl0OworCQkJOiB2YWN1dW1fY29zdF9saW1pdDsKIAogCQkvKiAtMSBpbiBhdXRvdmFj IHNldHRpbmcgbWVhbnMgdXNlIGxvZ19hdXRvdmFjdXVtX21pbl9kdXJhdGlvbiAqLwogCQlsb2df bWluX2R1cmF0aW9uID0gKGF2b3B0cyAmJiBhdm9wdHMtPmxvZ19taW5fZHVyYXRpb24gPj0gMCkK ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jIGIvc3JjL2JhY2tl bmQvdXRpbHMvaW5pdC9nbG9iYWxzLmMKaW5kZXggMWIxZDgxNDI1NC4uOGU1YjA2NWU4ZiAxMDA2 NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvaW5pdC9nbG9iYWxzLmMKKysrIGIvc3JjL2JhY2tl bmQvdXRpbHMvaW5pdC9nbG9iYWxzLmMKQEAgLTE0Miw4ICsxNDIsNiBAQCBpbnQJCQlNYXhCYWNr ZW5kcyA9IDA7CiBpbnQJCQlWYWN1dW1Db3N0UGFnZUhpdCA9IDE7CS8qIEdVQyBwYXJhbWV0ZXJz IGZvciB2YWN1dW0gKi8KIGludAkJCVZhY3V1bUNvc3RQYWdlTWlzcyA9IDI7CiBpbnQJCQlWYWN1 dW1Db3N0UGFnZURpcnR5ID0gMjA7Ci1pbnQJCQlWYWN1dW1Db3N0TGltaXQgPSAyMDA7Ci1kb3Vi bGUJCVZhY3V1bUNvc3REZWxheSA9IDA7CiAKIGludDY0CQlWYWN1dW1QYWdlSGl0ID0gMDsKIGlu dDY0CQlWYWN1dW1QYWdlTWlzcyA9IDA7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9t aXNjL2d1Y190YWJsZXMuYyBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjX3RhYmxlcy5jCmlu ZGV4IDgwNjI1ODllZmQuLjc3ZGIxYTE0NmMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxz L21pc2MvZ3VjX3RhYmxlcy5jCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjX3RhYmxl cy5jCkBAIC0yNDA5LDcgKzI0MDksNyBAQCBzdHJ1Y3QgY29uZmlnX2ludCBDb25maWd1cmVOYW1l c0ludFtdID0KIAkJCWdldHRleHRfbm9vcCgiVmFjdXVtIGNvc3QgYW1vdW50IGF2YWlsYWJsZSBi ZWZvcmUgbmFwcGluZy4iKSwKIAkJCU5VTEwKIAkJfSwKLQkJJlZhY3V1bUNvc3RMaW1pdCwKKwkJ JnZhY3V1bV9jb3N0X2xpbWl0LAogCQkyMDAsIDEsIDEwMDAwLAogCQlOVUxMLCBOVUxMLCBOVUxM CiAJfSwKQEAgLTM3MDEsNyArMzcwMSw3IEBAIHN0cnVjdCBjb25maWdfcmVhbCBDb25maWd1cmVO YW1lc1JlYWxbXSA9CiAJCQlOVUxMLAogCQkJR1VDX1VOSVRfTVMKIAkJfSwKLQkJJlZhY3V1bUNv c3REZWxheSwKKwkJJnZhY3V1bV9jb3N0X2RlbGF5LAogCQkwLCAwLCAxMDAsCiAJCU5VTEwsIE5V TEwsIE5VTEwKIAl9LApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgg Yi9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaAppbmRleCAxMjIzZDE1ZTBkLi40NDBkZGQy MTU0IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaAorKysgYi9zcmMv aW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaApAQCAtMzAwLDYgKzMwMCw4IEBAIGV4dGVybiBQR0RM TElNUE9SVCBpbnQgdmFjdXVtX211bHRpeGFjdF9mcmVlemVfbWluX2FnZTsKIGV4dGVybiBQR0RM TElNUE9SVCBpbnQgdmFjdXVtX211bHRpeGFjdF9mcmVlemVfdGFibGVfYWdlOwogZXh0ZXJuIFBH RExMSU1QT1JUIGludCB2YWN1dW1fZmFpbHNhZmVfYWdlOwogZXh0ZXJuIFBHRExMSU1QT1JUIGlu dCB2YWN1dW1fbXVsdGl4YWN0X2ZhaWxzYWZlX2FnZTsKK2V4dGVybiBQR0RMTElNUE9SVCBkb3Vi bGUgdmFjdXVtX2Nvc3RfZGVsYXk7CitleHRlcm4gUEdETExJTVBPUlQgaW50IHZhY3V1bV9jb3N0 X2xpbWl0OwogCiAvKiBWYXJpYWJsZXMgZm9yIGNvc3QtYmFzZWQgcGFyYWxsZWwgdmFjdXVtICov CiBleHRlcm4gUEdETExJTVBPUlQgcGdfYXRvbWljX3VpbnQzMiAqVmFjdXVtU2hhcmVkQ29zdEJh bGFuY2U7CkBAIC0zMDcsNiArMzA5LDggQEAgZXh0ZXJuIFBHRExMSU1QT1JUIHBnX2F0b21pY191 aW50MzIgKlZhY3V1bUFjdGl2ZU5Xb3JrZXJzOwogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBWYWN1 dW1Db3N0QmFsYW5jZUxvY2FsOwogCiBleHRlcm4gUEdETExJTVBPUlQgYm9vbCBWYWN1dW1GYWls c2FmZUFjdGl2ZTsKK2V4dGVybiBQR0RMTElNUE9SVCBpbnQgVmFjdXVtQ29zdExpbWl0OworZXh0 ZXJuIFBHRExMSU1QT1JUIGRvdWJsZSBWYWN1dW1Db3N0RGVsYXk7CiAKIC8qIGluIGNvbW1hbmRz L3ZhY3V1bS5jICovCiBleHRlcm4gdm9pZCBFeGVjVmFjdXVtKFBhcnNlU3RhdGUgKnBzdGF0ZSwg VmFjdXVtU3RtdCAqdmFjc3RtdCwgYm9vbCBpc1RvcExldmVsKTsKQEAgLTM0Nyw2ICszNTEsOSBA QCBleHRlcm4gSW5kZXhCdWxrRGVsZXRlUmVzdWx0ICp2YWNfY2xlYW51cF9vbmVfaW5kZXgoSW5k ZXhWYWN1dW1JbmZvICppdmluZm8sCiAJCQkJCQkJCQkJCQkJSW5kZXhCdWxrRGVsZXRlUmVzdWx0 ICppc3RhdCk7CiBleHRlcm4gU2l6ZSB2YWNfbWF4X2l0ZW1zX3RvX2FsbG9jX3NpemUoaW50IG1h eF9pdGVtcyk7CiAKKy8qIEluIHBvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jICovCitleHRlcm4gdm9p ZCBWYWN1dW1VcGRhdGVDb3N0cyh2b2lkKTsKKwogLyogaW4gY29tbWFuZHMvdmFjdXVtcGFyYWxs ZWwuYyAqLwogZXh0ZXJuIFBhcmFsbGVsVmFjdXVtU3RhdGUgKnBhcmFsbGVsX3ZhY3V1bV9pbml0 KFJlbGF0aW9uIHJlbCwgUmVsYXRpb24gKmluZHJlbHMsCiAJCQkJCQkJCQkJCQkgaW50IG5pbmRl eGVzLCBpbnQgbnJlcXVlc3RlZF93b3JrZXJzLApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvbWlz Y2FkbWluLmggYi9zcmMvaW5jbHVkZS9taXNjYWRtaW4uaAppbmRleCAwNmE4NmY5YWMxLi42NmRi MWIyYzY5IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9taXNjYWRtaW4uaAorKysgYi9zcmMvaW5j bHVkZS9taXNjYWRtaW4uaApAQCAtMjY2LDggKzI2Niw2IEBAIGV4dGVybiBQR0RMTElNUE9SVCBp bnQgbWF4X3BhcmFsbGVsX21haW50ZW5hbmNlX3dvcmtlcnM7CiBleHRlcm4gUEdETExJTVBPUlQg aW50IFZhY3V1bUNvc3RQYWdlSGl0OwogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBWYWN1dW1Db3N0 UGFnZU1pc3M7CiBleHRlcm4gUEdETExJTVBPUlQgaW50IFZhY3V1bUNvc3RQYWdlRGlydHk7Ci1l eHRlcm4gUEdETExJTVBPUlQgaW50IFZhY3V1bUNvc3RMaW1pdDsKLWV4dGVybiBQR0RMTElNUE9S VCBkb3VibGUgVmFjdXVtQ29zdERlbGF5OwogCiBleHRlcm4gUEdETExJTVBPUlQgaW50NjQgVmFj dXVtUGFnZUhpdDsKIGV4dGVybiBQR0RMTElNUE9SVCBpbnQ2NCBWYWN1dW1QYWdlTWlzczsKZGlm ZiAtLWdpdCBhL3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oIGIvc3JjL2luY2x1 ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgKaW5kZXggYzE0MDM3MWI1MS4uNjVhZmQxZWExZSAx MDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgKKysrIGIvc3Jj L2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgKQEAgLTYzLDkgKzYzLDYgQEAgZXh0ZXJu IGludAlTdGFydEF1dG9WYWNXb3JrZXIodm9pZCk7CiAvKiBjYWxsZWQgZnJvbSBwb3N0bWFzdGVy IHdoZW4gYSB3b3JrZXIgY291bGQgbm90IGJlIGZvcmtlZCAqLwogZXh0ZXJuIHZvaWQgQXV0b1Zh Y1dvcmtlckZhaWxlZCh2b2lkKTsKIAotLyogYXV0b3ZhY3V1bSBjb3N0LWRlbGF5IGJhbGFuY2Vy ICovCi1leHRlcm4gdm9pZCBBdXRvVmFjdXVtVXBkYXRlRGVsYXkodm9pZCk7Ci0KICNpZmRlZiBF WEVDX0JBQ0tFTkQKIGV4dGVybiB2b2lkIEF1dG9WYWNMYXVuY2hlck1haW4oaW50IGFyZ2MsIGNo YXIgKmFyZ3ZbXSkgcGdfYXR0cmlidXRlX25vcmV0dXJuKCk7CiBleHRlcm4gdm9pZCBBdXRvVmFj V29ya2VyTWFpbihpbnQgYXJnYywgY2hhciAqYXJndltdKSBwZ19hdHRyaWJ1dGVfbm9yZXR1cm4o KTsKLS0gCjIuMzcuMgoK --00000000000061568505f8afa5eb--