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 1pkWox-0008Cq-SB for pgsql-hackers@arkaria.postgresql.org; Thu, 06 Apr 2023 21:07:04 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1pkWow-0007RC-Dl for pgsql-hackers@arkaria.postgresql.org; Thu, 06 Apr 2023 21:07:02 +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 1pkWov-0007R3-Um for pgsql-hackers@lists.postgresql.org; Thu, 06 Apr 2023 21:07:02 +0000 Received: from mail-pj1-x1029.google.com ([2607:f8b0:4864:20::1029]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.94.2) (envelope-from ) id 1pkWor-001Jbz-3z for pgsql-hackers@postgresql.org; Thu, 06 Apr 2023 21:07:01 +0000 Received: by mail-pj1-x1029.google.com with SMTP id lr16-20020a17090b4b9000b0023f187954acso41870554pjb.2 for ; Thu, 06 Apr 2023 14:06:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1680815214; x=1683407214; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=YIZ+G63KDHknxq/MpMiQ1BbIpBnm9UZSvL9zJ4X9+5U=; b=g8HG2GXqKVOX/NBpWpc+SqD17CijHCoD6RAqqcwcU8abJJDCVUYBpDltQ2GXV7pc/C qPSwpNcVkop6s1N54T8tgqfWMjGDXoCcx2vqt+rc9uPvUoOLiY/zh7EFPSo/I6I/PbVH JE7bIOHcN8d7TTeEeGsazr1BYtO2nG6BkdcllpdPP+42M0RVNMVsp5qs6yXeGTTuRoNP ZezJJ6cl2jTRds1qb7TRzbbzqRR/RRBrO64XqibyPxeDdd8j4edKmQFxIBdX0udZuuEX xVoa++EjBiWhoU566jlghnEcvPOjHQ01E3oZol7TICUO/SnuZjAaabeBNjSeDjyHhmza zKOQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1680815214; x=1683407214; 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=YIZ+G63KDHknxq/MpMiQ1BbIpBnm9UZSvL9zJ4X9+5U=; b=fsuJzJyLQqSRB548pA4vfayD4zN39yzYNEyvI2JV+Yieb5IamBZ+rZW9gJd4io9i9V bcDVizr6hpjYr+3f2OGmktVXXoCQ76b+v2zUhLzHxKgMH7Ybp0uuGAeuYFQ0Cji8wIzP 2kUBUrC374co6Hy0qbipDYrKPvvZ21jOOC9Mq05dpBXj4UfVVZcTdOfdKr6oYxsi153Z QiW1rEVGsQP6qehzZ4DNIZr0/akBVpdD/qsl9T10+aRldpHrNDmivP19qp9okYsmqvr1 YOrG7PwYmepSTRI5bZNKVIv3y0wOJ6Egs+a5IlAjJp+yX+D9dTzZ4imePKc9j3DoNhUe y3tA== X-Gm-Message-State: AAQBX9dxHvotID9C36SjmGM3812qaVu5BLr3WybqakSXdJAv/6X6ihaA eSq/eUNdWcgwFhrJahiljRRWTE0/rskcS2Bckk8= X-Google-Smtp-Source: AKy350Z+6QS0QjAyuEo7I/0Dyddhe1a3DbEylbiM4dAgNQsb4hrUp5WnK0QOsNN9d4N1V97Ta2GxoG8BK2wJ2UTw/70= X-Received: by 2002:a17:903:441:b0:1a2:8c7e:f325 with SMTP id iw1-20020a170903044100b001a28c7ef325mr187546plb.11.1680815214184; Thu, 06 Apr 2023 14:06:54 -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 17:06:41 -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="000000000000c6e76205f8b14956" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --000000000000c6e76205f8b14956 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable I think attached v18 addresses all outstanding issues except a run through the docs making sure all mentions of the balancing algorithm are still correct. 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. In attached v18, I have flipped them. Existing (in master) GUCs which were exported for VacuumCostLimit and VacuumCostDelay retain their names and new globals vacuum_cost_limit and vacuum_cost_delay have been introduced for use in the code. Flipping these kind of melted my mind, so I could definitely use another set of eyes double checking that the correct ones are being used in the correct places throughout 0002 and 0003. On Thu, Apr 6, 2023 at 3:09=E2=80=AFPM Melanie Plageman wrote: > > 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_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 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 no= t 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_do= balance)) > > > + 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 no= t 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 f= ew > > > spurious whitespaces or similar. There is one rather annoying pginden= t > > > 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 dboi= d > > > and tableoid (lock/no lock, where to put it, etc) > > > > > > - I see several places in docs which reference the balancing algorith= m > > > for autovac workers. I did not read them in great detail, but we ma= y > > > 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_b= ase=3D%d, > > > > > > cost_delay=3D%g)", > > > > > > - worker->wi_proc->pid, > > > > > > worker->wi_dboid, worker->wi_tableoid, > > > > > > - worker->wi_dobalance ? "yes" = : "no", > > > > > > - worker->wi_cost_limit, > > > > > > worker->wi_cost_limit_base, > > > > > > - worker->wi_cost_delay); > > > > > > > > > > > > I think it's better to keep this kind of log in some form for > > > > > > debugging. For example, we can show these values of autovacuum = workers > > > > > > in VacuumUpdateCosts(). > > > > > > > > > > I added a message to do_autovacuum() after calling VacuumUpdateCo= sts() > > > > > 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 VacuumUpdate= Costs() > > > > > behind the shared lock in that loop so that we could access the p= id and > > > > > such in the logging message after updating the cost and delay, bu= t it is > > > > > probably okay. Though noone is going to be changing those at this > > > > > point, it still seemed better to access them under the lock. > > > > > > > > > > This does mean we won't log anything when we do change the values= of > > > > > VacuumCostDelay and VacuumCostLimit while vacuuming a table. Is i= t worth > > > > > adding some code to do that in VacuumUpdateCosts() (only when the= value > > > > > has changed not on every call to VacuumUpdateCosts())? Or perhaps= we > > > > > could add it in the config reload branch that is already in > > > > > vacuum_delay_point()? > > > > > > > > Previously, we used to show the pid in the log since a worker/launc= her > > > > set other workers' delay costs. But now that the worker sets its de= lay > > > > 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 failsa= fe=3D%s)", > > > > + MyWorkerInfo->wi_dboid, MyWorkerInfo->wi_tableoid, > > > > + pg_atomic_unlocked_test_flag(&MyWorkerInfo->wi_dobalan= ce) > > > > ? "no" : "yes", > > > > + VacuumCostLimit, VacuumCostDelay, > > > > + VacuumCostDelay > 0 ? "yes" : "no", > > > > + VacuumFailsafeActive ? "yes" : "no"); > > > > } > > > > else > > > > { > > > > > > Makes sense. I've updated the log message to roughly what you suggest= ed. > > > I also realized I think it does make sense to call it in > > > VacuumUpdateCosts() -- only for autovacuum workers of course. I've do= ne > > > this. I haven't taken the lock though and can't decide if I must sinc= e > > > they access dboid and tableoid -- those are not going to change at th= is > > > 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 ever= y > 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 < DEBUG= 2. > 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 th= e > function). But, we could assert that the lock is not already = held. > - If we later decide we don't like this choice and want to move t= he > logging elsewhere, it will necessarily log less frequently wh= ich > seems like a harder change to make than logging more frequent= ly. > > - 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 Okay, in an attempt to wrap up this saga, I have made the following change: Autovacuum workers, at the end of VacuumUpdateCosts(), check if cost limit or cost delay have been changed. If they have, they assert that they don't already hold the AutovacuumLock, take it in shared mode, and do the logging. - Melanie --000000000000c6e76205f8b14956 Content-Type: text/x-patch; charset="US-ASCII"; name="v18-0003-Autovacuum-refreshes-cost-based-delay-params-mor.patch" Content-Disposition: attachment; filename="v18-0003-Autovacuum-refreshes-cost-based-delay-params-mor.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg5lx3f22 RnJvbSA5MDJlZjkyMDg5ZDhiMDczYmUwZDY2NGZhNWQ1Y2MyMzYyNGFhMzEzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBTYXQsIDI1IE1hciAyMDIzIDE0OjE0OjU1IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTggMy8zXSBBdXRvdmFjdXVtIHJlZnJlc2hlcyBjb3N0LWJhc2VkIGRlbGF5IHBhcmFt cyBtb3JlCiBvZnRlbgoKQWxsb3cgYXV0b3ZhY3V1bSB0byByZWxvYWQgdGhlIGNvbmZpZyBmaWxl IG1vcmUgb2Z0ZW4gc28gdGhhdCBjb3N0LWJhc2VkCmRlbGF5IHBhcmFtZXRlcnMgY2FuIHRha2Ug ZWZmZWN0IHdoaWxlIFZBQ1VVTWluZyBhIHJlbGF0aW9uLiBQcmV2aW91c2x5LAphdXRvdmFjdXVt IHdvcmtlcnMgb25seSByZWxvYWRlZCB0aGUgY29uZmlnIGZpbGUgb25jZSBwZXIgcmVsYXRpb24K dmFjdXVtZWQsIHNvIGNvbmZpZyBjaGFuZ2VzIGNvdWxkIG5vdCB0YWtlIGVmZmVjdCB1bnRpbCBi ZWdpbm5pbmcgdG8KdmFjdXVtIHRoZSBuZXh0IHRhYmxlLgoKTm93LCBjaGVjayBpZiBhIHJlbG9h ZCBpcyBwZW5kaW5nIHJvdWdobHkgb25jZSBwZXIgYmxvY2ssIHdoZW4gY2hlY2tpbmcKaWYgd2Ug bmVlZCB0byBkZWxheS4KCkluIG9yZGVyIGZvciBhdXRvdmFjdXVtIHdvcmtlcnMgdG8gc2FmZWx5 IHVwZGF0ZSB0aGVpciBvd24gY29zdCBkZWxheQphbmQgY29zdCBsaW1pdCBwYXJhbWV0ZXJzIHdp dGhvdXQgaW1wYWN0aW5nIHBlcmZvcm1hbmNlLCB3ZSBoYWQgdG8KcmV0aGluayB3aGVuIGFuZCBo b3cgdGhlc2UgdmFsdWVzIHdlcmUgYWNjZXNzZWQuCgpQcmV2aW91c2x5LCBhbiBhdXRvdmFjdXVt IHdvcmtlcidzIHdpX2Nvc3RfbGltaXQgd2FzIHNldCBvbmx5IGF0IHRoZQpiZWdpbm5pbmcgb2Yg dmFjdXVtaW5nIGEgdGFibGUsIGFmdGVyIHJlbG9hZGluZyB0aGUgY29uZmlnIGZpbGUuClRoZXJl Zm9yZSwgYXQgdGhlIHRpbWUgdGhhdCBhdXRvdmFjX2JhbGFuY2VfY29zdCgpIHdhcyBjYWxsZWQs IHdvcmtlcnMKdmFjdXVtaW5nIHRhYmxlcyB3aXRoIG5vIGNvc3QtcmVsYXRlZCBzdG9yYWdlIHBh cmFtZXRlcnMgY291bGQgc3RpbGwKaGF2ZSBkaWZmZXJlbnQgdmFsdWVzIGZvciB0aGVpciB3aV9j b3N0X2xpbWl0X2Jhc2UgYW5kIHdpX2Nvc3RfZGVsYXkuCgpOb3cgdGhhdCB0aGUgY29zdCBwYXJh bWV0ZXJzIGNhbiBiZSB1cGRhdGVkIHdoaWxlIHZhY3V1bWluZyBhIHRhYmxlLAp3b3JrZXJzIHdp bGwgKHdpdGhpbiBzb21lIG1hcmdpbiBvZiBlcnJvcikgaGF2ZSBubyByZWFzb24gdG8gaGF2ZQpk aWZmZXJlbnQgdmFsdWVzIGZvciBjb3N0IGxpbWl0IGFuZCBjb3N0IGRlbGF5IChpbiB0aGUgYWJz ZW5jZSBvZgpjb3N0LXJlbGF0ZWQgc3RvcmFnZSBwYXJhbWV0ZXJzKS4gVGhpcyByZW1vdmVzIHRo ZSByYXRpb25hbGUgZm9yIGtlZXBpbmcKY29zdCBsaW1pdCBhbmQgY29zdCBkZWxheSBpbiBzaGFy ZWQgbWVtb3J5LiBCYWxhbmNpbmcgdGhlIGNvc3QgbGltaXQKcmVxdWlyZXMgb25seSB0aGUgbnVt YmVyIG9mIGFjdGl2ZSBhdXRvdmFjdXVtIHdvcmtlcnMgdmFjdXVtaW5nIGEgdGFibGUKd2l0aCBu byBjb3N0LWJhc2VkIHN0b3JhZ2UgcGFyYW1ldGVycy4KClJldmlld2VkLWJ5OiBNYXNhaGlrbyBT YXdhZGEgPHNhd2FkYS5tc2hrQGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6IERhbmllbCBHdXN0YWZz c29uIDxkYW5pZWxAeWVzcWwuc2U+ClJldmlld2VkLWJ5OiBLeW90YXJvIEhvcmlndWNoaSA8aG9y aWt5b3RhLm50dEBnbWFpbC5jb20+CkRpc2N1c3Npb246IGh0dHBzOi8vd3d3LnBvc3RncmVzcWwu b3JnL21lc3NhZ2UtaWQvZmxhdC9DQUFLUnVfWm5nenFuRU9EYzdMbVMxTkgwNEt0Nlk5aHVTano1 cHA3JTJCRFhocmpEQTBndyU0MG1haWwuZ21haWwuY29tCi0tLQogc3JjL2JhY2tlbmQvYWNjZXNz L2hlYXAvdmFjdXVtbGF6eS5jICB8ICAgMiArLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVt LmMgICAgICAgICB8ICA0NiArKystCiBzcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxl bC5jIHwgICAxIC0KIHNyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jICAgfCAyODkg KysrKysrKysrKysrKysrLS0tLS0tLS0tLS0KIHNyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5o ICAgICAgICAgfCAgIDEgKwogNSBmaWxlcyBjaGFuZ2VkLCAyMTcgaW5zZXJ0aW9ucygrKSwgMTIy IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1 bWxhenkuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYwppbmRleCAyYmE4 NWJkM2Q2Li4wYTllYmQyMmJkIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92 YWN1dW1sYXp5LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jCkBA IC0zODksNyArMzg5LDcgQEAgaGVhcF92YWN1dW1fcmVsKFJlbGF0aW9uIHJlbCwgVmFjdXVtUGFy YW1zICpwYXJhbXMsCiAJQXNzZXJ0KHBhcmFtcy0+aW5kZXhfY2xlYW51cCAhPSBWQUNPUFRWQUxV RV9VTlNQRUNJRklFRCk7CiAJQXNzZXJ0KHBhcmFtcy0+dHJ1bmNhdGUgIT0gVkFDT1BUVkFMVUVf VU5TUEVDSUZJRUQgJiYKIAkJICAgcGFyYW1zLT50cnVuY2F0ZSAhPSBWQUNPUFRWQUxVRV9BVVRP KTsKLQlWYWN1dW1GYWlsc2FmZUFjdGl2ZSA9IGZhbHNlOworCUFzc2VydCghVmFjdXVtRmFpbHNh ZmVBY3RpdmUpOwogCXZhY3JlbC0+Y29uc2lkZXJfYnlwYXNzX29wdGltaXphdGlvbiA9IHRydWU7 CiAJdmFjcmVsLT5kb19pbmRleF92YWN1dW1pbmcgPSB0cnVlOwogCXZhY3JlbC0+ZG9faW5kZXhf Y2xlYW51cCA9IHRydWU7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0u YyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCmluZGV4IGYyYmU3NGNkYjUuLmNhMzQ3 ZTBhNmQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCisrKyBiL3Ny Yy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCkBAIC00OCw2ICs0OCw3IEBACiAjaW5jbHVkZSAi cGdzdGF0LmgiCiAjaW5jbHVkZSAicG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgiCiAjaW5jbHVkZSAi cG9zdG1hc3Rlci9iZ3dvcmtlcl9pbnRlcm5hbHMuaCIKKyNpbmNsdWRlICJwb3N0bWFzdGVyL2lu dGVycnVwdC5oIgogI2luY2x1ZGUgInN0b3JhZ2UvYnVmbWdyLmgiCiAjaW5jbHVkZSAic3RvcmFn ZS9sbWdyLmgiCiAjaW5jbHVkZSAic3RvcmFnZS9wbXNpZ25hbC5oIgpAQCAtNTIzLDkgKzUyNCw5 IEBAIHZhY3V1bShMaXN0ICpyZWxhdGlvbnMsIFZhY3V1bVBhcmFtcyAqcGFyYW1zLCBCdWZmZXJB Y2Nlc3NTdHJhdGVneSBic3RyYXRlZ3ksCiAJewogCQlMaXN0Q2VsbCAgICpjdXI7CiAKLQkJVmFj dXVtVXBkYXRlQ29zdHMoKTsKIAkJaW5fdmFjdXVtID0gdHJ1ZTsKLQkJVmFjdXVtQ29zdEFjdGl2 ZSA9ICh2YWN1dW1fY29zdF9kZWxheSA+IDApOworCQlWYWN1dW1GYWlsc2FmZUFjdGl2ZSA9IGZh bHNlOworCQlWYWN1dW1VcGRhdGVDb3N0cygpOwogCQlWYWN1dW1Db3N0QmFsYW5jZSA9IDA7CiAJ CVZhY3V1bVBhZ2VIaXQgPSAwOwogCQlWYWN1dW1QYWdlTWlzcyA9IDA7CkBAIC01NzksMTIgKzU4 MCwyMCBAQCB2YWN1dW0oTGlzdCAqcmVsYXRpb25zLCBWYWN1dW1QYXJhbXMgKnBhcmFtcywgQnVm ZmVyQWNjZXNzU3RyYXRlZ3kgYnN0cmF0ZWd5LAogCQkJCQlDb21tYW5kQ291bnRlckluY3JlbWVu dCgpOwogCQkJCX0KIAkJCX0KKworCQkJLyoKKwkJCSAqIEVuc3VyZSBWYWN1dW1GYWlsc2FmZUFj dGl2ZSBoYXMgYmVlbiByZXNldCBiZWZvcmUgdmFjdXVtaW5nIHRoZQorCQkJICogbmV4dCByZWxh dGlvbi4KKwkJCSAqLworCQkJVmFjdXVtRmFpbHNhZmVBY3RpdmUgPSBmYWxzZTsKIAkJfQogCX0K IAlQR19GSU5BTExZKCk7CiAJewogCQlpbl92YWN1dW0gPSBmYWxzZTsKIAkJVmFjdXVtQ29zdEFj dGl2ZSA9IGZhbHNlOworCQlWYWN1dW1GYWlsc2FmZUFjdGl2ZSA9IGZhbHNlOworCQlWYWN1dW1D b3N0QmFsYW5jZSA9IDA7CiAJfQogCVBHX0VORF9UUlkoKTsKIApAQCAtMjI0NSw3ICsyMjU0LDI4 IEBAIHZhY3V1bV9kZWxheV9wb2ludCh2b2lkKQogCS8qIEFsd2F5cyBjaGVjayBmb3IgaW50ZXJy dXB0cyAqLwogCUNIRUNLX0ZPUl9JTlRFUlJVUFRTKCk7CiAKLQlpZiAoIVZhY3V1bUNvc3RBY3Rp dmUgfHwgSW50ZXJydXB0UGVuZGluZykKKwlpZiAoSW50ZXJydXB0UGVuZGluZyB8fAorCQkoIVZh Y3V1bUNvc3RBY3RpdmUgJiYgIUNvbmZpZ1JlbG9hZFBlbmRpbmcpKQorCQlyZXR1cm47CisKKwkv KgorCSAqIEF1dG92YWN1dW0gd29ya2VycyBzaG91bGQgcmVsb2FkIHRoZSBjb25maWd1cmF0aW9u IGZpbGUgaWYgcmVxdWVzdGVkLgorCSAqIFRoaXMgYWxsb3dzIGNoYW5nZXMgdG8gW2F1dG92YWN1 dW1fXXZhY3V1bV9jb3N0X2xpbWl0IGFuZAorCSAqIFthdXRvdmFjdXVtX112YWN1dW1fY29zdF9k ZWxheSB0byB0YWtlIGVmZmVjdCB3aGlsZSBhIHRhYmxlIGlzIGJlaW5nCisJICogdmFjdXVtZWQg b3IgYW5hbHl6ZWQuCisJICovCisJaWYgKENvbmZpZ1JlbG9hZFBlbmRpbmcgJiYgSXNBdXRvVmFj dXVtV29ya2VyUHJvY2VzcygpKQorCXsKKwkJQ29uZmlnUmVsb2FkUGVuZGluZyA9IGZhbHNlOwor CQlQcm9jZXNzQ29uZmlnRmlsZShQR0NfU0lHSFVQKTsKKwkJVmFjdXVtVXBkYXRlQ29zdHMoKTsK Kwl9CisKKwkvKgorCSAqIElmIHdlIGRpc2FibGVkIGNvc3QtYmFzZWQgZGVsYXlzIGFmdGVyIHJl bG9hZGluZyB0aGUgY29uZmlnIGZpbGUsCisJICogcmV0dXJuLgorCSAqLworCWlmICghVmFjdXVt Q29zdEFjdGl2ZSkKIAkJcmV0dXJuOwogCiAJLyoKQEAgLTIyNzgsNyArMjMwOCwxNSBAQCB2YWN1 dW1fZGVsYXlfcG9pbnQodm9pZCkKIAogCQlWYWN1dW1Db3N0QmFsYW5jZSA9IDA7CiAKLQkJVmFj dXVtVXBkYXRlQ29zdHMoKTsKKwkJLyoKKwkJICogQmFsYW5jZSBhbmQgdXBkYXRlIGxpbWl0IHZh bHVlcyBmb3IgYXV0b3ZhY3V1bSB3b3JrZXJzLiBXZSBtdXN0IGRvCisJCSAqIHRoaXMgcGVyaW9k aWNhbGx5LCBhcyB0aGUgbnVtYmVyIG9mIHdvcmtlcnMgYWNyb3NzIHdoaWNoIHdlIGFyZQorCQkg KiBiYWxhbmNpbmcgdGhlIGxpbWl0IG1heSBoYXZlIGNoYW5nZWQuCisJCSAqCisJCSAqIFhYWDog VGhlcmUgbWF5IGJlIGJldHRlciBjcml0ZXJpYSBmb3IgZGV0ZXJtaW5pbmcgd2hlbiB0byBkbyB0 aGlzCisJCSAqIGJlc2lkZXMgImNoZWNrIGFmdGVyIG5hcHBpbmciLgorCQkgKi8KKwkJQXV0b1Zh Y3V1bVVwZGF0ZUNvc3RMaW1pdCgpOwogCiAJCS8qIE1pZ2h0IGhhdmUgZ290dGVuIGFuIGludGVy cnVwdCB3aGlsZSBzbGVlcGluZyAqLwogCQlDSEVDS19GT1JfSU5URVJSVVBUUygpOwpkaWZmIC0t Z2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyBiL3NyYy9iYWNrZW5k L2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKaW5kZXggY2MwYWZmNzkwNC4uZTIwMGQ1Y2FmOCAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYworKysgYi9z cmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC05OTUsNyArOTk1LDYgQEAg cGFyYWxsZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQogCQkJ CQkJCQkJCQkJIGZhbHNlKTsKIAogCS8qIFNldCBjb3N0LWJhc2VkIHZhY3V1bSBkZWxheSAqLwot CVZhY3V1bUNvc3RBY3RpdmUgPSAodmFjdXVtX2Nvc3RfZGVsYXkgPiAwKTsKIAlWYWN1dW1VcGRh dGVDb3N0cygpOwogCVZhY3V1bUNvc3RCYWxhbmNlID0gMDsKIAlWYWN1dW1QYWdlSGl0ID0gMDsK ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jIGIvc3JjL2Jh Y2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKaW5kZXggMzY0NGI4NjQ0My4uODUyOTMyNGVi ZCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKKysrIGIv c3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKQEAgLTEzOSw2ICsxMzksMTggQEAg aW50CQkJTG9nX2F1dG92YWN1dW1fbWluX2R1cmF0aW9uID0gNjAwMDAwOwogc3RhdGljIGJvb2wg YW1fYXV0b3ZhY3V1bV9sYXVuY2hlciA9IGZhbHNlOwogc3RhdGljIGJvb2wgYW1fYXV0b3ZhY3V1 bV93b3JrZXIgPSBmYWxzZTsKIAorLyoKKyAqIFZhcmlhYmxlcyB0byBzYXZlIHRoZSBjb3N0LXJl bGF0ZWQgc3RvcmFnZSBwYXJhbWV0ZXJzIGZvciB0aGUgY3VycmVudAorICogcmVsYXRpb24gYmVp bmcgdmFjdXVtZWQgYnkgdGhpcyBhdXRvdmFjdXVtIHdvcmtlci4gVXNpbmcgdGhlc2UsIHdlIGNh bgorICogZW5zdXJlIHdlIGRvbid0IG92ZXJ3cml0ZSB0aGUgdmFsdWVzIG9mIHZhY3V1bV9jb3N0 X2RlbGF5IGFuZAorICogdmFjdXVtX2Nvc3RfbGltaXQgYWZ0ZXIgcmVsb2FkaW5nIHRoZSBjb25m aWd1cmF0aW9uIGZpbGUuIFRoZXkgYXJlCisgKiBpbml0aWFsaXplZCB0byAiaW52YWxpZCIgdmFs dWVzIHRvIGluZGljYXRlIHRoYXQgbm8gY29zdC1yZWxhdGVkIHN0b3JhZ2UKKyAqIHBhcmFtZXRl cnMgd2VyZSBzcGVjaWZpZWQgYW5kIHdpbGwgYmUgc2V0IGluIGRvX2F1dG92YWN1dW0oKSBhZnRl ciBjaGVja2luZworICogdGhlIHN0b3JhZ2UgcGFyYW1ldGVycyBpbiB0YWJsZV9yZWNoZWNrX2F1 dG92YWMoKS4KKyAqLworc3RhdGljIGRvdWJsZSBhdl9zdG9yYWdlX3BhcmFtX2Nvc3RfZGVsYXkg PSAtMTsKK3N0YXRpYyBpbnQJYXZfc3RvcmFnZV9wYXJhbV9jb3N0X2xpbWl0ID0gLTE7CisKIC8q IEZsYWdzIHNldCBieSBzaWduYWwgaGFuZGxlcnMgKi8KIHN0YXRpYyB2b2xhdGlsZSBzaWdfYXRv bWljX3QgZ290X1NJR1VTUjIgPSBmYWxzZTsKIApAQCAtMTg5LDggKzIwMSw4IEBAIHR5cGVkZWYg c3RydWN0IGF1dG92YWNfdGFibGUKIHsKIAlPaWQJCQlhdF9yZWxpZDsKIAlWYWN1dW1QYXJhbXMg YXRfcGFyYW1zOwotCWRvdWJsZQkJYXRfdmFjdXVtX2Nvc3RfZGVsYXk7Ci0JaW50CQkJYXRfdmFj dXVtX2Nvc3RfbGltaXQ7CisJZG91YmxlCQlhdF9zdG9yYWdlX3BhcmFtX3ZhY19jb3N0X2RlbGF5 OworCWludAkJCWF0X3N0b3JhZ2VfcGFyYW1fdmFjX2Nvc3RfbGltaXQ7CiAJYm9vbAkJYXRfZG9i YWxhbmNlOwogCWJvb2wJCWF0X3NoYXJlZHJlbDsKIAljaGFyCSAgICphdF9yZWxuYW1lOwpAQCAt MjA5LDcgKzIyMSw3IEBAIHR5cGVkZWYgc3RydWN0IGF1dG92YWNfdGFibGUKICAqIHdpX3NoYXJl ZHJlbCBmbGFnIGluZGljYXRpbmcgd2hldGhlciB0YWJsZSBpcyBtYXJrZWQgcmVsaXNzaGFyZWQK ICAqIHdpX3Byb2MJCXBvaW50ZXIgdG8gUEdQUk9DIG9mIHRoZSBydW5uaW5nIHdvcmtlciwgTlVM TCBpZiBub3Qgc3RhcnRlZAogICogd2lfbGF1bmNodGltZSBUaW1lIGF0IHdoaWNoIHRoaXMgd29y a2VyIHdhcyBsYXVuY2hlZAotICogd2lfY29zdF8qCVZhY3V1bSBjb3N0LWJhc2VkIGRlbGF5IHBh cmFtZXRlcnMgY3VycmVudCBpbiB0aGlzIHdvcmtlcgorICogd2lfZG9iYWxhbmNlIFdoZXRoZXIg dGhpcyB3b3JrZXIgc2hvdWxkIGJlIGluY2x1ZGVkIGluIGJhbGFuY2UgY2FsY3VsYXRpb25zCiAg KgogICogQWxsIGZpZWxkcyBhcmUgcHJvdGVjdGVkIGJ5IEF1dG92YWN1dW1Mb2NrLCBleGNlcHQg Zm9yIHdpX3RhYmxlb2lkIGFuZAogICogd2lfc2hhcmVkcmVsIHdoaWNoIGFyZSBwcm90ZWN0ZWQg YnkgQXV0b3ZhY3V1bVNjaGVkdWxlTG9jayAobm90ZSB0aGVzZQpAQCAtMjIzLDExICsyMzUsOCBA QCB0eXBlZGVmIHN0cnVjdCBXb3JrZXJJbmZvRGF0YQogCU9pZAkJCXdpX3RhYmxlb2lkOwogCVBH UFJPQwkgICAqd2lfcHJvYzsKIAlUaW1lc3RhbXBUeiB3aV9sYXVuY2h0aW1lOwotCWJvb2wJCXdp X2RvYmFsYW5jZTsKKwlwZ19hdG9taWNfZmxhZyB3aV9kb2JhbGFuY2U7CiAJYm9vbAkJd2lfc2hh cmVkcmVsOwotCWRvdWJsZQkJd2lfY29zdF9kZWxheTsKLQlpbnQJCQl3aV9jb3N0X2xpbWl0Owot CWludAkJCXdpX2Nvc3RfbGltaXRfYmFzZTsKIH0gV29ya2VySW5mb0RhdGE7CiAKIHR5cGVkZWYg c3RydWN0IFdvcmtlckluZm9EYXRhICpXb3JrZXJJbmZvOwpAQCAtMjczLDYgKzI4Miw4IEBAIHR5 cGVkZWYgc3RydWN0IEF1dG9WYWN1dW1Xb3JrSXRlbQogICogYXZfc3RhcnRpbmdXb3JrZXIgcG9p bnRlciB0byBXb3JrZXJJbmZvIGN1cnJlbnRseSBiZWluZyBzdGFydGVkIChjbGVhcmVkIGJ5CiAg KgkJCQkJdGhlIHdvcmtlciBpdHNlbGYgYXMgc29vbiBhcyBpdCdzIHVwIGFuZCBydW5uaW5nKQog ICogYXZfd29ya0l0ZW1zCQl3b3JrIGl0ZW0gYXJyYXkKKyAqIGF2X253b3JrZXJzRm9yQmFsYW5j ZSB0aGUgbnVtYmVyIG9mIGF1dG92YWN1dW0gd29ya2VycyB0byB1c2Ugd2hlbgorICogCQkJCQlj YWxjdWxhdGluZyB0aGUgcGVyIHdvcmtlciBjb3N0IGxpbWl0CiAgKgogICogVGhpcyBzdHJ1Y3Qg aXMgcHJvdGVjdGVkIGJ5IEF1dG92YWN1dW1Mb2NrLCBleGNlcHQgZm9yIGF2X3NpZ25hbCBhbmQg cGFydHMKICAqIG9mIHRoZSB3b3JrZXIgbGlzdCAoc2VlIGFib3ZlKS4KQEAgLTI4Niw2ICsyOTcs NyBAQCB0eXBlZGVmIHN0cnVjdAogCWRsaXN0X2hlYWQJYXZfcnVubmluZ1dvcmtlcnM7CiAJV29y a2VySW5mbwlhdl9zdGFydGluZ1dvcmtlcjsKIAlBdXRvVmFjdXVtV29ya0l0ZW0gYXZfd29ya0l0 ZW1zW05VTV9XT1JLSVRFTVNdOworCXBnX2F0b21pY191aW50MzIgYXZfbndvcmtlcnNGb3JCYWxh bmNlOwogfSBBdXRvVmFjdXVtU2htZW1TdHJ1Y3Q7CiAKIHN0YXRpYyBBdXRvVmFjdXVtU2htZW1T dHJ1Y3QgKkF1dG9WYWN1dW1TaG1lbTsKQEAgLTMxOSw3ICszMzEsNyBAQCBzdGF0aWMgdm9pZCBs YXVuY2hfd29ya2VyKFRpbWVzdGFtcFR6IG5vdyk7CiBzdGF0aWMgTGlzdCAqZ2V0X2RhdGFiYXNl X2xpc3Qodm9pZCk7CiBzdGF0aWMgdm9pZCByZWJ1aWxkX2RhdGFiYXNlX2xpc3QoT2lkIG5ld2Ri KTsKIHN0YXRpYyBpbnQJZGJfY29tcGFyYXRvcihjb25zdCB2b2lkICphLCBjb25zdCB2b2lkICpi KTsKLXN0YXRpYyB2b2lkIGF1dG92YWNfYmFsYW5jZV9jb3N0KHZvaWQpOworc3RhdGljIHZvaWQg YXV0b3ZhY19yZWNhbGN1bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNlKHZvaWQpOwogCiBzdGF0aWMg dm9pZCBkb19hdXRvdmFjdXVtKHZvaWQpOwogc3RhdGljIHZvaWQgRnJlZVdvcmtlckluZm8oaW50 IGNvZGUsIERhdHVtIGFyZyk7CkBAIC02NjksNyArNjgxLDcgQEAgQXV0b1ZhY0xhdW5jaGVyTWFp bihpbnQgYXJnYywgY2hhciAqYXJndltdKQogCQkJewogCQkJCUxXTG9ja0FjcXVpcmUoQXV0b3Zh Y3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7CiAJCQkJQXV0b1ZhY3V1bVNobWVtLT5hdl9zaWduYWxb QXV0b1ZhY1JlYmFsYW5jZV0gPSBmYWxzZTsKLQkJCQlhdXRvdmFjX2JhbGFuY2VfY29zdCgpOwor CQkJCWF1dG92YWNfcmVjYWxjdWxhdGVfd29ya2Vyc19mb3JfYmFsYW5jZSgpOwogCQkJCUxXTG9j a1JlbGVhc2UoQXV0b3ZhY3V1bUxvY2spOwogCQkJfQogCkBAIC04MTgsMTEgKzgzMCw2IEBAIEhh bmRsZUF1dG9WYWNMYXVuY2hlckludGVycnVwdHModm9pZCkKIAkJaWYgKCFBdXRvVmFjdXVtaW5n QWN0aXZlKCkpCiAJCQlBdXRvVmFjTGF1bmNoZXJTaHV0ZG93bigpOwogCi0JCS8qIHJlYmFsYW5j ZSBpbiBjYXNlIHRoZSBkZWZhdWx0IGNvc3QgcGFyYW1ldGVycyBjaGFuZ2VkICovCi0JCUxXTG9j a0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7Ci0JCWF1dG92YWNfYmFsYW5j ZV9jb3N0KCk7Ci0JCUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1bUxvY2spOwotCiAJCS8qIHJlYnVp bGQgdGhlIGxpc3QgaW4gY2FzZSB0aGUgbmFwdGltZSBjaGFuZ2VkICovCiAJCXJlYnVpbGRfZGF0 YWJhc2VfbGlzdChJbnZhbGlkT2lkKTsKIAl9CkBAIC0xNzU0LDEwICsxNzYxLDcgQEAgRnJlZVdv cmtlckluZm8oaW50IGNvZGUsIERhdHVtIGFyZykKIAkJTXlXb3JrZXJJbmZvLT53aV9zaGFyZWRy ZWwgPSBmYWxzZTsKIAkJTXlXb3JrZXJJbmZvLT53aV9wcm9jID0gTlVMTDsKIAkJTXlXb3JrZXJJ bmZvLT53aV9sYXVuY2h0aW1lID0gMDsKLQkJTXlXb3JrZXJJbmZvLT53aV9kb2JhbGFuY2UgPSBm YWxzZTsKLQkJTXlXb3JrZXJJbmZvLT53aV9jb3N0X2RlbGF5ID0gMDsKLQkJTXlXb3JrZXJJbmZv LT53aV9jb3N0X2xpbWl0ID0gMDsKLQkJTXlXb3JrZXJJbmZvLT53aV9jb3N0X2xpbWl0X2Jhc2Ug PSAwOworCQlwZ19hdG9taWNfY2xlYXJfZmxhZygmTXlXb3JrZXJJbmZvLT53aV9kb2JhbGFuY2Up OwogCQlkbGlzdF9wdXNoX2hlYWQoJkF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVdvcmtlcnMsCiAJ CQkJCQkmTXlXb3JrZXJJbmZvLT53aV9saW5rcyk7CiAJCS8qIG5vdCBtaW5lIGFueW1vcmUgKi8K QEAgLTE3ODEsMTAgKzE3ODUsMjAgQEAgRnJlZVdvcmtlckluZm8oaW50IGNvZGUsIERhdHVtIGFy ZykKIHZvaWQKIFZhY3V1bVVwZGF0ZUNvc3RzKHZvaWQpCiB7CisJZG91YmxlCQlvcmlnaW5hbF9j b3N0X2RlbGF5ID0gdmFjdXVtX2Nvc3RfZGVsYXk7CisJaW50CQkJb3JpZ2luYWxfY29zdF9saW1p dCA9IHZhY3V1bV9jb3N0X2xpbWl0OworCiAJaWYgKE15V29ya2VySW5mbykKIAl7Ci0JCXZhY3V1 bV9jb3N0X2RlbGF5ID0gTXlXb3JrZXJJbmZvLT53aV9jb3N0X2RlbGF5OwotCQl2YWN1dW1fY29z dF9saW1pdCA9IE15V29ya2VySW5mby0+d2lfY29zdF9saW1pdDsKKwkJaWYgKGF2X3N0b3JhZ2Vf cGFyYW1fY29zdF9kZWxheSA+PSAwKQorCQkJdmFjdXVtX2Nvc3RfZGVsYXkgPSBhdl9zdG9yYWdl X3BhcmFtX2Nvc3RfZGVsYXk7CisJCWVsc2UgaWYgKGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkg Pj0gMCkKKwkJCXZhY3V1bV9jb3N0X2RlbGF5ID0gYXV0b3ZhY3V1bV92YWNfY29zdF9kZWxheTsK KwkJZWxzZQorCQkJLyogZmFsbCBiYWNrIHRvIFZhY3V1bUNvc3REZWxheSAqLworCQkJdmFjdXVt X2Nvc3RfZGVsYXkgPSBWYWN1dW1Db3N0RGVsYXk7CisKKwkJQXV0b1ZhY3V1bVVwZGF0ZUNvc3RM aW1pdCgpOwogCX0KIAllbHNlCiAJewpAQCAtMTc5Miw4OCArMTgwNiwxMjQgQEAgVmFjdXVtVXBk YXRlQ29zdHModm9pZCkKIAkJdmFjdXVtX2Nvc3RfZGVsYXkgPSBWYWN1dW1Db3N0RGVsYXk7CiAJ CXZhY3V1bV9jb3N0X2xpbWl0ID0gVmFjdXVtQ29zdExpbWl0OwogCX0KKworCS8qCisJICogSWYg Y29uZmlndXJhdGlvbiBjaGFuZ2VzIGFyZSBhbGxvd2VkIHRvIGltcGFjdCBWYWN1dW1Db3N0QWN0 aXZlLCBtYWtlCisJICogc3VyZSBpdCBpcyB1cGRhdGVkLgorCSAqLworCWlmIChWYWN1dW1GYWls c2FmZUFjdGl2ZSkKKwkJQXNzZXJ0KCFWYWN1dW1Db3N0QWN0aXZlKTsKKwllbHNlIGlmICh2YWN1 dW1fY29zdF9kZWxheSA+IDApCisJCVZhY3V1bUNvc3RBY3RpdmUgPSB0cnVlOworCWVsc2UKKwl7 CisJCVZhY3V1bUNvc3RBY3RpdmUgPSBmYWxzZTsKKwkJVmFjdXVtQ29zdEJhbGFuY2UgPSAwOwor CX0KKworCWlmIChNeVdvcmtlckluZm8pCisJeworCQkvKiBPbmx5IGxvZyB1cGRhdGVzIHRvIGNv c3QtcmVsYXRlZCB2YXJpYWJsZXMgKi8KKwkJaWYgKHZhY3V1bV9jb3N0X2RlbGF5ID09IG9yaWdp bmFsX2Nvc3RfZGVsYXkgJiYKKwkJCXZhY3V1bV9jb3N0X2xpbWl0ID09IG9yaWdpbmFsX2Nvc3Rf bGltaXQpCisJCQlyZXR1cm47CisKKwkJQXNzZXJ0KCFMV0xvY2tIZWxkQnlNZShBdXRvdmFjdXVt TG9jaykpOworCisJCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX1NIQVJFRCk7CisK KwkJZWxvZyhERUJVRzIsCisJCQkgIkF1dG92YWN1dW0gVmFjdXVtVXBkYXRlQ29zdHMoZGI9JXUs IHJlbD0ldSwgZG9iYWxhbmNlPSVzLCBjb3N0X2xpbWl0PSVkLCBjb3N0X2RlbGF5PSVnIGFjdGl2 ZT0lcyBmYWlsc2FmZT0lcykiLAorCQkJIE15V29ya2VySW5mby0+d2lfZGJvaWQsIE15V29ya2Vy SW5mby0+d2lfdGFibGVvaWQsCisJCQkgcGdfYXRvbWljX3VubG9ja2VkX3Rlc3RfZmxhZygmTXlX b3JrZXJJbmZvLT53aV9kb2JhbGFuY2UpID8gIm5vIiA6ICJ5ZXMiLAorCQkJIHZhY3V1bV9jb3N0 X2xpbWl0LCB2YWN1dW1fY29zdF9kZWxheSwKKwkJCSB2YWN1dW1fY29zdF9kZWxheSA+IDAgPyAi eWVzIiA6ICJubyIsCisJCQkgVmFjdXVtRmFpbHNhZmVBY3RpdmUgPyAieWVzIiA6ICJubyIpOwor CisJCUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1bUxvY2spOworCX0KIH0KIAogLyoKLSAqIGF1dG92 YWNfYmFsYW5jZV9jb3N0Ci0gKgkJUmVjYWxjdWxhdGUgdGhlIGNvc3QgbGltaXQgc2V0dGluZyBm b3IgZWFjaCBhY3RpdmUgd29ya2VyLgotICoKLSAqIENhbGxlciBtdXN0IGhvbGQgdGhlIEF1dG92 YWN1dW1Mb2NrIGluIGV4Y2x1c2l2ZSBtb2RlLgorICogVXBkYXRlIHZhY3V1bV9jb3N0X2xpbWl0 IHdpdGggdGhlIGNvcnJlY3QgdmFsdWUgZm9yIGFuIGF1dG92YWN1dW0gd29ya2VyLAorICogZ2l2 ZW4gdGhlIHZhbHVlIG9mIG90aGVyIHJlbGV2YW50IGNvc3QgbGltaXQgcGFyYW1ldGVycyBhbmQg dGhlIG51bWJlciBvZgorICogd29ya2VycyBhY3Jvc3Mgd2hpY2ggdGhlIGxpbWl0IG11c3QgYmUg YmFsYW5jZWQuIEF1dG92YWN1dW0gd29ya2VycyBtdXN0CisgKiBjYWxsIHRoaXMgcmVndWxhcmx5 IGluIGNhc2UgYXZfbndvcmtlcnNGb3JCYWxhbmNlIGhhcyBiZWVuIHVwZGF0ZWQgYnkKKyAqIGFu b3RoZXIgd29ya2VyIG9yIGJ5IHRoZSBhdXRvdmFjdXVtIGxhdW5jaGVyLiBUaGV5IG11c3QgYWxz byBjYWxsIGl0IGFmdGVyIGEKKyAqIGNvbmZpZyByZWxvYWQuCiAgKi8KLXN0YXRpYyB2b2lkCi1h dXRvdmFjX2JhbGFuY2VfY29zdCh2b2lkKQordm9pZAorQXV0b1ZhY3V1bVVwZGF0ZUNvc3RMaW1p dCh2b2lkKQogeworCWlmICghTXlXb3JrZXJJbmZvKQorCQlyZXR1cm47CisKIAkvKgotCSAqIFRo ZSBpZGVhIGhlcmUgaXMgdGhhdCB3ZSByYXRpb24gb3V0IEkvTyBlcXVhbGx5LiAgVGhlIGFtb3Vu dCBvZiBJL08KLQkgKiB0aGF0IGEgd29ya2VyIGNhbiBjb25zdW1lIGlzIGRldGVybWluZWQgYnkg Y29zdF9saW1pdC9jb3N0X2RlbGF5LCBzbyB3ZQotCSAqIHRyeSB0byBlcXVhbGl6ZSB0aG9zZSBy YXRpb3MgcmF0aGVyIHRoYW4gdGhlIHJhdyBsaW1pdCBzZXR0aW5ncy4KLQkgKgogCSAqIG5vdGU6 IGluIGNvc3RfbGltaXQsIHplcm8gYWxzbyBtZWFucyB1c2UgdmFsdWUgZnJvbSBlbHNld2hlcmUs IGJlY2F1c2UKIAkgKiB6ZXJvIGlzIG5vdCBhIHZhbGlkIHZhbHVlLgogCSAqLwotCWludAkJCXZh Y19jb3N0X2xpbWl0ID0gKGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQgPiAwID8KLQkJCQkJCQkJ ICBhdXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0IDogVmFjdXVtQ29zdExpbWl0KTsKLQlkb3VibGUJ CXZhY19jb3N0X2RlbGF5ID0gKGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkgPj0gMCA/Ci0JCQkJ CQkJCSAgYXV0b3ZhY3V1bV92YWNfY29zdF9kZWxheSA6IFZhY3V1bUNvc3REZWxheSk7Ci0JZG91 YmxlCQljb3N0X3RvdGFsOwotCWRvdWJsZQkJY29zdF9hdmFpbDsKLQlkbGlzdF9pdGVyCWl0ZXI7 Ci0KLQkvKiBub3Qgc2V0PyBub3RoaW5nIHRvIGRvICovCi0JaWYgKHZhY19jb3N0X2xpbWl0IDw9 IDAgfHwgdmFjX2Nvc3RfZGVsYXkgPD0gMCkKLQkJcmV0dXJuOwogCi0JLyogY2FsY3VsYXRlIHRo ZSB0b3RhbCBiYXNlIGNvc3QgbGltaXQgb2YgcGFydGljaXBhdGluZyBhY3RpdmUgd29ya2VycyAq LwotCWNvc3RfdG90YWwgPSAwLjA7Ci0JZGxpc3RfZm9yZWFjaChpdGVyLCAmQXV0b1ZhY3V1bVNo bWVtLT5hdl9ydW5uaW5nV29ya2VycykKKwlpZiAoYXZfc3RvcmFnZV9wYXJhbV9jb3N0X2xpbWl0 ID4gMCkKKwkJdmFjdXVtX2Nvc3RfbGltaXQgPSBhdl9zdG9yYWdlX3BhcmFtX2Nvc3RfbGltaXQ7 CisJZWxzZQogCXsKLQkJV29ya2VySW5mbwl3b3JrZXIgPSBkbGlzdF9jb250YWluZXIoV29ya2Vy SW5mb0RhdGEsIHdpX2xpbmtzLCBpdGVyLmN1cik7CisJCWludAkJCW53b3JrZXJzX2Zvcl9iYWxh bmNlOworCisJCWlmIChhdXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0ID4gMCkKKwkJCXZhY3V1bV9j b3N0X2xpbWl0ID0gYXV0b3ZhY3V1bV92YWNfY29zdF9saW1pdDsKKwkJZWxzZQorCQkJdmFjdXVt X2Nvc3RfbGltaXQgPSBWYWN1dW1Db3N0TGltaXQ7CisKKwkJLyogT25seSBiYWxhbmNlIGxpbWl0 IGlmIG5vIGNvc3QtcmVsYXRlZCBzdG9yYWdlIHBhcmFtZXRlcnMgc3BlY2lmaWVkICovCisJCWlm IChwZ19hdG9taWNfdW5sb2NrZWRfdGVzdF9mbGFnKCZNeVdvcmtlckluZm8tPndpX2RvYmFsYW5j ZSkpCisJCQlyZXR1cm47CisKKwkJQXNzZXJ0KHZhY3V1bV9jb3N0X2xpbWl0ID4gMCk7CiAKLQkJ aWYgKHdvcmtlci0+d2lfcHJvYyAhPSBOVUxMICYmCi0JCQl3b3JrZXItPndpX2RvYmFsYW5jZSAm JgotCQkJd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2UgPiAwICYmIHdvcmtlci0+d2lfY29zdF9k ZWxheSA+IDApCi0JCQljb3N0X3RvdGFsICs9Ci0JCQkJKGRvdWJsZSkgd29ya2VyLT53aV9jb3N0 X2xpbWl0X2Jhc2UgLyB3b3JrZXItPndpX2Nvc3RfZGVsYXk7CisJCW53b3JrZXJzX2Zvcl9iYWxh bmNlID0gcGdfYXRvbWljX3JlYWRfdTMyKCZBdXRvVmFjdXVtU2htZW0tPmF2X253b3JrZXJzRm9y QmFsYW5jZSk7CisKKwkJLyogVGhlcmUgaXMgYXQgbGVhc3QgMSBhdXRvdmFjIHdvcmtlciAodGhp cyB3b3JrZXIpICovCisJCWlmIChud29ya2Vyc19mb3JfYmFsYW5jZSA8PSAwKQorCQkJZWxvZyhF UlJPUiwgIm53b3JrZXJzX2Zvcl9iYWxhbmNlIG11c3QgYmUgPiAwIik7CisKKwkJdmFjdXVtX2Nv c3RfbGltaXQgPSBNYXgodmFjdXVtX2Nvc3RfbGltaXQgLyBud29ya2Vyc19mb3JfYmFsYW5jZSwg MSk7CiAJfQorfQogCi0JLyogdGhlcmUgYXJlIG5vIGNvc3QgbGltaXRzIC0tIG5vdGhpbmcgdG8g ZG8gKi8KLQlpZiAoY29zdF90b3RhbCA8PSAwKQotCQlyZXR1cm47CisvKgorICogYXV0b3ZhY19y ZWNhbGN1bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNlCisgKgkJUmVjYWxjdWxhdGUgdGhlIG51bWJl ciBvZiB3b3JrZXJzIHRvIGNvbnNpZGVyLCBnaXZlbiBjb3N0LXJlbGF0ZWQKKyAqCQlzdG9yYWdl IHBhcmFtZXRlcnMgYW5kIHRoZSBjdXJyZW50IG51bWJlciBvZiBhY3RpdmUgd29ya2Vycy4KKyAq CisgKiBDYWxsZXIgbXVzdCBob2xkIHRoZSBBdXRvdmFjdXVtTG9jayBpbiBhdCBsZWFzdCBzaGFy ZWQgbW9kZSB0byBhY2Nlc3MKKyAqIHdvcmtlci0+d2lfcHJvYy4KKyAqLworc3RhdGljIHZvaWQK K2F1dG92YWNfcmVjYWxjdWxhdGVfd29ya2Vyc19mb3JfYmFsYW5jZSh2b2lkKQoreworCWRsaXN0 X2l0ZXIJaXRlcjsKKwlpbnQJCQlvcmlnX253b3JrZXJzX2Zvcl9iYWxhbmNlOworCWludAkJCW53 b3JrZXJzX2Zvcl9iYWxhbmNlID0gMDsKKworCUFzc2VydChMV0xvY2tIZWxkQnlNZShBdXRvdmFj dXVtTG9jaykpOworCisJb3JpZ19ud29ya2Vyc19mb3JfYmFsYW5jZSA9CisJCXBnX2F0b21pY19y ZWFkX3UzMigmQXV0b1ZhY3V1bVNobWVtLT5hdl9ud29ya2Vyc0ZvckJhbGFuY2UpOwogCi0JLyoK LQkgKiBBZGp1c3QgY29zdCBsaW1pdCBvZiBlYWNoIGFjdGl2ZSB3b3JrZXIgdG8gYmFsYW5jZSB0 aGUgdG90YWwgb2YgY29zdAotCSAqIGxpbWl0IHRvIGF1dG92YWN1dW1fdmFjdXVtX2Nvc3RfbGlt aXQuCi0JICovCi0JY29zdF9hdmFpbCA9IChkb3VibGUpIHZhY19jb3N0X2xpbWl0IC8gdmFjX2Nv c3RfZGVsYXk7CiAJZGxpc3RfZm9yZWFjaChpdGVyLCAmQXV0b1ZhY3V1bVNobWVtLT5hdl9ydW5u aW5nV29ya2VycykKIAl7CiAJCVdvcmtlckluZm8Jd29ya2VyID0gZGxpc3RfY29udGFpbmVyKFdv cmtlckluZm9EYXRhLCB3aV9saW5rcywgaXRlci5jdXIpOwogCi0JCWlmICh3b3JrZXItPndpX3By b2MgIT0gTlVMTCAmJgotCQkJd29ya2VyLT53aV9kb2JhbGFuY2UgJiYKLQkJCXdvcmtlci0+d2lf Y29zdF9saW1pdF9iYXNlID4gMCAmJiB3b3JrZXItPndpX2Nvc3RfZGVsYXkgPiAwKQotCQl7Ci0J CQlpbnQJCQlsaW1pdCA9IChpbnQpCi0JCQkoY29zdF9hdmFpbCAqIHdvcmtlci0+d2lfY29zdF9s aW1pdF9iYXNlIC8gY29zdF90b3RhbCk7Ci0KLQkJCS8qCi0JCQkgKiBXZSBwdXQgYSBsb3dlciBi b3VuZCBvZiAxIG9uIHRoZSBjb3N0X2xpbWl0LCB0byBhdm9pZCBkaXZpc2lvbi0KLQkJCSAqIGJ5 LXplcm8gaW4gdGhlIHZhY3V1bSBjb2RlLiAgQWxzbywgaW4gY2FzZSBvZiByb3VuZG9mZiB0cm91 YmxlCi0JCQkgKiBpbiB0aGVzZSBjYWxjdWxhdGlvbnMsIGxldCdzIGJlIHN1cmUgd2UgZG9uJ3Qg ZXZlciBzZXQKLQkJCSAqIGNvc3RfbGltaXQgdG8gbW9yZSB0aGFuIHRoZSBiYXNlIHZhbHVlLgot CQkJICovCi0JCQl3b3JrZXItPndpX2Nvc3RfbGltaXQgPSBNYXgoTWluKGxpbWl0LAotCQkJCQkJ CQkJCQl3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSksCi0JCQkJCQkJCQkJMSk7Ci0JCX0KKwkJ aWYgKHdvcmtlci0+d2lfcHJvYyA9PSBOVUxMIHx8CisJCQlwZ19hdG9taWNfdW5sb2NrZWRfdGVz dF9mbGFnKCZ3b3JrZXItPndpX2RvYmFsYW5jZSkpCisJCQljb250aW51ZTsKIAotCQlpZiAod29y a2VyLT53aV9wcm9jICE9IE5VTEwpCi0JCQllbG9nKERFQlVHMiwgImF1dG92YWNfYmFsYW5jZV9j b3N0KHBpZD0lZCBkYj0ldSwgcmVsPSV1LCBkb2JhbGFuY2U9JXMgY29zdF9saW1pdD0lZCwgY29z dF9saW1pdF9iYXNlPSVkLCBjb3N0X2RlbGF5PSVnKSIsCi0JCQkJIHdvcmtlci0+d2lfcHJvYy0+ cGlkLCB3b3JrZXItPndpX2Rib2lkLCB3b3JrZXItPndpX3RhYmxlb2lkLAotCQkJCSB3b3JrZXIt PndpX2RvYmFsYW5jZSA/ICJ5ZXMiIDogIm5vIiwKLQkJCQkgd29ya2VyLT53aV9jb3N0X2xpbWl0 LCB3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSwKLQkJCQkgd29ya2VyLT53aV9jb3N0X2RlbGF5 KTsKKwkJbndvcmtlcnNfZm9yX2JhbGFuY2UrKzsKIAl9CisKKwlpZiAobndvcmtlcnNfZm9yX2Jh bGFuY2UgIT0gb3JpZ19ud29ya2Vyc19mb3JfYmFsYW5jZSkKKwkJcGdfYXRvbWljX3dyaXRlX3Uz MigmQXV0b1ZhY3V1bVNobWVtLT5hdl9ud29ya2Vyc0ZvckJhbGFuY2UsCisJCQkJCQkJbndvcmtl cnNfZm9yX2JhbGFuY2UpOwogfQogCiAvKgpAQCAtMjQyMSwyMyArMjQ3MSwzNCBAQCBkb19hdXRv dmFjdXVtKHZvaWQpCiAJCQljb250aW51ZTsKIAkJfQogCi0JCS8qIE11c3QgaG9sZCBBdXRvdmFj dXVtTG9jayB3aGlsZSBtdWNraW5nIHdpdGggY29zdCBiYWxhbmNlIGluZm8gKi8KLQkJTFdMb2Nr QWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZFKTsKKwkJLyoKKwkJICogU2F2ZSB0 aGUgY29zdC1yZWxhdGVkIHN0b3JhZ2UgcGFyYW1ldGVyIHZhbHVlcyBpbiBnbG9iYWwgdmFyaWFi bGVzCisJCSAqIGZvciByZWZlcmVuY2Ugd2hlbiB1cGRhdGluZyB2YWN1dW1fY29zdF9kZWxheSBh bmQgdmFjdXVtX2Nvc3RfbGltaXQKKwkJICogZHVyaW5nIHZhY3V1bWluZyB0aGlzIHRhYmxlLgor CQkgKi8KKwkJYXZfc3RvcmFnZV9wYXJhbV9jb3N0X2RlbGF5ID0gdGFiLT5hdF9zdG9yYWdlX3Bh cmFtX3ZhY19jb3N0X2RlbGF5OworCQlhdl9zdG9yYWdlX3BhcmFtX2Nvc3RfbGltaXQgPSB0YWIt PmF0X3N0b3JhZ2VfcGFyYW1fdmFjX2Nvc3RfbGltaXQ7CiAKLQkJLyogYWR2ZXJ0aXNlIG15IGNv c3QgZGVsYXkgcGFyYW1ldGVycyBmb3IgdGhlIGJhbGFuY2luZyBhbGdvcml0aG0gKi8KLQkJTXlX b3JrZXJJbmZvLT53aV9kb2JhbGFuY2UgPSB0YWItPmF0X2RvYmFsYW5jZTsKLQkJTXlXb3JrZXJJ bmZvLT53aV9jb3N0X2RlbGF5ID0gdGFiLT5hdF92YWN1dW1fY29zdF9kZWxheTsKLQkJTXlXb3Jr ZXJJbmZvLT53aV9jb3N0X2xpbWl0ID0gdGFiLT5hdF92YWN1dW1fY29zdF9saW1pdDsKLQkJTXlX b3JrZXJJbmZvLT53aV9jb3N0X2xpbWl0X2Jhc2UgPSB0YWItPmF0X3ZhY3V1bV9jb3N0X2xpbWl0 OworCQkvKgorCQkgKiBXZSBvbmx5IGV4cGVjdCB0aGlzIHdvcmtlciB0byBldmVyIHNldCB0aGUg ZmxhZywgc28gZG9uJ3QgYm90aGVyCisJCSAqIGNoZWNraW5nIHRoZSByZXR1cm4gdmFsdWUuIFdl IHNob3VsZG4ndCBoYXZlIHRvIHJldHJ5LgorCQkgKi8KKwkJaWYgKHRhYi0+YXRfZG9iYWxhbmNl KQorCQkJcGdfYXRvbWljX3Rlc3Rfc2V0X2ZsYWcoJk15V29ya2VySW5mby0+d2lfZG9iYWxhbmNl KTsKKwkJZWxzZQorCQkJcGdfYXRvbWljX2NsZWFyX2ZsYWcoJk15V29ya2VySW5mby0+d2lfZG9i YWxhbmNlKTsKIAotCQkvKiBkbyBhIGJhbGFuY2UgKi8KLQkJYXV0b3ZhY19iYWxhbmNlX2Nvc3Qo KTsKKwkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfU0hBUkVEKTsKKwkJYXV0b3Zh Y19yZWNhbGN1bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNlKCk7CisJCUxXTG9ja1JlbGVhc2UoQXV0 b3ZhY3V1bUxvY2spOwogCi0JCS8qIHNldCB0aGUgYWN0aXZlIGNvc3QgcGFyYW1ldGVycyBmcm9t IHRoZSByZXN1bHQgb2YgdGhhdCAqLworCQkvKgorCQkgKiBXZSB3YWl0IHVudGlsIHRoaXMgcG9p bnQgdG8gdXBkYXRlIGNvc3QgZGVsYXkgYW5kIGNvc3QgbGltaXQKKwkJICogdmFsdWVzLCBldmVu IHRob3VnaCB3ZSByZWxvYWRlZCB0aGUgY29uZmlndXJhdGlvbiBmaWxlIGFib3ZlLCBzbworCQkg KiB0aGF0IHdlIGNhbiB0YWtlIGludG8gYWNjb3VudCB0aGUgY29zdC1yZWxhdGVkIHN0b3JhZ2Ug cGFyYW1ldGVycy4KKwkJICovCiAJCVZhY3V1bVVwZGF0ZUNvc3RzKCk7CiAKLQkJLyogZG9uZSAq LwotCQlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKIAogCQkvKiBjbGVhbiB1cCBtZW1v cnkgYmVmb3JlIGVhY2ggaXRlcmF0aW9uICovCiAJCU1lbW9yeUNvbnRleHRSZXNldEFuZERlbGV0 ZUNoaWxkcmVuKFBvcnRhbENvbnRleHQpOwpAQCAtMjUyMSwxNiArMjU4MiwxNyBAQCBkZWxldGVk OgogCQlwZnJlZSh0YWIpOwogCiAJCS8qCi0JCSAqIFJlbW92ZSBteSBpbmZvIGZyb20gc2hhcmVk IG1lbW9yeS4gIFdlIGNvdWxkLCBidXQgaW50ZW50aW9uYWxseQotCQkgKiBkb24ndCwgY2xlYXIg d2lfY29zdF9saW1pdCBhbmQgZnJpZW5kcyAtLS0gdGhpcyBpcyBvbiB0aGUKLQkJICogYXNzdW1w dGlvbiB0aGF0IHdlIHByb2JhYmx5IGhhdmUgbW9yZSB0byBkbyB3aXRoIHNpbWlsYXIgY29zdAot CQkgKiBzZXR0aW5ncywgc28gd2UgZG9uJ3Qgd2FudCB0byBnaXZlIHVwIG91ciBzaGFyZSBvZiBJ L08gZm9yIGEgdmVyeQotCQkgKiBzaG9ydCBpbnRlcnZhbCBhbmQgdGhlcmVieSB0aHJhc2ggdGhl IGdsb2JhbCBiYWxhbmNlLgorCQkgKiBSZW1vdmUgbXkgaW5mbyBmcm9tIHNoYXJlZCBtZW1vcnku ICBXZSBzZXQgd2lfZG9iYWxhbmNlIG9uIHRoZQorCQkgKiBhc3N1bXB0aW9uIHRoYXQgd2UgYXJl IG1vcmUgbGlrZWx5IHRoYW4gbm90IHRvIHZhY3V1bSBhIHRhYmxlIHdpdGgKKwkJICogbm8gY29z dC1yZWxhdGVkIHN0b3JhZ2UgcGFyYW1ldGVycyBuZXh0LCBzbyB3ZSB3YW50IHRvIGNsYWltIG91 cgorCQkgKiBzaGFyZSBvZiBJL08gYXMgc29vbiBhcyBwb3NzaWJsZSB0byBhdm9pZCB0aHJhc2hp bmcgdGhlIGdsb2JhbAorCQkgKiBiYWxhbmNlLgogCQkgKi8KIAkJTFdMb2NrQWNxdWlyZShBdXRv dmFjdXVtU2NoZWR1bGVMb2NrLCBMV19FWENMVVNJVkUpOwogCQlNeVdvcmtlckluZm8tPndpX3Rh Ymxlb2lkID0gSW52YWxpZE9pZDsKIAkJTXlXb3JrZXJJbmZvLT53aV9zaGFyZWRyZWwgPSBmYWxz ZTsKIAkJTFdMb2NrUmVsZWFzZShBdXRvdmFjdXVtU2NoZWR1bGVMb2NrKTsKKwkJcGdfYXRvbWlj X3Rlc3Rfc2V0X2ZsYWcoJk15V29ya2VySW5mby0+d2lfZG9iYWxhbmNlKTsKIAl9CiAKIAkvKgpA QCAtMjU2Miw2ICsyNjI0LDcgQEAgZGVsZXRlZDoKIAkJewogCQkJQ29uZmlnUmVsb2FkUGVuZGlu ZyA9IGZhbHNlOwogCQkJUHJvY2Vzc0NvbmZpZ0ZpbGUoUEdDX1NJR0hVUCk7CisJCQlWYWN1dW1V cGRhdGVDb3N0cygpOwogCQl9CiAKIAkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdf RVhDTFVTSVZFKTsKQEAgLTI3OTcsOCArMjg2MCw2IEBAIHRhYmxlX3JlY2hlY2tfYXV0b3ZhYyhP aWQgcmVsaWQsIEhUQUIgKnRhYmxlX3RvYXN0X21hcCwKIAkJaW50CQkJZnJlZXplX3RhYmxlX2Fn ZTsKIAkJaW50CQkJbXVsdGl4YWN0X2ZyZWV6ZV9taW5fYWdlOwogCQlpbnQJCQltdWx0aXhhY3Rf ZnJlZXplX3RhYmxlX2FnZTsKLQkJaW50CQkJdmFjX2Nvc3RfbGltaXQ7Ci0JCWRvdWJsZQkJdmFj X2Nvc3RfZGVsYXk7CiAJCWludAkJCWxvZ19taW5fZHVyYXRpb247CiAKIAkJLyoKQEAgLTI4MDgs MjAgKzI4NjksNiBAQCB0YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJs ZV90b2FzdF9tYXAsCiAJCSAqIGRlZmF1bHRzLCBhdXRvdmFjdXVtJ3Mgb3duIGZpcnN0IGFuZCBw bGFpbiB2YWN1dW0gc2Vjb25kLgogCQkgKi8KIAotCQkvKiAtMSBpbiBhdXRvdmFjIHNldHRpbmcg bWVhbnMgdXNlIHBsYWluIHZhY3V1bV9jb3N0X2RlbGF5ICovCi0JCXZhY19jb3N0X2RlbGF5ID0g KGF2b3B0cyAmJiBhdm9wdHMtPnZhY3V1bV9jb3N0X2RlbGF5ID49IDApCi0JCQk/IGF2b3B0cy0+ dmFjdXVtX2Nvc3RfZGVsYXkKLQkJCTogKGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkgPj0gMCkK LQkJCT8gYXV0b3ZhY3V1bV92YWNfY29zdF9kZWxheQotCQkJOiBWYWN1dW1Db3N0RGVsYXk7Ci0K LQkJLyogMCBvciAtMSBpbiBhdXRvdmFjIHNldHRpbmcgbWVhbnMgdXNlIHBsYWluIHZhY3V1bV9j b3N0X2xpbWl0ICovCi0JCXZhY19jb3N0X2xpbWl0ID0gKGF2b3B0cyAmJiBhdm9wdHMtPnZhY3V1 bV9jb3N0X2xpbWl0ID4gMCkKLQkJCT8gYXZvcHRzLT52YWN1dW1fY29zdF9saW1pdAotCQkJOiAo YXV0b3ZhY3V1bV92YWNfY29zdF9saW1pdCA+IDApCi0JCQk/IGF1dG92YWN1dW1fdmFjX2Nvc3Rf bGltaXQKLQkJCTogVmFjdXVtQ29zdExpbWl0OwotCiAJCS8qIC0xIGluIGF1dG92YWMgc2V0dGlu ZyBtZWFucyB1c2UgbG9nX2F1dG92YWN1dW1fbWluX2R1cmF0aW9uICovCiAJCWxvZ19taW5fZHVy YXRpb24gPSAoYXZvcHRzICYmIGF2b3B0cy0+bG9nX21pbl9kdXJhdGlvbiA+PSAwKQogCQkJPyBh dm9wdHMtPmxvZ19taW5fZHVyYXRpb24KQEAgLTI4NzcsOCArMjkyNCwxMCBAQCB0YWJsZV9yZWNo ZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJsZV90b2FzdF9tYXAsCiAJCXRhYi0+YXRf cGFyYW1zLm11bHRpeGFjdF9mcmVlemVfdGFibGVfYWdlID0gbXVsdGl4YWN0X2ZyZWV6ZV90YWJs ZV9hZ2U7CiAJCXRhYi0+YXRfcGFyYW1zLmlzX3dyYXBhcm91bmQgPSB3cmFwYXJvdW5kOwogCQl0 YWItPmF0X3BhcmFtcy5sb2dfbWluX2R1cmF0aW9uID0gbG9nX21pbl9kdXJhdGlvbjsKLQkJdGFi LT5hdF92YWN1dW1fY29zdF9saW1pdCA9IHZhY19jb3N0X2xpbWl0OwotCQl0YWItPmF0X3ZhY3V1 bV9jb3N0X2RlbGF5ID0gdmFjX2Nvc3RfZGVsYXk7CisJCXRhYi0+YXRfc3RvcmFnZV9wYXJhbV92 YWNfY29zdF9saW1pdCA9IGF2b3B0cyA/CisJCQlhdm9wdHMtPnZhY3V1bV9jb3N0X2xpbWl0IDog MDsKKwkJdGFiLT5hdF9zdG9yYWdlX3BhcmFtX3ZhY19jb3N0X2RlbGF5ID0gYXZvcHRzID8KKwkJ CWF2b3B0cy0+dmFjdXVtX2Nvc3RfZGVsYXkgOiAtMTsKIAkJdGFiLT5hdF9yZWxuYW1lID0gTlVM TDsKIAkJdGFiLT5hdF9uc3BuYW1lID0gTlVMTDsKIAkJdGFiLT5hdF9kYXRuYW1lID0gTlVMTDsK QEAgLTMzODAsMTAgKzM0MjksMTggQEAgQXV0b1ZhY3V1bVNobWVtSW5pdCh2b2lkKQogCQl3b3Jr ZXIgPSAoV29ya2VySW5mbykgKChjaGFyICopIEF1dG9WYWN1dW1TaG1lbSArCiAJCQkJCQkJICAg TUFYQUxJR04oc2l6ZW9mKEF1dG9WYWN1dW1TaG1lbVN0cnVjdCkpKTsKIAorCiAJCS8qIGluaXRp YWxpemUgdGhlIFdvcmtlckluZm8gZnJlZSBsaXN0ICovCiAJCWZvciAoaSA9IDA7IGkgPCBhdXRv dmFjdXVtX21heF93b3JrZXJzOyBpKyspCisJCXsKIAkJCWRsaXN0X3B1c2hfaGVhZCgmQXV0b1Zh Y3V1bVNobWVtLT5hdl9mcmVlV29ya2VycywKIAkJCQkJCQkmd29ya2VyW2ldLndpX2xpbmtzKTsK KworCQkJcGdfYXRvbWljX2luaXRfZmxhZygmd29ya2VyW2ldLndpX2RvYmFsYW5jZSk7CisJCX0K KworCQlwZ19hdG9taWNfaW5pdF91MzIoJkF1dG9WYWN1dW1TaG1lbS0+YXZfbndvcmtlcnNGb3JC YWxhbmNlLCAwKTsKKwogCX0KIAllbHNlCiAJCUFzc2VydChmb3VuZCk7CmRpZmYgLS1naXQgYS9z cmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaCBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1 bS5oCmluZGV4IDUwY2FmMTMxNWQuLjJhODU2YjBlNWUgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRl L2NvbW1hbmRzL3ZhY3V1bS5oCisrKyBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oCkBA IC0zNTAsNiArMzUwLDcgQEAgZXh0ZXJuIEluZGV4QnVsa0RlbGV0ZVJlc3VsdCAqdmFjX2NsZWFu dXBfb25lX2luZGV4KEluZGV4VmFjdXVtSW5mbyAqaXZpbmZvLAogZXh0ZXJuIFNpemUgdmFjX21h eF9pdGVtc190b19hbGxvY19zaXplKGludCBtYXhfaXRlbXMpOwogCiAvKiBJbiBwb3N0bWFzdGVy L2F1dG92YWN1dW0uYyAqLworZXh0ZXJuIHZvaWQgQXV0b1ZhY3V1bVVwZGF0ZUNvc3RMaW1pdCh2 b2lkKTsKIGV4dGVybiB2b2lkIFZhY3V1bVVwZGF0ZUNvc3RzKHZvaWQpOwogCiAvKiBpbiBjb21t YW5kcy92YWN1dW1wYXJhbGxlbC5jICovCi0tIAoyLjM3LjIKCg== --000000000000c6e76205f8b14956 Content-Type: text/x-patch; charset="US-ASCII"; name="v18-0002-Separate-vacuum-cost-variables-from-GUCs.patch" Content-Disposition: attachment; filename="v18-0002-Separate-vacuum-cost-variables-from-GUCs.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg5lx3f11 RnJvbSA5MmZjODc5NjlhNDk2YzFhMWY1ZmQ2MTJkM2M3YzMyMjUxZGVjNmUxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBUaHUsIDYgQXByIDIwMjMgMTY6MDI6MTIgLTA0MDAKU3ViamVjdDogW1BB VENIIHYxOCAyLzNdIFNlcGFyYXRlIHZhY3V1bSBjb3N0IHZhcmlhYmxlcyBmcm9tIEdVQ3MKClZh Y3V1bSBjb2RlIHJ1biBib3RoIGJ5IGF1dG92YWN1dW0gd29ya2VycyBhbmQgYSBiYWNrZW5kIGRv aW5nClZBQ1VVTS9BTkFMWVpFIHByZXZpb3VzbHkgaW5zcGVjdGVkIFZhY3V1bUNvc3RMaW1pdCBh bmQgVmFjdXVtQ29zdERlbGF5LAp3aGljaCBhcmUgdGhlIGdsb2JhbCB2YXJpYWJsZXMgYmFja2lu ZyB0aGUgR1VDcyB2YWN1dW1fY29zdF9saW1pdCBhbmQKdmFjdXVtX2Nvc3RfZGVsYXkuCgpBdXRv dmFjdXVtIHdvcmtlcnMgbmVlZGVkIHRvIG92ZXJyaWRlIHRoZXNlIHZhcmlhYmxlcyB3aXRoIHRo ZWlyIG93bgp2YWx1ZXMsIGRlcml2ZWQgZnJvbSBhdXRvdmFjdXVtX3ZhY3V1bV9jb3N0X2xpbWl0 IGFuZAphdXRvdmFjdXVtX3ZhY3V1bV9jb3N0X2RlbGF5IGFuZCB3b3JrZXIgY29zdCBsaW1pdCBi YWxhbmNpbmcgbG9naWMuIFRoaXMKbGVkIHRvIGNvbmZ1c2luZyBjb2RlIHdoaWNoLCBpbiBzb21l IGNhc2VzLCBib3RoIGRlcml2ZWQgYW5kIHNldCBhIG5ldwp2YWx1ZSBvZiBWYWN1dW1Db3N0TGlt aXQgZnJvbSBWYWN1dW1Db3N0TGltaXQuCgpJbiBwcmVwYXJhdGlvbiBmb3IgcmVmcmVzaGluZyB0 aGVzZSBHVUMgdmFsdWVzIG1vcmUgb2Z0ZW4sIGludHJvZHVjZQpuZXcsIGluZGVwZW5kZW50IGds b2JhbCB2YXJpYWJsZXMgYW5kIGFkZCBhIGZ1bmN0aW9uIHRvIHVwZGF0ZSB0aGVtCnVzaW5nIHRo ZSBHVUNzIGFuZCBleGlzdGluZyBsb2dpYy4KClBlciBzdWdnZXN0aW9uIGJ5IEt5b3Rhcm8gSG9y aWd1Y2hpCgpSZXZpZXdlZC1ieTogTWFzYWhpa28gU2F3YWRhIDxzYXdhZGEubXNoa0BnbWFpbC5j b20+ClJldmlld2VkLWJ5OiBEYW5pZWwgR3VzdGFmc3NvbiA8ZGFuaWVsQHllc3FsLnNlPgpSZXZp ZXdlZC1ieTogS3lvdGFybyBIb3JpZ3VjaGkgPGhvcmlreW90YS5udHRAZ21haWwuY29tPgpEaXNj dXNzaW9uOiBodHRwczovL3d3dy5wb3N0Z3Jlc3FsLm9yZy9tZXNzYWdlLWlkL2ZsYXQvQ0FBS1J1 X1puZ3pxbkVPRGM3TG1TMU5IMDRLdDZZOWh1U2p6NXBwNyUyQkRYaHJqREEwZ3clNDBtYWlsLmdt YWlsLmNvbQotLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jICAgICAgICAgfCAyOSAr KysrKysrKysrKysrKystLS0tLS0tLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxs ZWwuYyB8ICAzICsrLQogc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMgICB8IDM0 ICsrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLQogc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVt LmggICAgICAgICB8ICA1ICsrKysKIHNyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5o ICAgfCAgMyAtLS0KIDUgZmlsZXMgY2hhbmdlZCwgNDAgaW5zZXJ0aW9ucygrKSwgMzQgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMgYi9zcmMv YmFja2VuZC9jb21tYW5kcy92YWN1dW0uYwppbmRleCA3ZmM1YzE5ZTM3Li5mMmJlNzRjZGI1IDEw MDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYworKysgYi9zcmMvYmFja2Vu ZC9jb21tYW5kcy92YWN1dW0uYwpAQCAtNzIsNiArNzIsMTUgQEAgaW50CQkJdmFjdXVtX211bHRp eGFjdF9mcmVlemVfdGFibGVfYWdlOwogaW50CQkJdmFjdXVtX2ZhaWxzYWZlX2FnZTsKIGludAkJ CXZhY3V1bV9tdWx0aXhhY3RfZmFpbHNhZmVfYWdlOwogCisvKgorICogVmFyaWFibGVzIGZvciBj b3N0LWJhc2VkIHZhY3V1bSBkZWxheS4gVGhlIGRlZmF1bHRzIGRpZmZlciBiZXR3ZWVuCisgKiBh dXRvdmFjdXVtIGFuZCB2YWN1dW0uIFRoZXkgc2hvdWxkIGJlIHNldCB3aXRoIHRoZSBhcHByb3By aWF0ZSBHVUMgdmFsdWUgaW4KKyAqIHZhY3V1bSBjb2RlLiBUaGV5IGFyZSBpbml0aWFsaXplZCBo ZXJlIHRvIHRoZSBkZWZhdWx0cyBmb3IgY2xpZW50IGJhY2tlbmRzCisgKiBleGVjdXRpbmcgVkFD VVVNIG9yIEFOQUxZWkUuCisgKi8KK2RvdWJsZQkJdmFjdXVtX2Nvc3RfZGVsYXkgPSAwOworaW50 CQkJdmFjdXVtX2Nvc3RfbGltaXQgPSAyMDA7CisKIC8qCiAgKiBWYWN1dW1GYWlsc2FmZUFjdGl2 ZSBpcyBhIGRlZmluZWQgYXMgYSBnbG9iYWwgc28gdGhhdCB3ZSBjYW4gZGV0ZXJtaW5lCiAgKiB3 aGV0aGVyIG9yIG5vdCB0byByZS1lbmFibGUgY29zdC1iYXNlZCB2YWN1dW0gZGVsYXkgd2hlbiB2 YWN1dW1pbmcgYSB0YWJsZS4KQEAgLTUxNCw4ICs1MjMsOSBAQCB2YWN1dW0oTGlzdCAqcmVsYXRp b25zLCBWYWN1dW1QYXJhbXMgKnBhcmFtcywgQnVmZmVyQWNjZXNzU3RyYXRlZ3kgYnN0cmF0ZWd5 LAogCXsKIAkJTGlzdENlbGwgICAqY3VyOwogCisJCVZhY3V1bVVwZGF0ZUNvc3RzKCk7CiAJCWlu X3ZhY3V1bSA9IHRydWU7Ci0JCVZhY3V1bUNvc3RBY3RpdmUgPSAoVmFjdXVtQ29zdERlbGF5ID4g MCk7CisJCVZhY3V1bUNvc3RBY3RpdmUgPSAodmFjdXVtX2Nvc3RfZGVsYXkgPiAwKTsKIAkJVmFj dXVtQ29zdEJhbGFuY2UgPSAwOwogCQlWYWN1dW1QYWdlSGl0ID0gMDsKIAkJVmFjdXVtUGFnZU1p c3MgPSAwOwpAQCAtMjI0NCwxNCArMjI1NCwxNCBAQCB2YWN1dW1fZGVsYXlfcG9pbnQodm9pZCkK IAkgKi8KIAlpZiAoVmFjdXVtU2hhcmVkQ29zdEJhbGFuY2UgIT0gTlVMTCkKIAkJbXNlYyA9IGNv bXB1dGVfcGFyYWxsZWxfZGVsYXkoKTsKLQllbHNlIGlmIChWYWN1dW1Db3N0QmFsYW5jZSA+PSBW YWN1dW1Db3N0TGltaXQpCi0JCW1zZWMgPSBWYWN1dW1Db3N0RGVsYXkgKiBWYWN1dW1Db3N0QmFs YW5jZSAvIFZhY3V1bUNvc3RMaW1pdDsKKwllbHNlIGlmIChWYWN1dW1Db3N0QmFsYW5jZSA+PSB2 YWN1dW1fY29zdF9saW1pdCkKKwkJbXNlYyA9IHZhY3V1bV9jb3N0X2RlbGF5ICogVmFjdXVtQ29z dEJhbGFuY2UgLyB2YWN1dW1fY29zdF9saW1pdDsKIAogCS8qIE5hcCBpZiBhcHByb3ByaWF0ZSAq LwogCWlmIChtc2VjID4gMCkKIAl7Ci0JCWlmIChtc2VjID4gVmFjdXVtQ29zdERlbGF5ICogNCkK LQkJCW1zZWMgPSBWYWN1dW1Db3N0RGVsYXkgKiA0OworCQlpZiAobXNlYyA+IHZhY3V1bV9jb3N0 X2RlbGF5ICogNCkKKwkJCW1zZWMgPSB2YWN1dW1fY29zdF9kZWxheSAqIDQ7CiAKIAkJcGdzdGF0 X3JlcG9ydF93YWl0X3N0YXJ0KFdBSVRfRVZFTlRfVkFDVVVNX0RFTEFZKTsKIAkJcGdfdXNsZWVw KG1zZWMgKiAxMDAwKTsKQEAgLTIyNjgsOCArMjI3OCw3IEBAIHZhY3V1bV9kZWxheV9wb2ludCh2 b2lkKQogCiAJCVZhY3V1bUNvc3RCYWxhbmNlID0gMDsKIAotCQkvKiB1cGRhdGUgYmFsYW5jZSB2 YWx1ZXMgZm9yIHdvcmtlcnMgKi8KLQkJQXV0b1ZhY3V1bVVwZGF0ZURlbGF5KCk7CisJCVZhY3V1 bVVwZGF0ZUNvc3RzKCk7CiAKIAkJLyogTWlnaHQgaGF2ZSBnb3R0ZW4gYW4gaW50ZXJydXB0IHdo aWxlIHNsZWVwaW5nICovCiAJCUNIRUNLX0ZPUl9JTlRFUlJVUFRTKCk7CkBAIC0yMzE5LDExICsy MzI4LDExIEBAIGNvbXB1dGVfcGFyYWxsZWxfZGVsYXkodm9pZCkKIAkvKiBDb21wdXRlIHRoZSB0 b3RhbCBsb2NhbCBiYWxhbmNlIGZvciB0aGUgY3VycmVudCB3b3JrZXIgKi8KIAlWYWN1dW1Db3N0 QmFsYW5jZUxvY2FsICs9IFZhY3V1bUNvc3RCYWxhbmNlOwogCi0JaWYgKChzaGFyZWRfYmFsYW5j ZSA+PSBWYWN1dW1Db3N0TGltaXQpICYmCi0JCShWYWN1dW1Db3N0QmFsYW5jZUxvY2FsID4gMC41 ICogKChkb3VibGUpIFZhY3V1bUNvc3RMaW1pdCAvIG53b3JrZXJzKSkpCisJaWYgKChzaGFyZWRf YmFsYW5jZSA+PSB2YWN1dW1fY29zdF9saW1pdCkgJiYKKwkJKFZhY3V1bUNvc3RCYWxhbmNlTG9j YWwgPiAwLjUgKiAoKGRvdWJsZSkgdmFjdXVtX2Nvc3RfbGltaXQgLyBud29ya2VycykpKQogCXsK IAkJLyogQ29tcHV0ZSBzbGVlcCB0aW1lIGJhc2VkIG9uIHRoZSBsb2NhbCBjb3N0IGJhbGFuY2Ug Ki8KLQkJbXNlYyA9IFZhY3V1bUNvc3REZWxheSAqIFZhY3V1bUNvc3RCYWxhbmNlTG9jYWwgLyBW YWN1dW1Db3N0TGltaXQ7CisJCW1zZWMgPSB2YWN1dW1fY29zdF9kZWxheSAqIFZhY3V1bUNvc3RC YWxhbmNlTG9jYWwgLyB2YWN1dW1fY29zdF9saW1pdDsKIAkJcGdfYXRvbWljX3N1Yl9mZXRjaF91 MzIoVmFjdXVtU2hhcmVkQ29zdEJhbGFuY2UsIFZhY3V1bUNvc3RCYWxhbmNlTG9jYWwpOwogCQlW YWN1dW1Db3N0QmFsYW5jZUxvY2FsID0gMDsKIAl9CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9j b21tYW5kcy92YWN1dW1wYXJhbGxlbC5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFy YWxsZWwuYwppbmRleCA1NjMxMTdhOGY2Li5jYzBhZmY3OTA0IDEwMDY0NAotLS0gYS9zcmMvYmFj a2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRz L3ZhY3V1bXBhcmFsbGVsLmMKQEAgLTk5NSw3ICs5OTUsOCBAQCBwYXJhbGxlbF92YWN1dW1fbWFp bihkc21fc2VnbWVudCAqc2VnLCBzaG1fdG9jICp0b2MpCiAJCQkJCQkJCQkJCQkgZmFsc2UpOwog CiAJLyogU2V0IGNvc3QtYmFzZWQgdmFjdXVtIGRlbGF5ICovCi0JVmFjdXVtQ29zdEFjdGl2ZSA9 IChWYWN1dW1Db3N0RGVsYXkgPiAwKTsKKwlWYWN1dW1Db3N0QWN0aXZlID0gKHZhY3V1bV9jb3N0 X2RlbGF5ID4gMCk7CisJVmFjdXVtVXBkYXRlQ29zdHMoKTsKIAlWYWN1dW1Db3N0QmFsYW5jZSA9 IDA7CiAJVmFjdXVtUGFnZUhpdCA9IDA7CiAJVmFjdXVtUGFnZU1pc3MgPSAwOwpkaWZmIC0tZ2l0 IGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMgYi9zcmMvYmFja2VuZC9wb3N0 bWFzdGVyL2F1dG92YWN1dW0uYwppbmRleCBjMWU5MTFiMWIzLi4zNjQ0Yjg2NDQzIDEwMDY0NAot LS0gYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYworKysgYi9zcmMvYmFja2Vu ZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwpAQCAtMTc3MywxNiArMTc3MywyNCBAQCBGcmVlV29y a2VySW5mbyhpbnQgY29kZSwgRGF0dW0gYXJnKQogfQogCiAvKgotICogVXBkYXRlIHRoZSBjb3N0 LWJhc2VkIGRlbGF5IHBhcmFtZXRlcnMsIHNvIHRoYXQgbXVsdGlwbGUgd29ya2VycyBjb25zdW1l Ci0gKiBlYWNoIGEgZnJhY3Rpb24gb2YgdGhlIHRvdGFsIGF2YWlsYWJsZSBJL08uCisgKiBVcGRh dGUgdmFjdXVtIGNvc3QtYmFzZWQgZGVsYXktcmVsYXRlZCBwYXJhbWV0ZXJzIGZvciBhdXRvdmFj dXVtIHdvcmtlcnMgYW5kCisgKiBiYWNrZW5kcyBleGVjdXRpbmcgVkFDVVVNIG9yIEFOQUxZWkUg dXNpbmcgdGhlIHZhbHVlIG9mIHJlbGV2YW50IGd1Y3MgYW5kCisgKiBnbG9iYWwgc3RhdGUuIFRo aXMgbXVzdCBiZSBjYWxsZWQgZHVyaW5nIHNldHVwIGZvciB2YWN1dW0gYW5kIGFmdGVyIGV2ZXJ5 CisgKiBjb25maWcgcmVsb2FkIHRvIGVuc3VyZSB1cC10by1kYXRlIHZhbHVlcy4KICAqLwogdm9p ZAotQXV0b1ZhY3V1bVVwZGF0ZURlbGF5KHZvaWQpCitWYWN1dW1VcGRhdGVDb3N0cyh2b2lkKQog ewogCWlmIChNeVdvcmtlckluZm8pCiAJewotCQlWYWN1dW1Db3N0RGVsYXkgPSBNeVdvcmtlcklu Zm8tPndpX2Nvc3RfZGVsYXk7Ci0JCVZhY3V1bUNvc3RMaW1pdCA9IE15V29ya2VySW5mby0+d2lf Y29zdF9saW1pdDsKKwkJdmFjdXVtX2Nvc3RfZGVsYXkgPSBNeVdvcmtlckluZm8tPndpX2Nvc3Rf ZGVsYXk7CisJCXZhY3V1bV9jb3N0X2xpbWl0ID0gTXlXb3JrZXJJbmZvLT53aV9jb3N0X2xpbWl0 OworCX0KKwllbHNlCisJeworCQkvKiBNdXN0IGJlIGV4cGxpY2l0IFZBQ1VVTSBvciBBTkFMWVpF ICovCisJCXZhY3V1bV9jb3N0X2RlbGF5ID0gVmFjdXVtQ29zdERlbGF5OworCQl2YWN1dW1fY29z dF9saW1pdCA9IFZhY3V1bUNvc3RMaW1pdDsKIAl9CiB9CiAKQEAgLTIzMTEsOCArMjMxOSw2IEBA IGRvX2F1dG92YWN1dW0odm9pZCkKIAkJYXV0b3ZhY190YWJsZSAqdGFiOwogCQlib29sCQlpc3No YXJlZDsKIAkJYm9vbAkJc2tpcGl0OwotCQlkb3VibGUJCXN0ZFZhY3V1bUNvc3REZWxheTsKLQkJ aW50CQkJc3RkVmFjdXVtQ29zdExpbWl0OwogCQlkbGlzdF9pdGVyCWl0ZXI7CiAKIAkJQ0hFQ0tf Rk9SX0lOVEVSUlVQVFMoKTsKQEAgLTI0MTUsMTQgKzI0MjEsNiBAQCBkb19hdXRvdmFjdXVtKHZv aWQpCiAJCQljb250aW51ZTsKIAkJfQogCi0JCS8qCi0JCSAqIFJlbWVtYmVyIHRoZSBwcmV2YWls aW5nIHZhbHVlcyBvZiB0aGUgdmFjdXVtIGNvc3QgR1VDcy4gIFdlIGhhdmUgdG8KLQkJICogcmVz dG9yZSB0aGVzZSBhdCB0aGUgYm90dG9tIG9mIHRoZSBsb29wLCBlbHNlIHdlJ2xsIGNvbXB1dGUg d3JvbmcKLQkJICogdmFsdWVzIGluIHRoZSBuZXh0IGl0ZXJhdGlvbiBvZiBhdXRvdmFjX2JhbGFu Y2VfY29zdCgpLgotCQkgKi8KLQkJc3RkVmFjdXVtQ29zdERlbGF5ID0gVmFjdXVtQ29zdERlbGF5 OwotCQlzdGRWYWN1dW1Db3N0TGltaXQgPSBWYWN1dW1Db3N0TGltaXQ7Ci0KIAkJLyogTXVzdCBo b2xkIEF1dG92YWN1dW1Mb2NrIHdoaWxlIG11Y2tpbmcgd2l0aCBjb3N0IGJhbGFuY2UgaW5mbyAq LwogCQlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2NrLCBMV19FWENMVVNJVkUpOwogCkBAIC0y NDM2LDcgKzI0MzQsNyBAQCBkb19hdXRvdmFjdXVtKHZvaWQpCiAJCWF1dG92YWNfYmFsYW5jZV9j b3N0KCk7CiAKIAkJLyogc2V0IHRoZSBhY3RpdmUgY29zdCBwYXJhbWV0ZXJzIGZyb20gdGhlIHJl c3VsdCBvZiB0aGF0ICovCi0JCUF1dG9WYWN1dW1VcGRhdGVEZWxheSgpOworCQlWYWN1dW1VcGRh dGVDb3N0cygpOwogCiAJCS8qIGRvbmUgKi8KIAkJTFdMb2NrUmVsZWFzZShBdXRvdmFjdXVtTG9j ayk7CkBAIC0yNTMzLDEwICsyNTMxLDYgQEAgZGVsZXRlZDoKIAkJTXlXb3JrZXJJbmZvLT53aV90 YWJsZW9pZCA9IEludmFsaWRPaWQ7CiAJCU15V29ya2VySW5mby0+d2lfc2hhcmVkcmVsID0gZmFs c2U7CiAJCUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1bVNjaGVkdWxlTG9jayk7Ci0KLQkJLyogcmVz dG9yZSB2YWN1dW0gY29zdCBHVUNzIGZvciB0aGUgbmV4dCBpdGVyYXRpb24gKi8KLQkJVmFjdXVt Q29zdERlbGF5ID0gc3RkVmFjdXVtQ29zdERlbGF5OwotCQlWYWN1dW1Db3N0TGltaXQgPSBzdGRW YWN1dW1Db3N0TGltaXQ7CiAJfQogCiAJLyoKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2NvbW1h bmRzL3ZhY3V1bS5oIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKaW5kZXggMTIyM2Qx NWUwZC4uNTBjYWYxMzE1ZCAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVt LmgKKysrIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKQEAgLTMwNyw2ICszMDcsOCBA QCBleHRlcm4gUEdETExJTVBPUlQgcGdfYXRvbWljX3VpbnQzMiAqVmFjdXVtQWN0aXZlTldvcmtl cnM7CiBleHRlcm4gUEdETExJTVBPUlQgaW50IFZhY3V1bUNvc3RCYWxhbmNlTG9jYWw7CiAKIGV4 dGVybiBQR0RMTElNUE9SVCBib29sIFZhY3V1bUZhaWxzYWZlQWN0aXZlOworZXh0ZXJuIFBHRExM SU1QT1JUIGRvdWJsZSB2YWN1dW1fY29zdF9kZWxheTsKK2V4dGVybiBQR0RMTElNUE9SVCBpbnQg dmFjdXVtX2Nvc3RfbGltaXQ7CiAKIC8qIGluIGNvbW1hbmRzL3ZhY3V1bS5jICovCiBleHRlcm4g dm9pZCBFeGVjVmFjdXVtKFBhcnNlU3RhdGUgKnBzdGF0ZSwgVmFjdXVtU3RtdCAqdmFjc3RtdCwg Ym9vbCBpc1RvcExldmVsKTsKQEAgLTM0Nyw2ICszNDksOSBAQCBleHRlcm4gSW5kZXhCdWxrRGVs ZXRlUmVzdWx0ICp2YWNfY2xlYW51cF9vbmVfaW5kZXgoSW5kZXhWYWN1dW1JbmZvICppdmluZm8s CiAJCQkJCQkJCQkJCQkJSW5kZXhCdWxrRGVsZXRlUmVzdWx0ICppc3RhdCk7CiBleHRlcm4gU2l6 ZSB2YWNfbWF4X2l0ZW1zX3RvX2FsbG9jX3NpemUoaW50IG1heF9pdGVtcyk7CiAKKy8qIEluIHBv c3RtYXN0ZXIvYXV0b3ZhY3V1bS5jICovCitleHRlcm4gdm9pZCBWYWN1dW1VcGRhdGVDb3N0cyh2 b2lkKTsKKwogLyogaW4gY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyAqLwogZXh0ZXJuIFBhcmFs bGVsVmFjdXVtU3RhdGUgKnBhcmFsbGVsX3ZhY3V1bV9pbml0KFJlbGF0aW9uIHJlbCwgUmVsYXRp b24gKmluZHJlbHMsCiAJCQkJCQkJCQkJCQkgaW50IG5pbmRleGVzLCBpbnQgbnJlcXVlc3RlZF93 b3JrZXJzLApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgg Yi9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaAppbmRleCBjMTQwMzcxYjUxLi42 NWFmZDFlYTFlIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0u aAorKysgYi9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaApAQCAtNjMsOSArNjMs NiBAQCBleHRlcm4gaW50CVN0YXJ0QXV0b1ZhY1dvcmtlcih2b2lkKTsKIC8qIGNhbGxlZCBmcm9t IHBvc3RtYXN0ZXIgd2hlbiBhIHdvcmtlciBjb3VsZCBub3QgYmUgZm9ya2VkICovCiBleHRlcm4g dm9pZCBBdXRvVmFjV29ya2VyRmFpbGVkKHZvaWQpOwogCi0vKiBhdXRvdmFjdXVtIGNvc3QtZGVs YXkgYmFsYW5jZXIgKi8KLWV4dGVybiB2b2lkIEF1dG9WYWN1dW1VcGRhdGVEZWxheSh2b2lkKTsK LQogI2lmZGVmIEVYRUNfQkFDS0VORAogZXh0ZXJuIHZvaWQgQXV0b1ZhY0xhdW5jaGVyTWFpbihp bnQgYXJnYywgY2hhciAqYXJndltdKSBwZ19hdHRyaWJ1dGVfbm9yZXR1cm4oKTsKIGV4dGVybiB2 b2lkIEF1dG9WYWNXb3JrZXJNYWluKGludCBhcmdjLCBjaGFyICphcmd2W10pIHBnX2F0dHJpYnV0 ZV9ub3JldHVybigpOwotLSAKMi4zNy4yCgo= --000000000000c6e76205f8b14956 Content-Type: text/x-patch; charset="US-ASCII"; name="v18-0001-Make-vacuum-failsafe_active-global.patch" Content-Disposition: attachment; filename="v18-0001-Make-vacuum-failsafe_active-global.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lg5lx3ex0 RnJvbSAwMDQyMDY3Y2U3MmE0NzRmZTQwODcyNDViOTc4ODQ3YzBiODM1YjcyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBGcmksIDMxIE1hciAyMDIzIDEwOjM4OjM5IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTggMS8zXSBNYWtlIHZhY3V1bSBmYWlsc2FmZV9hY3RpdmUgZ2xvYmFsCgpXaGlsZSB2 YWN1dW1pbmcgYSB0YWJsZSBpbiBmYWlsc2FmZSBtb2RlLCBWYWN1dW1Db3N0QWN0aXZlIHNob3Vs ZCBub3QgYmUKcmUtZW5hYmxlZC4gVGhpcyBjdXJyZW50bHkgaXNuJ3QgYSBwcm9ibGVtIGJlY2F1 c2UgdmFjdXVtIGNvc3QKcGFyYW1ldGVycyBhcmUgb25seSByZWZyZXNoZWQgaW4gYmV0d2VlbiB2 YWN1dW1pbmcgdGFibGVzIGFuZCBmYWlsc2FmZQpzdGF0dXMgaXMgcmVzZXQgZm9yIGV2ZXJ5IHRh YmxlLiBJbiBwcmVwYXJhdGlvbiBmb3IgYWxsb3dpbmcgdmFjdXVtIGNvc3QKcGFyYW1ldGVycyB0 byBiZSB1cGRhdGVkIG1vcmUgZnJlcXVlbnRseSwgZWxldmF0ZQpMVlJlbFN0YXRlLT5mYWlsc2Fm ZV9hY3RpdmUgdG8gYSBnbG9iYWwsIFZhY3V1bUZhaWxzYWZlQWN0aXZlLCB3aGljaAp3aWxsIGJl IGNoZWNrZWQgd2hlbiBkZXRlcm1pbmluZyB3aGV0aGVyIG9yIG5vdCB0byByZS1lbmFibGUgdmFj dXVtCmNvc3QtcmVsYXRlZCBkZWxheXMuCgpSZXZpZXdlZC1ieTogTWFzYWhpa28gU2F3YWRhIDxz YXdhZGEubXNoa0BnbWFpbC5jb20+ClJldmlld2VkLWJ5OiBEYW5pZWwgR3VzdGFmc3NvbiA8ZGFu aWVsQHllc3FsLnNlPgpSZXZpZXdlZC1ieTogS3lvdGFybyBIb3JpZ3VjaGkgPGhvcmlreW90YS5u dHRAZ21haWwuY29tPgpEaXNjdXNzaW9uOiBodHRwczovL3d3dy5wb3N0Z3Jlc3FsLm9yZy9tZXNz YWdlLWlkL2ZsYXQvQ0FBS1J1X1puZ3pxbkVPRGM3TG1TMU5IMDRLdDZZOWh1U2p6NXBwNyUyQkRY aHJqREEwZ3clNDBtYWlsLmdtYWlsLmNvbQotLS0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3Zh Y3V1bWxhenkuYyB8IDE2ICsrKysrKystLS0tLS0tLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3Zh Y3V1bS5jICAgICAgICB8IDE1ICsrKysrKysrKysrKysrKwogc3JjL2luY2x1ZGUvY29tbWFuZHMv dmFjdXVtLmggICAgICAgIHwgIDEgKwogMyBmaWxlcyBjaGFuZ2VkLCAyMyBpbnNlcnRpb25zKCsp LCA5IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3Zh Y3V1bWxhenkuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYwppbmRleCA2 MzkxNzlhYTQ2Li4yYmE4NWJkM2Q2IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVh cC92YWN1dW1sYXp5LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5j CkBAIC0xNTMsOCArMTUzLDYgQEAgdHlwZWRlZiBzdHJ1Y3QgTFZSZWxTdGF0ZQogCWJvb2wJCWFn Z3Jlc3NpdmU7CiAJLyogVXNlIHZpc2liaWxpdHkgbWFwIHRvIHNraXA/IChkaXNhYmxlZCBieSBE SVNBQkxFX1BBR0VfU0tJUFBJTkcpICovCiAJYm9vbAkJc2tpcHdpdGh2bTsKLQkvKiBXcmFwYXJv dW5kIGZhaWxzYWZlIGhhcyBiZWVuIHRyaWdnZXJlZD8gKi8KLQlib29sCQlmYWlsc2FmZV9hY3Rp dmU7CiAJLyogQ29uc2lkZXIgaW5kZXggdmFjdXVtaW5nIGJ5cGFzcyBvcHRpbWl6YXRpb24/ICov CiAJYm9vbAkJY29uc2lkZXJfYnlwYXNzX29wdGltaXphdGlvbjsKIApAQCAtMzkxLDcgKzM4OSw3 IEBAIGhlYXBfdmFjdXVtX3JlbChSZWxhdGlvbiByZWwsIFZhY3V1bVBhcmFtcyAqcGFyYW1zLAog CUFzc2VydChwYXJhbXMtPmluZGV4X2NsZWFudXAgIT0gVkFDT1BUVkFMVUVfVU5TUEVDSUZJRUQp OwogCUFzc2VydChwYXJhbXMtPnRydW5jYXRlICE9IFZBQ09QVFZBTFVFX1VOU1BFQ0lGSUVEICYm CiAJCSAgIHBhcmFtcy0+dHJ1bmNhdGUgIT0gVkFDT1BUVkFMVUVfQVVUTyk7Ci0JdmFjcmVsLT5m YWlsc2FmZV9hY3RpdmUgPSBmYWxzZTsKKwlWYWN1dW1GYWlsc2FmZUFjdGl2ZSA9IGZhbHNlOwog CXZhY3JlbC0+Y29uc2lkZXJfYnlwYXNzX29wdGltaXphdGlvbiA9IHRydWU7CiAJdmFjcmVsLT5k b19pbmRleF92YWN1dW1pbmcgPSB0cnVlOwogCXZhY3JlbC0+ZG9faW5kZXhfY2xlYW51cCA9IHRy dWU7CkBAIC03MDksNyArNzA3LDcgQEAgaGVhcF92YWN1dW1fcmVsKFJlbGF0aW9uIHJlbCwgVmFj dXVtUGFyYW1zICpwYXJhbXMsCiAJCQl9CiAJCQllbHNlCiAJCQl7Ci0JCQkJaWYgKCF2YWNyZWwt PmZhaWxzYWZlX2FjdGl2ZSkKKwkJCQlpZiAoIVZhY3V1bUZhaWxzYWZlQWN0aXZlKQogCQkJCQlh cHBlbmRTdHJpbmdJbmZvU3RyaW5nKCZidWYsIF8oImluZGV4IHNjYW4gYnlwYXNzZWQ6ICIpKTsK IAkJCQllbHNlCiAJCQkJCWFwcGVuZFN0cmluZ0luZm9TdHJpbmcoJmJ1ZiwgXygiaW5kZXggc2Nh biBieXBhc3NlZCBieSBmYWlsc2FmZTogIikpOwpAQCAtMjI5Myw3ICsyMjkxLDcgQEAgbGF6eV92 YWN1dW0oTFZSZWxTdGF0ZSAqdmFjcmVsKQogCQkgKiB2YWN1dW1pbmcgb3IgaGVhcCB2YWN1dW1p bmcuICBUaGlzIFZBQ1VVTSBvcGVyYXRpb24gd29uJ3QgZW5kIHVwCiAJCSAqIGJhY2sgaGVyZSBh Z2Fpbi4KIAkJICovCi0JCUFzc2VydCh2YWNyZWwtPmZhaWxzYWZlX2FjdGl2ZSk7CisJCUFzc2Vy dChWYWN1dW1GYWlsc2FmZUFjdGl2ZSk7CiAJfQogCiAJLyoKQEAgLTIzNzQsNyArMjM3Miw3IEBA IGxhenlfdmFjdXVtX2FsbF9pbmRleGVzKExWUmVsU3RhdGUgKnZhY3JlbCkKIAkgKi8KIAlBc3Nl cnQodmFjcmVsLT5udW1faW5kZXhfc2NhbnMgPiAwIHx8CiAJCSAgIHZhY3JlbC0+ZGVhZF9pdGVt cy0+bnVtX2l0ZW1zID09IHZhY3JlbC0+bHBkZWFkX2l0ZW1zKTsKLQlBc3NlcnQoYWxsaW5kZXhl cyB8fCB2YWNyZWwtPmZhaWxzYWZlX2FjdGl2ZSk7CisJQXNzZXJ0KGFsbGluZGV4ZXMgfHwgVmFj dXVtRmFpbHNhZmVBY3RpdmUpOwogCiAJLyoKIAkgKiBJbmNyZWFzZSBhbmQgcmVwb3J0IHRoZSBu dW1iZXIgb2YgaW5kZXggc2NhbnMuCkBAIC0yNjE2LDEyICsyNjE0LDEyIEBAIHN0YXRpYyBib29s CiBsYXp5X2NoZWNrX3dyYXBhcm91bmRfZmFpbHNhZmUoTFZSZWxTdGF0ZSAqdmFjcmVsKQogewog CS8qIERvbid0IHdhcm4gbW9yZSB0aGFuIG9uY2UgcGVyIFZBQ1VVTSAqLwotCWlmICh2YWNyZWwt PmZhaWxzYWZlX2FjdGl2ZSkKKwlpZiAoVmFjdXVtRmFpbHNhZmVBY3RpdmUpCiAJCXJldHVybiB0 cnVlOwogCiAJaWYgKHVubGlrZWx5KHZhY3V1bV94aWRfZmFpbHNhZmVfY2hlY2soJnZhY3JlbC0+ Y3V0b2ZmcykpKQogCXsKLQkJdmFjcmVsLT5mYWlsc2FmZV9hY3RpdmUgPSB0cnVlOworCQlWYWN1 dW1GYWlsc2FmZUFjdGl2ZSA9IHRydWU7CiAKIAkJLyoKIAkJICogQWJhbmRvbiB1c2Ugb2YgYSBi dWZmZXIgYWNjZXNzIHN0cmF0ZWd5IHRvIGFsbG93IHVzZSBvZiBhbGwgb2YKQEAgLTI4MjAsNyAr MjgxOCw3IEBAIHNob3VsZF9hdHRlbXB0X3RydW5jYXRpb24oTFZSZWxTdGF0ZSAqdmFjcmVsKQog ewogCUJsb2NrTnVtYmVyIHBvc3NpYmx5X2ZyZWVhYmxlOwogCi0JaWYgKCF2YWNyZWwtPmRvX3Jl bF90cnVuY2F0ZSB8fCB2YWNyZWwtPmZhaWxzYWZlX2FjdGl2ZSB8fAorCWlmICghdmFjcmVsLT5k b19yZWxfdHJ1bmNhdGUgfHwgVmFjdXVtRmFpbHNhZmVBY3RpdmUgfHwKIAkJb2xkX3NuYXBzaG90 X3RocmVzaG9sZCA+PSAwKQogCQlyZXR1cm4gZmFsc2U7CiAKZGlmZiAtLWdpdCBhL3NyYy9iYWNr ZW5kL2NvbW1hbmRzL3ZhY3V1bS5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKaW5k ZXggZWExZDg5NjBmNC4uN2ZjNWMxOWUzNyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFu ZHMvdmFjdXVtLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKQEAgLTcyLDYg KzcyLDIxIEBAIGludAkJCXZhY3V1bV9tdWx0aXhhY3RfZnJlZXplX3RhYmxlX2FnZTsKIGludAkJ CXZhY3V1bV9mYWlsc2FmZV9hZ2U7CiBpbnQJCQl2YWN1dW1fbXVsdGl4YWN0X2ZhaWxzYWZlX2Fn ZTsKIAorLyoKKyAqIFZhY3V1bUZhaWxzYWZlQWN0aXZlIGlzIGEgZGVmaW5lZCBhcyBhIGdsb2Jh bCBzbyB0aGF0IHdlIGNhbiBkZXRlcm1pbmUKKyAqIHdoZXRoZXIgb3Igbm90IHRvIHJlLWVuYWJs ZSBjb3N0LWJhc2VkIHZhY3V1bSBkZWxheSB3aGVuIHZhY3V1bWluZyBhIHRhYmxlLgorICogSWYg ZmFpbHNhZmUgbW9kZSBoYXMgYmVlbiBlbmdhZ2VkLCB3ZSB3aWxsIG5vdCByZS1lbmFibGUgY29z dC1iYXNlZCBkZWxheQorICogZm9yIHRoZSB0YWJsZSB1bnRpbCBhZnRlciB2YWN1dW1pbmcgaGFz IGNvbXBsZXRlZCwgcmVnYXJkbGVzcyBvZiBvdGhlcgorICogc2V0dGluZ3MuCisgKgorICogT25s eSBWQUNVVU0gY29kZSBzaG91bGQgaW5zcGVjdCB0aGlzIHZhcmlhYmxlIGFuZCBvbmx5IHRhYmxl IGFjY2VzcyBtZXRob2RzCisgKiBzaG91bGQgc2V0IGl0IHRvIHRydWUuIEluIFRhYmxlIEFNLWFn bm9zdGljIFZBQ1VVTSBjb2RlLCB0aGlzIHZhcmlhYmxlIGlzCisgKiBpbnNwZWN0ZWQgdG8gZGV0 ZXJtaW5lIHdoZXRoZXIgb3Igbm90IHRvIGFsbG93IGNvc3QtYmFzZWQgZGVsYXlzLiBUYWJsZSBB TXMKKyAqIGFyZSBmcmVlIHRvIHNldCBpdCBpZiB0aGV5IGRlc2lyZSB0aGlzIGJlaGF2aW9yLCBi dXQgaXQgaXMgZmFsc2UgYnkgZGVmYXVsdAorICogYW5kIHJlc2V0IHRvIGZhbHNlIGluIGJldHdl ZW4gdmFjdXVtaW5nIGVhY2ggcmVsYXRpb24uCisgKi8KK2Jvb2wJCVZhY3V1bUZhaWxzYWZlQWN0 aXZlID0gZmFsc2U7CisKIC8qCiAgKiBWYXJpYWJsZXMgZm9yIGNvc3QtYmFzZWQgcGFyYWxsZWwg dmFjdXVtLiAgU2VlIGNvbW1lbnRzIGF0b3AKICAqIGNvbXB1dGVfcGFyYWxsZWxfZGVsYXkgdG8g dW5kZXJzdGFuZCBob3cgaXQgd29ya3MuCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9jb21tYW5k cy92YWN1dW0uaCBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oCmluZGV4IDE5Y2E4MThk YzIuLjEyMjNkMTVlMGQgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5o CisrKyBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oCkBAIC0zMDYsNiArMzA2LDcgQEAg ZXh0ZXJuIFBHRExMSU1QT1JUIHBnX2F0b21pY191aW50MzIgKlZhY3V1bVNoYXJlZENvc3RCYWxh bmNlOwogZXh0ZXJuIFBHRExMSU1QT1JUIHBnX2F0b21pY191aW50MzIgKlZhY3V1bUFjdGl2ZU5X b3JrZXJzOwogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBWYWN1dW1Db3N0QmFsYW5jZUxvY2FsOwog CitleHRlcm4gUEdETExJTVBPUlQgYm9vbCBWYWN1dW1GYWlsc2FmZUFjdGl2ZTsKIAogLyogaW4g Y29tbWFuZHMvdmFjdXVtLmMgKi8KIGV4dGVybiB2b2lkIEV4ZWNWYWN1dW0oUGFyc2VTdGF0ZSAq cHN0YXRlLCBWYWN1dW1TdG10ICp2YWNzdG10LCBib29sIGlzVG9wTGV2ZWwpOwotLSAKMi4zNy4y Cgo= --000000000000c6e76205f8b14956--